tonglin0325的个人主页

Java泛型

tonglin0325

泛型就是指在对象建立时不指定类中属性的具体类型，而由外部在声明及实例化对喜爱时指定类型。

在泛型的指定中无法指定基本数据类型的，必须设置成一个类，这样在设置一个数字时就必须使用包装类。

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
class Point<T>{		//此处T可以是任意的标识符号，T是type的简称
	private T var;		//此变量的类型由外部决定

	public T getVar() {		//返回值的类型由外部决定
		return var;
	}

	public void setVar(T var) {	//设置的类型由外部指定
		this.var = var;
	}
}

public class Generics_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
//		Point<Integer> p = new Point<Integer>();	//里面的var类型为Integer类型
//		p.setVar(30);  														//设置数字，自动装箱
//		System.out.println(p.getVar()*2);					//计算结果，按数字取出
		Point<String> p = new Point<String>();	//里面的var类型为Integer类型
		p.setVar("张三");  														//设置数字，自动装箱
		System.out.println(p.getVar().length());					//计算结果，按数字取出
	}

}

 

泛型的构造方法

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
class Point<T>{			//此处T可以是任意的标识符号，T是type的简称
	private T var;		//此变量的类型由外部决定
	
	public Point(T var) {					//构造方法
		super();
		this.var = var;
	}

	public T getVar() {					//返回值的类型由外部决定
		return var;
	}

	public void setVar(T var) {	//设置的类型由外部指定
		this.var = var;
	}

}

public class Generics_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
//		Point<Integer> p = new Point<Integer>();	//里面的var类型为Integer类型
//		p.setVar(30);  														//设置数字，自动装箱
//		System.out.println(p.getVar()*2);					//计算结果，按数字取出
		
//		Point<String> p = new Point<String>();	//里面的var类型为Integer类型
//		p.setVar("张三");  														//设置数字，自动装箱
//		System.out.println(p.getVar().length());					//计算结果，按数字取出
		
		Point<String> p = new Point<String>("张三");
		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
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
class Point<T>{		//此处T可以是任意的标识符号，T是type的简称
	private T var;	//此变量的类型由外部决定
	
	public Point(T var) {		//构造方法
		super();
		this.var = var;
	}

	public T getVar() {			//返回值的类型由外部决定
		return var;
	}

	public void setVar(T var) {	//设置的类型由外部指定
		this.var = var;
	}
	
}

class Notepad<K,V>{			//此处T可以是任意的标识符号，T是type的简称
	private K key;			//此变量的类型由外部决定
	private V value;		//此变量的类型由外部决定
	
