AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

【java】泛型编程

2023-08-22 44
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 【java】泛型编程

泛型类

package com.test.entity;
public class Score<T> {
    String name;
    String id;
    public T value;
    public Score(String name, String id, T value)
    {
        this.name = name;
        this.id = id;
        this.value = value;
    }
}
import com.test.entity.Score;
public class Main {
    public static void main(String[] args) {
        Score<String> score1 = new Score<String>("计算机网络", "EP074512", "优秀");
        String value1 = score1.value;   //一旦类型明确，那么泛型就变成对应的类型了
        System.out.println(value1);
        Score<Integer> score2 = new Score<>("计算机网络", "EP074512", 99);
        int value2 = score2.value;
        System.out.println(value2);
    }
        }

优秀

99

public class Test<T>{
    private T value;
    public void setValue(T value) {
        this.value = value;
    }
    public T getValue() {
        return value;
    }
}

泛型与多态

子类实现此接口时，可以选择在实现类明确泛型类型，或是继续使用此泛型让具体创建的对象来确定类型

package com.test.entity;
public interface Study<T>
{
    T test(T a);
    //在实现接口或是继承父类时，如果子类是一个普通类，那么可以直接明确对应类型
}
import com.test.entity.Study;
public class Main {
    public static void main(String[] args) {
        A a = new A();
        Integer i = a.test(101);
        System.out.println(i);
    }
    static class A implements Study<Integer> {
        @Override
        public Integer test(Integer a) {
            return a;
        }
        //在实现接口或是继承父类时，如果子类是一个普通类，那么可以直接明确对应类型
    }
}
import com.test.entity.Study;
public class Main {
    public static void main(String[] args) {
        A<String> a = new A<>();
        String i = a.test("coleak");
        System.out.println(i);
        A<Integer> b = new A<>();
        int j = b.test(99);
        System.out.println(j);
    }
    static class A<T> implements Study<T> {
        //让子类继续为一个泛型类，那么可以不用明确
        @Override
        public T test(T a) {
            return a;
        }
    }
}

泛型方法

public class Main {
    public static void main(String[] args) {
        String str = test("Hello World!");
        System.out.println(str);
        int i=test(10);
        System.out.println(i);
        int k=test2("coleak");
        System.out.println(k);
    }
    private static <T> T test(T t) {   //在返回值类型前添加<>并填写泛型变量表示这个是一个泛型方法
        return t;
    }
        private static <T> int test2(String t){   //在返回值类型前添加<>并填写泛型变量表示这个是一个泛型方法
            return t.length();
    }
}
import java.util.Arrays;
public class Main {
    public static void main(String[] args) {
        String[] strings = new String[2];
        Main main = new Main();
        main.add(strings, "Hello");
        main.add(strings,"coleak");
        System.out.println(Arrays.toString(strings));
    }
    private <T> void add(T[] arr, T t){
        if(arr[0] ==null)
            arr[0] = t;
        arr[1]=t;
    }
}

[Hello, coleak]

import java.util.Arrays;
import java.util.Comparator;
public class Main {
    public static void main(String[] args) {
        Integer[] arr = {1, 4, 5, 2, 6, 3, 0, 7, 9, 8};
        Arrays.sort(arr, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {   //两个需要比较的数会在这里给出
                return o2 - o1;
                //compare方法要求返回一个int来表示两个数的大小关系，大于0表示大于，小于0表示小于
                //这里直接o2-o1就行，如果o2比o1大，那么肯定应该排在前面，所以说返回正数表示大于
            }
        });
        System.out.println(Arrays.toString(arr));
    }
}
//简化版
import java.util.Arrays;
public class Main {
    public static void main(String[] args) {
        Integer[] arr = {1, 4, 5, 2, 6, 3, 0, 7, 9, 8};
        Arrays.sort(arr, (o1, o2) -> o2 - o1);   //瞬间变一行，效果跟上面是一样的
        System.out.println(Arrays.toString(arr));
    }
}

