java学习笔记--泛型类，泛型接口,泛型方法

泛型

泛型就是 参数化类型，即把一个具体的类型参数化，被参数化的变量被称为类型（形参/实参），在方法中被定义是形参，在使用/调用的时候是类型实参

泛型是为了在不创建新的数据类型的情况下，来控制形参的类型。

import java.util.ArrayList;
import java.util.List;

public class fanxingts {
    public static void main(String[] args){
        //创建一个Arraylist
        List arry = new ArrayList();
        arry.add("传入一个字符串");
        arry.add(1234);//传入一个integer类型
        //用String类型来使用Array
        String item = (String)arry.get(0);
        String interg = (String)arry.get(1);//系统会报错，因为不能将Arraylist中的integer类型转换成String来传入数据

    }
}

我们就可以通过泛型来在编译阶段就找出这个问题

import java.util.ArrayList;
        import java.util.List;

public class fanxingts {
    public static void main(String[] args){
        //让Arraylist参数化，只传入String
        List <String>arry = new ArrayList();
        arry.add("传入一个字符串");
        arry.add(1234);//这时传入一个integer类型时会报错
    }
}

泛型的三种用法：泛型类、泛型接口、泛型方法

泛型类

使用泛型能将一个类定义成一个容器，在外部实例化的时候赋予容器不同的形式

public class fanxingts {
    public static void main(String[] args){
        container<String> ct = new container<String>("一个String的泛型类");
        container<Integer> ctin = new container<Integer>(123);//一个Integer类型的泛型类
    }
}

class container <L>{
    //用泛型构建参数
    public L data;
    //使用泛型来构建构造器
    container(L data){
        this.data = data;
    }
    //泛型方法
    public T getdata(){
        return data;
    }
}

泛型接口

泛型接口的定义与泛型类大致相同，不过在泛型接口被实现的类调用的时候有两种不同的情况

实现泛型接口的类不传入实参时

interface fxinterface<C>{
     C show();
}
class instantiate<C> implements fxinterface<C>{
    C show(){
        return null;
    }
}

当实现泛型接口的类传入实参时

interface fxinterface<C>{
     C show();
}
class instantiate implements fxinterface<String>{
    C show(){
        return null;
    }
}

泛型方法

调用泛型类，并且将泛型类的对象传入给泛型方法中

public class fanxingts {
    class Generic<T> {
        private T data;

     //定义一个普通方法,虽然用了T泛型但是还是普通方法
    Generic(T data) {
        this.data = data;
    }

    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }

}

//定义一个泛型方法，来调用这个泛型类
//同时给这个泛型方法定义两个泛型，一个用来存储调用泛型类的泛型，一个用来规定方法的泛型
<T> T showdata(Generic<T> Gc) {
        System.out.println(Gc.getData());
        T test = Gc.getData();
        return test;
        }
public static void main(String[] args){
        fanxingts.Generic<String> gen = new fanxingts().new Generic<String>("实例化泛型类");
        new fanxingts().<String>showdata(gen);//，调用泛型方法的时候传入泛型类对象
        System.out.println();
        }
}