泛型_笔记1

泛型编程让你编写完全一般化并可重复使用的算法，其效率与针对某特定数据类型而设计的算法相同。泛型即是指具有在多种数据类型上皆可操作的含意，与模板有些相似。

1. 第一个小列子
   有一个类A，其中有String类型的属性a1；有一个类B，其中有Integer类型的属性b1；现在我们要对这两个类的数据进行相关的操作。以往的方法，我们需要写两个类来完成相应的工作。（问题：代码冗余）
2. 第二个列子
   对于上面的问题，只写一个类，改进办法为将其中的属性用Object修饰，可以减少代码量。带来的新问题是，在对象引用的时候，可能需要进行强制转换，而某些情况下，强制转化是不可行的。（类不可转换的异常）
3. 泛型
   为了解决上面的问题，引入泛型。

//定义一个简单的泛型类
class Demo<T>{
    private T obj;
    public Demo(T obj) {
         this.obj=obj;
    }
    public T getObj() {
        return obj;
    }
    public void setObj(T obj) {
        this.obj = obj;
    }
    public void show(){
        System.out.println("该泛型类中属性值为:"+obj);
    }
}

                //简单的泛型类测试
        Demo<String> d1=new Demo<String>("haha");
        System.out.println(d1.getObj());
        Demo<Integer> d2=new Demo<Integer>(123);
        System.out.println( d2.getObj());

关于泛型类的几点：
1，泛型类可以被继承
2，泛型类可以被实现
3，泛型类的类型参数可以是泛型类
4，泛型类的类型参数可以不唯一
eg1：写一个新的泛型类，继承前面的泛型类

class Demo3<T,K> extends Demo<T>{
    private K var2;

    public Demo3(T var1, K var2) {
        super(var1);
        this.var2=var2;
    }
    public  T getT(){
        return super.getObj();
    }
    public K getK(){
        return var2;
    }
    //重写父类的show方法
    @Override
    public void show() {
        // TODO Auto-generated method stub
        super.show();
    }
}
//测试泛型类的继承
        Demo3<String, Integer> d4=new Demo3<String, Integer>("JENY", 33);
        System.out.println("姓名："+d4.getT()+"  年龄:"+d4.getK());

eg2：定义一个含有多个泛型参数的类

//含有两个参数的泛型类
class Demo2<T,K>{
    private T data1;
    private K data2;
    public Demo2(T data1, K data2) {
        // TODO Auto-generated constructor stub
        this.data1=data1;
        this.data2=data2;
    }
    public T getData1(){
        return data1;
    }
    public K getData2(){
        return data2;
    }
}
//测试泛型类的类型参数个数不唯一
        Demo2<String, Integer> d3=new Demo2<String, Integer>("Tom", 20);
        System.out.println("姓名："+d3.getData1()+"  年龄："+d3.getData2());

1. 泛型类的限定符：上边界限定符extends；下边界限定符super；

//定义3个类
class animal{
    public  void eat(){
        System.out.println("动物都吃东西");
    }
}
class Dog extends animal{
    @Override
    public void eat() {
        // TODO Auto-generated method stub
        System.out.println("狗啃骨头");
    }
}
class Cat extends animal{
    @Override
    public void eat() {
        // TODO Auto-generated method stub
        System.out.println("猫吃鱼儿");
    }
}
//定义泛型类
class demo<T extends animal>{
    private T obj;
    public demo(T obj) {
        this.obj=obj;
    }
    public void setObj(T obj) {
        this.obj = obj;
    }
    public T getObj() {
        return obj;
    }
}
``

//测试代码
demo<Dog> demo1=new demo<Dog>(new Dog());
demo1.getObj().eat();
demo<Cat> demo2=new demo<Cat>(new Cat());
demo2.getObj().eat();

            demo<Cat> demo3=demo2;
    demo3.getObj().eat();

// 泛型参数为Cat的泛型类引用可以指向同类型的对象，但是不能demo3=demo1，即是说泛型实列之间的不兼容;为此可以用通配符解决，？作为通配符代表任意类型
//上边界限定通配符 ？指向animal类或者其子类
demo<? extends animal> demo4=new demo<Dog>(new Dog());
demo4.getObj().eat();
//下边界限定通配符 ？指向Dog或者父类
demo<? super Dog> demo5=new demo<animal>(new animal());
demo5.getObj().eat();