	public Notepad(K key, V value) {		//构造方法
		super();
		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 Generics_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
//		Point<Integer> p = newdd Point<Integer>();	//里面的var类型为Integer类型
//		p.setVar(30);  														//设置数字，自动装箱
//		System.out.println(p.getVar()*2);					//计算结果，按数字取出
		
//		Point<String> p = new Point<String>();	//里面的var类型为Integer类型
//		p.setVar("张三");  														//设置数字，自动装箱
//		System.out.println(p.getVar().length());					//计算结果，按数字取出
		
//		Point<String> p = new Point<String>("张三");
//		System.out.println("内容："+p.getVar());
		
		Notepad<String,Integer> t = new Notepad<String,Integer>("张三",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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
class Point<T>{								//此处T可以是任意的标识符号，T是type的简称
	private T var;								//此变量的类型由外部决定
	
	public Point(T var) {					//构造方法
		super();
		this.var = var;
	}
	
	public String toString(){			//覆写Object类中的toString()方法
		return this.var.toString();
	}

	public T getVar() {					//返回值的类型由外部决定
		return var;
	}

	public void setVar(T var) {	//设置的类型由外部指定
		this.var = var;
	}
	

}

class Notepad<K,V>{								//此处T可以是任意的标识符号，T是type的简称
	private K key;											//此变量的类型由外部决定
	private V value;										//此变量的类型由外部决定
	
	public Notepad(K key, V value) {		//构造方法
		super();
		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 Generics_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根

		Point<String> p = new Point<String>("张三");
		fun(p);
	}
	
	public static void fun(Point<?> point){			//使用泛型接收Point的对象
		System.out.println("内容：" + point);
	}
	
}

 

受限泛型

在引用传递中，在泛型操作中也可以设置一个泛型对象的范围上限和范围下限。

范围上限使用extends关键字声明，标识参数化的类型可能是所指定的类型或者是此类型的子类。

范围下限使用super关键字声明，标识参数化的类型可能是所指定的类型，或者是此类型的父类型，或是Object类。

 

范围上限

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
37
38
39
40
41
import java.awt.datatransfer.FlavorTable;

class info<T extends Number>{	//在声明的地方指定泛型的上限范围
//class info<T>{								//此处T可以是任意的标识符号，T是type的简称
	private T var;								//此变量的类型由外部决定
	
	public info(T var) {					//构造方法
		super();
		this.var = var;
	}
	
	public String toString(){			//覆写Object类中的toString()方法
		return this.var.toString();
	}

	public T getVar() {					//返回值的类型由外部决定
		return var;
	}

	public void setVar(T var) {	//设置的类型由外部指定
		this.var = var;
	}
}

public class Generics_extends_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		
		info<Float> i1 = new info<Float>(10.1f);			//声明并实例化Float类型的泛型对象
		info<Integer> i2 = new info<Integer>(10);		//声明并实例化Integer类型的泛型对象
		fun(i1);																		//是数字可以传递
		fun(i2);																		//是数字可以传递
	}
	
	public static void fun(info<?> temp){			//使用泛型接收info的对象
//	public static void fun(info<? extends Number> temp){			//使用泛型接收info的对象
		System.out.println("temp:" + 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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
import java.awt.datatransfer.FlavorTable;

//class info<T extends Number>{	//在声明的地方指定泛型的上限范围
class info<T>{								//此处T可以是任意的标识符号，T是type的简称
	private T var;								//此变量的类型由外部决定
	
	public info(T var) {					//构造方法
		super();
		this.var = var;
	}
	
	public String toString(){			//覆写Object类中的toString()方法
		return this.var.toString();
	}

	public T getVar() {					//返回值的类型由外部决定
		return var;
	}

	public void setVar(T var) {	//设置的类型由外部指定
		this.var = var;
	}
}

public class Generics_extends_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		
//		info<Float> i1 = new info<Float>(10.1f);			//声明并实例化Float类型的泛型对象
//		info<Integer> i2 = new info<Integer>(10);		//声明并实例化Integer类型的泛型对象
		
		info<Object> i1 = new info<Object>(new Object());	//声明并实例化Object类型的泛型对象
		info<String> i2 = new info<String>("张三");					//声明并实例化String类型的泛型对象
		fun(i1);																		//是数字可以传递
		fun(i2);																		//是数字可以传递
	}
	
//	public static void fun(info<?> temp){			//使用泛型接收info的对象
//	public static void fun(info<? extends Number> temp){			//使用泛型接收info的对象
	public static void fun(info<? super String> temp){			//使用泛型接收info的对象
		System.out.println("temp:" + temp);
	}
}

 

泛型接口

定义泛型接口

定义子类方式<1>——在子类的定义上声明泛型类型

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
interface Info_1<T>{
	public T getVar();
}

class InfoImp<T> implements Info_1<T>{
	
	private T var;							//定义属性
	
	public InfoImp(T var) {		//构造方法
		super();
		this.var = var;
	}

	public void setVar(T var) {
		this.var = var;
	}

	@Override
	public T getVar() {
		// TODO 自动生成的方法存根
		return this.var;
	}
	
}

public class Generics_Interface_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		InfoImp<String> p = new InfoImp<String>("张三");
		System.out.println("内容："+p.getVar());
	}

}

定义子类方式<2>——直接在接口中指定具体类型

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
37
38
39
40
interface Info_1<T>{
	public T getVar();
}

