草庐IT

day29--Java泛型02

liyuelian 2023-04-16 原文

Java泛型02

5.自定义泛型

5.1自定义泛型类

基本语法：

class 类名<T,R...>{//…表示可以有多个泛型
  成员
}

注意细节：

  1. 普通成员可以使用泛型（属性、方法）
  2. 使用泛型的数组不能初始化
  3. 静态方法中不能使用类的泛型
  4. 泛型类的类型，是在创建类的对象时确定的（因为创建对象时，需要指定确定类型）
  5. 如果在创建对象时没有指定类型，默认为Object

例子：

// Tiger后面有泛型，所以我们把 Tiger称为自定义泛型类
class Tiger<T,R,M>{// T,R,M是泛型的标识符，一般是单个的大写字母；泛型的标识符可以有多个
    String name;
    R r;  // 普通成员可以使用泛型（属性、方法），这里是属性使用泛型
    M m;
    T t;

    // 使用泛型的数组不能初始化,因为数组在new的时候不能确定T的类型，就无法在内存开辟空间
    T[] ts ;

    public Tiger(String name) {
        this.name = name;
    }

    public Tiger(R r, M m, T t) {// 构造器使用泛型
        this.r = r;
        this.m = m;
        this.t = t;
    }

    //因为静态是和类相关的，在来加载的时候，对象还没有创建
    //所以如果静态方法和静态属性使用到泛型，JVM就无法完成初始化
    //因此静态方法和静态属性不能使用泛型
//    static R r2;
//    public static void m1(M m){
//
//    }

    public String getName() {
        return name;
    }

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

    public R getR() {
        return r;
    }

    public void setR(R r) { // 方法使用泛型
        this.r = r;
    }

    public M getM() {  // 返回类型 使用泛型
        return m;
    }

    public void setM(M m) {
        this.m = m;
    }

    public T getT() {
        return t;
    }

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

    @Override
    public String toString() {
        return "Tiger{" +
                "name='" + name + '\'' +
                ", r=" + r +
                ", m=" + m +
                ", t=" + t +
                ", ts=" + Arrays.toString(ts) +
                '}';
    }
}

练习：说明自定义泛型代码是否正确，并说明原因

package li.generic.customgeneric;

import java.util.Arrays;

public class CustomGeneric_ {
    public static void main(String[] args) {

        //T=Double , R=String , M=Integer
        Tiger<Double,String ,Integer> g = new Tiger<>("john");//ok
        g.setT(10.9);//ok
        // g.setT("yy");//错误，类型不对
        System.out.println(g);

        //这里没有指定泛型类型，全部默认为Object类型
        //T=Object , R=Object , M=Object
        Tiger g2 = new Tiger("join~~");
        g2.setT("yy");//ok,因为T为Object类型，“yy”为String类型，是Object的子类
        System.out.println("g2="+g2);

    }
}

5.2自定义泛型接口

基本语法：

interface 接口名<T,R...>{
    
}

注意细节：

  1. 接口中，静态成员不能使用泛型（这个和泛型类的规定一样）
  2. 泛型接口的类型，在继承接口或者实现接口时确定
  3. 没有指定类型，就默认为Object类

例子：

package li.generic.customgeneric;

public class CustomInterfaceGeneric {
     public static void main(String[] args) {

    }
}

interface IUsb<U,R>{
    //U name; //这里的接口属性默认前面加上了static final，接口中，静态成员不能使用泛型
    
    //普通方法中，可以使用接口泛型
    R get(U u);

    void hi(R r);

    void run(R r1,R r2,U u1,U u2);

    //在jdk8中，可以在接口中使用默认方法,也是可以使用泛型的
    default R method(U u){
        return null;
    }
}

// 在继承接口时，指定泛型接口的类型
interface IA extends IUsb<String,Double>{ }

