泛型简介，泛型类及使用

如果我们需要产生多个对象，每个对象的逻辑完全一样，只是对象内的成员变量的类型不同。那么我们该如何去做？

①   创建多个类文件，给每个类中的成员变量设置指定的数据类型;

public class Demo1{
    public static void main(String []args){
        MyClass1 myclass1=new MyClass1("张三");
        System.out.println(myclass1.getData());
        MyClass2 myclass2=new MyClass2(10);
        System.out.println(myclass2.getData());
    }
}

class MyClass1{
    private String data;
    public MyClass1(String data){
        this.data=data;
    }
    
    public void setData(String data){
        this.data=data;
    }
    public String getData(){
        return data;
    }
}

class MyClass2{
    private int data;
    public MyClass2(int data){
        this.data=data;
    }
    
    public void setData(int data){
        this.data=data;
    }
    public int getData(){
        return data;
    }
}

缺点：这种方式会导致类的膨胀，重用性太差;

①   创建一个类文件，给这个类中的成员变量设置Object数据类型;

public class Demo11{
    public static void main(String []args){
        MyClass myClass1=new MyClass("张三");
        System.out.println((String)myClass1.getData());
        MyClass myClass2=new MyClass(10);
        System.out.println((Integer)myClass2.getData());
        //以上可以执行
        //但int类型不能装换为String类型
        System.out.println((String)myClass2.getData());
    }
}

class MyClass{
    private Object data;
    public MyClass(Object data){
        this.data=data;
    }
    
    public void setData(Object data){
        this.data=data;
    }
    public Object getData(){
        return data;
    }
}

缺点：编译时正常，但运行时可能会异常;

 

泛型类就能解决以上两个问题;

泛型简介

①   泛型是JDK4.5引入的新特性，也是最重要的一个特性;

②   泛型可以再编译的时候检查类型安全，并且所有的强制转换都是自动和隐式的;

③   泛型的原理就是“类型的参数化”，即把类型看作参数。也就是说把所要操作的数据类型看作参数，就像方法的形式参数是运行时传递的值的占位符一样;

④   简单的说，类型变量扮演的角色就如同一个参数，它提供给编译器用来类型检查的信息;

⑤   泛型可以提高代码的扩展性和重用性;

总结：所谓泛型，即通过参数化类型来实现在同一份代码上操作多种数据类型，泛型编程是一种编程范式，它利用“参数化类型”将类型抽象化，从而实现更为灵活的复用;

泛型类示例：

public class GenClass <T>{
    private T obj;
    public GenClass(T obj){
    this.obj=obj;
}
public T getObj(){
    return obj;
}
public void setObj(T obj){
    this.obj=obj;
}
}

T代表类型，比如Integer，String

用泛型类解决以上问题

public class GenericDemo1{
    public static void main(String []args){
        //创建一个泛型类对象
        GenClass<String> gen1=new GenClass<String>("张三");
        System.out.println(gen1.getData());
        GenClass<Integer> gen2=new GenClass<Integer>(10);
        System.out.println(gen2.getData());
        //使用了泛型之后再做强制类型转换编译无法通过
        //System.out.println((String)gen2.getData());
    }
}

//创建一个泛型类
class GenClass<T>{
    private T data;
    public GenClass(T data){
        this.data=data;
    }
    
    public void setData(T data){
        this.data=data;
    }
    public T getData(){
        return data;
    }
}

泛型的用法

① 泛型的参数类型可以使泛型类;

public class GenericDemo1{
    public static void main(String []args){
        //一个泛型类作为另一个泛型类的参数
        GenClass<GenClass<Student>> gen1=new GenClass<GenClass<Student>>();
        GenClass<Student> gen2=new GenClass<Student>();
        gen2.setData(new Student("张三"));
        gen1.setData(gen2);
        
        System.out.println(gen1.getData().getData());
    }
}

//创建一个泛型类
class GenClass<T>{
    private T data;
    public GenClass(){
        
    }
    public GenClass(T data){
        this.data=data;
    }
    
    public void setData(T data){
        this.data=data;
    }
    public T getData(){
        return data;
    }
}

class Student{
    private String name;
    public Student(String name){
        this.name=name;
    }
    public String toString(){
        return "我是："+name;
    }
}

② 泛型类可以同时设置多个类型参数;

public class GenericDemo1{
    public static void main(String []args){
        //带2个参数的泛型
        GenClass2<String,Integer> gen1=new GenClass2<String,Integer>("张三",20);
        System.out.println(gen1.getData1());
        System.out.println(gen1.getData2());
    }
}

class GenClass2<T1,T2>{
    private T1 data1;
    private T2 data2;
    public GenClass2(T1 data1,T2 data2){
        this.data1=data1;
        this.data2=data2;
    }
    public T1 getData1(){
        return data1;
    }
    public T2 getData2(){
        return data2;
    }
}

③ 泛型类可以继承泛型类;

public class GenericDemo2{
    public static void main(String []args){
        //一个泛型类继承另一个泛型类
        SubClass<String,Integer> sub=new SubClass<String,Integer>("张三",20);
        System.out.println(sub.show1());
    }
}

class SuperClass<T1>{
    private T1 var1;
    public SuperClass(T1 var1){
        this.var1=var1;
    }
    
    public T1 show1(){
        return var1;
    }
}

class SubClass<T1,T2> extends SuperClass<T1>{
    private T2 var2;
    public SubClass(T1 var1,T2 var2){
        super(var1);
        this.var2=var2;
    }
    //重写父类的方法
    public T1 show1(){
        return super.show1();
    }
}

④泛型类可以实现泛型接口;

public class GenericDemo2{
    public static void main(String []args){
        //一个泛型类继承另一个泛型类
        SubClass<String,Integer> sub=new SubClass<String,Integer>("张三",20);
        System.out.println(sub.show1());
        //实现接口的方法
        sub.show2(100);
    }
}

class SuperClass<T1>{
    private T1 var1;
    public SuperClass(T1 var1){
        this.var1=var1;
    }
    
    public T1 show1(){
        return var1;
    }
}

interface IInfo<T2>{
    public void show2(T2 var3);
}

class SubClass<T1,T2> extends SuperClass<T1> implements IInfo<T2>{
    private T2 var2;
    public SubClass(T1 var1,T2 var2){
        super(var1);
        this.var2=var2;
    }
    //重写父类的方法
    public T1 show1(){
        return super.show1();
    }
    //实现接口的方法
    public void show2(T2 var3){
        System.out.println(var3);
        System.out.println(var2);
        //虽然都是Integer类型，但泛型会先将其转为Object类型，所以不能相加
        //System.out.println(var2+var3);
    }
}