class InfoImp implements Info_1<String>{//定义泛型接口的子类，指定类型为String
//class InfoImp<T> implements Info_1<T>{	//定义泛型接口的子类
	
//	private T var;							//定义属性
	private String var;							//定义属性
	
//	public InfoImp(T var) {		//构造方法
	public InfoImp(String var) {		//构造方法
		super();
		this.var = var;
	}

//	public void setVar(T var) {
	public void setVar(String var) {
		this.var = var;
	}

	@Override
//	public T getVar() {
	public String getVar() {
		// TODO 自动生成的方法存根
		return this.var;
	}
	
}

public class Generics_Interface_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		InfoImp p = new InfoImp("张三");
		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
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
class Demo_Generics{
	public <T> T fun(T t){		//可以接收任意类型的数据
		return t;
	}
}

interface Info_1<T>{
	public T getVar();
}

class InfoImp implements Info_1<String>{//定义泛型接口的子类，指定类型为String
//class InfoImp<T> implements Info_1<T>{	//定义泛型接口的子类
	
//	private T var;							//定义属性
	private String var;							//定义属性
	
//	public InfoImp(T var) {		//构造方法
	public InfoImp(String var) {		//构造方法
		super();
		this.var = var;
	}

//	public void setVar(T var) {
	public void setVar(String var) {
		this.var = var;
	}

	@Override
//	public T getVar() {
	public String getVar() {
		// TODO 自动生成的方法存根
		return this.var;
	}
	
}

public class Generics_Interface_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
//		InfoImp p = new InfoImp("张三");
//		System.out.println("内容："+p.getVar());
		
		Demo_Generics d = new Demo_Generics();
		String str = d.fun("张三");		//传递字符串
		int i = d.fun(30);							//传递数字，自动装箱
		System.out.println(str);
		System.out.println(i);
	}

}

 

通过泛型方法返回泛型类实例

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
37
38
39
40
41
class info<T extends Number>{	//在声明的地方指定泛型的上限范围
//class info<T>{								//此处T可以是任意的标识符号，T是type的简称
	private T var;								//此变量的类型由外部决定
	
//	public info(T var) {					//构造方法
//		super();
//		this.var = var;
//	}
	
	public String toString(){			//覆写Object类中的toString()方法
		return this.var.toString();
	}

	public T getVar() {					//返回值的类型由外部决定
		return var;
	}

	public void setVar(T var) {	//设置的类型由外部指定
		this.var = var;
	}
}

public class Generics_extends_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
				
		info<Integer> i = fun(30);						//传递整数到fun()方法
		System.out.println(i.getVar());

	}
		
	public static <T extends Number> info<T> fun (T param){	//fun返回的参数类型是info<T>
		info<T> temp = new info<T>();		//根据传入的数据类型实例化info对象
		temp.setVar(param);							//将传递的内容设置到info类中的var属性之中
		return 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
28
29
30
31
32
33
34
35
36
37
38
39
40
//class info<T extends Number>{	//在声明的地方指定泛型的上限范围
class info<T>{								//此处T可以是任意的标识符号，T是type的简称
	private T var;								//此变量的类型由外部决定
	
//	public info(T var) {					//构造方法
//		super();
//		this.var = var;
//	}
	
	public String toString(){			//覆写Object类中的toString()方法
		return this.var.toString();
	}

	public T getVar() {					//返回值的类型由外部决定
		return var;
	}

	public void setVar(T var) {	//设置的类型由外部指定
		this.var = var;
	}
}

public class Generics_extends_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
			
		info<String> i1 = new info<String>();		//设置String为泛型类型
		info<String> i2 = new info<String>();		//设置String为泛型类型
		i1.setVar("HELLO");									//设置内容
		i2.setVar("张三");										//设置内容
		add(i1,i2);
	}
		
	public static <T> void add(info<T> i1,info<T> i2){
		System.out.println(i1.getVar()+""+i2.getVar());
	}

}

 

泛型数组

程序从fun1()方法返回一个泛型数组，在fun1()方法接收参数时使用了可变参数传递方式，然后将fun1()返回的泛型数组内容交给fun2()方法进行输出。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class Generics_array_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		Integer i[] = fun1(1,2,3,4,5);				//返回泛型数组
		fun2(i);												//输出数组内容
	}
	
	public static <T> T[] fun1(T...arg){	//接收可变参数，返回泛型数组
		return arg;											//返回泛型数组
	}

	public static <T> void fun2(T param[]){
		System.out.println("接收泛型数组：");	//接收泛型数组
		for(T t:param){
			System.out.println(t+"、");
		}
		System.out.println();
	}
	
}

 

