Java泛型应用

泛型类

package com.generic_class;


//对比不使用泛型
//class Generic{
//    private String val;
//
//    public void setVal(String val){
//        this.val =  val;
//    }
//    public String getVal(){
//        return val;
//    }
//}

/**
 * 自定义泛型类案例
 * @param <T>
 */
public class GenericDemo<T> { /*声明泛型类*/

    private T val; /*成员变量valde*/

    public void setVal(T val){
        this.val = val;
    }

//    public <T> T getVal(T val) { //返回值为泛型形参T的成员方法*//*
//        return val;
//    }
    public T getVal() { /*返回值为泛型形参T的成员方法*/
        return val;
    }

    public static void main(String[] args) {
        //创建泛型类对象时传入具体实际类型
        GenericDemo<String> demo = new GenericDemo<String>();
        //调用成员方法时，泛型形参自动转换为String类型
        demo.setVal("123");
        System.out.println(demo.getVal());
    }
}

泛型接口及其实现类

package com.generic_interface;

//接口1
public interface Addable<T> {//类型形参T
    public void add();
}

package com.generic_interface;

//接口2
public interface Getable<T> {
    public T get(int i);
}

/**
 * 类如何实现接口：
 * 类型形参
 * class 类名<类型形参列表> implements 接口名<类型形参列表>{}
 * 类型实参
 * class 类名<类型实参列表> implements 接口名<类型实参列表>{}
 */

package com.generic_interface;

//实现类1--单实现
public class ArrayUtil<T> implements Addable<T>{/*类型形参*/

    //实现泛型接口
    @Override
    public void add() {
        System.out.println("泛型接口的实现类");
    }
}

package com.generic_interface;

//实现类2--多实现
public class ArrayUtil2<T> implements Addable<T>,Getable<T> {
    @Override
    public void add() {
        System.out.println("多实现泛型接口add方法");
    }

    @Override
    public T get(int i) {
        System.out.println("多实现泛型接口get方法");
        return null;
    }
}

package com.generic_interface;

//实现类3--多泛型参数多实现
public class ArrayUtil3<T,S> implements Addable<T>,Getable<S>{
    @Override
    public S get(int i) {
        System.out.println("多实现多泛型接口get方法");
        return null;
    }

    @Override
    public void add() {
        System.out.println("多实现泛型接口add方法");
    }
}

package com.generic_interface;

//测试类
public class TestGenericInterface123 {
    public static void main(String[] args) {
    
        ArrayUtil<String> a1 = new ArrayUtil<String>();
        ArrayUtil2<Integer> a2 = new ArrayUtil2<Integer>();
        
        //类型形参列表，传递类型实参
        ArrayUtil3<Integer,String> a3 = new ArrayUtil3<Integer,String>();

        //省略类型实参时，默认是Object类型
        ArrayUtil3 a3_2 = new ArrayUtil3();

        System.out.println("泛型接口实现测试：实现类对象已经正常创建。");
    }
}

泛型方法

package com.generic_method;

class Demo{

    //使用泛型类型形参定义的方法
    public <T> T get(T arg){
        System.out.println("泛型方法");
        return arg;
    }
    
}

//测试类
public class GenericMethodTest {
    public static void main(String[] args) {
        Demo demo = new Demo();
        String getString = demo.get("泛型方法实参String");
        Integer integer = demo.get(123);
        System.out.println(getString);
        System.out.println(integer);
    }
}

泛型实验–礼品盒

package com.generic_wildcard;

//礼物类
public class Gift {
    protected String name = "礼物名称";
    public Gift(){
        System.out.println("礼物！");
    }
}

package com.generic_wildcard;

//生日礼物类--礼物类子类1
public class BirthdayGift extends Gift{
    public BirthdayGift(){
        this.name = "生日礼物!";
        System.out.println("生日礼物！");
    }
}

package com.generic_wildcard;

//情人节礼物类--礼物类子类2
public class LoverGift extends Gift {
    public LoverGift(){
        this.name = "情人礼物!";
        System.out.println("情人礼物!");
    }
}

package com.generic_wildcard;

//礼物盒Box类
public class Box <T extends Gift>{ /*实参传入T的是Gift或其子类类型，即限制了上限*/

    private T gift; 
    //公共方法--礼物盒
    public Box(T gift){
        this.gift = gift;
        System.out.println("礼物盒");
    }
}

package com.generic_wildcard;

//测试类
public class BoxUtil {

    /**
     * 通配符?代替一个乃至多个真正字符的特殊符号，
     * 代表任意类型，作为类型实参，实例化对象时使用
     */
    public void open(Box<?> x){
        System.out.println("打开"+ x +"盒"); //打印x对象
    }

    public static void main(String[] args) {

        //输出：“礼物！”
        System.out.println("父类构造方法输出：“礼物！”");
        Gift gift = new Gift();
        System.out.println();

        //输出：“礼物！”、“生日礼物！”
        System.out.println("父类构造方法输出：“礼物！”且子类构造方法输出：“生日礼物！”");
        BirthdayGift bg = new BirthdayGift();
        System.out.println();

        System.out.println("父类礼物：");
        Box<Gift> box = new Box<Gift>(gift);

        System.out.println("生日礼物：");
        Box<BirthdayGift> box2 = new Box<BirthdayGift>(bg);

        BoxUtil bop = new BoxUtil();
        System.out.println();

        bop.open(box);

        bop.open(box2);

    }
}

输出结果：

父类构造方法输出：“礼物！”
礼物！

父类构造方法输出：“礼物！”且子类构造方法输出：“生日礼物！”
礼物！
生日礼物!

父类礼物：
礼物盒。
生日礼物：
礼物盒。

打开com.generic_wildcard.Box@1b6d3586盒
打开com.generic_wildcard.Box@4554617c盒

来源：CSDN

作者：NAREN_BLOG

链接：https://blog.csdn.net/weixin_44780816/article/details/104414629