//当我们去实现IA接口时，因为IA在继承IUsb接口时，指定了U为String类型，R为 Double类型
//因此，在实现IUsb方法的时候，使用String替换U，使用Double替换R
class AA implements IA{

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

    @Override
    public void hi(Double aDouble) {

    }

    @Override
    public void run(Double r1, Double r2, String u1, String u2) {

    }
}

//实现接口时，直接指定泛型接口的类型
//给U指定了Integer，给R指定了Float
//所以当我们实现IUsb方法时，会使用Integer替换U，使用Float替换R
class BB implements IUsb<Integer,Float>{

    @Override
    public Float get(Integer integer) {
        return null;
    }

    @Override
    public void hi(Float aFloat) {

    }

    @Override
    public void run(Float r1, Float r2, Integer u1, Integer u2) {

    }
}

//没有指定类型，则默认为Object
class CC implements IUsb{//等价于 class CC implements IUsb<Object,Object>{

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

    @Override
    public void hi(Object o) {

    }

    @Override
    public void run(Object r1, Object r2, Object u1, Object u2) {

    }
}

5.3自定义泛型方法

基本语法：

修饰符 <T,R...> 返回类型 方法名(参数列表){
    
}

注意细节：

  1. 泛型方法，可以定义在普通类中，也可以定义在泛型类中
  2. 当泛型方法被调用时，类型会确定
  3. public void eat(E e){},修饰符后面没有<T,R...> 则eat方法不是泛型方法，只是使用了泛型

例子：

package li.generic.customgeneric;

import java.util.ArrayList;

public class CustomMethodGeneric {
    public static void main(String[] args) {
        Car car = new Car();
        car.fly("宝马", 100);//当调用方法时，传入参数，编译器就会确定类型
        // class java.lang.String
        //class java.lang.Integer
        System.out.println("==========");
        car.fly(300, 100.7);//当调用方法时，传入参数，编译器就会确定类型
        //class java.lang.Integer
        //class java.lang.Double

  		System.out.println("==========");
        //fish的T=String，R=ArrayList
        Fish<String, ArrayList> fish = new Fish<>();
        fish.hello(new ArrayList(),11.3f);
        //class java.util.ArrayList
        //class java.lang.Float
    }
}

//泛型方法，可以定义在普通的类中，也可以定义在泛型类中

class Car {//普通类

    public void run() {//普通方法
    }

    //<T,R>就是泛型，是提供给fly方法使用的
    public <T, R> void fly(T t, R r) {//泛型方法
        System.out.println(t.getClass());
        System.out.println(r.getClass());
    }
}

class Fish<T, R> {//泛型类

    public void run() {//普通方法
    }

    public <U, M> void eat(U u, M m) {//泛型方法
    }

    //说明：下面的hi方法不是泛型方法，因为修饰符后面没有表示符<T,R...>
    //是hi方法使用了类声明的泛型
    public void hi(T t) { }

    //泛型方法可以使用类声明的泛型，也可以使用自己声明的泛型
    public <K> void hello(R r,K k){//R是类声明的标识符，K则是方法自己声明的标识符
        System.out.println(r.getClass());
        System.out.println(k.getClass());
    }
}

5.4泛型方法练习

下面代码是否正确，如果有错误，修改正确，并说明输出什么？

package li.generic.customgeneric;

public class CustomMethodGenericExercise {
    public static void main(String[] args) {
        Apple<String, Integer, Double> apple = new Apple<>();//ok
        apple.fly(10);//ok 10会被自动装箱，输出Integer
        apple.fly(new Dog());//ok 输出Dog
    }
}

class Apple<T, R, M> {
    public <E> void fly(E e) {//泛型方法
        System.out.println(e.getClass().getSimpleName());
    }

  //  public void eat(U u) {}//错误，因为U没有声明

    public void run(M m) {
    }
}

class Dog {
}

6.泛型继承和通配

