泛型:
本质即“参数化类型”。一提到参数,最熟悉的就是定义方法时有形参,然后调用此方法时传递实参。
那么参数化类型怎么理解呢?顾名思义,就是将类型由原来的具体的类型参数化,类似于方法中的变量参数,
此时类型也定义成参数形式(可以称之为类型形参),然后在使用/调用时传入具体的类型(类型实参)。
这种参数类型可以用在类、方法和接口中,分别被称为泛型类、泛指方法、泛指接口。
泛型定义格式:
- <类型>:指定一种类型的格式。这里的类型可以看成是形参
- <类型1,类型2…>:指定多类型的格式,多种类型之间用逗号隔开。这里的类型可以看成是形参
- 将来具体调用时候给定的类型可以看成是实参,并且实参的类型只能是引用数据类型
泛型的好处:
- 泛型好处一:使用泛型,把运行期间才出现的问题提前到编译期出现
- 泛型好处二:使用泛型,程序就不需要再添加强制转换
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
/*
泛型的两个好处
*/
public class GenericDemo {
public static void main(String[] args) {
//创建集合对象
// Collection c = new ArrayList();
Collection<String> c = new ArrayList<String>(); //泛型好处一:使用泛型,把运行期间才出现的问题提前到编译期出现(下面c.add(100)c.add(100)报错)
//添加元素
c.add("hello");
c.add("world");
c.add("javaee");
// c.add(100);
//遍历元素
// Iterator it = c.iterator();
Iterator<String> it = c.iterator();
while(it.hasNext()){
// Object obj = it.next();
// System.out.println(obj);
// String s = (String)it.next(); //ClassCastException
//泛型好处二:使用泛型,程序就不需要再添加强制转换
String s = it.next(); //ClassCastException
System.out.println(s);
}
}
}
泛型类的定义格式:
- 格式:修饰符 class 类名<类型> { }
- 范例:public class Generic { }
注:此处T可以随便写为任意标识,常见的如T、E、K、V等形式的参数常用于表示泛型
public class Student {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
public class Teacher {
private int age;
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
public class Generic<T> {
private T t;
public T getT() {
return t;
}
public void setT(T t) {
this.t = t;
}
}
/*
测试类
*/
public class GenericDemo {
public static void main(String[] args) {
//创建一个学生对象
Student s1 = new Student();
s1.setName("张彤彤");
System.out.println(s1.getName());
//创建一个老师对象
Teacher t1 = new Teacher();
t1.setAge(26);
// t1.setAge("26");
System.out.println(t1.getAge());
System.out.println("---------------------");
Generic<String> g1 = new Generic<String>();
s1.setName("杜美美");
System.out.println(s1.getName());
Generic<Integer> g2 = new Generic<>();
t1.setAge(26);
System.out.println(t1.getAge());
System.out.println("---------------------");
Generic<Boolean> g3 = new Generic<>();
g3.setT(true);
System.out.println(g3.getT());
}
}
泛型方法的定义格式:
- 泛型方法的定义格式:
- 格式:修饰符<类型> 返回值类型方法名(类型 变量名){ }
- 范例:public void show(T t){ }
注:此处T可以随便写为任意标识,常见的如T、E、K、V等形式的参数常用于表示泛型
/*
public class Generic {
public void show(String s){
System.out.println(s);
}
public void show(Integer i){
System.out.println(i);
}
public void show(Boolean b){
System.out.println(b);
}
}
*/
/*
//泛型类改进
public class Generic<T>{
public void show(T s){
System.out.println(s);
}
}
*/
//泛型方法改进
public class Generic<T>{
public <T> void show(T t){
System.out.println(t);
}
}
/*
测试类
*/
public class GenericDemo {
public static void main(String[] args) {
// Generic g = new Generic();
// g.show("张彤彤");
// g.show(23);
// g.show(true);
g.show(12.34);
// Generic<String> g1 = new Generic<String>();
// g1.show("张彤彤");
//
// Generic<Integer> g2 = new Generic<>();
// g2.show(23);
//
// Generic<Boolean> g3 = new Generic<Boolean>();
// g3.show(true);
Generic g = new Generic();
g.show("谢婷婷");
g.show(26);
g.show(true);
}
}
泛型接口的定义格式:
- 格式:修饰符 interface 类名<类型> { }
- 范例:public interface Generic {}
注:此处T可以随便写为任意标识,常见的如T、E、K、V等形式的参数常用于表示泛型
/*
接口
*/
public interface Generic<T> { //接口不能直接实例化,需要给一个实现类
void show(T t);
}
/*
实现类
*/
public class GenericImpl<T> implements Generic<T> {
@Override
public void show(T t) {
System.out.println(t);
}
}
/*
测试类
*/
public class GenericDemo {
public static void main(String[] args) {
GenericImpl<String> g1 = new GenericImpl<>();
g1.show("张彤彤");
GenericImpl<Integer> g2 = new GenericImpl<>();
g2.show(23);
}
}