泛型【小白学Java-学习笔记19】

1.定义和使用含有泛型的类

package generic.demo1;

/**
 * 定义一个含有泛型的类，泛型是一个未知的数据类型，当我们不确定什么数据类型的时候，我们可以使用泛型
 * 泛型可以接收任意的数据类型，如Integer,String,Student
 * 创建对象的的时候确定泛型的数据类型
 * @param <E>
 */
public class Demo01Generic <E>{
    private E game;

    public E getGame() {
        return game;
    }

    public void setGame(E game) {
        this.game = game;
    }
}

package generic.demo1;

public class Demo02GenericClass {
    public static void main(String[] args) {
        //Demo01Generic类不写泛型，则默认是Object类型
        Demo01Generic gc = new Demo01Generic();
        gc.setGame("so angry ");
        //创建Demo01Generic对象，泛型使用Integer类型
        Demo01Generic<Integer> gc2 = new Demo01Generic<>();
        gc2.setGame(1);
        Integer game = gc2.getGame();
        System.out.println(game);

        //创建Demo01Generic对象，泛型使用String类型
        Demo01Generic<String> gc3 = new Demo01Generic<>();
        gc3.setGame("lobster");
        String game1 = gc3.getGame();
        System.out.println(game1);
    }
}

运行结果

2.定义和使用含有泛型的方法

含有泛型的方法的定义格式如下

修饰符<泛型> 返回值类型 方法名(参数列表(使用泛型)){
	//方法体
}

注意：含有泛型的方法在调用的时候确定泛型的数据类型。传递什么类型的参数，泛型就是什么类型

package generic.demo1;

/**
 * 含有泛型的方法
 * 含有泛型的方法的定义格式如下
 * 修饰符<泛型> 返回值类型 方法名(参数列表(使用泛型)){
 * 	//方法体
 * }
 * 注意：含有泛型的方法在调用的时候确定泛型的数据类型。传递什么类型的参数，泛型就是什么类型
 */
public class GenericMethod {
    //定义一个含有泛型的方法
    public <M> void method(M m){
        System.out.println(m);
    }
    //定义一个含有泛型的静态方法
    public static <S> void method1(S s){
        System.out.println(s);
    }
}

package generic.demo1;

/**
 * 测试含有泛型的方法
 */
public class Demo03GenericMethod {
    public static void main(String[] args) {
        //创建一个GenericMethod对象
        GenericMethod gc = new GenericMethod();
        //调用含有泛型的方法，传递什么类型，泛型就是什么类型
        gc.method(10);
        gc.method("abc");
        gc.method(8.8);
        gc.method(true);
        System.out.println("========");
        gc.method1("静态方法，不建议通过创建对象使用，可以用更好的方法");
        //静态方法可以怎么调用？
        //类名.静态方法名(参数)
        GenericMethod.method1("这是一个含有泛型的静态方法");
        GenericMethod.method1(1);
        GenericMethod.method1(8.8);
        GenericMethod.method1(true);
    }
}

运行结果

3.定义和使用含有泛型的接口

案例说明

package generic.demo1;

/**
 * 定义一个有泛型的接口
 */
public interface GenericInterface<I> {
    public abstract void method(I i);
}

package generic.demo1;
/*
GenericInterface接口的实现类1
 */
public class GenericInterfaceImpl1 implements GenericInterface<String>{
    //重写接口的抽象方法
    @Override
    public void method(String s) {
        System.out.println(s);
    }


}

package generic.demo1;

/**
 * 含有泛型的接口的实现类2
 */
public class GenericInterfaceImpl2<I> implements GenericInterface<I> {
    @Override
    public void method(I i) {
        System.out.println(i);
    }
}

package generic.demo1;

/**
 * 测试含有泛型的接口
 */
public class Demo04GenericInterface {
    public static void main(String[] args) {

        //创建GenericInterfaceImpl1对象
        GenericInterfaceImpl1 gci1 = new GenericInterfaceImpl1();
        gci1.method("字符串");
        //创建GenericInterfaceImpl2对象
        GenericInterfaceImpl2<Integer> gci2 = new GenericInterfaceImpl2<>();
        gci2.method(10);
        GenericInterfaceImpl2<Double> gci3 = new GenericInterfaceImpl2<>();
        gci3.method(8.8);



    }
}

运行结果