泛型应用

一个人有联系方式、基本信息等，这些信息的类型可以通过泛型进行声明，然后传给Person

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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
interface Generics_array_interface{		//定义一个标识接口，此接口没有定义任何方法
	
}

class Contact implements Generics_array_interface{		//实现Generics_array_interface接口

	private String address;				//联系地址
	private String telephone;				//联系方式
	private String zipcode;					//邮政编码
	
	public Contact(String address, String telephone, String zipcode) {	//构造方法
		super();
		this.address = address;
		this.telephone = telephone;
		this.zipcode = zipcode;
	}

	public String getAddress() {
		return address;
	}

	public void setAddress(String address) {
		this.address = address;
	}

	public String getTelephone() {
		return telephone;
	}

	public void setTelephone(String telephone) {
		this.telephone = telephone;
	}

	public String getZipcode() {
		return zipcode;
	}

	public void setZipcode(String zipcode) {
		this.zipcode = zipcode;
	}
	
	public String toString(){			//覆写Object类中的toString()方法
			return "联系方式："+"\n"+"联系电话："+this.telephone+"联系地址："+this.address+"邮政编码："+this.zipcode;
	}
	
	
}

class Introduction implements Generics_array_interface{
	private String name;
	private String sex;
	private int age;
	
	public Introduction(String name, String sex, int age) {	//构造方法
		super();
		this.name = name;
		this.sex = sex;
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getSex() {
		return sex;
	}
	public void setSex(String sex) {
		this.sex = sex;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	
	public String toString(){			//覆写Object类中的toString()方法
		return "基本信息："+"\n"+"姓名："+this.name+"性别："+this.sex+"年龄："+this.age;
	}
	
}

class Person_ <T extends Generics_array_interface>{
	private T info;

	public Person_(T info) {	//构造方法
		super();
		this.info = info;
	}

	public T getInfo() {
		return info;
	}

	public void setInfo(T info) {
		this.info = info;
	}

	@Override
	public String toString() {			//覆写Object类中的toString()方法
		return this.info.toString();
	}
	
}

public class Generics_array_demo {

	public static void main(String[] args) {
//		Integer i[] = fun1(1,2,3,4,5);				//返回泛型数组
//		fun2(i);												//输出数组内容
		
		Person_ <Contact> per = null;	//声明Person_对象，同时指定Contact类型
		per = new Person_<Contact>(new Contact("北京市","010010101010","100876"));//实例化Person_对象，同时设置信息
		System.out.println(per);
	}
	
//	public static <T> T[] fun1(T...arg){	//接收可变参数，返回泛型数组
//		return arg;											//返回泛型数组
//	}
//
//	public static <T> void fun2(T param[]){
//		System.out.println("接收泛型数组：");	//接收泛型数组
//		for(T t:param){
//			System.out.println(t+"、");
//		}
//		System.out.println();
//	}
	
}

 

tonglin0325

标签

标签云

AWS Airbnb Android CDH Doris ELK Flink Git Grafana HAProxy HBase Hadoop Hive Hudi InfluxDB JDBC JMeter JVM JavaSE JavaWeb LaTex Linkedin Linux ML ML Infra MPP Maven MySQL Nexus OpenTSDB Paper Play Prometheus Python React Redis RocksDB Scala Solr Spark SpringBoot SpringMVC Thrift YARN antlr arthas avro cassandra clickhouse confluent docker filebeat flume golang google gradle hexo impala jenkins k8s kafka kerberos kudu ldap mac mongo mybatis nginx nlp open-falcon parquet presto ranger scyllaDB twitter zookeeper 前端 图存储及计算 多线程 广告系统 开发工具 数据结构 杂谈 正则表达式 算法 系统设计 计算机网络 设计模式

文章归档

最近文章