Java学习-Day21（泛型）

泛型

使用传统方法出现的问题：

1. 不能对加入到集合ArrayList中的数据类型进行约束（不安全）
2. 遍历的时候，需要进行类型转换，如果集合中的数据量较大，对效率有影响

//使用传统的方法来解决===> 使用泛型
//老韩解读
//1. 当我们 ArrayList 表示存放到 ArrayList 集合中的元素是 Dog 类型 (细节后面说...)
//2. 如果编译器发现添加的类型， 不满足要求， 就会报错
//3. 在遍历的时候， 可以直接取出 Dog 类型而不是 Object
//4. public class ArrayList {} E 称为泛型,那么 Dog->E
ArrayList<Dog> arrayList = new ArrayList<Dog>();
arrayList.add(new Dog("旺财", 10));
arrayList.add(new Dog("发财", 1));
arrayList.add(new Dog("小黄", 5));
//假如我们的程序员， 不小心， 添加了一只猫
//arrayList.add(new Cat("招财猫", 8));报错
System.out.println("===使用泛型====");
for (Dog dog : arrayList) {
System.out.println(dog.getName() + "-" + dog.getAge());
}

泛型的好处：

1. 编译时，检查添加元素的类型，提高了安全性

2. 减少了类型转换的次数,提高效率[说明]

   √不使用泛型

   Dog -加入-> Object -取出-> Dog//放入到ArrayList 会先转成Object，在取出时，还需要转换成Dog

   √使用泛型

   Dog -> Dog -> Dog//放入时，和取出时，不需要类型转换，提高效率

3. 不再提示编译警告

泛型介绍：

int a = 10;
泛型 => Integer, String,Dog

1. 泛型又称参数化类型，是Jdk5.0出现的新特性,解决数据类型的安全性问题
2. 在类声明或实例化时只要指定好需要的具体的类型即可。
3. Java泛型可以保证如果程序在编译时没有发出警告，运行时就不会产生ClassCastException异常。同时,代码更加简洁、健壮
4. 泛型的作用是:可以在类声明时通过一个标识表示类中某个属性的类型，或者是某个方法的返回值的类型，或者是参数类型。

//注意， 特别强调： E 具体的数据类型在定义 Person 对象的时候指定,即在编译期间， 就确定 E 是什么类型
Person<String> person = new Person<String>("韩顺平教育");
person.show(); //String
/*
你可以这样理解， 上面的 Person 类
class Person {
String s ;//E 表示 s 的数据类型, 该数据类型在定义 Person 对象的时候指定,即在编译期间， 就确定 E
是什么类型
public Person(String s) {//E 也可以是参数类型
this.s = s;
} p
ublic String f() {//返回类型使用 E
return s;
}
}
*/

泛型的作用是： 可以在类声明时通过一个标识表示类中某个属性的类型，或者是某个方法的返回值的类型， 或者是参数类型

泛型的声明：

/*
interface 接口{ }
class 类 { }
说明
1、其中KTV不代表值，而是表示类型
2、任意字母都可以。常用T表示，是Type的缩写
*/

泛型的实例化：

要在类名后面指定类型参数的值，如

/*
1、List strList = new ArrayList()
2、Iterator itertor = costomers.iterator();
*/

泛型使用注意事项和细节：

1. interface List< T >{} , public class HashSet< E >{}等等说明: T,E只能是引用类型,不能是基本数据类型

   List< lnteger > list = new ArrayList<Integer>();//OK
   List<int> list2 = new ArrayList<int>();//错误
   

2. 在给泛型指定具体类型后，可以传入该类型或者其子类类型

3. 泛型使用形式

   List< lnteger > list1 = new ArrayList< Integer>();
   
   List< lnteger > list2 =new ArrayList<>();
   //实际开发时，右边的<>可以简写，只写左边就可以了，推荐这种写法
   

   3．如果我们这样写 List list3 = new ArrayList();默认给它的泛型是< E >，E就是Object

自定义泛型

自定义泛型类

基本语法：

class 类名{

​ 成员

}

注意细节：

1. 普通成员可以使用泛型（属性、方法）
2. 使用泛型的数组不能初始化
3. 静态方法中不能使用类的泛型
4. 泛型类的类型，是在创建对象时确定的（因为创建对象时需要指定确定类型
5. 如果在创建对象时，没有指定类型，默认为Object

public static void main(String[] args) {
//T=Double, R=String, M=Integer
Tiger<Double,String,Integer> g = new Tiger<>("john");
    
g.setT(10.9); //OK
//g.setT("yy"); //错误， 类型不对
    
System.out.println(g);
Tiger g2 = new Tiger("john~~");//OK T=Object R=Object M=Object
    
g2.setT("yy"); //OK ,因为 T=Object "yy"=String 是 Object 子类
System.out.println("g2=" + g2);
}
} 

