Java-泛型

1.Java-泛型

1.1泛型应用

泛型可以解决数据类型的安全性问题,其主要原理是在类声明时通过一个标识表示类中某个属性的类型或者是某个方法的返回值以及参数类型。

1.2泛型的定义

[访问权限] class 类名称 <泛型的标识符1，泛型的标识符2,....>{
	[访问权限] 泛型类型标识 变量名称;
	[访问权限] 泛型类型标识 方法名称(){};
	[访问权限] 返回值类型声明 方法名称(泛型类型标识 变量名称){};
}
1
2
3
4
5

1.3声明泛型

class Point<T>{
	private T var;
	public T getVar(){
		return var;
	}
	public void serVar(T var){
		this.var=var;
	}
}
1
2
3
4
5
6
7
8
9

指明泛型也可以用其他字母标识，这里的T是Type的缩写，也便于理解。

1.3.1使用Point类将var设置为String类型

class Point<T>{
    private T var;
    public T getVar(){
        return var;
    }
    public void serVar(T var){
        this.var=var;
    }
}

public class ConnetionDemo {
    public static void main(String[] args) {
        Point<String> p = new Point<String>();
        p.serVar("张三");
        System.out.println(p.getVar());

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

1.3.2使用Point类将var设置为int类型

class Point<T>{
    private T var;
    public T getVar(){
        return var;
    }
    public void serVar(T var){
        this.var=var;
    }
}

public class ConnetionDemo {
    public static void main(String[] args) {
        Point<Integer> p = new Point<Integer>();
        p.serVar(18);
        System.out.println(p.getVar());

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

1.3.3注意

如果设置的内容和泛型指定的类型不一致会出错

1.4泛型应用中的构造方法

泛型类的构造方法的定义

class Point<T>{
    private T var;
    
    public Point(T var){
        this.var=var;
        
    }
    
    public T getVar(){
        return var;
    }
    public void serVar(T var){
        this.var=var;
    }
}

public class ConnetionDemo {
    public static void main(String[] args) {
        Point<Integer> p = new Point<Integer>(18);
        System.out.println(p.getVar());

    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

其实程序和上面的差别不大，就只是在构造方法中设置类的属性。

1.5指定多个泛型

如果一个类中有多个属性需要使用不同的泛型，也就是说即便有泛型的声明，也只是在类的定义上声明，而与构造方法无关。

class Point<K,V>{
    private K key;
    private V value;

    public Point(K key, V value) {
        this.key = key;
        this.value = value;
    }

    public K getKey() {
        return key;
    }

    public void setKey(K key) {
        this.key = key;
    }

    public V getValue() {
        return value;
    }

    public void setValue(V value) {
        this.value = value;
    }
}

public class ConnetionDemo {
    public static void main(String[] args) {
      Point<String,Integer> t=null;
        t = new Point<String, Integer>("lucy",18);
        System.out.println(t.getKey());
        System.out.println(t.getValue());


    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

1.6泛型的安全警告

最好声明类对象时，指定类型例如Point,如果不指定，会出现安全警告，虽然可以执行，但最好不要这样做。

例如

class Point<T>{
    private T var;



    public T getVar(){
        return var;
    }
    public void serVar(T var){
        this.var=var;
    }
}

public class ConnetionDemo {
    public static void main(String[] args) {
        Point p = new Point();
        p.serVar("张三");
        System.out.println(p.getVar());

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

1.7通配符

在泛型操作中也可以通过通配符接收任意泛型类型的对象。

1.7.1使用泛型声明后的对象应用传递问题

class Point<T>{
    private T var;



    public T getVar(){
        return var;
    }
    public void serVar(T var){
        this.var=var;
    }


}

public class ConnetionDemo {
    public static void main(String[] args) {
        Point<String> p = new Point<>();
        p.serVar("张三");
        fun(p);

    }
    public static void  fun(Point<Object> temp){
        System.out.println(temp);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

1.7.2使用通配符解决

class Point<T>{
    private T var;



    public T getVar(){
        return var;
    }
    public void serVar(T var){
        this.var=var;
    }


}

public class ConnetionDemo {
    public static void main(String[] args) {
        Point<String> p = new Point<>();
        p.serVar("张三");
        fun(p);

    }
    public static void  fun(Point<?> temp){
        System.out.println(temp);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

Point表示可以使用任意的泛型类型对象,注意使用?接收对象时，不能设置被泛型指定的内容。
例如：

Point<?> p=new Point<String>();
1

1.7.3受限泛型

在引用传递中，在泛型操作中可以设置一个泛型对象的范围上限和范围下限，范围上限使用extends关键字，表示泛型的类型可能是所指定的类型或者是此类型的子类，而范围下限使用super进行声明，表示泛型的类型可能是所指定的类型。

设置上限

声明对象:类名称<? extends 类> 对象名称
定义类：[访问权限] 类名称 <泛型标识 extends 类>{}
1
2

设置下限

声明对象:类名称<? super 类> 对象名称
定义类：[访问权限] 类名称 <泛型标识 super 类>{}
1
2

泛型的上限

假设一个方法中只能接收的泛型对象只能是数字(Byte、Short、Long、Integer、Float、Double)类型，此时在定义方法参数接收对象时，就必须指定泛型的上限。因为所有的数字包装类都是Number类型的子类。

public static void fun(Info<? extends Number> temp){
......
}
1
2
3

在类定义时指定泛型的上限。

class Info<T extends Number>{
.........
}
1
2
3

以上代码Info类中的泛型的范围就是所有数字。

泛型下限

当使用的泛型只能在本类及父类类型上应用时，就必须使用泛型的范围下限进行配置。

public static void fun(Info<? super String> temp){
.........
}
1
2
3

fun方法只能接收泛型是String和Object类型的引用。

1.8泛型接口

泛型接口

[访问权限] interface 接口名称<泛型标识符>{
........
}
1
2
3

方式一 在子类定义上声明泛型类型

class InfoImpl<T> implements Info<T>{
.......
}
1
2
3

方式二 直接在接口中指定具体类型

class infoImpl implements Info<String>{
.......
}
1
2
3

1.9 泛型方法

定义

[访问权限] <泛型标识> 泛型类型 方法名称(泛型标识 参数名称)
1

定义一个泛型方法

class Demo(){
	public <T> T fun(T t){
	..........
}
}
1
2
3
4
5

2.0泛型数组

接收和返回泛型数组

public class GenericeDemo(){
	public static void main(String []args){
	Integer i []=fun1(1,2,3,4,5,6,7,8);
	fun2(i);
	}
	public static <T> t[] fun1(T ...arg){
			return arg;
	}
	public static<T> void fun2(T param[]){
		for(T t:param){
				System.out.println(t)
			}
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14