Java基础入门笔记07——泛型类

package study1118;
						A	  T
//泛型类的定义 class 泛型名<类型> { }
//泛型类中所有类型都将会时新建泛型对象时，new的时候指定的那种类型
class A<T>{ 
   
    private T key;
    public void setKey(T key) { 
   
        this.key = key;
    }
    public T getKey(){ 
   
        return this.key;
    };
}

public class Test01 { 
   
    public static void main(String[] args) { 
   
        //新建一个泛型对象，指定泛型为String
        A<String> a1 = new A<>();
        a1.setKey("sadas");
        String s = a1.getKey();
        System.out.println(s);

        //新建一个泛型对象，指定泛型为Integer
        A<Integer> a3 = new A<>();
        a3.setKey(5);
        int i = a3.getKey();
        System.out.println(i);


        //新建一个泛型对象，若不定义泛型则默认泛型为Object
        A a2=new A();
        a2.setKey(new Object());
        Object key = a2.getKey();
        System.out.println(key);


        //同样的泛型类，在new对象时候，泛型指定不同的数据类型生成的泛型对象之间不能互相赋值
        //但进行赋值的类如果有泛型为Object的类则可以，涉及到自动转换类型
        
        a1=a3;//编译报错
        a3=a1;//编译报错
        a3=a2;//通过
    }
}

package study1118;

//泛型接口的定义
interface IB<T>{ 
   
    T test(T t);
    //接口中的方法默认都是抽象方法（没有方法体）
    //需要在实现类中进行重写
}

//实现接口IB的抽象方法时，如果未传入实参（此处的实参是某一种泛型），默认泛型为定义接口时所指定的类型
class B1<T> implements IB<T>{ 
   
    @Override
    public T test(T t) { 
   
        return t;
    }
}
//实现接口IB的抽象方法时，如果传入了指定泛型类型，则这个类实现接口的所有方法的参数都将指定为该泛型类型
class B2 implements IB<String>{ 
   
    @Override//重写方法的快捷键ctrl+O
    public String test(String s) { 
   
        return null;
    }
}

public class Test02 { 
   
    public static void main(String[] args) { 
   
//B1类和B2类用法上的区别

//新建B1类对象时候，需要指定泛型类型，若不指定会默认为Object类型，因为定义B1类时没有限制泛型，可以任意
    B1 objectB1 = new B1<Integer>();
    
//新建B2类对象时候，不需要指定泛型类型，因为定义B2类时已经限制了泛型（此处为String）
    B2 b2 = new B2();
    }
}

class C1{ 
   
// 定义泛型方法(无返回值的方法)
    public<T> void test(T s){ 
   
        T st = s ;
        
    }
// 定义泛型方法(有返回值，返回类型为T的方法) 
    public<T> T test1(T s){ 
   
        return s;
    }
    
    //有可变参数的方法
    public void test2(String... strs){ 
   
        for (String str : strs) { 
   
            System.out.println(str);
        }
    }
    //有可变参数的泛型方法
    public<T> void test3(T... strs){ 
   
        for (T str : strs) { 
   
            System.out.println(str);
        }
    }
}

class C2<E>{ 
   
    private E e;
    //在类上定义的泛型，可以在普通的方法中使用
    public <T> void test(T s){ 
   
        System.out.println(this.e);
    }
    //在类上定义的泛型,无法在静态方法中使用
    public static void test1(){ 
   
// System.out.println(this.e);//编译报错——因为无法从静态上下文中引用非静态 变量 this
    }
    
    // 静态方法如果要使用泛型,应该在定义静态方法时同时指明泛型
	public static<T> void test2(T t){ 
   
        System.out.println(t);

}

public class Test02 { 
   
    public static void main(String[] args) { 
   
        C2<Object> c = new C2<>();
        //泛型方法可以根据传入的参数数据类型来确定返回类型，意思就是数据类型是动态的，在调用方法时才会确定
        String s=c.test("xxx"); 
        Integer i=c.test(1);
        Boolean b=c.test(true);
        
    }
}

package study1118;
import java.util.ArrayList;
import java.util.List;

class Dd{ 
   
    public void meth(List<?> list){ 
    }
    //假设有一个方法meth（），需要一个list集合的参数，但是目前不确定list中存的数据到底是什么类型，所以可以用"?"表示任意泛型
   

public class Test03 { 
   
    public static void main(String[] args) { 
   
        Dd dd = new Dd();
    
    //新建一个list集合，往里面丢两个字符串对象
    List<String> l1 = new ArrayList<>();
    l1.add("asas");
    l1.add("qqqq");
    dd.meth(l1);//此时meth方法就接收到了一个装有String数据类型的集合l1

	//新建一个list集合，往里面丢两个数字类型的对象
    List<Integer> l2 = new ArrayList<>();
    l2.add(50);
    l2.add(3);
    dd.meth(l2);//此时meth方法就接收到了一个装有Integer数据类型的集合l2 
   		 }
	}
}