[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

泛型界限

设置上界

public class Score<T extends Number> {   
//设定类型参数上界，必须是Number或是Number的子类
    private final String name;
    private final String id;
    private final T value;
    public Score(String name, String id, T value) {
        this.name = name;
        this.id = id;
        this.value = value;
    }
    public T getValue() {
        return value;
    }
}
import com.test.entity.Score;
public class Main {
    public static void main(String[] args) {
        Score<?> score1 = new Score<>("数据结构与算法", "EP074512", 60.0);
        Score<?  extends Number> score2 = 
        new Score<>("数据结构与算法", "EP074512", 60.66);
        //可以看到，此时虽然使用的是通配符，但是不再是Object类型，而是对应的上界
        Score<Integer> score3 = new Score<>("数据结构与算法", "EP074512", 60);
        System.out.println(score1.getValue());
        System.out.println(score2.getValue());
        System.out.println(score3.getValue());
    }
}

设置下界

public static void main(String[] args) {
    Score<? super Number> score = new Score<>("数据结构与算法基础", "EP074512", 10);
    Object o = score.getValue();
}

类型擦除

实际上在Java中并不是真的有泛型类型（为了兼容之前的Java版本）因为所有的对象都是属于一个普通的类型，一个泛型类型编译之后，实际上会直接使用默认的类型

如果我们给类型变量设定了上界，那么会从默认类型变成上界定义的类型

public abstract class A <T>{
    abstract T test(T t);
}
public abstract class A {
    abstract Object test(Object t);  //默认就是Object
}
public abstract class A <T extends Number>{   //设定上界为Number
    abstract T test(T t);
}
public abstract class A {
    abstract Number test(Number t);  //上界Number，因为现在只可能出现Number的子类
}
public static void main(String[] args) {
    A<String> a = new B();
    String  i = a.test("10");     //因为类型A只有返回值为原始类型Object的方法
}
public static void main(String[] args) {
    A a = new B();
    String i = (String) a.test("10");   //依靠强制类型转换完成的
}
public class B extends A<String>{
    @Override
    String test(String s) {
        return null;
    }
}
// Compiled from "B.java"
public class com.test.entity.B extends com.test.entity.A<java.lang.String> {
  public com.test.entity.B();
  java.lang.String test(java.lang.String);
  java.lang.Object test(java.lang.Object);   
    //桥接方法，这才是真正重写的方法，但是使用时会调用上面的方法
}

通过反编译进行观察，实际上是编译器帮助我们生成了一个桥接方法用于支持重写

函数式接口

Supplier供给型函数式接口

import com.test.entity.Student;
import java.util.function.Supplier;
public class Main {
    //专门供给Student对象的Supplier
    private static final Supplier<Student> STUDENT_SUPPLIER = Student::new;
    public static void main(String[] args) {
        Student student1 = STUDENT_SUPPLIER.get();
        Student student2 =new Student();
        student1.hello();
        student2.hello();
    }
}

Consumer消费型函数式接口

import com.test.entity.Student;
import java.util.function.Consumer;
import java.util.function.Supplier;
public class Main {
    private static final Supplier<Student> STUDENT_SUPPLIER = Student::new;
    private static final Consumer<Student> STUDENT_CONSUMER = student -> System.out.println(student+" 真好吃!");
    public static void main(String[] args) {
        Student student =STUDENT_SUPPLIER.get();
        STUDENT_CONSUMER   //我们可以提前将消费之后的操作以同样的方式预定好
                .andThen(stu -> System.out.println("我是吃完之后的操作！"))
                .andThen(stu -> System.out.println("好了好了，吃饱了！"))
                .accept(student);   //预定好之后，再执行
    }
}

com.test.entity.Student@3fb6a447 真好吃!

我是吃完之后的操作！

好了好了，吃饱了！

Function函数型函数式接口

@FunctionalInterface
public interface Function<T, R> {
    R apply(T t);   
    //这里一共有两个类型参数，其中一个是接受的参数类型，还有一个是返回的结果类型
    default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
        Objects.requireNonNull(before);
        return (V v) -> apply(before.apply(v));
    }
    default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
        Objects.requireNonNull(after);
        return (T t) -> after.apply(apply(t));
    }
    static <T> Function<T, T> identity() {
        return t -> t;
    }
}
import java.util.function.Function;
public class Main {
    private static final Function<String,Integer> INTEGER_STRING_FUNCTION = String::length;
    public static void main(String[] args) {
        int number = INTEGER_STRING_FUNCTION.apply("coleak");
        System.out.println(number);
    }
}

6

import java.util.function.Function;
public class Main {
    private static final Function<Integer, String> INTEGER_STRING_FUNCTION = Object::toString;
    public static void main(String[] args) {
        String str = INTEGER_STRING_FUNCTION
                .compose((String s) -> s.length())   //将此函数式的返回值作为当前实现的实参
                .apply("lbwnb");   //传入上面函数式需要的参数
        System.out.println(str);
        System.out.println(str.getClass());
    }
}
public static void main(String[] args) {
    Boolean str = INTEGER_STRING_FUNCTION
            .andThen(String::isEmpty)   
        //在执行完后，返回值作为参数执行andThen内的函数式，最后得到的结果就是最终的结果了
            .apply(10);
    System.out.println(str);
}
public static void main(String[] args) {
    Function<String, String> function = Function.identity();   //原样返回
    System.out.println(function.apply("不会吧不会吧，不会有人听到现在还是懵逼的吧"));
}

Predicate断言型函数式接口