泛型的继承和通配符说明：

  1. 泛型不具备继承性

    List list = new ArrayList(); //错误

  2. <?> ：支持任意泛型类型

  3. <? extends A>：支持A类以及A类的子类，规定了泛型的上限

  4. <? super A>：支持A类以及A类的父类，不限于直接父类，规定了泛型的下限

例子：

package li.generic;

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

public class GenericExtends {
    public static void main(String[] args) {
        Object o = new String("xx");//正确，类有继承关系
        // List<Object> list = new ArrayList<String>(); //错误，泛型不具备继承性

        //举例说明下面三个方法的使用
        List<Object> list1 = new ArrayList<>();
        List<String> list2 = new ArrayList<>();
        List<AA> list3 = new ArrayList<>();
        List<BB> list4 = new ArrayList<>();
        List<CC> list5 = new ArrayList<>();

        // List<?> c 可以接受任意的泛型类型
        printCollection1(list1);
        printCollection1(list2);
        printCollection1(list3);
        printCollection1(list4);
        printCollection1(list5);

        // ? extends AA 表示上限，可以接受AA或者AA的子类，不限于直接子类
        // printCollection2(list1);//错误，list1是Object类型
        // printCollection2(list2);//错误，list2是String类型
        printCollection2(list3);//正确，AA
        printCollection2(list4);//正确，BB继承了AA类
        printCollection2(list5);//正确，CC继承了BB类

        //? super AA:表示可以接受AA类以及AA的父类，不限于直接父类
        printCollection3(list1);//正确，Object类是所有类的父类
        // printCollection3(list2);//错误，String类非AA类的父类
        printCollection3(list3);//正确，AA
        //printCollection3(list4);//错误，BB类非AA的父类
        //printCollection3(list5);//错误，CC类非AA类的父类


    }

    //编写几个方法
    //List<?> 表示任意的泛型类型都可以接收
    public static void printCollection1(List<?> c) {
        for (Object object : c) {//通配符，取出时就是Object
            System.out.println(object);
        }
    }

    //? extends AA ：表示上限，可以接受AA或者AA的子类，不限于直接子类
    public static void printCollection2(List<? extends AA> c) {
        for (Object object : c) {
            System.out.println(object);
        }
    }

    //? super AA ：支持AA类以及AA类的父类，不限于直接父类
    //规定了泛型的下限
    public static void printCollection3(List<? super AA> c) {
        for (Object object : c) {
            System.out.println(object);
        }
    }
}

class AA { }

class BB extends AA { }

class CC extends BB { }

7.泛型练习

7.1编程题 HomeWork01

定义一个泛型类DAO，在其中定义一个Map成员变量，Map的键为String类型，值为T类型。

分别创建以下方法：

  1. public void save（String id，T entity）：保存T类型的对象到Map成员变量中
  2. public T get（String id）：从map中 获取id对应的对象
  3. public void update（String id，T entity）：替换map中key为id的内容，改为entity对象
  4. public List list（）：返回map中存放的所有T对象
  5. public void delete（String id）：删除指定id对象

定义一个User类：该类包含：private成员变量（int类型）id，age；（String类型）name

创建DAO类的对象，分别调用其save、get、update、list、delete方法来操作User对象，使用Junit单元测试类进行测试。

为什么需要JUnit：

一个类很多功能代码需要测试，为了测试就需要将测试代码写到main方法中

如果有多个功能代码测试，就需要来回注释，切换很麻烦

如果可以直接运行一个方法，就方便许多，并且可以给出相关信息

JUnit是一个Java语言的单元测试框架

多数 Java的开发环境都已经集成了JUnit作为单元测试的工具

在测试方法前面加上@Test ，按Alt+Enter，弹出提示框，选择Add 'JUnit5.4' to classpath

练习：

package li.generic.junit;

import java.util.*;

