java泛型

泛型
没有引入时：
//没有泛型 时，Object 是所有类的父类,所以向上转型
class Generics
{
    private Object obj;
    public void setObj(Object obj)
    {
        this.obj = obj;
    }
    public Object getObj()
    {
        return this.obj;
    }
}

public class Hi
{
    public static void main(String[] args)
    {
        Generics gd = new Generics();
        gd.setObj(new Integer(5));
        Integer in = (Integer)gd.getObj();
        System.out.println("设置的数："+in);
        gd.setObj(new Float(1.23F));
        Float f = (Float)gd.getObj();
        System.out.println("设置的数："+f);
    }
}
/*
设置的数：5
设置的数：1.23
*/
如果向下转型则容易报错

泛型的创建
[public] class 类名 <泛型类型标识1[,泛型 类型标识2,...]>
{
    // 定义属性
    [访问控制符] 泛型类型标识     变量名;
    // 定义方法
    [访问控制符] 泛型类型标识    方法名(){};
    // 定义方法
    [访问控制符] 返回值类型    方法名(泛型类型标识   参数名){};
}
一般而言，类型的参数命名为单个大写字母,普通名称如下：
E--元素
K--键
N--数字
T--类型
V--值
S,U,V--第二，第三，第四个类型
// 声明泛型
class Generics<T>
{
    private T obj;
    public void setObj(T obj)
    {
        this.obj = obj;
    }
    public T getObj()
    {
        return obj;
    }
}

// 定义泛型对象
类名<泛型类型> 对象名 = new 类名<泛型类型>();
其中类型为引用类型，不可为基本数据类型

class Generics<T>
{
    private T obj;
    public void setObj(T obj)
    {
        this.obj = obj;
    }
    public T getObj()
    {
        return this.obj;
    }
}
public class Hi
{
    public static void main(String[] args)
    {
        // 只能是用引用的 Integer，不能用 int表示
        Generics<Integer> gd1 = new Generics<Integer>();
        gd1.setObj(new Integer(5)); // 同上转型
        Integer in = gd1.getObj();  // 向下转型
        System.out.println("设置的数为："+in);
        Generics<Float> gd2 = new Generics<Float>();
        gd2.setObj(new Float(1.23)); // 同上转型  
        Float f = gd2.getObj(); // 向下转型
        System.out.println("设置的数组为："+f);
    }
}
/*
设置的数为：5
设置的数组为：1.23
*/
泛型类的构造方法与普通的无什么不同
构造方法格式如下：
[访问控制符] 类名([泛型类型] 参数列表)
{
    // 构造方法语句
}
// 应用
class Generics<T>
{
    private T obj;
    public Generics(){}
    public Generics(T obj)
    {
        setObj(obj);
    }
    public void setObj(T obj)
    {
        this.obj = obj;
    }
    public T getObj()
    {
        return this.obj;
    }
}
public class Hi
{
    public static void main(String[] args)
    {
        Generics<Integer> gd = new Generics<Integer>(5);
        int in = gd.getObj();
        System.out.println(in);
    }
}

//定义泛型类时声明多个类型
class Generics<T,S>
{
    private T obj1;
    private S obj2;
    public Generics(){}
    public Generics(T obj1, S obj2)
    {
        setObj1(obj1);
        setObj2(obj2);
    }
    public void setObj1(T obj1)
    {
        this.obj1 = obj1;
    }
    public void setObj2(S obj2)
    {
        this.obj2 = obj2;
    }
    public T getObj1()
    {
        return this.obj1;
    }
    public S getObj2()
    {
        return this.obj2;
    }
    public void show()
    {
        System.out.println("姓名："+getObj1()+",年龄："+getObj2());
    }
}
public class Hi
{
    public static void main(String[] args)
    {
        Generics<String, Integer> gd = new Generics<String, Integer>("小二", 27);
        gd.show();
    }
}
//姓名：小二,年龄：27

