day29--Java泛型02

Java泛型02

5.自定义泛型

5.1自定义泛型类

基本语法：

class 类名<T,R...>{//…表示可以有多个泛型  成员}

注意细节：

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

例子：

// Tiger后面有泛型，所以我们把 Tiger称为自定义泛型类class Tiger<T,R,M>{// 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;    }    //因为静态是和类相关的，在来加载的时候，对象还没有创建    //所以如果静态方法和静态属性使用到泛型，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) +                '}';    }}

练习：说明自定义泛型代码是否正确，并说明原因

package li.generic.customgeneric;import java.util.Arrays;public class CustomGeneric_ {    public static void main(String[] args) {        //T=Double , R=String , M=Integer        Tiger<Double,String ,Integer> g = new Tiger<>("john");//ok        g.setT(10.9);//ok        // g.setT("yy");//错误，类型不对        System.out.println(g);        //这里没有指定泛型类型，全部默认为Object类型        //T=Object , R=Object , M=Object        Tiger g2 = new Tiger("join~~");        g2.setT("yy");//ok,因为T为Object类型，“yy”为String类型，是Object的子类        System.out.println("g2="+g2);    }}

5.2自定义泛型接口

基本语法：

interface 接口名<T,R...>{    }

注意细节：

1. 接口中，静态成员不能使用泛型（这个和泛型类的规定一样）
2. 泛型接口的类型，在继承接口或者实现接口时确定
3. 没有指定类型，就默认为Object类

例子：

package li.generic.customgeneric;public class CustomInterfaceGeneric {     public static void main(String[] args) {    }}interface IUsb<U,R>{    //U name; //这里的接口属性默认前面加上了static final，接口中，静态成员不能使用泛型        //普通方法中，可以使用接口泛型    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;    }}// 在继承接口时，指定泛型接口的类型interface IA extends IUsb<String,Double>{ }//当我们去实现IA接口时，因为IA在继承IUsb接口时，指定了U为String类型，R为 Double类型//因此，在实现IUsb方法的时候，使用String替换U，使用Double替换Rclass 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替换Rclass 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) {    }}//没有指定类型，则默认为Objectclass CC implements IUsb{//等价于 class CC implements IUsb<Object,Object>{    @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) {    }}

5.3自定义泛型方法

基本语法：

修饰符 <T,R...> 返回类型 方法名(参数列表){    }

注意细节：

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

例子：

package li.generic.customgeneric;import java.util.ArrayList;public class CustomMethodGeneric {    public static void main(String[] args) {        Car car = new Car();        car.fly("宝马", 100);//当调用方法时，传入参数，编译器就会确定类型        // class java.lang.String        //class java.lang.Integer        System.out.println("==========");        car.fly(300, 100.7);//当调用方法时，传入参数，编译器就会确定类型        //class java.lang.Integer        //class java.lang.Double  		System.out.println("==========");        //fish的T=String，R=ArrayList        Fish<String, ArrayList> fish = new Fish<>();        fish.hello(new ArrayList(),11.3f);        //class java.util.ArrayList        //class java.lang.Float    }}//泛型方法，可以定义在普通的类中，也可以定义在泛型类中class Car {//普通类    public void run() {//普通方法    }    //<T,R>就是泛型，是提供给fly方法使用的    public <T, R> void fly(T t, R r) {//泛型方法        System.out.println(t.getClass());        System.out.println(r.getClass());    }}class Fish<T, R> {//泛型类    public void run() {//普通方法    }    public <U, M> void eat(U u, M m) {//泛型方法    }    //说明：下面的hi方法不是泛型方法，因为修饰符后面没有表示符<T,R...>    //是hi方法使用了类声明的泛型    public void hi(T t) { }    //泛型方法可以使用类声明的泛型，也可以使用自己声明的泛型    public <K> void hello(R r,K k){//R是类声明的标识符，K则是方法自己声明的标识符        System.out.println(r.getClass());        System.out.println(k.getClass());    }}

5.4泛型方法练习

下面代码是否正确，如果有错误，修改正确，并说明输出什么？

package li.generic.customgeneric;public class CustomMethodGenericExercise {    public static void main(String[] args) {        Apple<String, Integer, Double> apple = new Apple<>();//ok        apple.fly(10);//ok 10会被自动装箱，输出Integer        apple.fly(new Dog());//ok 输出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) {    }}class Dog {}