java 基本语法之泛型

1. 为什么需要泛型?

1. 适应于不同数据类型执行相同的代码
2. 在编码时可以指定数据类型，而不需要强制类型转换，编译器就可以发现异常

2. 什么是泛型?

参数类型先不指定，传入时，才确定是什么数据类型

3. 泛型类型?

泛型类 泛型接口 泛型方法

泛型类: 可以有构造方法，不一定写成T,也可以换成别的K E V 之类的

public class CommonGeneric<T> {
    private T data;
     public CommonGeneric(T data) {
        this.data = data;
    }

  public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }

}

泛型接口

public interface ICommonGeneric<T> {
    void run();
}
1.可以是直接泛型实现
public class CommonGenericImpl<T> implements ICommonGeneric<T> {
    @Override
    public void run() {

    }
}

2. 可以是指定类型实现
public class CommonGenericImpl2 implements ICommonGeneric<String> {
    @Override
    public String run() {
        return null;
    }
}

泛型方法

使用泛型方法时，确定数据类型

public class CommonGenericMethod {

    public <T> T genericMethod(T ...a) {   //一定要打上<T> 才是泛型方法
        System.out.println(a);
        return a[a.length/2];
    }

    public void test(int x, int y) {
        System.out.println(x + y);
    }

    public static void main(String[] args) {
        CommonGenericMethod method = new CommonGenericMethod();
        method.test(100,101);
        System.out.println(method.<String>genericMethod("hello","word","gavin"));
        System.out.println(method.genericMethod("hello","word","gavin"));   //新版编辑器支持
       System.out.println(method.genericMethod(20,30,40,"hello word ","你好","你好"));//不建议这样混用
    }

}
------------------------------
201
word
word
hello word 
-----------------------------

泛型类或者泛型方法，都是允许有多个参数的

public class CommonGeneric<T,K> {
    private T data;

总结：

1. 不是定义在泛型类中的方法，就叫泛型方法，必须包含<T>
2. 普通类中，无法在方法中，声明泛型类型。‘

public class Test {
    public T t(T data) {   //报错
        return null;
    }
}

3. 泛型类的 泛型<T> 声明，只影响类中的普通方法。泛型类中的泛型方法，声明名字，是独立与类的。

public class CommonGenericMethod2 {
    static class Animal {
        @Override
        public String toString() {
            return "I am just a Animal";
        }
    }

    static class Dog extends Animal {
        @Override
        public String toString() {
            return "I am a Dog";
        }
    }

    static class Plant {
        @Override
        public String toString() {
            return "I am a plant";
        }
    }

    static class GenericModel<T> {
        public void getName_1(T t) {  //注意类声明中的<T> 仅影响 这个类的普通方法
            System.out.println(t);
        }

        //<E> <T> 都是泛型声明，跟类声明的<T> 可以理解为完全独立，仅仅是名称重复
        public <E> void getName_2(E t) {
            System.out.println(t);
        }

        //<E> <T> 都是泛型声明，跟类声明的<T> 可以理解为完全独立，仅仅是名称重复
        public <T> void getName_3(T t) {
            System.out.println(t);
        }

        public static void main(String[] args) {
            Dog dog = new Dog();
            Plant plant = new Plant();

            GenericModel<Animal> genericModel = new GenericModel<>();
            genericModel.getName_1(dog);
//            genericModel.getName_1(plant);   普通方法，无法直接用别的类型

            genericModel.getName_2(dog);
            genericModel.getName_2(plant);  //泛型方法<E> 声明

            genericModel.getName_3(dog);    //泛型方法<T> 声明 与类声明的<T> 仅仅是名称重复
            genericModel.getName_3(plant);

//            GenericModel<Object> genericMode2 = new GenericModel<>();
//            genericMode2.getName_1(dog);
//            genericMode2.getName_1(plant);
//            genericMode2.getName_2(dog);
//            genericMode2.getName_2(plant);
//            genericMode2.getName_3(dog);
//            genericMode2.getName_3(plant);

        }

    }
}

4.关于限定类型变量

泛型可以用来限制 类或者方法的使用类型

public class GenericTest<T extends Test> {
    public static <T extends Comparable> T min(int a, int b) {
        return null;
    }
}

5.泛型的使用限制

1. 不允许实例化 泛型变量
2. 静态域或者普通方法里不能引用类型变量 （静态方法 本身是泛型方法 除外）

public class Constraint<T> {
    private T data;
    public Constraint(T data) {
    // this.data = new T();  不允许实例化
    }
    //public static T intance;  静态域或者普通方法里不能引用类型变量
    //静态方法 本身是泛型方法 可以使用
    private static <T> T getInstance() {
        return null;
    }
}

6 .通配符类型

？ extends X 表示类型的上界，类型参数是X的子类
？ super X 表示类型的下界，类型参数是X的超类