//老韩解读
//1. Tiger 后面泛型， 所以我们把 Tiger 就称为自定义泛型类
//2, T, R, M 泛型的标识符, 一般是单个大写字母
//3. 泛型标识符可以有多个.
//4. 普通成员可以使用泛型 (属性、 方法)
//5. 使用泛型的数组， 不能初始化
//6. 静态方法中不能使用类的泛型
class Tiger<T, R, M> {
String name;
R r; //属性使用到泛型
M m;
T t;
//因为数组在 new 不能确定 T 的类型， 就无法在内存开空间
T[] ts;
public Tiger(String name) {
this.name = name;
}
    
public Tiger(R r, M m, T t) {//构造器使用泛型
this.r = r;
this.m = m;
this.t = t;
} 
    
public Tiger(String name, R r, M m, T t) {//构造器使用泛型
this.name = name;
this.r = r;
this.m = m;
this.t = t;
} 
//因为静态是和类相关的， 在类加载时， 对象还没有创建
//所以， 如果静态方法和静态属性使用了泛型， JVM 就无法完成初始化
// static R r2;
// public static void m1(M m) {
//
// }
    
//方法使用泛型
public String getName() {
return name;
} 
public void setName(String name) {
this.name = name;
} 
public R getR() {
return r;
} 
public void setR(R r) {//方法使用到泛型
this.r = r;
} 
public M getM() {//返回类型可以使用泛型.
return m;
} 
public void setM(M m) {
this.m = m;
} 
public T getT() {
return t;
} 
public void setT(T t) {
this.t = t;
} 

@Override
public String toString() {
return "Tiger{" +
"name='" + name + '\'' +
", r=" + r +
", m=" + m +
", t=" + t +
", ts=" + Arrays.toString(ts) +
'}';
}
    

自定义泛型接口

基本语法：

interface 接口名 {

}

注意细节：

1. 接口中， 静态成员也不能使用泛型（接口的成员都是用public static final修饰的）
2. 泛型接口的类型, 在继承接口或者实现接口时确定
3. 没有指定类型， 默认为 Object （即使不指定，也建议直接写上Object，而不是啥都不写）

/*
*
* 泛型接口使用的说明
* 1. 接口中， 静态成员也不能使用泛型
* 2. 泛型接口的类型, 在继承接口或者实现接口时确定
* 3. 没有指定类型， 默认为 Object
*/
//在继承接口 指定泛型接口的类型
interface IA extends IUsb<String, Double> {
} //
当我们去实现 IA 接口时， 因为 IA 在继承 IUsu 接口时， 指定了 U 为 String R 为 Double
//， 在实现 IUsu 接口的方法时， 使用 String 替换 U, 是 Double 替换 R
class AA implements IA {
@Override
public Double get(String s) {
return null;
} @
Override
public void hi(Double aDouble) {
} @
Override
public void run(Double r1, Double r2, String u1, String u2) {
}
} //
实现接口时， 直接指定泛型接口的类型
//给 U 指定 Integer 给 R 指定了 Float
//所以， 当我们实现 IUsb 方法时， 会使用 Integer 替换 U, 使用 Float 替换 R
class BB implements IUsb<Integer, Float> {
@Override
public Float get(Integer integer) {
return null;
} 
@Override
public void hi(Float aFloat) {
}
@Override
public void run(Float r1, Float r2, Integer u1, Integer u2) {
}
} 
//没有指定类型， 默认为 Object
//建议直接写成 IUsb
class CC implements IUsb { //等价 class CC implements IUsb {
@Override
public Object get(Object o) {
return null;
} 
@Override
public void hi(Object o) {
} 
@Override
public void run(Object r1, Object r2, Object u1, Object u2) {
}
} 
interface IUsb<U, R> {
int n = 10;
//U name; 不能这样使用
//普通方法中， 可以使用接口泛型
R get(U u);
void hi(R r);
void run(R r1, R r2, U u1, U u2);
//在 jdk8 中， 可以在接口中， 使用默认方法, 也是可以使用泛型
default R method(U u) {
return null;

自定义泛型方法

基本语法

修饰符 返回类型 方法名（参数列表）{

}

注意：

1. 泛型方法，可以定义在普通类中,也可以定义在泛型类中
2. 当泛型方法被调用时，类型会确定
3. public void eat(E e){},修饰符后没有eat方法不是泛型方法，而是使用了泛型

public static void main(String[] args) {
Car car = new Car();
car.fly("宝马", 100);//当调用方法时， 传入参数， 编译器， 就会确定类型
System.out.println("=======");
car.fly(300, 100.1);//当调用方法时， 传入参数， 编译器， 就会确定类型
//测试
//T->String, R-> ArrayList
Fish<String, ArrayList> fish = new Fish<>();
fish.hello(new ArrayList(), 11.3f);
}
} 
//泛型方法， 可以定义在普通类中, 也可以定义在泛型类中
class Car {//普通类
public void run() {//普通方法
}
//说明 泛型方法
//1.  就是泛型
//2. 是提供给 fly 使用的
public <T, R> void fly(T t, R r) {//泛型方法
System.out.println(t.getClass());//String
System.out.println(r.getClass());//Integer
}
} 
class Fish<T, R> {//泛型类
public void run() {//普通方法
}
public<U,M> void eat(U u, M m) {//泛型方法
} //
说明
//1. 下面 hi 方法不是泛型方法
//2. 是 hi 方法使用了类声明的 泛型
public void hi(T t) {
} 
//泛型方法， 可以使用类声明的泛型， 也可以使用自己声明泛型
public<K> void hello(R r, K k) {
System.out.println(r.getClass());//ArrayList
System.out.println(k.getClass());//Float
}

public static void main(String[] args) {
//T->String, R->Integer, M->Double
Apple<String, Integer, Double> apple = new Apple<>();
apple.fly(10);//10 会被自动装箱 Integer10, 输出 Integer
apple.fly(new Dog());//Dog
}
class Apple<T, R, M> {//自定义泛型类
public <E> void fly(E e) { //泛型方法
System.out.println(e.getClass().getSimpleName());
} 
//public void eat(U u) {}//错误， 因为 U 没有声明
public void run(M m) {
} //ok
} 
class Dog {
}

泛型的继承和通配符

1. 泛型不具备继承性

   List< Object > list = new ArrayList< String >()//错误，泛型没有继承性
   

2. : 支持任意泛型类型
3. : 支持A类以及A类的子类,规定了泛型的上限
4. : 支持A类以及A类的父类，不限于直接父类，规定了泛型的下限

Object o = new String("xx");
//泛型没有继承性
//List