자바 범 형 기본 지식 및 통용 방법

10943 단어 자바범 형방법.
1.일반적인 소개
1.범 형 을 도입 하 는 목적
범 형 을 도입 하 는 동 기 를 이해 하려 면 먼저 문법 사탕 부터 알 아야 한다.
문법 사탕
문법 사탕(Syntactic Sugar)은 당의 문법 이 라 고도 부 르 는데 영국 컴퓨터 학자 Peter.J.Landin 이 발명 한 용어 로 컴퓨터 언어 에 추 가 된 특정한 문법 을 말한다.이런 문법 은 언어의 기능 에 영향 을 주지 않 지만 프로그래머 가 사용 하기에 더욱 편리 하 다.자바 에서 가장 자주 사용 하 는 문법 사탕 은 주로 범 형,길 어 지 는 매개 변수,조건 컴 파일,자동 분해 포장,내부 류 등 이 있다.가상 컴퓨터 는 이러한 문법 을 지원 하지 않 는 다.그들 은 컴 파일 단계 에서 간단 한 기초 문법 구조 로 복원 되 었 고 이 과정 은 해법 당 이 되 었 다.
범 형의 목적:자바 범 형 은 일종 의 문법 설탕 을 범 형 을 통 해 컴 파일 단계 에서 일부 유형 전환 작업 을 완성 하고 실행 할 때 유형 전환 을 강제 하여 ClassCastException,즉 유형 전환 이상 이 발생 하지 않도록 하 는 것 이다.
2.범 형 초기 분석
JDK 1.5 시 에 야 범 형 을 추 가 했 고 어느 정도 에 집합 하기 편리 하 게 사용 되 어 그 요소 의 데이터 형식 을 기억 할 수 있 게 했다.
범 형(Generic type 또는 Generics)이 나타 나 기 전에 코드 를 이렇게 썼 습 니 다.

public static void main(String[] args)
{
    List list = new ArrayList();
    list.add("123");
    list.add("456");
    System.out.println((String)list.get(0));
}
물론 이것 은 완전히 허용 되 는 것 입 니 다.List 의 내용 은 Object 형식 이기 때문에 자 연 스 럽 게 모든 대상 유형 을 넣 을 수 있 고 꺼 낼 수 있 습 니 다.그러나 이렇게 쓰 면 두 가지 문제 가 있 습 니 다.
1.한 대상 이 집합 에 들 어 갈 때 집합 은 이 대상 의 유형 을 기억 하지 못 하고 집합 에서 이 대상 을 다시 꺼 낼 때 이 대상 의 컴 파일 형식 은 Object 로 변 합 니 다.
2.실행 할 때 인위적으로 유형 을 구체 적 인 목표 로 강제로 전환 해 야 합 니 다.실제 프로그램 은 이렇게 간단 하지 않 습 니 다.조심 하지 않 으 면 자바.lang.ClassCastException 이 나타 날 수 있 습 니 다.
그래서 범 형 이 나타 난 후에 위의 코드 는 모두 가 알 고 있 는 쓰기 로 바 뀌 었 다.

public static void main(String[] args)
{
    List<String> list = new ArrayList<String>();
    list.add("123");
    list.add("456");
    System.out.println(list.get(0));
}
이것 이 바로 범 형 이다.범 형 은 자바 언어 형식 시스템 에 대한 확장 입 니 다.C++와 유사 한 템 플 릿 입 니 다.형식 매개 변 수 를 매개 변수 화 형식 을 사용 할 때 지정 한 형식의 자리 표시 자로 볼 수 있 습 니 다.범 형 을 도입 하 는 것 은 자바 언어 에 비교적 큰 기능 강화 로 많은 장점 을 가 져 왔 다.
3.일반적인 장점
① 유형 안전.형식 오 류 는 현재 컴 파일 하 는 동안 잡 혔 습 니 다.실행 할 때 자바.lang.ClassCastException 으로 보 여 주 는 것 이 아니 라 형식 검 사 를 실행 할 때 컴 파일 로 옮 길 때 개발 자 들 이 오 류 를 쉽게 찾 고 프로그램의 신뢰성 을 높 일 수 있 습 니 다.
② 코드 의 많은 강제 형식 전환 을 없 애고 코드 의 가 독성 을 강화 합 니 다.
③ 비교적 큰 최적화 에 가능성 을 가 져 왔 다.
2.일반적인 사용
1.범 형 류 와 범 형 인터페이스
다음은 JDK 1.5 이후 List 인터페이스 와 Array List 류 의 코드 세 션 입 니 다.