// =========
//接收任意指定泛型时需要使用通配符
//无界通配符 "?"
class Generics<T,S>
{
    private T obj1;
    private S obj2;
    public Generics(){}
    public Generics(T obj1, S obj2)
    {
        setObj1(obj1);
        setObj2(obj2);
    }
    public void setObj1(T obj1)
    {
        this.obj1 = obj1;
    }
    public void setObj2(S obj2)
    {
        this.obj2 = obj2;
    }
    public T getObj1()
    {
        return this.obj1;
    }
    public S getObj2()
    {
        return this.obj2;
    }
    public void show()
    {
        System.out.println("姓名："+getObj1()+",年龄："+getObj2());
    }
    public String toString()
    {
        return "姓名："+getObj1()+",年龄："+getObj2();
    }
}
public class Hi
{
    public static void main(String[] args)
    {
        Generics<?,?> gd = new Generics<String, Integer>("小二", 27);
        gd.show();
        fun(gd);
    }
    public static void fun(Generics<?,?> t)
    {
        System.out.println("fun():"+t);
    }
}
/*
姓名：小二,年龄：27
fun():姓名：小二,年龄：27
*/

受限泛型
设置类型形参的上限
定义类
<泛型 类型 标识 extends 泛型类型1 & 泛型类型2 ....>
一个类型参数可以用多个限界类型。限界类之间用 "&"分隔开，在多个限界类型中，可以用多个接口，
但只能有一个类。如果类作为限界类型，则必须放在限界列表中的第一个。
// 设置通配符的上限
// 因为是 继承了 Number类，所以只能是数字
class Generics<T extends Number>
{
    private T obj;
    public void setObj(T obj)
    {
        this.obj = obj;
    }
    public T getObj()
    {
        return this.obj;
    }
    public void show(Generics<?> t)
    {
        System.out.println("show():"+getObj());
    }
}
public class Hi
{
    public static void main(String[] args)
    {
        Generics<Integer> gd1 = new Generics<Integer>();
        gd1.setObj(3);
        gd1.show(gd1);
        info(gd1);
        Generics<Double> gd2 = new Generics<Double>();
        gd2.setObj(1.234);
        gd2.show(gd2);
        info(gd2);
    }
    public static void info(Generics<? extends Number> t)
    {
        System.out.println("info():"+t.getObj());
    }
}
/*
show():3
info():3
show():1.234
info():1.234
*/
// =========
//还可以设置下限，使其只能是某种类型或该类型的父类，只需使用 super关键字
<? super 泛型类型>
class Generics<T>
{
    private T obj;
    public Generics(){}
    public Generics(T obj)
    {
        setObj(obj);
    }
    public void setObj(T obj)
    {
        this.obj = obj;
    }
    public T getObj()
    {
        return this.obj;
    }
    public String toString()
    {
        return getObj().toString();    
    }
}
public class Hi
{
    public static void main(String[] args)
    {
        Generics<Integer> p = new Generics<Integer>(21);
        info(p);
    }
    //可接收 Integer, Number, Object
    public static void info(Generics<? super Integer> t)
    {
        System.out.println("info():"+t);
    }
}
// =============
//泛型也可以作为父类或子类,同样也适用于继承
//以泛型 类为父类,当父类为泛型时，该类也必定是泛型
class Generics<T>
{
    private T obj;
    public Generics(){}
    public Generics(T obj)
    {
        setObj(obj);
    }
    public void setObj(T obj)
    {
        this.obj = obj;
    }
    public T getObj()
    {
        return this.obj;
    }
}
public class Hi<T> extends Generics<T>
{
    public Hi(){}
    public Hi(T obj)
    {
        super(obj);
    }
    public String toString()
    {
        return getObj().toString();
    }
    public static void main(String[] args)
    {
        Hi<String> p = new Hi<String>("小二");
        System.out.println("内容为："+p);
    }
}
// =============
// 子类自身的需求增加泛型类型
class Generics<T>
{
    private T obj;
    public Generics(){}
    public Generics(T obj)
    {
        setObj(obj);
    }
    public void setObj(T obj)
    {
        this.obj = obj;
    }
    public T getObj()
    {
        return this.obj;
    }
}
public class Hi<T,S> extends Generics<T>
{
    private S sub;
    public Hi(){}
    public Hi(T obj, S sub)
    {
        super(obj);
        setSub(sub);
    }
    public void setSub(S sub)
    {
        this.sub = sub;
    }
    public S getSub()
    {
        return this.sub;
    }
    public String toString()
    {
        return ("姓名："+getObj().toString()+",年龄："+getSub());
    }
    public static void main(String[] args)
    {
        Hi<String, Integer> p = new Hi<String, Integer>("小二", 27);
        System.out.println("对象内容："+p);
    }
}
// ==========
//以非泛型类为父类，这时不再需要传递参数给父类
class Generics{}
public class Hi<T> extends Generics
{
    private T obj;
    public Hi(){}
    public Hi(T obj)
    {
        setObj(obj);
    }
    public void setObj(T obj)
    {
        this.obj = obj;
    }
    public T getObj()
    {
        return this.obj;
    }
    public String toString()
    {
        return getObj().toString();
    }
    public static void main(String[] args)
    {
        Hi<String> p = new Hi<String>("小二");
        System.out.println("对象内容："+p);
    }
}
// =============
//泛型 接口,与泛型类差不多
[访问控制符] interface 接口名称 <泛型类型标识>
{
    // code
}

