首页 > 其他分享 >泛型

泛型

时间:2024-05-13 23:20:39浏览次数:20  
标签:String void public Override 泛型 class

1 泛型在类上的引用

【案例1】创建类MyData,使用<>就有了泛型

public class MyData<T> {
    private T data;

    public T getData() {
        return data;
    }

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

【案例2】使用泛型

public class TestOne {
    public static void main(String[] args) {
        // 在创建支持泛型的类的对象时给出泛型的具体类型
        // 支持泛型的类在不给出泛型具体类型时,泛型被当做Object
        // 引用类型的泛型必须和对象类型的泛型一致,泛型不支持多态

        // 方式一 — 不推荐
        // MyData<String> myData = new MyData<String>();

        // 方式二 — 不推荐
        // MyData<String> myData = new MyData();

        // 方式三 — 推荐使用
        MyData<String> myData = new MyData<>();
        myData.setData("Tom");
        System.out.println(myData.getData());

    }
}

【案例3】

// 1. 方式一
// 在子类继承父类时给出父类的泛型具体类型(这里是String)
public class SubMyData extends MyData<String> {
    @Override
    public String getData() {
        return super.getData();
    }

    @Override
    public void setData(String data) {
        super.setData(data);
    }

// 方式二
// 子类继承父类的泛型,子类也做成泛型的类
public class SubMyData<T> extends MyData<T> {
    
    @Override
    public T getData() {
        return super.getData();
    }

    @Override
    public void setData(T data) {
        super.setData(data);
    }
}

 

2 泛型在接口上的使用

【案例1】

public interface MyInterOne<T> {
    //1.静态成员不支持泛型
    // public static final T data;    ×

    //2.泛型在方法上的使用
    //2.1 返回值是泛型
    public T methodOne();
    //2.2 参数是泛型
    public void methodTwo(T t);
    //2.3 返回值、参数都是泛型
    public T methodThree(T t);
}

【案例2】推荐方式三

// 1.接口的泛型需要在实现类实现接口时确定泛型的具体类型
// 如果实现类没有确定泛型的具体的类型则视作Object
public class MyInterOneImpl implements MyInterOne {
    @Override
    public Object methodOne() {
        return null;
    }

    @Override
    public void methodTwo(Object o) {

    }

    @Override
    public Object methodThree(Object o) {
        return null;
    }




// 2. 实现类实现泛型时给出泛型的具体类型
 public class MyInterOneImpl implements MyInterOne<String> {
    @Override
    public String methodOne() {
        return null;
    }

    @Override
    public void methodTwo(String s) {

    }

    @Override
    public String methodThree(String s) {
        return null;
    }



// 3.实现类实现接口时继承接口的泛型
public class MyInterOneImpl<T> implements MyInterOne<T> {

    @Override
    public T methodOne() {
        return null;
    }

    @Override
    public void methodTwo(T t) {

    }

    @Override
    public T methodThree(T t) {
        return null;
    }
}

【案例3】

public class TestTwo {
    public static void main(String[] args) {
        // 创建接口实现类对象时给出泛型的具体类型
        MyInterOne<String> myInterOne = new MyInterOneImpl<>();
    }
}

 

3 类型通配符

public class TestThree {
    public static void main(String[] args) {
        Collection<String> col1 = new ArrayList<>();
        col1.add("Tom");
        col1.add("Jerry");
        col1.add("Mary");
        
        Collection<Integer> col2 = new ArrayList<>();
        col2.add(10);
        col2.add(20);
        col2.add(30);
        
        methodOne(col1);
        methodTwo(col1);
        methodOne(col2);
        // methodTwo(col2);
        methodThree(col1);
        methodThree(col2);

        Collection<Animal> col3 = new ArrayList<>();
        Collection<Dog> col4 = new ArrayList<>();
        Collection<Cat> col5 = new ArrayList<>();

        methodThree(col3);
        methodFour(col3);
        methodFour(col4);
        methodFour(col5);
        methodFive(col3);
        // methodFive(col4);
        methodFive(col5);
    }

    public static void methodOne(Collection col){
        for (Object o : col) {
            System.out.println(o);
        }
    }

    public static void methodTwo(Collection<String> col){
        for (String s : col) {
            System.out.println(s);
        }
    }

    // ?是泛型形参的通配类型,这种类型可以匹配任何支持泛型的实参
    public static void methodThree(Collection<?> col){
        for (Object o : col) {
            System.out.println(o);
        }
    }

    // 这种方式指定了泛型通配的父类,可以包含父类及父类的子类类型,相当于指定了泛型的上限
    public static void methodFour(Collection<? extends Animal> col){
        for (Animal animal : col) {
            System.out.println(animal);
        }
    }

