当前位置:

首页 > 编程开发 > Java反射、枚举、Lambda表达式及泛型通配符实例详解

Java反射、枚举、Lambda表达式及泛型通配符实例详解

前言 这次我们集中聊几个平时开发中高频出现、但不少同学又容易模糊的概念——反射、枚举、Lambda 表达式,以及泛型通配符。这几个知识点单独拎出来都不算难,但放在一起梳理一遍,能帮我们把 Ja va 的类型系统、运行时动态性以及函数式风格串起来,理解会更深。 一、反射 Ja va 的反射机制,说白了

本文目录

    前言

    这次我们集中聊几个平时开发中高频出现、但不少同学又容易模糊的概念——反射、枚举、Lambda 表达式,以及泛型通配符。这几个知识点单独拎出来都不算难,但放在一起梳理一遍,能帮我们把 Ja va 的类型系统、运行时动态性以及函数式风格串起来,理解会更深。

    一、反射

    Ja va 的反射机制,说白了就是让程序在运行的时候“看穿”一个类——它能知道这个类有哪些属性、方法,甚至能调用私有的成员。如果在运行时拿到了 Class 对象,就能修改类的部分信息。这种动态获取信息、动态调用方法的能力,就是反射。

    在实际开发中,反射出镜率最高的场景有两个:一是做第三方 SDK 集成时,经常遇到某些类或方法被标记为 private,常规手段调不了,反射就成了“后门”;二是各大框架的底层,比如 Spring,容器接管了所有 Bean 的管理,不管是 XML 配置还是注解配置,最终都是靠反射去动态创建实例、注入依赖。可以说,没有反射,就没有现在这些灵活的框架。

    Ja va 程序中的对象在运行时其实有两种类型:编译时类型和运行时类型。比如 `Person p = new Student()`,p 的编译时类型是 Person,运行时类型却是 Student。程序需要在运行时搞清楚对象和类的真实身份,反射就是干这个的。核心用到以下几个类:

    下面是官方文档的链接,值得收藏:

    Class | API reference | Android Developers
    Field | API reference | Android Developers
    Constructor | API reference | Android Developers
    Method | API reference | Android Developers

    Class 类是反射的起点,它代表类的实体。Ja va 文件编译后生成 .class 文件,JVM 解析它时,会把它变成一个 ja va.lang.Class 对象。这样一来,每个 Ja va 文件在运行时都变成了 Class 类的一个实例。通过反射操作这个实例,就能获取甚至修改类的属性和行为,让类“活”起来。先看看这几个类的常用方法:

    常用获得类相关的方法:

    方法用途
    getClassLoader()获得类的加载器
    getDeclaredClasses()返回一个数组,数组中包含该类中所有类和接口的对象(包括私有的)
    forName(String className)根据类名返回类的对象
    newInstance()创建类的实例
    getName()获得类的完整路径名字

    常用获得类中属性相关的方法(返回值是 Field 类):

    方法用途
    getField(String name)获得某个公有的属性对象
    getFields()获得所有公有的属性对象
    getDeclaredField(String name)获得某个属性对象
    getDeclaredFields()获得所有属性对象

    常用获得类中注解相关的方法(了解即可):

    方法用途
    getAnnotation(Class annotationClass)返回该类中与参数类型匹配的公有注解对象
    getAnnotations()返回该类所有的公有注解对象
    getDeclaredAnnotation(Class annotationClass)返回该类中与参数类型匹配的所有注解对象
    getDeclaredAnnotations()返回该类所有的注解对象

    常用获得类中构造器相关的方法(返回值是 Constructor 类):

    方法用途
    getConstructor(Class... parameterTypes)获得该类中与参数类型匹配的公有构造方法
    getConstructors()获得该类的所有公有构造方法
    getDeclaredConstructor(Class... parameterTypes)获得该类中与参数类型匹配的构造方法
    getDeclaredConstructors()获得该类所有构造方法

    常用获得类中方法相关的方法(返回值是 Method 类):

    方法用途
    getMethod(String name, Class... parameterTypes)获得该类某个公有的方法
    getMethods()获得该类所有公有的方法
    getDeclaredMethod(String name, Class... parameterTypes)获得该类某个方法
    getDeclaredMethods()获得该类所有方法

    接下来,我们用代码说话。先写一个学生类:

    package reflectdemo;
    public class Student {
        private String name = "bit";
        public int age = 18;
        public Student(){
            System.out.println("Student()");
        }
        private Student(String name,int age) {
            this.name = name;
            this.age = age;
            System.out.println("Student(String,name)");
        }
        private void eat(){
            System.out.println("i am eat");
        }
        public void sleep(){
            System.out.println("i am pig");
        }
        private void function(String str) {
            System.out.println(str);
        }
        @Override
        public String toString() {
            return "Student{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }

    获取 Class 对象有三种方式。先看 forName 的源码:

        @CallerSensitive
        public static Class forName(String className)
                    throws ClassNotFoundException {
            Class caller = Reflection.getCallerClass();
            return forName0(className, true, ClassLoader.getClassLoader(caller), caller);
        }

    方法声明了异常,所以调用时得 try-catch。代码写出来是这样:

    package reflectdemo;
    public class Test {
        public static void main(String[] args){
            try {
                Class c1 = Class.forName("reflectdemo.Student");
            } catch (ClassNotFoundException e) {
                throw new RuntimeException(e);
            }
        }
    }

    另外两种方式也一并列出来:

    Class c2 = Student.class;
    Student student = new Student();
    Class c3 = student.getClass();

    验证一下这三种方式拿到的是否同一个 Class 对象:

    package reflectdemo;
    public class Test {
        public static void main(String[] args){
            try {
                Class c1 = Class.forName("reflectdemo.Student");
                Class c2 = Student.class;
                Student student = new Student();
                Class c3 = student.getClass();
                System.out.println(c1.equals(c2));
                System.out.println(c2.equals(c3));
                System.out.println(c1.equals(c3));
            } catch (ClassNotFoundException e) {
                throw new RuntimeException(e);
            }
        }
    }

    结果很清楚:三种方式拿到的都是同一个 Class 对象。所以反射的第一步,就是拿到目标类的 Class 对象,然后通过它去操作类的属性和方法。总结一下获取 Class 的三种方式:

    • Class.forName("类的全路径名"):静态方法,适合在运行时明确知道类名的情况。
    • 类名.class:适合在编译前就已经明确要操作的类。
    • 对象.getClass():通过实例获取。

    接下来演示反射创建实例:

    package reflectdemo;
    public class Test {
        public static void reflectNewInstance(){
            try {
                Class c1 = Class.forName("reflectdemo.Student");
                Student student = (Student)c1.newInstance();
                System.out.println(student);
            } catch (ClassNotFoundException | InstantiationException | IllegalAccessException e) {
                throw new RuntimeException(e);
            }
        }
        public static void main(String[] args){
            reflectNewInstance();
        }
    }

    同理,获取私有构造方法:

    package reflectdemo;
    import ja va.lang.reflect.Constructor;
    import ja va.lang.reflect.InvocationTargetException;
    public class Test {
        public static void reflectPrivateConstructor(){
            try {
                Class c1 = Class.forName("reflectdemo.Student");
                Constructor constructor = (Constructor)c1.getDeclaredConstructor(String.class, int.class);
                constructor.setAccessible(true);
                Student student = constructor.newInstance("suzhe", 21);
                System.out.println(student);
            } catch (ClassNotFoundException | NoSuchMethodException | InvocationTargetException | InstantiationException | IllegalAccessException e) {
                throw new RuntimeException(e);
            }
        }
        public static void main(String[] args){
            reflectPrivateConstructor();
        }
    }

    注意,对于私有构造方法,必须调用 setAccessible(true) 来“确认知情并强制获取”,否则会报错。

    反射私有属性:

    package reflectdemo;
    import ja va.lang.reflect.Constructor;
    import ja va.lang.reflect.Field;
    import ja va.lang.reflect.InvocationTargetException;
    public class Test {
        public static void reflectPrivateField(){
            try {
                Class c1 = Class.forName("reflectdemo.Student");
                Field field = c1.getDeclaredField("name");
                field.setAccessible(true);
                Student student = (Student)c1.newInstance();
                field.set(student, "suzhe");
                System.out.println(student);
            } catch (ClassNotFoundException | NoSuchFieldException | InstantiationException | IllegalAccessException e) {
                throw new RuntimeException(e);
            }
        }
        public static void main(String[] args){
            reflectPrivateField();
        }
    }

    反射私有方法:

    package reflectdemo;
    import ja va.lang.reflect.Constructor;
    import ja va.lang.reflect.Field;
    import ja va.lang.reflect.InvocationTargetException;
    import ja va.lang.reflect.Method;
    public class Test {
        public static void reflectPrivateMethod(){
            try {
                Class c1 = Class.forName("reflectdemo.Student");
                Method method = c1.getDeclaredMethod("function", String.class);
                method.setAccessible(true);
                Student student = (Student)c1.newInstance();
                method.invoke(student, "new arg");
            } catch (ClassNotFoundException | NoSuchMethodException | InvocationTargetException | InstantiationException | IllegalAccessException e) {
                throw new RuntimeException(e);
            }
        }
        public static void main(String[] args){
            reflectPrivateMethod();
        }
    }

    反射的优点在于:可以动态获取类的所有信息,调用任意方法,增加程序的灵活性和扩展性,降低耦合度。很多流行框架(Struts、Hibernate、Spring)的底层都有它的身影。但缺点也很明显——性能开销大,毕竟是在运行时做类型检查和解析。

    二、枚举

    枚举是 JDK 1.5 之后加入的特性,主要用来解决一个问题:常量管理。以前我们这样定义常量:

    public static final int RED = 1;
    public static final int GREEN = 2;
    public static final int BLACK = 3;

    这样写的问题在于,类型是 int,如果碰巧有个数字 1,它可能被误认为是 RED。现在用枚举,就有了真正的类型:

    public enum TestEnum {
        RED,BLACK,GREEN;
    }

    枚举的本质是 ja va.lang.Enum 的子类——就算没有显式继承,它也默认继承了。看一个简单的使用示例:

    package enumdemo;
    public enum TestEnum {
        RED,WHITE,GREEN,BLACK;
        public static void main(String[] args) {
            TestEnum testEnum = RED;
            switch(testEnum){
                case RED:
                    System.out.println("RED");
                    break;
                case BLACK:
                    System.out.println("BLACK");
                    break;
                case GREEN:
                    System.out.println("GREEN");
                    break;
                case WHITE:
                    System.out.println("WHITE");
                    break;
                default:
                    System.out.println("No Match...");
                    break;
            }
        }
    }

    枚举的常用方法:

    方法名称描述
    values()以数组形式返回枚举类型的所有成员
    ordinal()获取枚举成员的索引位置
    valueOf()将普通字符串转换为枚举实例
    compareTo()比较两个枚举成员在定义时的顺序

    简单演示一下:

    package enumdemo;
    public enum TestEnum {
        RED,WHITE,GREEN,BLACK;
        public static void main(String[] args) {
            TestEnum[] testEnums = TestEnum.values();
            for(int i = 0; i < testEnums.length; i++){
                System.out.println(testEnums[i] + ":" + testEnums[i].ordinal());
            }
            TestEnum testEnum = TestEnum.valueOf("WHITE");
            System.out.println(testEnum);
            System.out.println(WHITE.compareTo(GREEN));
        }
    }

    注意,枚举的构造方法默认是私有的。枚举本质上还是类,所以也可以这样定义:

    package enumdemo;
    public enum TestEnum {
        RED(0, "RED"), WHITE(1, "WHITE"), GREEN(2, "GREEN"), BLACK(3, "BLACK");
        public int ordinal;
        public String color;
        private TestEnum(int ordinal, String color){
            this.ordinal = ordinal;
            this.color = color;
        }
        public static void main(String[] args) {
            TestEnum[] testEnums = TestEnum.values();
            for(int i = 0; i < testEnums.length; i++){
                System.out.println(testEnums[i] + ":" + testEnums[i].ordinal());
            }
            TestEnum testEnum = TestEnum.valueOf("WHITE");
            System.out.println(testEnum);
            System.out.println(WHITE.compareTo(GREEN));
        }
    }

    结果和之前一样。枚举的优点很明显:常量更安全、有内置方法、代码更优雅。缺点是:不可继承,无法扩展。

    刚刚在反射那部分,我们说过任何类哪怕构造方法私有,也能通过反射拿到实例。那枚举的构造方法也是私有的,能不能通过反射创建实例呢?试试看:

    package enumdemo;
    import ja va.lang.reflect.Constructor;
    import ja va.lang.reflect.InvocationTargetException;
    public class Test {
        public static void main(String[] args) {
            try{
                Class c1 = Class.forName("enumdemo.TestEnum");
                Constructor constructor = c1.getDeclaredConstructor(int.class, String.class);
                constructor.setAccessible(true);
                TestEnum testEnum = (TestEnum)constructor.newInstance(4, "BLUE");
                System.out.println(testEnum);
            } catch (ClassNotFoundException | InvocationTargetException | NoSuchMethodException | InstantiationException | IllegalAccessException e) {
                throw new RuntimeException(e);
            }
        }
    }

    报错说没有这个构造方法,但实际上我们确实提供了。这是因为我们只传了子类的两个参数,而父类 Enum 的构造方法也需要参数。修改一下,传入四个参数:

    package enumdemo;
    import ja va.lang.reflect.Constructor;
    import ja va.lang.reflect.InvocationTargetException;
    public class Test {
        public static void main(String[] args) {
            try{
                Class c1 = Class.forName("enumdemo.TestEnum");
                Constructor constructor = c1.getDeclaredConstructor(String.class, int.class, int.class, String.class);
                constructor.setAccessible(true);
                TestEnum testEnum = (TestEnum)constructor.newInstance(4, "BLUE");
                System.out.println(testEnum);
            } catch (ClassNotFoundException | InvocationTargetException | NoSuchMethodException | InstantiationException | IllegalAccessException e) {
                throw new RuntimeException(e);
            }
        }
    }

    还是报错?这是因为 newInstance 方法的源码里明确做了判断:

        @CallerSensitive
        public T newInstance(Object ... initargs)
            throws InstantiationException, IllegalAccessException,
                   IllegalArgumentException, InvocationTargetException
        {
            if (!override) {
                if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
                    Class caller = Reflection.getCallerClass();
                    checkAccess(caller, clazz, null, modifiers);
                }
            }
            if ((clazz.getModifiers() & Modifier.ENUM) != 0)
                throw new IllegalArgumentException("Cannot reflectively create enum objects");
            // ...
        }

    看到没?一旦检测到是枚举类型,反射直接抛出异常。所以枚举类型是安全的——即使反射也无法破坏它的构造。

    三、Lambda 表达式

    Lambda 表达式是 Ja va 8 引入的一个重要特性,核心就是用表达式代替功能接口的实现。基本语法:

    (parameters) -> expression
    (parameters) ->{ statements; }

    参数部分可以显式声明类型,也可以由 JVM 推断,当只有一个参数时,圆括号可以省略。箭头后面是方法体,可以是一个表达式或代码块。

    // 1. 不需要参数,返回值为 2
    () -> 2
    // 2. 接收一个参数(数字类型),返回其2倍的值
    x -> 2 * x
    // 3. 接受2个参数(数字),并返回他们的和
    (x, y) -> x + y
    // 4. 接收2个int型整数,返回他们的乘积
    (int x, int y) -> x * y
    // 5. 接受一个 string 对象,并在控制台打印,不返回任何值
    (String s) -> System.out.print(s)

    理解 Lambda 之前,先搞清楚什么是函数式接口——就是有且只有一个抽象方法的接口。如果一个接口只有一个抽象方法,它就是函数式接口。如果加了 @FunctionalInterface 注解,编译器会强制检查:

    @FunctionalInterface
    interface NoParameterNoReturn {
        void test();
        default void test2() {
            System.out.println("JDK1.8新特性,default默认方法可以有具体的实现");
        }
    }

    基本使用示例:

    //无返回值无参数
    @FunctionalInterface
    interface NoParameterNoReturn {
        void test();
    }
    //无返回值一个参数
    @FunctionalInterface
    interface OneParameterNoReturn {
        void test(int a);
    }
    //无返回值多个参数
    @FunctionalInterface
    interface MoreParameterNoReturn {
        void test(int a,int b);
    }
    //有返回值无参数
    @FunctionalInterface
    interface NoParameterReturn {
        int test();
    }
    //有返回值一个参数
    @FunctionalInterface
    interface OneParameterReturn {
        int test(int a);
    }
    //有返回值多参数
    @FunctionalInterface
    interface MoreParameterReturn {
        int test(int a,int b);
    }

    Lambda 可以理解为匿名内部类的简化写法。没有 Lambda 时:

    NoParameterNoReturn noParameterNoReturn = new NoParameterNoReturn(){
        @Override
        public void test() {
            System.out.println("hello");
        }
    };
    noParameterNoReturn.test();

    有了 Lambda 之后:

    public class TestDemo {
        public static void main(String[] args) {
            NoParameterNoReturn noParameterNoReturn = ()->{
                System.out.println("无参数无返回值");
            };
        noParameterNoReturn.test();
        OneParameterNoReturn oneParameterNoReturn = (int a)->{
            System.out.println("一个参数无返回值:"+ a);
        };
        oneParameterNoReturn.test(10);
        MoreParameterNoReturn moreParameterNoReturn = (int a,int b)->{
            System.out.println("多个参数无返回值:"+a+" "+b);
        };
        moreParameterNoReturn.test(20,30);
        NoParameterReturn noParameterReturn = ()->{
            System.out.println("有返回值无参数!");
            return 40;
        };
        int ret = noParameterReturn.test();
        System.out.println(ret);
        OneParameterReturn oneParameterReturn = (int a)->{
            System.out.println("有返回值有一个参数!");
            return a;
        };
        ret = oneParameterReturn.test(50);
        System.out.println(ret);
        MoreParameterReturn moreParameterReturn = (int a,int b)->{
            System.out.println("有返回值多个参数!");
            return a+b;
        };
        ret = moreParameterReturn.test(60,70);
        System.out.println(ret);
        }
    }

    简化规则:参数类型可以省略(要省就全省);只有一个参数时小括号可省;方法体只有一句代码时大括号可省;如果方法体只有一条 return 语句,大括号和 return 关键字都可以省略。

    public static void main(String[] args) {
        MoreParameterNoReturn moreParameterNoReturn = ( a, b)->{
            System.out.println("无返回值多个参数,省略参数类型:"+a+" "+b);
        };
        moreParameterNoReturn.test(20,30);
        OneParameterNoReturn oneParameterNoReturn = a ->{
            System.out.println("无参数一个返回值,小括号可以省略:"+ a);
        };
        oneParameterNoReturn.test(10);
        NoParameterNoReturn noParameterNoReturn = ()->System.out.println("无参数无返回值,方法体中只有一行代码");
        noParameterNoReturn.test();
        //方法体中只有一条语句,且是return语句
        NoParameterReturn noParameterReturn = ()-> 40;
        int ret = noParameterReturn.test();
        System.out.println(ret);
    }

    四、变量捕获及 Lambda 在集合中的使用

    Lambda 表达式中有变量捕获的概念,理解它才能更好地把握作用域。匿名内部类中也有变量捕获。先看一个匿名内部类的简单例子:

    class Test {
        public void func(){
            System.out.println("func()");
        }
    }
    public class TestDemo {
        public static void main(String[] args) {
            new Test(){
                @Override
                public void func() {
                    System.out.println("我是内部类,且重写了func这个方法!");
                }
            };
        }
    }

    再来看变量捕获:

    class Test {
        public void func(){
            System.out.println("func()");
        }
    }
    public class TestDemo {
        public static void main(String[] args) {
            int a = 100;
            new Test(){
                @Override
                public void func() {
                    System.out.println("我是内部类,且重写了func这个方法!");
                    System.out.println("我是捕获到变量 a == "+a
                        +" 我是一个常量,或者是一个没有改变过值的变量!");
                }
            };
        }
    }

    变量 a 就是被捕获的变量。它要么被 final 修饰,要么在使用前没有被修改过。下面这段代码会编译报错:

    public class TestDemo {
        public static void main(String[] args) {
            int a = 100;
            new Test(){
                @Override
                public void func() {
                    a = 99; // 编译错误
                    System.out.println("我是内部类,且重写了func这个方法!");
                    System.out.println("我是捕获到变量 a == "+a
                        +" 我是一个常量,或者是一个没有改变过值的变量!");
                }
            };
        }
    }

    即使把修改操作提到外部,也会报错:

    public class TestDemo {
        public static void main(String[] args) {
            int a = 100;
            a = 99;
            new Test(){
                @Override
                public void func() {
                    System.out.println("我是内部类,且重写了func这个方法!");
                    System.out.println("我是捕获到变量 a == "+a
                        +" 我是一个常量,或者是一个没有改变过值的变量!");
                }
            };
        }
    }

    Lambda 中同样有变量捕获:

    @FunctionalInterface
    interface NoParameterNoReturn {
        void test();
    }
    public static void main(String[] args) {
        int a = 10;
        NoParameterNoReturn noParameterNoReturn = ()->{
            // a = 99; error
            System.out.println("捕获变量:"+a);
        };
        noParameterNoReturn.test();
    }

    为了让 Lambda 与集合更好地配合,集合类也新增了一些接口方法:

    对应的接口新增的方法
    CollectionremoveIf()、spliterator()、stream()、parallelStream()、forEach()
    ListreplaceAll()、sort()
    MapgetOrDefault()、forEach()、replaceAll()、putIfAbsent()、remove()、replace()、computeIfAbsent()、computeIfPresent()、compute()、merge()

    先看 forEach 方法,它来自 Iterable 接口:

    default void forEach(Consumer action) {
        Objects.requireNonNull(action);
        for (T t : this) {
            action.accept(t);
        }
    }

    使用示例:

    public static void main(String[] args) {
        ArrayList list = new ArrayList<>();
        list.add("Hello");
        list.add("bit");
        list.add("hello");
        list.add("lambda");
        list.forEach(new Consumer(){
            @Override
            public void accept(String str){
                System.out.print(str+" ");
            }
        });
    }

    用 Lambda 简化后:

    public static void main(String[] args) {
        ArrayList list = new ArrayList<>();
        list.add("Hello");
        list.add("bit");
        list.add("hello");
        list.add("lambda");
        list.forEach(s -> {
            System.out.println(s);
        });
    }

    再看 sort 方法:

    public void sort(Comparator c) {
        final int expectedModCount = modCount;
        Arrays.sort((E[]) elementData, 0, size, c);
        if (modCount != expectedModCount) {
            throw new ConcurrentModificationException();
        }
        modCount++;
    }

    传统写法:

    public static void main(String[] args) {
        ArrayList list = new ArrayList<>();
        list.add("Hello");
        list.add("bit");
        list.add("hello");
        list.add("lambda");
        list.sort(new Comparator() {
            @Override
            public int compare(String str1, String str2){
                return str1.length()-str2.length();
            }
        });
        System.out.println(list);
    }

    Lambda 写法:

    public static void main(String[] args) {
        ArrayList list = new ArrayList<>();
        list.add("Hello");
        list.add("bit");
        list.add("hello");
        list.add("lambda");
        list.sort((str1,str2)-> str1.length()-str2.length());
        System.out.println(list);
    }

    最后看 Map 的 forEach 方法:

    default void forEach(BiConsumer action) {
        Objects.requireNonNull(action);
        for (Map.Entry entry : entrySet()) {
            K k;
            V v;
            try {
                k = entry.getKey();
                v = entry.getValue();
            } catch(IllegalStateException ise) {
                throw new ConcurrentModificationException(ise);
            }
            action.accept(k, v);
        }
    }

    传统写法:

    public static void main(String[] args) {
        HashMap map = new HashMap<>();
        map.put(1, "hello");
        map.put(2, "bit");
        map.put(3, "hello");
        map.put(4, "lambda");
        map.forEach(new BiConsumer(){
            @Override
            public void accept(Integer k, String v){
                System.out.println(k + "=" + v);
            }
        });
    }

    Lambda 写法:

    public static void main(String[] args) {
        HashMap map = new HashMap<>();
        map.put(1, "hello");
        map.put(2, "bit");
        map.put(3, "hello");
        map.put(4, "lambda");
        map.forEach((k,v)-> System.out.println(k + "=" + v));
    }

    Lambda 的优点:代码简洁、开发迅速、方便函数式编程、容易并行计算,改善了集合操作。缺点:代码可读性变差,非并行场景下性能未必优于传统 for 循环,调试起来相对麻烦。

    五、泛型的通配符

    泛型中的通配符 ? 用来表示某个未知类型,主要解决泛型参数过于固定导致方法复用性差的问题。由于泛型具有不变性,某个具体泛型类型不能自然代表其他泛型类型,所以通配符的出现让方法能接收多种不同类型的泛型对象。

    public class TestDemo {
        public static void main(String[] args) {
            Message message = new Message();
            message.setMessage(55);
            fun(message);
        }
        public static void fun(Message temp){
            //temp.setMessage(100); 无法修改!
            System.out.println(temp.getMessage());
        }
    }

    无界通配符可以接收任意泛型类型,但因为具体类型未知,所以不能安全地写入数据,只适合做通用接收和读取展示。

    通配符上界使用 ? extends 上界类型,表示实际类型只能是该上界类型或其子类。适合读取数据的场景,因为取出的对象至少可以被看作上界类型;但不适合写入数据,因为编译器无法确定容器中保存的是哪个子类。

    class Food {
    }
    class Fruit extends Food {
    }
    class Apple extends Fruit {
    }
    class Banana extends Fruit {
    }
    class Message {
        private T message ;
        public T getMessage() {
            return message;
        }
        public void setMessage(T message) {
            this.message = message;
        }
    }
    public class TestDemo {
        public static void main(String[] args) {
            Message message = new Message<>();
            message.setMessage(new Apple());
            fun(message);
            Message message2 = new Message<>();
            message2.setMessage(new Banana());
            fun(message2);
        }
        public static void fun(Message temp){
            //temp.setMessage(new Banana()); //仍然无法修改!
            //temp.setMessage(new Apple()); //仍然无法修改!
            System.out.println(temp.getMessage());
        }
    }

    通配符下界使用 ? super 下界类型,表示实际类型只能是该下界类型或其父类。适合写入数据的场景,因为写入下界类型或其子类一定是安全的;但读取时无法确定真实父类范围,只能把它看作更宽泛的类型。

    class Food {
    }
    class Fruit extends Food {
    }
    class Apple extends Fruit {
    }
    class Plate {
        private T plate;
        public T getPlate() {
            return plate;
        }
        public void setPlate(T plate) {
            this.plate = plate;
        }
    }
    public class TestDemo {
        public static void main(String[] args) {
            Plate plate1 = new Plate<>();
            plate1.setPlate(new Fruit());
            fun(plate1);
            Plate plate2 = new Plate<>();
            plate2.setPlate(new Food());
            fun(plate2);
        }
        public static void fun(Plate temp){
            temp.setPlate(new Apple());
            temp.setPlate(new Fruit());
            //Fruit fruit = temp.getPlate(); 不能接收,这里无法确定是哪个父类
            System.out.println(temp.getPlate());
        }
    }

    简单总结:通配符让泛型方法更灵活,上界偏向读取,下界偏向写入。行业里常说的原则就是——生产者用 extends,消费者用 super。

    总结

    这篇内容系统梳理了 Ja va 中的反射、枚举和 Lambda 三大特性。反射让程序在运行时动态获取类信息并操作对象,通过 Class 类实现,常用于框架开发和访问私有成员,但性能有损耗;枚举用于组织常量集合,类型安全且不可变,构造方法天然私有,连反射都无法破坏;Lambda 是函数式编程的核心,简化了匿名内部类的写法,通过函数式接口实现代码简洁化,但可读性会下降。另外也涉及了泛型通配符的使用场景,包括无界、上界 extends 和下界 super。这些特性共同增强了 Ja va 的灵活性和表现力,但各自在性能或可维护性上也有相应的权衡。

    本站声明:本文内容由网友自发贡献,版权归原作者所有,本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容,请联系bd@zhengruan.com
    作者最新文章
    编程开发
    相关文章 更多
    关于AWSLambda中的冷启动,你想了解的信息都在这!
    关于AWSLambda中的冷启动,你想了解的信息都在这!

    原文:https://hackernoon.com/cold-starts-in-aws-lambda-f9e3432adbf0作者:Serhat Can译者:donghui关于AWS Lambda中的冷启动,有不少相关的博客文章。我正在进行一些研究,希望在此列出一些优质文章以及关键要点,以便大家能

    AWSLambda取消代码存储配额,别误会:函数大小限制没变
    AWSLambda取消代码存储配额,别误会:函数大小限制没变

    亚马逊云科技最近宣布为 Lambda 推出自管理代码存储,让函数和层可以直接引用客户自有 S3 存储桶中的部署包,而不必将其存放在 Lambda 管理的存储空间中。这一变化取消了每个区域的代码存储配额,过去,运行大规模函数集群的团队通常需要通过提交支持工单来提高这一配额;同时,Lambda 管理的存

    Java 中 Lambda 表达式在异步回调链路中怎么用
    Java 中 Lambda 表达式在异步回调链路中怎么用

    Lambda表达式在Java异步回调中通过CompletableFuture链式调用封装任务、处理结果、统一异常并透传上下文,与监控、日志等基础设施联动实现自动埋点、告警和重试,从而构建可维护、可观测的异步执行骨架。

    Java 中 Lambda 表达式在异步计算任务中怎么应用
    Java 中 Lambda 表达式在异步计算任务中怎么应用

    Lambda表达式作为行为参数传递给CompletableFuture:supplyAsync启动任务,thenApply串行加工,thenCompose避免嵌套依赖,allOf/anyOf并行执行独立任务,自定义线程池管理IO密集型操作,实现高效异步编程。

    Java 中 Lambda 表达式在定时任务执行中怎么用
    Java 中 Lambda 表达式在定时任务执行中怎么用

    Lambda表达式虽不直接执行定时任务,但能简化任务逻辑编写。在Timer中作为任务内容填充者,配合ScheduledExecutorService使用更自然,在Quartz中辅助封装参数和回调。需注意变量捕获、避免内存泄漏及复杂逻辑单独封装。

    怎么通过 List.replaceAll() 配合 Lambda 一次性更新数组列表中的所有业务状态
    怎么通过 List.replaceAll() 配合 Lambda 一次性更新数组列表中的所有业务状态

    今天想跟兄弟们聊一个特别实用的操作——List.replaceAll()配合Lambda表达式,批量更新列表里每个元素的业务状态。简洁,高效,还不用自己手写循环——听起来很香对吧? 但事情真的就这么一步到位吗?有几个坑,提前讲清楚。 一句话说清楚:List.replaceAll()配合Lambda,

    Java 中 Lambda 表达式怎么进行数据集合处理
    Java 中 Lambda 表达式怎么进行数据集合处理

    Lambda表达式与StreamAPI组合,以声明式编程替代传统循环和匿名内部类,通过forEach遍历、filter筛选、map转换、sorted排序等操作处理集合,支持并行流,极大提升代码可读性与开发效率。

    如何在并行流中安全收集嵌套 Lambda 表达式的结果
    如何在并行流中安全收集嵌套 Lambda 表达式的结果

    并行流中嵌套Lambda因局部变量必须为事实不可变而无法修改外部变量。可通过CopyOnWriteArrayList等线程安全容器收集结果,或利用flatMap加collect的无状态流式组合以避免副作用,从而安全地完成并行收集。

    如何利用Lambda表达式优化Elasticsearch中的动态查询变量构建逻辑实战
    如何利用Lambda表达式优化Elasticsearch中的动态查询变量构建逻辑实战

    Lambda表达式将Elasticsearch动态查询中的字段名从字符串硬编码改为方法引用,实现编译期校验、IDE自动补全与重构同步更新,避免运行时字段名错误,提升查询逻辑的清晰度和可维护性,增强代码健壮性,并提高开发效率。

    如何利用Lambda表达式优化RocketMQ中的自定义变量过滤逻辑并实战
    如何利用Lambda表达式优化RocketMQ中的自定义变量过滤逻辑并实战

    RocketMQ不支持服务端Lambda过滤,只能通过SQL92或Tag做粗筛,再在消费端用Lambda进行二次精细筛选。这种分层过滤方式避免了全量消息反序列化带来的压力,结合配置中心动态调整策略,实现灵活的消息路由。需注意开启SQL92配置并保持属性类型一致。

    查看更多
    精品专题 更多
    装机必备
    装机必备

    正软商城装机必备专区,精选办公、浏览器、安全防护、影音播放、压缩解压、设计创作和系统工具等电脑常用正版软件,帮助用户快速完成新电脑软件配置。

    Windows
    Windows

    正软商城Windows软件专区,汇集适用于Windows电脑的办公、设计、安全防护、影音播放、开发工具和系统优化软件,提供软件介绍、系统要求、正版授权及购买下载服务。

    PDF教程
    PDF教程

    正软商城PDF教程频道提供PDF编辑、转换、合并、拆分、压缩及格式处理方法,同时介绍常用PDF软件和工具的使用技巧。

    Mac软件 更多
    讯飞智作 网页版
    讯飞智作 网页版
    Windows/ macOS/ Linux

    讯飞智作是一款基于语音合成技术、虚拟人驱动技术与数字人形象声音构建能力的 AI 数字人音视频创作平台。

    火山引擎 网页版
    火山引擎 网页版
    Windows/ macOS/ Linux

    火山引擎是字节跳动旗下企业级云与AI服务平台。聚焦大模型核心能力,依托字节自研豆包多模态大模型,凭借火山方舟一站式平台,提供模型精调、推理部署、智能应用搭建等全链路服务,结合高性能AI算力,助力各行业快速落地大模型数字化与智能化应用。

    Aperty macOS版
    Aperty macOS版
    macOS

    Aperty 是 Skylum 推出的 AI 人像修图软件,支持自然肤质修饰、瑕疵处理、面部与身体调整、预设及批量同步。

    WINDOWS 更多
    讯飞智作 网页版
    讯飞智作 网页版
    Windows/ macOS/ Linux

    讯飞智作是一款基于语音合成技术、虚拟人驱动技术与数字人形象声音构建能力的 AI 数字人音视频创作平台。

    火山引擎 网页版
    火山引擎 网页版
    Windows/ macOS/ Linux

    火山引擎是字节跳动旗下企业级云与AI服务平台。聚焦大模型核心能力,依托字节自研豆包多模态大模型,凭借火山方舟一站式平台,提供模型精调、推理部署、智能应用搭建等全链路服务,结合高性能AI算力,助力各行业快速落地大模型数字化与智能化应用。

    PixTV 网页版
    PixTV 网页版
    Windows

    PixTV 是一款在浏览器中使用的 AI 视觉内容创作平台,提供图片、视频、音频、文字生成、AI 分镜、局部重绘、提示词反推和无限画布等工具,适合短剧、漫剧、广告及社交媒体内容制作。