public class JUnit_ {
    public static void main(String[] args) {
        //这里给T指定的类型是User
        DAO<User> userDAO = new DAO<>();

        userDAO.save("001", new User(1, 23, "Jack"));
        userDAO.save("002", new User(2, 32, "John"));
        userDAO.save("003", new User(3, 19, "King"));
        userDAO.save("004", new User(4, 55, "Poly"));

        System.out.println("====调用get方法====");
        System.out.println(userDAO.get("004"));
        System.out.println(userDAO.get("002"));

        System.out.println("====调用update方法====");
        User user = new User(2, 999, "孙悟空");
        userDAO.update("002", user);
        System.out.println(userDAO.get("002"));

        System.out.println("====调用list方法====");
        for (User user1:userDAO.list()) {
            System.out.println(user1);
        }

        System.out.println("====调用delete方法====");
        userDAO.delete("001");
        for (User user1:userDAO.list()) {
            System.out.println(user1);
        }

    }
}

class DAO<T> {
    private Map<String, T> map = new HashMap<>();

    public void save(String id, T entity) {//保存T类型的对象到Map成员变量中
        map.put(id, entity);
    }

    public T get(String id) {//从map中 获取id对应的对象
        return map.get(id);
    }

    public void update(String id, T entity) {//替换map中key为id的内容，改为entity对象
        map.put(id, entity);
    }

    //遍历map[K-V],将map的所有的values(即entity)封装到一个ArrayList中，再返回即可
    public List<T> list() {//返回map中存放的所有T对象
        List<T> list = new ArrayList<>();
        Set<String> set = map.keySet();
        for (Object key: set) {
            list.add(map.get(key));//也可以使用本类的get(String id)方法
        }
        return  list;

    }

    public void delete(String id) {//删除指定id对象
        map.remove(id);
    }

}

class User {
    private int id;
    private int age;
    private String name;

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