//              ,     E
public interface List<E> extends Collection<E> {
   //     ,E        
   public E get(int index) {}
   public void add(E e) {} 
}
//             ,     E
public class ArrayList<E> extends AbstractList<E> implements List<E>{
   //    ,E        
   public void set(E e) {
   .......................
   }
}
이것 이 바로 범 형의 실질 이다.인 터 페 이 스 를 정의 할 때 유형 형 삼 을 설명 할 수 있 고 유형 형 삼 은 전체 인터페이스,유형 내 에서 유형 으로 사용 할 수 있 으 며 거의 모든 일반 유형 을 사용 할 수 있 는 곳 에서 이런 유형 형 삼 을 사용 할 수 있다.
다음은 범 형 류 의 사용 을 구체 적 으로 설명 한다.범 형 인터페이스의 사용 은 범 형 류 와 거의 같 아서 스스로 공부 하 는 것 과 비교 할 수 있다.
범 형 류
용기 클래스 를 정의 합 니 다.키 값 을 키-value 에 저장 합 니 다.키 값 이 맞 는 유형 이 확실 하지 않 습 니 다.각각 K 와 V 로 지정 할 수 있 습 니 다.

public class Container<K, V> {
    private K key;
    private V value;
    public Container(K k, V v) {
        key = k;
        value = v;
    }
    public K getkey() {
        return key;
    }
    public V getValue() {
        return value;
    }
    public void setKey() {
        this.key = key;
    }
    public void setValue() {
        this.value = value;
    }
}
Container 클래스 를 사용 할 때 K,V 의 구체 적 인 유형 만 지정 하면 논리 적 으로 다른 Container 인 스 턴 스 를 만들어 서로 다른 데이터 형식 을 저장 할 수 있 습 니 다.

 public static void main(String[] args){
                  Container<String,String> c1=new Container<String ,String>("name","hello");
                  Container<String,Integer> c2=new Container<String,Integer>("age",22);
                  Container<Double,Double> c3=new Container<Double,Double>(1.1,1.3);
                  System.out.println(c1.getKey() + " : " + c1.getValue());      
                  System.out.println(c2.getKey() + " : " + c2.getValue());                                                               
                  System.out.println(c3.getKey() + " : " + c3.getValue());
        }
JDK 1.7 에 범 형의'마름모꼴'문법 을 추 가 했 습 니 다.자바 는 구조 기 후에 완 성 된 범 형 정 보 를 가지 고 있 지 않 고 한 쌍 의 괄호(<>)만 제시 하면 됩 니 다.자바 는 첨 괄호 안에 어떤 범 형 정보 가 있어 야 하 는 지 추측 할 수 있 습 니 다.
다음 과 같다.

Container<String,String> c1=new Container<>("name","hello");
Container<String,Integer> c2=new Container<>("age",22);
범 형 류 파 생 자 류
범 형 성명 이 있 는 인터페이스,부모 클래스 를 만 든 후에 이 인터페이스 에 실현 클래스 를 만 들 거나 이 부모 클래스 에서 아 이 를 낳 을 수 있 습 니 다.이 인터페이스,부모 클래스 에서 아 이 를 낳 을 때 유형 형 삼 을 포함 하지 않 고 구체 적 인 유형 으로 전달 해 야 합 니 다.잘못된 방식:

public class A extends Container<K, V>{}
올 바른 방식:

public class A extends Container<Integer, String>{}
구체 적 인 유형 을 지정 하지 않 아 도 됩 니 다.다음 과 같 습 니 다.

public class A extends Container{}
이때 시스템 은 K,V 형 인삼 을 Object 형식 으로 처리한다.
2.일반적인 방법
앞에서 범 형 류 와 범 형 인 터 페 이 스 를 소개 할 때 범 형 류,범 형 인터페이스 의 방법 에서 범 형 에서 설명 한 유형 형 참 을 일반 유형 으로 사용 할 수 있다 고 언급 했다.다음 과 같은 방식:

public class Container<K, V> {
........................
    public K getkey() {
        return key;
    }
    public void setKey() {
        this.key = key;
    }
....................
}
그러나 다른 상황 에서 클래스,인터페이스 에서 범 형 을 사용 하지 않 았 을 때 방법 을 정의 할 때 유형 형 참 을 정의 하려 면 범 형 방법 을 사용한다.다음 방법:

public class Main{
      public static <T> void out(T t){
                System.out.println(t);
      }
      public static void main(String[] args){
              out("hansheng");
              out(123);
      }
}
일반적인 방법 이란 방법 을 설명 할 때 하나 이상 의 유형 을 정의 하 는 것 이다.일반적인 방법의 용법 형식 은 다음 과 같다.

   <T, S>          (    )
{
   
 }
메모:방법 성명 에서 정 의 된 형 삼 은 이 방법 에서 만 사용 할 수 있 고 인터페이스,클래스 성명 에서 정 의 된 유형 형 삼 은 전체 인터페이스,클래스 에서 사용 할 수 있 습 니 다.

class Demo{  
     public <T> T fun(T t){   //              
     	 return t ;     //          
     }  
}
public class GenericsDemo26{  
     public static void main(String args[]){  
          Demo d = new Demo() ; //    Demo    
          String str = d.fun("  ") ; //        
          int i = d.fun(30) ;  //     ,      
          System.out.println(str) ; //       
          System.out.println(i) ;  //       
     }  
}; 
fun()방법 을 호출 할 때 들 어 오 는 실제 대상 에 따라 컴 파일 러 는 유형 형 참 T 가 대표 하 는 실제 유형 을 판단 합 니 다.
3.범용 구조 기
범 형 방법 이 방법 서명 에서 형식 형 삼 을 설명 할 수 있 듯 이 자바 도 구조 기 서명 에서 형식 형 삼 을 설명 할 수 있 도록 허용 하여 이른바 범 형 구조 기 가 생 겼 다.
일반적인 범 형 방법 을 사용 하 는 것 과 마찬가지 로 하 나 는 명시 적 지정 범 형 매개 변수 이 고 다른 하 나 는 암시 적 추정 입 니 다.명시 적 지정 이 라면 명시 적 으로 지정 한 유형 매개 변 수 를 기준 으로 들 어 오 는 매개 변수의 유형 과 지정 한 유형 이 실제 참조 되 지 않 으 면 컴 파일 오류 가 발생 합 니 다.

public class Person {
    public <T> Person(T t) {
        System.out.println(t);
    }
}

public static void main(String[] args){
        //  
        new Person(22);
        //  
        new<String>Person("hello");
    }
여기 서 유일 하 게 특별한 설명 이 필요 한 것 은 구조 기 가 범 형 구조 기 라면 이런 유형 도 범 형 류 인 상황 에서 범 형 구조 기 를 어떻게 사용 해 야 하 는 지 하 는 것 이다.
범 형 구조 기 는 자신의 유형 적 인 파 라 메 터 를 명시 적 으로 지정 할 수 있 기 때문이다.
아래 의 이 예 를 대표 로 하 다

public class Person<E> {
    public <T> Person(T t) {
        System.out.println(t);
    }
}
이러한 용법:Persona=newPerson<>(15);이런 문법 은 허용 되 지 않 으 니,직접 번역 하여 잘못 보고 할 것 이다!
3.유형 마스크
말 그대로 임 의 유형 에 맞 는 실 삼 이다.
형식 마스크 는 물음표(?)입 니 다.하나의 물음 표를 유형 실 참 으로 List 집합 에 전달 하고 쓰기:List(원소 형식 을 알 수 없 는 List 라 는 뜻).이 물음표(?)마스크 가 되 었 습 니 다.요소 형식 은 모든 형식 과 일치 할 수 있 습 니 다.

public void test(List<?> c){
    for(int i =0;i<c.size();i++){
        System.out.println(c.get(i));
    }
}
현재 테스트()방법 을 호출 하기 위해 모든 종류의 List 를 입력 할 수 있 습 니 다.프로그램 은 집합 c 의 요 소 를 방문 할 수 있 습 니 다.그 유형 은 Object 입 니 다.

List<?> c = new ArrayList<String>();
        //     
        c.add(new Object());