import com.test.entity.Student;
import java.util.function.Predicate;
public class Main {
    private static final Predicate<Student> STUDENT_PREDICATE = student -> student.score >= 60;
    public static void main(String[] args) {
        Student student = new Student();
        student.score = 80;
        if(STUDENT_PREDICATE.test(student)) {  
            //test方法的返回值是一个boolean结果
            System.out.println("及格了，真不错");
        } else {
            System.out.println("不及格");
        }
    }
}
import com.test.entity.Student;
import java.util.function.Predicate;
public class Main {
    private static final Predicate<Student> STUDENT_PREDICATE = student -> student.score >= 60;
    public static void main(String[] args) {
        Student student = new Student();
        student.score = 99;
        boolean b = STUDENT_PREDICATE
                .and(stu -> stu.score > 90)   //需要同时满足这里的条件，才能返回true
                .test(student);
        if(!b) System.out.println("Java到现在都没考到90分？你的室友都拿国家奖学金了");
    }
}

判空包装

import com.test.entity.Student;
import java.util.Optional;
public class Main {
    public static void main(String[] args) {
        test("coelak");
    }
    private static void test(String str){
        String s = Optional.ofNullable(str).orElse("我是为null的情况备选方案");
        System.out.println(s);
    }
    }
}
import com.test.entity.Student;
import java.util.Optional;
public class Main {
    public static void main(String[] args) {
        test("coelak");
    }
    private static void test(String str){
        Integer i = Optional
                .ofNullable(str)
                .map(String::length)   
            //使用map来进行映射，将当前类型转换为其他类型，或者是进行处理
                .orElse(-1);
        System.out.println(i);
    }
}


文章标签：
Java
编译器
关键词：
Java编程
Java泛型
Java泛型编程
coleak
目录
相关文章
叫个什么名字
|
1月前
|
Java 开发者
Java多线程编程中的常见误区与最佳实践####
本文深入剖析了Java多线程编程中开发者常遇到的几个典型误区，如对`start()`与`run()`方法的混淆使用、忽视线程安全问题、错误处理未同步的共享变量等，并针对这些问题提出了具体的解决方案和最佳实践。通过实例代码对比，直观展示了正确与错误的实现方式，旨在帮助读者构建更加健壮、高效的多线程应用程序。 ####
叫个什么名字
56 5
mrq4nk6ni2neg
|
1月前
|
安全 Java UED
深入浅出Java多线程编程
【10月更文挑战第40天】在Java的世界中，多线程是提升应用性能和响应能力的关键。本文将通过浅显易懂的方式介绍Java中的多线程编程，从基础概念到高级特性，再到实际应用案例，带你一步步深入了解如何在Java中高效地使用多线程。文章不仅涵盖了理论知识，还提供了实用的代码示例，帮助你在实际开发中更好地应用多线程技术。
mrq4nk6ni2neg
44 5
艾利克斯冰
|
1月前
|
JSON Java Apache
非常实用的Http应用框架，杜绝Java Http 接口对接繁琐编程
UniHttp 是一个声明式的 HTTP 接口对接框架，帮助开发者快速对接第三方 HTTP 接口。通过 @HttpApi 注解定义接口，使用 @GetHttpInterface 和 @PostHttpInterface 等注解配置请求方法和参数。支持自定义代理逻辑、全局请求参数、错误处理和连接池配置，提高代码的内聚性和可读性。
艾利克斯冰
132 3
游客moiomvrp3vyac2
|
18天前
|
Java 程序员
Java编程中的异常处理：从基础到高级
在Java的世界中，异常处理是代码健壮性的守护神。本文将带你从异常的基本概念出发，逐步深入到高级用法，探索如何优雅地处理程序中的错误和异常情况。通过实际案例，我们将一起学习如何编写更可靠、更易于维护的Java代码。准备好了吗？让我们一起踏上这段旅程，解锁Java异常处理的秘密！
游客moiomvrp3vyac2
33 0
互联网课堂
|
2天前
|
算法 Java 调度
java并发编程中Monitor里的waitSet和EntryList都是做什么的
在Java并发编程中，Monitor内部包含两个重要队列：等待集（Wait Set）和入口列表（Entry List）。Wait Set用于线程的条件等待和协作，线程调用`wait()`后进入此集合，通过`notify()`或`notifyAll()`唤醒。Entry List则管理锁的竞争，未能获取锁的线程在此排队，等待锁释放后重新竞争。理解两者区别有助于设计高效的多线程程序。 - **Wait Set**：线程调用`wait()`后进入，等待条件满足被唤醒，需重新竞争锁。 - **Entry List**：多个线程竞争锁时，未获锁的线程在此排队，等待锁释放后获取锁继续执行。
互联网课堂
25 12
游客5fdji2pvmf8888
|
22天前
|
设计模式 Java 开发者
Java多线程编程的陷阱与解决方案####
本文深入探讨了Java多线程编程中常见的问题及其解决策略。通过分析竞态条件、死锁、活锁等典型场景，并结合代码示例和实用技巧，帮助开发者有效避免这些陷阱，提升并发程序的稳定性和性能。 ####
游客5fdji2pvmf8888
52 16
aliyun0641063962-48771
|
22天前
|
缓存 Java 开发者
Java多线程编程的陷阱与最佳实践####
本文深入探讨了Java多线程编程中常见的陷阱，如竞态条件、死锁和内存一致性错误，并提供了实用的避免策略。通过分析典型错误案例，本文旨在帮助开发者更好地理解和掌握多线程环境下的编程技巧，从而提升并发程序的稳定性和性能。 ####
aliyun0641063962-48771
46 11
游客nmbcre4jd7shs
|
15天前
|
安全 算法 Java
Java多线程编程中的陷阱与最佳实践####
本文探讨了Java多线程编程中常见的陷阱，并介绍了如何通过最佳实践来避免这些问题。我们将从基础概念入手，逐步深入到具体的代码示例，帮助开发者更好地理解和应用多线程技术。无论是初学者还是有经验的开发者，都能从中获得有价值的见解和建议。 ####
游客nmbcre4jd7shs
33 4
mg的嘟嘟
|
15天前
|
Java 调度
Java中的多线程编程与并发控制
本文深入探讨了Java编程语言中多线程编程的基础知识和并发控制机制。文章首先介绍了多线程的基本概念，包括线程的定义、生命周期以及在Java中创建和管理线程的方法。接着，详细讲解了Java提供的同步机制，如synchronized关键字、wait()和notify()方法等，以及如何通过这些机制实现线程间的协调与通信。最后，本文还讨论了一些常见的并发问题，例如死锁、竞态条件等，并提供了相应的解决策略。
mg的嘟嘟
40 3
肥猪肥猪-17824
|
26天前
|
Java 程序员
Java编程中的异常处理：从基础到高级
在Java的世界里，异常是程序运行中不可忽视的“惊喜”。它们可能突如其来，也可能悄无声息地潜伏。掌握异常处理的艺术，意味着你能够优雅地面对程序的不完美，并确保它即使在风雨飘摇中也能继续航行。本文将引导你理解Java异常的本质，探索捕获和处理这些异常的方法，并最终学会如何利用自定义异常为你的代码增添力量。
肥猪肥猪-17824
38 8