    public int getId() {
        return id;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

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

有关day29--Java泛型02的更多相关文章

  1. java - 等价于 Java 中的 Ruby Hash - 2

    我真的很习惯使用Ruby编写以下代码:my_hash={}my_hash['test']=1Java中对应的数据结构是什么？ 最佳答案 HashMapmap=newHashMap();map.put("test",1);我假设？ 关于java-等价于Java中的RubyHash，我们在StackOverflow上找到一个类似的问题： https://stackoverflow.com/questions/22737685/

  2. java - 从 JRuby 调用 Java 类的问题 - 2

    我正在尝试使用boilerpipe来自JRuby。我看过guide从JRuby调用Java，并成功地将它与另一个Java包一起使用，但无法弄清楚为什么同样的东西不能用于boilerpipe。我正在尝试基本上从JRuby中执行与此Java等效的操作:URLurl=newURL("http://www.example.com/some-location/index.html");Stringtext=ArticleExtractor.INSTANCE.getText(url);在JRuby中试过这个:require'java'url=java.net.URL.new("http://www

  3. java - 我的模型类或其他类中应该有逻辑吗 - 2

    我只想对我一直在思考的这个问题有其他意见，例如我有classuser_controller和classuserclassUserattr_accessor:name,:usernameendclassUserController//dosomethingaboutanythingaboutusersend问题是我的User类中是否应该有逻辑user=User.newuser.do_something(user1)oritshouldbeuser_controller=UserController.newuser_controller.do_something(user1,user2)我

  4. java - 什么相当于 ruby​​ 的 rack 或 python 的 Java wsgi？ - 2

    什么是ruby​​的rack或python的Java的wsgi？还有一个路由库。 最佳答案 来自Python标准PEP333:Bycontrast,althoughJavahasjustasmanywebapplicationframeworksavailable,Java's"servlet"APImakesitpossibleforapplicationswrittenwithanyJavawebapplicationframeworktoruninanywebserverthatsupportstheservletAPI.ht

  5. Observability：从零开始创建 Java 微服务并监控它 （二） - 2

    这篇文章是继上一篇文章“Observability：从零开始创建Java微服务并监控它（一）”的续篇。在上一篇文章中，我们讲述了如何创建一个Javaweb应用，并使用Filebeat来收集应用所生成的日志。在今天的文章中，我来详述如何收集应用的指标，使用APM来监控应用并监督web服务的在线情况。源码可以在地址 https://github.com/liu-xiao-guo/java_observability 进行下载。摄入指标指标被视为可以随时更改的时间点值。当前请求的数量可以改变任何毫秒。你可能有1000个请求的峰值，然后一切都回到一个请求。这也意味着这些指标可能不准确，你还想提取最小/

  6. 【Java 面试合集】HashMap中为什么引入红黑树，而不是AVL树呢 - 2

    HashMap中为什么引入红黑树，而不是AVL树呢1.概述开始学习这个知识点之前我们需要知道，在JDK1.8以及之前，针对HashMap有什么不同。JDK1.7的时候，HashMap的底层实现是数组+链表JDK1.8的时候，HashMap的底层实现是数组+链表+红黑树我们要思考一个问题，为什么要从链表转为红黑树呢。首先先让我们了解下链表有什么不好？？？2.链表上述的截图其实就是链表的结构，我们来看下链表的增删改查的时间复杂度增：因为链表不是线性结构，所以每次添加的时候，只需要移动一个节点，所以可以理解为复杂度是N(1)删：算法时间复杂度跟增保持一致查：既然是非线性结构，所以查询某一个节点的时候

  7. postman——集合——执行集合——测试脚本——pm对象简单示例02 - 2

    //1.验证返回状态码是否是200pm.test("Statuscodeis200",function(){pm.response.to.have.status(200);});//2.验证返回body内是否含有某个值pm.test("Bodymatchesstring",function(){pm.expect(pm.response.text()).to.include("string_you_want_to_search");});//3.验证某个返回值是否是100pm.test("Yourtestname",function(){varjsonData=pm.response.json

  8. 【Java入门】使用Java实现文件夹的遍历 - 2

    遍历文件夹我们通常是使用递归进行操作，这种方式比较简单，也比较容易理解。本文为大家介绍另一种不使用递归的方式，由于没有使用递归，只用到了循环和集合，所以效率更高一些！一、使用递归遍历文件夹整体思路1、使用File封装初始目录，2、打印这个目录3、获取这个目录下所有的子文件和子目录的数组。4、遍历这个数组，取出每个File对象4-1、如果File是否是一个文件，打印4-2、否则就是一个目录，递归调用代码实现publicclassSearchFile{publicstaticvoidmain(String[]args){//初始目录Filedir=newFile("d:/Dev");Datebeg

  9. 牛客网专项练习30天Pytnon篇第02天 - 2

    1.在Python3中，下列关于数学运算结果正确的是:（B）a=10b=3print(a//b)print(a%b)print(a/b)A.3，3，3.3333...B.3，1，3.3333...C.3.3333...，3.3333...，3D.3.3333...，1，3.3333...解析：    在Python中，//表示地板除（向下取整），%表示取余，/表示除（Python2向下取整返回3）2.如下程序Python2会打印多少个数:（D）k=1000whilek>1:    print(k)k=k/2A.1000 B.10C.11D.9解析：    按照题意每次循环K/2，直到K值小于等

  10. java - 为什么 ruby​​ modulo 与 java/other lang 不同？ - 2

    我基本上来自Java背景并且努力理解Ruby中的模运算。(5%3)(-5%3)(5%-3)(-5%-3)Java中的上述操作产生，2个-22个-2但在Ruby中，相同的表达式会产生21个-1-2.Ruby在逻辑上有多擅长这个？模块操作在Ruby中是如何实现的？如果将同一个操作定义为一个web服务，两个服务如何匹配逻辑。 最佳答案 在Java中，模运算的结果与被除数的符号相同。在Ruby中，它与除数的符号相同。remainder()在Ruby中与被除数的符号相同。您可能还想引用modulooperation.

随机推荐