interface Hi<T>
{
    public T add();
}

// =========
interface InterGenerics<T>
{
    public T show();
}
class Generics<T> implements InterGenerics<T>
{
    private T obj;
    public Generics(){}
    public Generics(T obj)
    {
        setObj(obj);
    }
    public void setObj(T obj)
    {
        this.obj = obj;
    }
    public T getObj()
    {
        return this.obj;
    }
    public T show()
    {
        return getObj();
    }
}
public class Hi
{
    public static void main(String[] args)
    {
        Generics<Integer> g = new Generics<Integer>(5);
        System.out.println("对象内容："+g.show());
    }
}
//=============
子类在实现泛型接口时明确地给出泛型类型
interface InterGenerics<T>
{
    public T show();
}
class Generics implements InterGenerics<Integer>
{
    private Integer obj;
    public Generics(){}
    public Generics(Integer obj)
    {
        setObj(obj);
    }
    public void setObj(Integer obj)
    {
        this.obj = obj;
    }
    public Integer getObj()
    {
        return this.obj;
    }
    public Integer show()
    {
        return this.getObj();
    }
}
public class Hi
{
    public static void main(String[] args)
    {
        Generics g = new Generics(5);
        System.out.println(g.show());
    }
}
// -----------
//泛型方法
格式：
[访问控制符] [static|final] <泛型类型标识>返回值类型 方法名([<泛型类型参数>] [参数])
// ---------
class Generics
{
    public <T> T show(T t)
    {
        return t;
    }
    public static <T> T staticShow(T t)
    {
        return t;
    }
}
// ==========
使用泛型方法
格式1：
[对象名|类名.]方法名(实参列表);

格式2:
[对象名|类名.]<实际泛型类型>方法名(实参列表);
// ------------
class Generics
{
    public <T> T show(T t)
    {
        return t;
    }
    public static <T> T staticShow(String str, T t)
    {
        return t;
    }
}

public class Hi
{
    public static void main(String[] args)
    {
        Generics gen = new Generics();
        System.out.println("格式一:"+gen.show("小二"));
        System.out.println("格式1："+Generics.staticShow("小二", 27));
        
        System.out.println("格式2:"+gen.<String>show("小二"));
        System.out.println("格式3："+Generics.<Integer>staticShow("99", 98));
    }
}