하지만 원 소 를 넣 을 수 는 없다.프로그램 이 c 집합 에 있 는 요소 의 종 류 를 정할 수 없 기 때문에 대상 을 추가 할 수 없습니다.집합 요소 의 유형 을 확인 하기 위해 서 는 밴드 제한 어댑터 를 도입 해 야 한다.
밴드 제한 어댑터
쉽게 말 하면 마스크 를 사용 하 는 목적 은 일반적인 유형의 매개 변수 유형 을 제한 하여 특정한 조건 을 만족 시 키 고 특정한 유형 으로 고정 시 키 는 것 이다.
주로 두 가지 로 나 뉘 는데 그것 이 바로 상한 어댑터 와 하한 어댑터 이다.
1.상한 마스크
범 형 카 테 고리 사용 을 제한 하려 면 특정한 유형 이나 하위 유형 만 사용 해 야 이 유형 을 예화 할 수 있 습 니 다.유형 을 정의 할 때 extends 키 워드 를 사용 하여 이 유형 을 지정 하려 면 특정한 종 류 를 계승 하거나 특정한 인 터 페 이 스 를 실현 해 야 합 니 다.이런 종류 나 인터페이스 자체 일 수도 있 습 니 다.

             Shape       
List<? extends Shape>
이것 이 바로 상한 선 마스크 입 니 다.키워드 extends 를 사용 하여 이 루어 집 니 다.예화 할 때 지정 한 유형의 실 삼 은 extends 후 유형의 하위 클래스 나 그 자체 일 수 있 습 니 다.예 를 들 면:

//Circle    
List<? extends Shape> list = new ArrayList<Circle>();
이렇게 하면 집합 중의 원소 의 유형 을 확정한다.구체 적 인 유형 은 확실 하지 않 지만 적어도 그 부 류 는 안다.그리고 다른 조작 을 합 니 다.
2.하한 선 마스크
범 형 카 테 고리 사용 을 제한 하려 면 특정한 유형 이나 부모 유형 으로 만 이 유형 을 예화 할 수 있 습 니 다.유형 을 정의 할 때 슈퍼 키 워드 를 사용 하여 이 유형 을 지정 할 수 있 습 니 다.이 유형 은 반드시 특정한 유형의 부모 클래스 나 특정한 인터페이스의 부모 인터페이스 여야 합 니 다.이것 이나 인터페이스 자체 일 수도 있 습 니 다.

             Circle       
List<? super Circle>
이것 이 바로 하한 선 마스크 입 니 다.키워드 슈퍼 를 사용 하여 이 루어 집 니 다.예화 할 때 지정 한 유형의 실 삼 은 extends 후 유형의 하위 클래스 나 그 자체 일 수 있 습 니 다.예 를 들 면:

             Circle       
List<? super Circle>
유형 지우 기

Class c1 = new ArrayList<Integer>().getClass();
Class c2 = new ArrayList<String>().getClass();
System.out.println(c1==c2);
프로그램 출력:
true。
이것 은 일반적인 유형의 인삼 이 어떤 유형의 실제 인삼 에 들 어 오 든 자바 에 게 는 똑 같은 처리 로 여 겨 지고 메모리 에서 도 하나의 메모리 공간 만 차지 하기 때문이다.자바 범 형 이라는 개념 이 제기 한 목적 을 보면 코드 컴 파일 단계 에 만 작용 하고 컴 파일 과정 에서 범 형 결 과 를 정확하게 검사 한 후에 범 형의 관련 정 보 를 지 울 것 이다.즉,성공 적 으로 컴 파일 된 class 파일 에는 어떠한 범 형 정보 도 포함 되 지 않 는 다 는 것 이다.일반적인 정 보 는 운행 단계 에 들 어가 지 않 습 니 다.
정적 방법,정적 초기 화 블록 또는 정적 변수의 성명 과 초기 화 에 서 는 형식 인삼 을 사용 할 수 없습니다.시스템 에 서 는 팬 클래스 가 진정 으로 생 성 되 지 않 기 때문에 인 스 턴 스 of 연산 자 는 팬 클래스 를 사용 할 수 없습니다.
총결산
이 글 은 여기까지 입 니 다.당신 에 게 도움 을 줄 수 있 기 를 바 랍 니 다.또한 당신 이 우리 의 더 많은 내용 에 관심 을 가 져 주 실 수 있 기 를 바 랍 니 다!

좋은 웹페이지 즐겨찾기