自定义泛型

一、泛型类

1、当类里面有属性的类型不确定时，可以使用泛型。
2、一个类可以指定多个泛型
3、实列化后，指定了泛型的类型，那么后续使用这个实列就是确定的，类型需要匹配
4、泛型在任意时候，都不能与static使用，因为泛型实在创建对象时指定的，静态比对象进内存快。

定义格式：

修饰符 class 类名<代表泛型的变量> { }
在创建对象的时候确定泛型的类型
例如，ArrayList list = new ArrayList();

package generic;

import java.util.ArrayList;

/**
 * @author 15594
 */
public class User<T> {
   private int id ;
   private String name;
   private T t;

    public User() {
    }

    public User(int id, String name, T t) {
        this.id = id;
        this.name = name;
        this.t = t;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public T getT() {
        return t;
    }

    public void setT(T t) {
        this.t = t;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", t=" + t +
                '}';
    }
}

class  Test{
    public static void main(String[] args) {
        //如果定义了泛型，不指定泛，则默认为object。
        User user = new User(1,"lihua",new Object());

        System.out.println(user);
        User<String> user1 = new User<>(2,"xiaomin","你好");
        System.out.println(user1);

    }
}

/*
 * 1、继承泛型类——指明父类的类型，那么子类也就确定了
 * */
class User1 extends User<Integer>{
    User1(){
        super(1,"lihua",1);
        System.out.println(super.toString());
    }

}
class Test1{
    public static void main(String[] args) {
        User1 user1 = new User1();
        user1.toString();
    }
}

/*
 * 2、继承泛型类——不指明父类的类型
 * */
class User2<T> extends User<T>{
    private int id ;
    private String name;
    private T t;

    User2(){

    }
    User2(int id,String name,T t){
        this.id = id;
        this.name = name;
        this.t = t;
    }

    @Override
    public int getId() {
        return id;
    }

    @Override
    public void setId(int id) {
        this.id = id;
    }

    @Override
    public String getName() {
        return name;
    }

    @Override
    public void setName(String name) {
        this.name = name;
    }

    @Override
    public T getT() {
        return t;
    }

    @Override
    public void setT(T t) {
        this.t = t;
    }

    @Override
    public String toString() {
        return "User2{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", t=" + t +
                '}';
    }
}
class Test2{
    public static void main(String[] args) {
        User2<String> user2 = new User2<>(1,"lihua","1");
        System.out.println(user2);

    }
}

二、泛型方法

泛型方法可以声明为静态的，原因泛型方法实在调用方法时确定的，不是实列化时确定的

定义格式：

修饰符 <代表泛型的变量> 返回值类型 方法名(参数){ }

public class MyGenericMethod { 
	public <E> void show(E e) { 
		System.out.println(e.getClass()); 
	} 
	public <E> E show2(E e) { 
		return e; 
	}
}

调用方法时，确定泛型的类型

package generic;

import java.util.ArrayList;
import java.util.Arrays;

/**
 * @author 15594
 */
public class MethodGeneric {

    /**
    * 根据传入的参数类型返回参数
    * @param e 传入的泛型类型
    * @return 返回泛型类型
    * */
    public <E> E test(E e){
        return e;
    }

    public static  <E> ArrayList<E> test1(E e){
        ArrayList<E> list = new ArrayList<>();
        list.add(e);
        return list;
    }

    public static void main(String[] args) {

        MethodGeneric generic = new MethodGeneric();
        System.out.println(generic.test(1));

        ArrayList<String> strings = MethodGeneric.test1("111");
        System.out.println(strings.toString());
    }
}

三、泛型接口与泛型类差不多

定义格式：修饰符 interface接口名<代表泛型的变量> { }

public interface MyGenericInterface<E>{
	public abstract void add(E e);
	public abstract E getE(); 
}

定义类时确定泛型的类型

public class MyImp1 implements MyGenericInterface<String> {
	@Override
	public void add(String e) { // 省略... }
	@Override
	public String getE() { return null;}
}

四、参考

Java基础教程：Java泛型概述及应用（Java难点）