热门文章

最新文章

  • 1
    JAVA-MAVEN初学者教程（配置、pom.xml、依赖管理等）
  • 2
    战斗到底：Java vs. Python - 用哪个更适合处理海量数据？
  • 3
    从零搭建Web所需服务（四）Java连接ES进行分词并获取结果
  • 4
    java源码 - ReentrantLock
  • 5
    Java-学习笔记-8-接口
  • 6
    用 Java Servlet 实现文件上载（老文新发）
  • 7
    Java Poi 创建与读取Excel
  • 8
    java中的工厂模式
  • 9
    关于《Java数字图像处理-编程技巧与应用实践》一书 源代码
  • 10
    Java程序内存分析：使用mat工具分析内存占用
  • 1
    【Java开发指南 | 第三十一篇】Java 包(package)
    71
  • 2
    【Java开发指南 | 第二十九篇】Java接口
    46
  • 3
    【Java开发指南 | 第二十八篇】Java封装
    53
  • 4
    【Java开发指南 | 第二十六篇】Java多态
    40
  • 5
    【Java开发指南 | 第二十四篇】Java继承
    59
  • 6
    【Java开发指南 | 第九篇】访问实例变量和方法、继承、接口
    53
  • 7
    【Java开发指南 | 第八篇】Java变量、构造方法、创建对象
    92
  • 8
    Java Stream API详解与使用
    93
  • 9
    Java医院绩效考核系统源码B/S+avue+MySQL助力医院实现精细化管理
    81
  • 10
    《手把手教你》系列技巧篇（四十三）-java+ selenium自动化测试-处理https 安全问题或者非信任站点-上篇（详解教程）
    132

    • 相关课程

    更多
  • Java面试疑难点解析 - 面试技巧及语言基础
  • Java面试疑难点解析 - Java Web开发
  • Java面试疑难点解析 - 系统架构及项目设计
  • Java编程入门
  • Java面向对象编程
  • Java高级编程

    • 相关电子书

    更多
  • Spring Cloud Alibaba - 重新定义 Java Cloud-Native
  • The Reactive Cloud Native Arch
  • JAVA开发手册1.5.0

    • 相关实验场景

    更多
  • 语言入门-2：基本类型
  • 阿里云平台上进行Java程序的编译与运行
  • 使用Java面向对象编写网络通信程序应用
  • 手动部署Java Web环境（Alibaba Cloud Linux 2）
  • 搭建Java Web开发环境（Anolis OS）
  • RocketMQ中使用Java客户端发送消息和消费的应用
    • 下一篇
    DataWorks