泛型類的概述和使用--泛型方法的概述和使用---泛型介面的概述和使用---泛型高級（通配符）

泛型类：把泛型定义在类上

package Day16;
//泛型类：把泛型定义在类上
public class ObjectDemo<T> {
    //把泛型定义在类上---调用时只能调用和添加本类型的数据
    private  T obj;

    public void setObj(T obj) {
        this.obj = obj;
    }

    public T getObj() {
        return obj;
    }
}

package cn.itcast_04;

/*
 * 泛型类的测试
 */
public class ObjectToolDemo {
    public static void main(String[] args) {
        // ObjectTool ot = new ObjectTool();
        //
        // ot.setObj(new String("风清扬"));
        // String s = (String) ot.getObj();
        // System.out.println("姓名是：" + s);
        //
        // ot.setObj(new Integer(30));
        // Integer i = (Integer) ot.getObj();
        // System.out.println("年龄是：" + i);

        // ot.setObj(new String("林青霞"));
        // // ClassCastException
        // Integer ii = (Integer) ot.getObj();
        // System.out.println("姓名是：" + ii);

        System.out.println("-------------");

        ObjectTool<String> ot = new ObjectTool<String>();
        // ot.setObj(new Integer(27)); //这个时候编译期间就过不去
        ot.setObj(new String("林青霞"));
        String s = ot.getObj();
        System.out.println("姓名是：" + s);

        ObjectTool<Integer> ot2 = new ObjectTool<Integer>();
        // ot2.setObj(new String("风清扬"));//这个时候编译期间就过不去
        ot2.setObj(new Integer(27));
        Integer i = ot2.getObj();
        System.out.println("年龄是：" + i);
    }
}

 泛型类：泛型定义在方法上

格式：public <泛型类>  返回值类型 方法名（泛型类 变量名）

package Day16;
//泛型类：把泛型定义在类上
//public class ObjectDemo<T> {
//    //把泛型定义在类上---调用时只能调用和添加本类型的数据
//    private  T obj;
//
//    public void setObj(T obj) {
//        this.obj = obj;
//    }
//
//    public T getObj() {
//        return obj;
//    }
//}
//泛型定义在方法上
public class ObjectDemo{
    //定义方法
    public<T> void show(T s){
        System.out.println(s);
    }


}

package Day16;

public class Lx8 {
    public static void main(String[] args) {
        //对ObjectDemo类创建
        ObjectDemo A = new ObjectDemo();

      //调用方法
        A.show("赵同刚");
        A.show(25);
        A.show("有钱");
        A.show(true);

    }
}

 泛型接口的概述和使用

一：定义泛型接口

package Day16;
//接口的定义格式：[修饰符] interface 接口名 [extends 父接口名列表]
//泛型接口--把泛型定义在接口上
public interface JK<T> {
    //定义一个抽象方法
    //实现类必须重写此方法
    public abstract void show(T f);
}

 二：实现类实现接口（分两种情况）

package Day16;
//接口的实现类
//实现类在实现接口的时候
////第一种情况：已经知道该是什么类型的了
//实现类的书写格式  [修饰符] class <类名> [extends 父类名] [implements 接口列表]
//public class SX implements JK<String> {
//    //在实现类中重写接口中的抽象方法
//    public void  show(String B){
//        System.out.println(B);
//    }
//}
//第二种情况：实现类在实现接口的时候还不知道是什么类型
public class SX<T> implements JK<T>{
    //实现类必须重写接口中的抽象方法
    public void  show(T e){
        System.out.println(e);
    }
}

 三：测试类

package Day16;

public class Lx9 {
    public static void main(String[] args) {
        //对接口实现类创建对象
        SX AA = new SX();
        //调用接口实现类当中的方法
        AA.show(true);
    }
}

 泛型高级（通配符）

* 泛型高级(通配符)
     * ?:任意类型，如果没有明确，那么就是Object以及任意的Java类了
     * ? extends E:向下限定，E及其子类
     * ? super E:向上限定，E极其父类

package cn.itcast_07;

import java.util.ArrayList;
import java.util.Collection;

/*
     * 泛型高级(通配符)
     * ?:任意类型，如果没有明确，那么就是Object以及任意的Java类了
     * ? extends E:向下限定，E及其子类
     * ? super E:向上限定，E极其父类
 */
public class GenericDemo {
    public static void main(String[] args) {
        // 泛型如果明确的写的时候，前后必须一致
        Collection<Object> c1 = new ArrayList<Object>();
        // Collection<Object> c2 = new ArrayList<Animal>();
        // Collection<Object> c3 = new ArrayList<Dog>();
        // Collection<Object> c4 = new ArrayList<Cat>();

        // ?表示任意的类型都是可以的
        Collection<?> c5 = new ArrayList<Object>();
        Collection<?> c6 = new ArrayList<Animal>();
        Collection<?> c7 = new ArrayList<Dog>();
        Collection<?> c8 = new ArrayList<Cat>();

        // ? extends E:向下限定，E及其子类
        // Collection<? extends Animal> c9 = new ArrayList<Object>();
        Collection<? extends Animal> c10 = new ArrayList<Animal>();
        Collection<? extends Animal> c11 = new ArrayList<Dog>();
        Collection<? extends Animal> c12 = new ArrayList<Cat>();

        // ? super E:向上限定，E极其父类
        Collection<? super Animal> c13 = new ArrayList<Object>();
        Collection<? super Animal> c14 = new ArrayList<Animal>();
        // Collection<? super Animal> c15 = new ArrayList<Dog>();
        // Collection<? super Animal> c16 = new ArrayList<Cat>();
    }
}

class Animal {
}

class Dog extends Animal {
}

class Cat extends Animal {
}