일반적인 1. 무엇입니까?
일반 인터페이스의 개념을 더욱 확장하고, "일반"은 사실상 의미 종류의 다양한. 뿐만 아니라, 코드 재사용, 커플 링을 감소시키기 때문에 클래스, 인터페이스 및 방법 코드 종류의 매우 넓은 범위에 적용 할 수있는 데이터 타입 코드들은 동일한 코드들의 세트는 데이터 타입의 다양한 사용될 수 있고, 서로 결합하여 동작이 더 이상 가능하지 뿐만 아니라 가독성과 보안 코드를 향상시킨다. 추상화의 장점을 이야기, 우리는 실제 예를 살펴.
2. 일반의 간단한 예에서 첫 번째보기
package genericity.demo;
/**
* @author BastetCat
* @data 2019/8/8 21:14
*/
public class Pair<T> {
T one;
T two;
public Pair(T one, T two) {
this.one = one;
this.two = two;
}
public T getOne() {
return one;
}
public T getTwo() {
return two;
}
}관측 및 일반 클래스의 차이 :
- 돌아 가기 또 하나 개의 클래스 이름
<T> - 하나의 입력이는 T입니다
T 3. 그래서 무엇인가?
T는 형식 매개 변수를 나타냅니다
일반적인 입력 파라미터, 데이터 프로세싱 유형이 고정되지 않고, 파라미터로서 전달 될 수있다.
지금 우리가 알고있는, 매개 변수로 제네릭 형식을 사용합니다.
4. 어떻게 제네릭을 사용하고 인수 그것으로 입력합니다?
다음 코드는 : 우리는 서로 다른 유형의 형식 매개 변수 (정수, 문자, 문자열)를 전달, 새로운 3 쌍 객체이었다.
package genericity.demo;
/**
* @author BastetCat
* @data 2019/8/8 21:22
*/
public class Test {
public static void main(String[] args) {
Pair<Integer> pairInteger = new Pair<Integer>(1,2);
int one1 = pairInteger.getOne();
int two1 = pairInteger.getTwo();
System.out.println("one:"+one1+",two:"+two1);
Pair<Character> pairCharacter = new Pair<Character>('一','二');
char one2 = pairCharacter.getOne();
char two2 = pairCharacter.getTwo();
System.out.println("one:"+one2+",two:"+two2);
Pair<String> pairString = new Pair<String>("I","II");
String one3 = pairString.getOne();
String two3 = pairString.getTwo();
System.out.println("one:"+one3+",two:"+two3);
}
}결과는 다음과 같다 :
one:1,two:2
one:一,two:二
one:I,two:II물론, 우리는 단지 형식 매개 변수를 전달할 수 없습니다 여러 유형의 매개 변수를 전달할 수 있습니다. 콤마 파라미터의 종류의 복수 ","분리된다. 다음 예제와 같이 :
package genericity.demo;
/**
* @author BastetCat
* @data 2019/8/8 21:37
*/
public class PairTwo <U,V> {
U one;
V two;
public PairTwo(U one, V two) {
this.one = one;
this.two = two;
}
public U getOne() {
return one;
}
public V getTwo() {
return two;
}
}그래서 사용하기 :
PairTwo<String,Integer> pairTwo = new PairTwo<>("牛牛",20);주 : Java 7의 시작부터, 매개 변수 뒤에 지원 유형 생략, 간단한 쓰기 때문에.
제네릭의 기본 원리
결국 제네릭 형식 인수는 무엇입니까? 왜 우리는 형식 매개 변수를 정의해야 하는가? 일반 범주를 정의, 직접 개체를 사용하는 것도 가능하다. 우리가 쓸 수 있습니다 전에 같은 쌍 클래스 :
package genericity.demo;
/**
* @author BastetCat
* @data 2019/8/8 21:44
*/
public class PairObject {
Object one;
Object two;
public PairObject(Object one, Object two) {
this.one = one;
this.two = two;
}
public Object getOne() {
return one;
}
public Object getTwo() {
return two;
}
}이러한 사용 후, 효과는 동일합니다 :
package genericity.demo;
/**
* @author BastetCat
* @data 2019/8/8 21:46
*/
public class TestPairObject {
public static void main(String[] args) {
PairObject pairObject1 = new PairObject(1,2);
int one1 =(int)pairObject1.getOne();
int two1 =(int)pairObject1.getTwo();
System.out.println("one:"+one1+",two:"+two1);
PairObject pairObject2 = new PairObject("yi","er");
String one2 =(String)pairObject2.getOne();
String two2 =(String)pairObject2.getTwo();
System.out.println("one:"+one2+",two:"+two2);
}
}
출력 :
one:1,two:2
one:yi,two:er우리는 실제로 우리의 사용 개체 + 캐스트도 같은 결과를 얻을 것을 볼 수 있습니다. 사실, 우리의 자바 제네릭의 내부 원리는 경우입니다.
우리는 다음과 같이 우리의 Pair.class 및 Test.class라는 결과를 디 컴파일 JAD 도구를 사용 :
// Decompiled by Jad v1.5.8g. Copyright 2001 Pavel Kouznetsov.
// Jad home page: http://www.kpdus.com/jad.html
// Decompiler options: packimports(3)
// Source File Name: Pair.java
package genericity.demo;
public class Pair
{
public Pair(Object obj, Object obj1)
{
one = obj;
two = obj1;
}
public Object getOne()
{
return one;
}
public Object getTwo()
{
return two;
}
Object one;
Object two;
}
// Decompiled by Jad v1.5.8g. Copyright 2001 Pavel Kouznetsov.
// Jad home page: http://www.kpdus.com/jad.html
// Decompiler options: packimports(3)
// Source File Name: Test.java
package genericity.demo;
import java.io.PrintStream;
// Referenced classes of package genericity.demo:
// Pair
public class Test
{
public Test()
{
}
public static void main(String args[])
{
Pair pair = new Pair(Integer.valueOf(1), Integer.valueOf(2));
int i = ((Integer)pair.getOne()).intValue();
int j = ((Integer)pair.getTwo()).intValue();
System.out.println((new StringBuilder()).append("one:").append(i).append(",two:").append(j).toString());
Pair pair1 = new Pair(Character.valueOf('\u4E00'), Character.valueOf('\u4E8C'));
char c = ((Character)pair1.getOne()).charValue();
char c1 = ((Character)pair1.getTwo()).charValue();
System.out.println((new StringBuilder()).append("one:").append(c).append(",two:").append(c1).toString());
Pair pair2 = new Pair("I", "II");
String s = (String)pair2.getOne();
String s1 = (String)pair2.getTwo();
System.out.println((new StringBuilder()).append("one:").append(s).append(",two:").append(s1).toString());
}
}위의 분석을 통해 :
우리는 그것을 볼 수있는 자바 컴파일러 자바 소스 파일은 바이트 코드의 .class 파일을로드하고 실행할 수있는 가상 머신에 컴파일됩니다. 제네릭 클래스의 경우, 자바 컴파일러는 기존의 제네릭이 아닌 코드로 변환합니다. 지우기 타입 T는 다음 개체를 대체 필요한 캐스트를 삽입합니다. Java 가상 머신의 실제 구현은 제네릭이 일을 모를 때, 그냥 일반 클래스와 코드를 알고있다.
그런데 왜 이러한 일반적인 디자인을해야합니까?
자바 때문에 제네릭은 불과 5 지원 후 등의 호환성을 위해 설계, 최후의 선택입니다.
6. 제네릭의 장점을 사용하여
- 코드 재사용 : 우리는 다른 클래스를 지원할 수있는 코드가 있습니다.
- 결합 감소 디커플링을 달성하기 위해 코드와 논리 데이터 유형 간의 분리 :.
- 더 나은 가독성 : 목록으로 정의 우리는 설정 시간 사용은
List<String>, 본능적 있습니다리스트 저장하는 String 유형이. - 높은 보안 : 중요한 목표 및 프로그래밍 언어가 크래들에 버그를 파괴하는 것입니다, 런타임에 숙박하지 않는 서면으로 물려 될 수있다. 우리는 정의 할 경우
List<String>이러한 목록을. 우리가 (예 : 이클립스와 같은) 우리의 IDE 내부 목록에 데이터가 아닌 다른 문자열 유형을 넣을 때 오류 메시지가 표시됩니다. 심지어 어떤 IDE 경우. 시간을 컴파일, 자바 컴파일러라고하는 메시지가 표시됩니다 유형의 안전 . 이 프로그램에 대한 보안 가드를 설정합니다. 마찬가지로 일반의 사용은 정상적인 개체를 사용하여 번잡 한 캐스트를 제거합니다. 반면, 일반 목적의 사용은 메시지가 표시되지 시간을 컴파일합니다. 전달 된 매개 변수와 최종 캐스트의 유형이 일치하지 않는 경우. ClassCastException이 제네릭하지 않는 사용하여 실행됩니다.