    // 这种方式指定了通配类型必须是Cat或者Cat的父类对象,相当于指定了泛型的下限
    public static void methodFive(Collection<? super Cat> col){
        for (Object o : col) {
            System.out.println(o);
        }
    }
}

class Animal{}
class Dog extends Animal{}
class Cat extends Animal{}

 

4 泛型的集合

【案例】

public class TestFour {
    public static void main(String[] args) {
        // 泛型的集合
        List<String> list = new ArrayList<>();
        list.add("Tom");
        String s = list.get(0);

        // 迭代器可以指定泛型,但是迭代器的泛型必须和集合的泛型一致
        Iterator<String> iter = list.iterator();

        Map<String, Student> map = new HashMap<>();
        // Map可以单独指定键和值的泛型,键集泛型必须和键泛型一致,值集泛型必须和值泛型一致
        Set<String> keys = map.keySet();
        Collection<Student> values = map.values();
    }
}

 

标签:String,void,public,Override,泛型,class
From: https://www.cnblogs.com/apple677/p/16060966.html

相关文章

  • C/C++ 泛型 -- 继承与多态
    【1】继承与多态-- 多态在模板中的应用#include<iostream>usingnamespacestd;namespace_nmsp1{//多态//人类classHuman{public:virtualvoideat(){cout<<"人类以吃米饭和面食为主!"<<endl;......
  • go 1.18 泛型
     引用:https://segmentfault.com/a/1190000041634906Go1.18泛型全面讲解:一篇讲清泛型的全部WonderfulSoap 2022-03-31阅读 24 分钟English229 序2022年3月15日,争议非常大但同时也备受期待的泛型终于伴随着Go1.18发布了。可是因为Go对泛型的支......
  • dubbo 泛型调用示例 (dubbo generic call)
     1.背景泛型调用适用于观察者模式,即有很多广泛的消费者,但生产者又不想依赖消费者的client包,比如常见的API开放平台的回调机制; 2.泛型调用要实现泛型调用,几个核心点:泛型入参如何构建泛型服务service如何构建泛型调用结果如何拿到 2.1泛型入参 泛型入参须是Ha......
  • rust trait 关联类型和泛型的区别
    关联类型和泛型虽然在某些方面看起来相似,但它们在Rust中扮演着不同的角色,有着本质的区别。下面我会详细解释关联类型、泛型以及它们在Iteratortrait上的应用,以帮助理解为什么Iteratortrait使用关联类型而非泛型参数来定义。关联类型关联类型是trait的一部分,它允许trait......
  • dotnet 泛型委托 ACTION FUNC
    voidMain(){//泛型委托ACTIONFUNC//3.创建委托实例TestDele<string>testDele=newTestDele<string>(HellowDele);testDele("测试委托");//官方版本的泛型委托(不带返回值)Action<string>action=newAction<string>(HellowDele);......
  • dotnet的Lambda表达式 委托泛型(2) Action Func
    //总结://泛型:把类,方法,属性,字段做到了通用化//反射:操作dll文件的一个帮助类库//特性:就是一个特殊的类自定义标记属性特性他就是AOP的另一种实现方式验证属性//委托:就是多播委托,可以保存一个或者多个方法的信息。可以用来传递方法(把方法当作参数传递)。主要用来实现代码的解......
  • 泛型dotnet
    //什么是泛型List<T>T:表示类型参数,指代任意类型T可以是任意标识//编写代码时使用特殊符号替代位置类型,在实例化或使用/调用时才会进行具体类型的定义//特点:重用代码,保护类型安全性,提高性能//泛型集合<k,v>Dictionary<int,string>directory=newDiction......
  • 面向对象编程和`GP`泛型编程
    面向对象编程和GP泛型编程c++标准库标准库并不是用面向对象的概念设计出来的面向对象的概念关键点:class与class的继承关系虚函数->抽象class或者接口面向对象库复杂的点在于继承关系很复杂OOP(Object-Orientedprogramming)关键概念:class的数据放在类里面......
  • HarmonyOS 项目中泛型的使用
    泛型(Generics)概述泛型是一种编程语言特性,它支持类型参数化,使得定义的类、接口和方法可以适用于多种类型,而不仅仅是固定的一种类型。理解泛型泛型允许在定义接口时,让参数的类型更加灵活,从而使得功能更加强大。简而言之,泛型提供了一种方式,让代码能够适应不同的数据类型,而不需要为......
  • mORMot2 获取数据集(泛型)
    mORMot2获取数据集(泛型)第14章使用泛型现代Delphi版本的一个特点是能够使用泛型。varaMale:TSQLBaby;BeginaMale:=TSQLBaby.CreateAndFillPrepare(Client,'NameLIKE?ANDSex=?',['A\%',ord(sMale)]);trywhileaMale.FillOnedoDoSomethingWith(aM......