黑马程序员——java 泛型学习笔记

 

java 泛型学习笔记

1、泛型——所谓泛型是指对象建立时不指定类中属性的具体类型，而由外部在声明及实例化对象时指定类型。

2、泛型可以解决数据类型的安全性问题，其主要原理是在类声明时通过一个标识表示类中某个属性的类型或者是某个方法的返回值及参数类型。

*声明泛型

class Point<T>
{
    private T var;            //此变量的类型由外部指定
    public T getVar()        //返回值的类型由外部指定
    {
        return var;
    }
    public void setVar(T var)    //设置的类型由外部指定
    {
        this.var = var;
    }
}

public class GenericsDemo05
{
    public static void main(String[] args)
    {
        Point<Integer> p = new Point<Integer>();  //var类型设置为Integer
        
        p.setVar(30);                                //设置数字，自动装箱
        System.out.println(p.getVar());
    }
}

2、设置多个泛型类型

如果一个类中有多个属性需要使用不同的泛型声明，可以在声明类时指定多个泛型类型。

class Notepad<K,V>        //指定两个泛型类型
{
    private K key;        //此变量的类型由外部决定
    private V value;    //此变量的类型由外部决定
    public K getKey()
    {
        return key;
    }
    public void setKey(K key)        //设置key
    {
        this.key = key;
    }
    public V getValue()
    {
        return value;
    }
    public void setValue(V value)        //设置value
    {    
        this.value = value;
    }
}

public class GenericsDemo
{
    public static void main(String[] args)
    {
        Notepad<String,Integer> t = null;        //定义两个泛型类型的对象
        t = new Notepad<String,Integer>();        //里面的key为String，value为Integer
    
        t.setKey("张三");
        t.setValue("30");
        System.out.print("姓名：" + t.getKey());
        System.out.print(",年龄：" + t.getValue());
    }
}

3、通配符

4、泛型的上下限

5、泛型接口

*范例：定义泛型接口

interface Info<T>
{
    public T getVar();
}

*泛型接口的两种实现方式

|——直接在子类后声明泛型

|——直接在子类实现的接口中明确地给出泛型类型

*在子类的定义上声明泛型类型

interface Info<T>
{
    public T getVar();
}
class InfoImpl<T> implements Info<T>
{
    private T var;
    public InfoImpl(T var)
    {
        this.setVar(var);
    }
    public void setVar(T var)
    {
        this.var = var;
    }
    public T getVar()
    {
        return this.var;
    }
}

public class GenericsDemo
{
    public static void main(String[] args)
    {
        Info<String> i = null;
        i = new InfoImple<String>("张三");
        System.out.println("内容： " + i.getVar());
    }
}

*在接口中指定具体类型

interface Info<T>
{
    public T getVar();
}
class InfoImpl implements Info<String>
{
    private String var;
    public InfoImpl(String var)
    {
        this.setVar(var);
    }
    public void setVar(String var)
    {
        this.var = var;
    }
    public String getVar()
    {
        return this.var;
    }
}

public class GenericsDemo
{
    public static void main(String[] args)
    {
        Info<String> i = null;
        i = new InfoImple("张三");
        System.out.println("内容： " + i.getVar());
    }
}

 6.泛型方法

*可以在类中定义泛型方法，所在的类可以是泛型类，也可以不是

class Demo
{
    public <T> T fun(T t)
    {
        return t
    }
}
public class GenericsDemo
{
    public static void main(String[] args)
    {
        Demo d = new Demo();
        String str = d.fun("张三");
        int i = d.fun(30);
        System.out.println(str);
        System.out.println(i);
    }
}

 7、总结

——泛型可以使程序的操作更加安全，可以避免类转换异常

——在程序中如果使用类时没有指定泛型，则泛型将被擦掉，将使用Object接收参数。

——可以使用通配符”？“接收全部的泛型类型对象

——通过<? extends 类>可以设置泛型的上限，通过<? super 类>可以设置泛型的下限

——泛型方法可以定义在泛型类中，也可以定义在普通类中

——泛型可以在接口中定义，实现泛型接口的子类要指明具体的泛型类型。

——泛型可以嵌套使用