• 【Java基础】泛型+反射+枚举+Lambda表达式 知识点总结

    【大家好，我是爱干饭的猿，本文重点介绍Java基础：泛型、反射、枚举、Lambda表达式知识点总结。

    后续会继续分享其他重要知识点总结，如果喜欢这篇文章，点个赞👍，关注一下吧】

    上一篇文章：《【web】Java虚拟机(JVM)（重点：JVM 执行流程&垃圾回收相关算法）》

    🤞目录🤞

    💳1. 泛型

    1.1 什么是泛型？

    1.2 泛型类和泛型方法

    1.3 extends类型边界

    1.4 类型擦除

    1.5 通配符

    1. 通配符-上界

    2. 通配符-下界

    💳2. 反射

    2.1 定义

    2.2 用途 

    2.3 反射基本信息

    2.4 反射相关的类

    1. Class类(反射机制的起源 ) 和 Class类中的相关方法

    2. 反射示例（使用）

    2.5 反射优点和缺点

    💳3. 枚举

    3.1 背景及定义

    3.2 使用

    3.3 枚举优点缺点

    3.4 枚举是否可以通过反射，拿到实例对象呢？

    💳4. Lambda 表达式

    4.1 背景

    1. Lambda表达式的语法

    2. 函数式接口

    4.2 Lambda表达式的基本使用

    4.3 Lambda在集合当中的使用

    4.4 优点和缺点

     

    💳1. 泛型

    1.1 什么是泛型？

    作用参数校验，将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参）然后在使用/调用时传入具体的类型（类型实参）。

    也就是说在泛型使用过程中，操作的数据类型被指定为一个参数，这种参数类型可以用在类、接口和方法中，分别被称为泛型类、泛型接口、泛型方法。

    为什么会增加泛型机制呢？

    • 对于集合的使用更为规范。
    • 使用了泛型就解决了元素不确定性。

    1.2 泛型类和泛型方法

    泛型类：就是一个具有多种类型变量的类。

    泛型方法：就是在调用方法的时候指明泛型的具体类型 。

    一个最普通的泛型类：

    1. public class Test {
    2.     public static void main(String[] args) {
    3.         IMessage message = new MessageImpl1();
    4.         message.printMsg("123");
    5.         IMessage message1 = new MessageImpl2();
    6.         message1.printMsg(123);
    7.     }
    8. }
    9.  
    10. interface IMessage {
    11.     // 泛型方法
    12.      void printMsg(T t);
    13. }
    14.  
    15. class MessageImpl1 implements IMessage {
    16.  
    17.     @Override
    18.     public  void printMsg(T1 t1) {
    19.         System.out.println(t1);
    20.         System.out.println("是泛型类");
    21.     }
    22. }
    23.  
    24. class MessageImpl2 implements IMessage {
    25.  
    26.     @Override
    27.     public  void printMsg(T t) {
    28.         System.out.println(t);
    29.         System.out.println("是普通类");
    30.     }
    31. }

    1.3 extends类型边界

    在定义泛型类时，有时需要对传入的类型变量做一定的约束，可以通过类型边界来约束。泛型的限定符extends限定符，就是字面意思，限定了他的范围，即缩小泛型的类型范围。

    1. public class demo1 {
    2.     public static void main(String[] args) {
    3.         MyArray myArray = new MyArray();
    4.         MyArray myArray1 = new MyArray<>();
    5.     }
    6. }
    7.  
    8. class MyArrayextends Number> {
    9.     // ...
    10. }

    1.4 类型擦除

    泛型是作用在编译期间的一种机制，实际上运行期间是没有这么多类的，那运行期间是什么类型呢？这里就是类型擦除在做的事情。 

    1. class MyArray {
    2.     // 类型擦除为 Object
    3. }
    4.  
    5. class MyArray2extends Number> {
    6.     // 类型擦除为 Number
    7. }
    8.  
    9. class MyArray3extends Comparable> {
    10.     // 类型擦除为 Comparable
    11. }

    类型擦除主要看其类型边界而定。

    编译器在类型擦除阶段在做什么？

    1. 将类型变量用擦除后的类型替换，即 Object 或者 其他 

    2. 加入必要的类型转换语句

    3. 加入必要的 bridge method 保证多态的正确性

    1.5 通配符

    ? 用于在泛型的使用，即为通配符

    1. public class Demo2 {
    2.     public static void printAll(MyArrayList list){}
    3.  
    4.     public static void main(String[] args) {
    5.         // 可以传入任意类型的 MyArrayList
    6.         printAll(new MyArrayList());
    7.         printAll(new MyArrayList());
    8.         printAll(new MyArrayList());
    9.     }
    10. }
    11.  
    12. class MyArrayList {}
      13.  

      1. 通配符-上界
       

       

      用 extends 关键字声明，表示参数化的类型可能是所指定的类型，或者是此类型的子类。
       

      1. public class Demo2 {
      2.     // 可以传入类型实参是 Number 子类的任意类型的 MyArrayList
      3.     public static void printAll(MyArrayList list){}
      4.  
      5.     public static void main(String[] args) {
      6.         printAll(new MyArrayList());
      7.         printAll(new MyArrayList());
      8.         printAll(new MyArrayList());
      9.     }
      10. }
      11.  
      12. class MyArrayList {}
       

      2. 通配符-下界
       

       

      用 super 进行声明，表示参数化的类型可能是所指定的类型，或者是此类型的父类型，直至 Object。
       

      1. public class Demo2 {
      2.     // 可以传入类型实参是 Integer 父类的任意类型的 MyArrayList
      3.     public static void printAll(MyArrayListsuper Integer> list){}
      4.  
      5.     public static void main(String[] args) {
      6.         printAll(new MyArrayList());
      7.         printAll(new MyArrayList());
      8.         printAll(new MyArrayList());
      9.     }
      10. }
      11.  
      12. class MyArrayList {}
        13.  

        a. 泛型的限制
         

        1. 泛型类型参数不支持基本数据类型
         

        2. 无法实例化泛型类型的对象
         

        3. 无法使用泛型类型声明静态的属性
         

        4. 无法使用 instanceof 判断带类型参数的泛型类型
         

        5. 无法创建泛型类数组
         

        6. 无法 create、catch、throw 一个泛型类异常（异常不支持泛型） 7. 泛型类型不是形参一部分，无法重载
         

        b. 常用的 T，E，K，V，？
         

        本质上这些个都是通配符，没啥区别，只不过是编码时的一种约定俗成的东西。
         

        通常情况下：
         

        • ？ 表示不确定的 java 类型
        • T (type) 表示具体的一个java类型
        • K V (key value) 分别代表java键值中的Key Value
        • E (element) 代表Element
        • S, U, V 等等 - 第二、第三、第四个类型
         

         

        💳2. 反射
         

        2.1 定义
         

        Java的反射（reflection）机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性，既然能拿到那么，我们就可以修改部分类型信息；这种动态获取信 息以及动态调用对象方法的功能称为java语言的反射（reflection）机制。
         

        2.2 用途 
         

        1、在日常的第三方应用开发过程中，经常会遇到某个类的某个成员变量、方法或是属性是私有的或是只对系统应 用开放，这时候就可以利用Java的反射机制通过反射来获取所需的私有成员或是方法 。
         

        2、反射最重要的用途就是开发各种通用框架，比如在spring中，我们将所有的类Bean交给spring容器管理，无论 是XML配置Bean还是注解配置，当我们从容器中获取Bean来依赖注入时，容器会读取配置，而配置中给的就是类 的信息，spring根据这些信息，需要创建那些Bean，spring就动态的创建这些类。
         

        2.3 反射基本信息
         

        Java程序中许多对象在运行时会出现两种类型：运行时类型(RTTI)和编译时类型，例如Person p = new Student()；这句代码中p在编译时类型为Person，运行时类型为Student。程序需要在运行时发现对象和类的真实 信心。而通过使用反射程序就能判断出该对象和类属于哪些类。
         

        2.4 反射相关的类
         

        dfca84cba1c54f71a97e5ff85707c5ae.png
         

        1. Class类(反射机制的起源 ) 和 Class类中的相关方法
         

        Class帮助文档代表类的实体，在运行的Java应用程序中表示类和接口. Java文件被编译后，生成了.class文件，JVM此时就要去解读.class文件 ,被编译后的Java文件.class也被JVM解析为 一个对象，这个对象就是 java.lang.Class .这样当程序在运行时，每个java文件就最终变成了Class类对象的一个 实例。我们通过Java的反射机制应用到这个实例，就可以去获得甚至去添加改变这个类的属性和动作，使得这个类成为一个动态的类。
         

        常用获得类相关的方法 
         

        9157a378418247c1aea09c4296819d59.png
         

        常用获得类中属性相关的方法
         

        d21b9b3a4b70404ba39d8b4eaf3e6ba9.png获得类中注解相关的方法
         

        9880266523ce40b4b842dc36f757a00c.png获得类中构造器相关的方法
         

        cc27f2ea011e48a29cc7bf665c72c4ca.png
         

        获得类中方法相关的方法
         

        0e543ed409334aee9778a701b913e993.png
         

        2. 反射示例（使用）
         

        a. 获得Class对象的三种方式
         

        在反射之前，我们需要做的第一步就是先拿到当前需要反射的类的Class对象，然后通过Class对象的核心方法，达 到反射的目的，即：在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象， 都能够调用它的任意方法和属性，既然能拿到那么，我们就可以修改部分类型信息。
         

        第一种，使用 Class.forName("类的全路径名"); 静态方法。 前提：已明确类的全路径名。
         

        第二种，使用 .class 方法。 说明：仅适合在编译前就已经明确要操作的 Class。
         

        第三种，使用类对象的 getClass() 方法。
         

        b. 反射的使用
         

        注意：所有和反射相关的包都在 import java.lang.reflect 包下面。
         

        Son 类
         

        1. public class Son {
        2.     private String name;
        3.     private int age;
        4.     public int aa;
        5.     int bb;
        6.  
        7.     Son(){
        8.         System.out.println("我是包无参构造");
        9.     }
        10.     private Son(String name) {
        11.         System.out.println("我是私有有参构造 name = " + name);
        12.     }
        13.     public Son(String name, int age){
        14.         System.out.println("我是公有有参构造 name = " + name + "age" +age);
        15.     }
        16.  
        17.     void method1(){
        18.         System.out.println("我是无参方法");
        19.     }
        20.     private void method2(String dd){
        21.         System.out.println("我是包访问权限有参方法" + dd);
        22.     }
        23.     public void method3(String dd, String cc){
        24.         System.out.println("我是公共有参方法" + dd);
        25.     }
        26. }
         

        使用
         

        1. public class Test {
        2.     public static void main(String[] args) throws Exception{
        3.         // 得到class
        4.         Class c1 = Son.class;
        5.         Classextends Son> c2 = new Son().getClass();
        6.         Class c3 = Class.forName("Object.reflect.Son");
        7.  
        8.         System.out.println(c1 == c2);
        9.         System.out.println(c2 == c3);
        10.  
        11.         // 得到构造方法
        12.         Constructor[] constructors = c1.getConstructors();
        13.         System.out.println(Arrays.toString(constructors));
        14.         Constructor[] declaredConstructors = c1.getDeclaredConstructors();
        15.         System.out.println(Arrays.toString(declaredConstructors));
        16.  
        17.         // 得到方法
        18.         Method[] methods = c1.getMethods();
        19.         System.out.println(Arrays.toString(methods));
        20.         Method[] declaredMethods = c1.getDeclaredMethods();
        21.         System.out.println(declaredMethods);
        22.  
        23.         // 得到属性
        24.         Field[] fields = c1.getFields();
        25.         System.out.println(fields);
        26.         Field[] declaredFields = c1.getDeclaredFields();
        27.         System.out.println(declaredFields);
        28.  
        29.         // 使用反射使用对象私有的构造方法
        30.         Class clSon = Class.forName("Object.reflect.Son");
        31.         Constructor constructor = clSon.getDeclaredConstructor(String.class);
        32.         constructor.setAccessible(true);
        33.         Object hh = constructor.newInstance("hh");
        34.         Son son = (Son) hh;
        35.         System.out.println(son);
        36.  
        37.         // 使用反射设置对象私有的属性
        38.         Class sonClass = Son.class;
        39.         Field field = sonClass.getDeclaredField("name");
        40.         field.setAccessible(true);
        41.         Son son1 = sonClass.newInstance();
        42.         field.set(son1, "dd");
        43.         System.out.println(field.get(son1));
        44.  
        45.         // 使用反射使用对象私有方法
        46.         Class sonClass1 = Son.class;
        47.         Method method2 = sonClass1.getDeclaredMethod("method2", String.class);
        48.         method2.setAccessible(true);
        49.         Son son2 = sonClass1.newInstance();
        50.         method2.invoke(son2, "李四");
        51.     }
        52. }
         

        2.5 反射优点和缺点
         

        优点：
         

        1. 对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法
         

        2. 增加程序的灵活性和扩展性，降低耦合性，提高自适应能力
         

        3. 反射已经运用在了很多流行框架如：Struts、Hibernate、Spring 等等。
         

        缺点：
         

        1. 使用反射会有效率问题。会导致程序效率降低。
         

        2. 反射技术绕过了源代码的技术，因而会带来维护问题。反射代码比相应的直接代码更复杂 。
         

         

        💳3. 枚举
         

        枚举的使用
         

        3.1 背景及定义
         

        枚举是在JDK1.5以后引入的。主要用途是：将一组常量组织起来，在这之前表示一组常量通常使用定义常量的方式。
         

        优点：将常量组织起来统一进行管理
         

        场景：错误状态码，消息类型，颜色的划分，状态机等等....
         

        本质：是 java.lang.Enum 的子类，也就是说，自己写的枚举类，就算没有显示的继承 Enum ，但是其默认继承了 这个类。
         

        3.2 使用
         

        1. switch语句
         

        1. public enum Enum1 {
        2.     Red, Blue, Pink;
        3.  
        4.     public static void main(String[] args) {
        5.         Enum1 enum1 = Enum1.Red;
        6.         switch (enum1){
        7.             case Red:
        8.                 System.out.println("Red"); break;
        9.             case Blue:
        10.                 System.out.println("Blue"); break;
        11.             case Pink:
        12.                 System.out.println("Pink"); break;
        13.         }
        14.     }
        15. }
         

        2. 常用方法
         

        Enum 类的常用方法
         

        a22fd191ecec4632a3cca82062eafa44.png
         

        1. public enum Enum2 {
        2.     Red, Blue, Pink;
        3.  
        4.     public static void main(String[] args) {
        5.         Enum2[] values = Enum2.values();
        6.         // 得到枚举成员及其索引位置
        7.         for (Enum2 value : values) {
        8.             System.out.println("枚举成员：" + value +" 索引位置："+value.ordinal());
        9.         }
        10.         // 将普通字符串转换为枚举实例
        11.         System.out.println(Enum2.valueOf("Red"));
        12.  
        13.         // 得到成员实例
        14.         Enum2 red = Enum2.Red;
        15.         Enum2 blue = Enum2.Blue;
        16.  
        17.         // compereTo比较两个枚举成员在定义时的顺序
        18.         System.out.println(red.compareTo(blue));
        19.         System.out.println(Red.compareTo(Blue));
        20.         System.out.println(Pink.compareTo(Blue));
        21.     }
        22. }
         

         Java当中枚举实际上就是一个类
         

        1. public enum Enum3 {
        2.     Red("red",1), Blue("blue",2), Pink("pink", 3);
        3.  
        4.     private String name;
        5.     private int key;
        6.  
        7.     private Enum3 (String name,int key) {
        8.         this.name = name;
        9.         this.key = key;
        10.     }
        11.     public static Enum3 getEnumKey (int key) {
        12.         for (Enum3 t: Enum3.values()) {
        13.             if(t.key == key) {
        14.                 return t;
        15.             }
        16.         }
        17.         return null;
        18.     }
        19.  
        20.     public static void main(String[] args) {
        21.         System.out.println(Enum3.getEnumKey(1));
        22.     }
        23. }
         

        3.3 枚举优点缺点
         

        优点：
         

        1. 枚举常量更简单安全 。
         

        2. 枚举具有内置方法 ，代码更优雅
         

        缺点：
         

        1. 不可继承，无法扩展
         

        3.4 枚举是否可以通过反射，拿到实例对象呢？
         

        我们刚刚在反射里边看到了，任何一个类，哪怕其构造方法是私有的，我们也可以通过反射拿到他的实例对象，那么枚举的构造方法也是私有的，我们是否可以拿到呢？
         

        不能。
         

        没有对应的构造方法，我们所有的枚举类，都是默认继承与 java.lang.Enum，继承了父类除构造函数外的所有东西，并且子类要帮助父类进行构造！ 而我们写的类，并没有帮助父类构造！
         

        枚举被过滤了，所以不能通过反射获取枚举类的实例！这道题是2017年阿里巴巴曾经问到的一个问题。原版问题是：为什么枚举实现单例模式是安全的？
         

        用枚举实现一个单例模式 
         

        1. public enum TestEnum {
        2.     INSTANCE;
        3.     public TestEnum getInstance(){
        4.         return INSTANCE;
        5.     }
        6.     public static void main(String[] args) {
        7.         TestEnum singleton1=TestEnum.INSTANCE;
        8.         TestEnum singleton2=TestEnum.INSTANCE;
        9.         System.out.println("两个实例是否相同："+(singleton1==singleton2));
        10.     }
        11. }
         

         

        💳4. Lambda 表达式
         

        4.1 背景
         

        Lambda表达式是Java SE 8中一个重要的新特性。lambda表达式允许你通过表达式来代替功能接口。 lambda表达式就和方法一样,它提供了一个正常的参数列表和一个使用这些参数的主体(body,可以是一个表达式或一个代码 块)。Lambda 表达式（Lambda expression）可以看作是一个匿名函数，基于数学中的λ演算得名，也可称为闭 包（Closure）。
         

        1. Lambda表达式的语法
         

        基本语法: (parameters) -> expression 或 (parameters) ->{ statements; }
         

        Lambda表达式由三部分组成：
         

        1. paramaters：类似方法中的形参列表，这里的参数是函数式接口里的参数。这里的参数类型可以明确的声明 也可不声明而由JVM隐含的推断。另外当只有一个推断类型时可以省略掉圆括号。
         

        2. ->：可理解为“被用于”的意思
         

        3. 方法体：可以是表达式也可以代码块，是函数式接口里方法的实现。代码块可返回一个值或者什么都不反 回，这里的代码块块等同于方法的方法体。如果是表达式，也可以返回一个值或者什么都不反回。
         

        2. 函数式接口
         

        要了解Lambda表达式,首先需要了解什么是函数式接口，函数式接口定义：一个接口有且只有一个抽象方法 。
         

        注意：
         

        1. 如果一个接口只有一个抽象方法，那么该接口就是一个函数式接口
         

        2. 如果我们在某个接口上声明了 @FunctionalInterface 注解，那么编译器就会按照函数式接口的定义来要求 该接口，这样如果有两个抽象方法，程序编译就会报错的。所以，从某种意义上来说，只要你保证你的接口 中只有一个抽象方法，你可以不加这个注解。加上就会自动进行检测的。
         

        1. @FunctionalInterface
        2. interface IMessage{
        3.     void printMessage(String msg);
        4.  
        5.     default void printOther(){
        6.         System.out.println("接口中的普通方法");
        7.     }
        8. }
         

        4.2 Lambda表达式的基本使用
         

        1. // 无返回值无参
        2. interface NonReturnNonParameter{
        3.     void test();
        4. }
        5.  
        6. // 无返回值有参
        7. interface NonReturnHasParameter{
        8.     void test(String name, int age);
        9. }
        10.  
        11. // 有返回值无参
        12. interface HasReturnNonParameter{
        13.     String test();
        14. }
        15.  
        16. // 有返回值有参
        17. interface HasReturnHasParameter{
        18.     String test(String name, int age);
        19. }
        20.  
        21. public class LambdaUsage {
        22.     public static void main(String[] args) {
        23.         NonReturnNonParameter i1 = () -> System.out.println("Lambda 无返回值无参");
        24.         i1.test();
        25.  
        26.         NonReturnHasParameter i2 = (name, age) -> System.out.println("Lambda 无返回值有参");
        27.         i2.test("张三", 18);
        28.  
        29.         HasReturnNonParameter i3 = () -> "Lambda 有返回值无参";
        30.         System.out.println(i3.test());
        31.  
        32.         HasReturnHasParameter i4 = (name, age) -> "Lambda 有返回值有参";
        33.         System.out.println(i4.test("张三", 18));
        34.     }
        35. }
         

        4.3 Lambda在集合当中的使用
         

        为了能够让Lambda和Java的集合类集更好的一起使用，集合当中，也新增了部分接口，以便与Lambda表达式对接。
         

        1ff07e092f484b2ba8daa74f999bd8cf.png
         

        4.4 优点和缺点
         

        优点：
         

        1. 代码简洁，开发迅速
         

        2. 方便函数式编程
         

        3. 非常容易进行并行计算
         

        4. Java 引入 Lambda，改善了集合操作
         

        缺点：
         

        1. 代码可读性变差
         

        2. 在非并行计算中，很多计算未必有传统的 for 性能要高
         

        3. 不容易进行调试
         

         

        分享到此，感谢大家观看！！！
         

        如果你喜欢这篇文章，请点赞加关注吧，或者如果你对文章有什么困惑，可以私信我。
         

        🏓🏓🏓
         

         
        
                
                    
                

                
      13. 

                    相关阅读:
        
                    
Java-Swing程序设计                            
        
JVM内存模型解析                            
        
干货 | 基于深度学习的生态保护红线和生态空间管控区域内开发建设活动识别...                            
        
[附源码]Java计算机毕业设计SSM二手图书回收销售网站                            
        
回溯之 组合类问题                            
        
饥荒专用服务器                            
        
React 使用JSX或者TSX渲染页面                            
        
CentOS7常用yum仓库操作及安装                            
        
电脑Win11安装Autocad出现错误要如何处理                            
        
y49.第三章 Kubernetes从入门到精通 -- k8s实战案例(二二)                            
        
                            
                
        14. 
                
      14. 
                    原文地址：https://blog.csdn.net/m0_62218217/article/details/127822568
                
        15.