2022-08-01 java之泛型、枚举

你的名字 2023-09-30 14:40 48阅读 0赞

#### 目录 ####

*  一、泛型
 *   *  1.什么是泛型
     *  2.泛型的意义
     *  3.泛型用法
     *   *  1.java 中泛型标记符
         *  2.泛型方法
         *  3.泛型类
     *  4.通配符
     *   *  1.通配符
         *  2.上限通配符
         *  3.下限通配符
         *  4.类型擦除
 *  二、枚举
 *   *  1.什么是枚举
     *  2.定义枚举类型
     *  3.枚举与switch
     *  4.所有枚举类都是Enum的子类
     *  5.枚举类的构造器
     *  6.枚举类可以有成员
     *  7.枚举类中还可以有抽象方法
     *  8.每个枚举类都有两个特殊方法
     *  9.实例

## 一、泛型 ##

### 1.什么是泛型 ###

泛型是 Java SE5 出现的新特性，泛型的本质是类型参数化或参数化类型，在不创建新的类型的情况下，通过泛型指定的不同类型来控制形参具体限制的类型。

### 2.泛型的意义 ###

一般的类和方法，只能使用具体的类型：要么是基本类型，要么是自定义的类。如果要编写可以应用于多种类型的代码，这种刻板的限制对代码的束缚就会很大。

Java 在引入泛型之前，表示可变对象，通常使用 Object 来实现，但是在进行类型强制转换时存在安全风险。有了泛型后：

编译期间确定类型，保证类型安全，放的是什么，取的也是什么，不用担心抛出 ClassCastException 异常。

提升可读性，从编码阶段就显式地知道泛型集合、泛型方法等处理的对象类型是什么。

泛型合并了同类型的处理代码提高代码的重用率，增加程序的通用灵活性。

### 3.泛型用法 ###

#### 1.java 中泛型标记符 ####

E - Element (在集合中使用，因为集合中存放的是元素)  
T - Type（Java 类）  
K - Key（键）  
V - Value（值）  
N - Number（数值类型）  
？ - 表示不确定的 java 类型

#### 2.泛型方法 ####

定义泛型方法的规则：

*  所有泛型方法声明都有一个类型参数声明部分（由尖括号分隔），该类型参数声明部分在方法返回类型之前（在下面例子中的 ）。
 *  每一个类型参数声明部分包含一个或多个类型参数，参数间用逗号隔开。一个泛型参数，也被称为一个类型变量，是用于指定一个泛型类型名称的标识符。
 *  类型参数能被用来声明返回值类型，并且能作为泛型方法得到的实际参数类型的占位符。
 *  泛型方法体的声明和其他方法一样。注意类型参数只能代表引用型类型，不能是原始类型（像 int、double、char 等）。

#### 3.泛型类 ####

public class MyClass<T> {
        
        T name;
        T Value;
    }

### 4.通配符 ###

#### 1.通配符 ####

<?> 一般用在方法参数，表示可以接受该类所有类型的泛型变量。

#### 2.上限通配符 ####

<? extends 类> 表示?可以指代任何类型，但是该类型必须是后面类的子类。

#### 3.下限通配符 ####

<? super 类> 此时？表示可以指代任意类型，但是该类型必须是后面类的父类。

#### 4.类型擦除 ####

类型擦除：所有泛型类型参数，若没有设置泛型上限，则编译之后统一擦除为Object类型，若设置了泛型上限，则编译之后统一擦除为相应的泛型上限。

## 二、枚举 ##

### 1.什么是枚举 ###

我们学习过单例模式，即一个类只有一个实例。而枚举其实就是多例，一个类有多个实例，但实例的个数不是无穷的，是有限个数的。例如word文档的对齐方式有几种：左对齐、居中对齐、右对齐。开车的方向有几种：前、后、左、右！我们称呼枚举类中实例为枚举项！一般一个枚举类的枚举项的个数不应该太多，如果一个枚举类有30个枚举项就太多了！

### 2.定义枚举类型 ###

![在这里插入图片描述][50024b5061e84fae9a3d9240084fdbde.png_pic_center]

注意，定义枚举类的关键字是enum，而不是Enum，所有关键字都是小写的！  
其中FRONT、BEHIND、LEFT、RIGHT都是枚举项，它们都是本类的实例，本类一共就只有四个实例对象。  
在定义枚举项时，多个枚举项之间使用逗号分隔，最后一个枚举项后需要给出分号！但如果枚举类中只有枚举项（没有构造器、方法、实例变量），那么可以省略分号！建议不要省略分号！  
不能使用new来创建枚举类的对象，因为枚举类中的实例就是类中的枚举项，所以在类外只能使用类名.枚举项。

### 3.枚举与switch ###

枚举类也可以有构造器，构造器默认都是private修饰，而且只能是private。因为枚举类的实例不能让外界来创建！  
其实创建枚举项就等同于调用本类的无参构造器，所以SMALL、MEDIUM、LARGE、EXTRA\_LARGE四个枚举项等同于调用了四次无参构造器，所以你会看到四次输出。

enum Size {
        
    
      SMALL(),MEDIUM(),LARGE(),EXTRA_LARGE();
      private Size(){
        
      }
    }
    
    package com.picc.javaenum;
    
    public class EnumTest {
        
      public static void main(String[] args) {
        
        System.out.println(Size.SMALL);
      }
    }

![在这里插入图片描述][8a12e48d08984408bd78f568a836c1e1.png]

### 4.所有枚举类都是Enum的子类 ###

所有枚举类都默认是Enum类的子类，无需我们使用extends来继承。这说明Enum中的方法所有枚举类都拥有。

int compareTo(E e)：比较两个枚举常量谁大谁小，其实比较的就是枚举常量在枚举类中声明的顺序;  
boolean equals(Object o)：比较两个枚举常量是否相等；  
int hashCode()：返回枚举常量的hashCode；  
String name()：返回枚举常量的名字；  
int ordinal()：返回枚举常量在枚举类中声明的序号，第一个枚举常量序号为0；  
String toString()：把枚举常量转换成字符串；  
static T valueOf(Class enumType, String name)：把字符串转换成枚举常量。

### 5.枚举类的构造器 ###

枚举类也可以有构造器，构造器默认都是private修饰，而且只能是private。因为枚举类的实例不能让外界来创建！

enum Direction {
        
        FRONT, BEHIND, LEFT, RIGHT;//[在枚举常量后面必须添加分号，因为在枚举常量后面还有其他成员时，分号是必须的。枚举常量必须在枚举类中所有成员的上方声明。]
        
        Direction()//[枚举类的构造器不可以添加访问修饰符，枚举类的构造器默认是private的。但你自己不能添加private来修饰构造器。] {
        
            System.out.println("hello");
        }
    }

其实创建枚举项就等同于调用本类的无参构造器，所以FRONT、BEHIND、LEFT、RIGHT四个枚举项等同于调用了四次无参构造器，所以你会看到四个hello输出。

### 6.枚举类可以有成员 ###

其实枚举类和正常的类一样，可以有实例变量，实例方法，静态方法等等，只不过它的实例个数是有限的，不能再创建实例而已。

### 7.枚举类中还可以有抽象方法 ###

还可以在枚举类中给出抽象方法，然后在创建每个枚举项时使用“特殊”的语法来重复抽象方法。所谓“特殊”语法就是匿名内部类！也就是说每个枚举项都是一个匿名类的子类对象！通常fun()方法应该定义为抽象的方法，因为每个枚举常量都会去重写它。  
你无法把Direction声明为抽象类，但需要声明fun()方法为抽象方法。

enum Direction {
        
        FRONT() {
        
            public void fun() {
        
                System.out.println("FROND：重写了fun()方法");
            }
        }, 
        BEHIND() {
        
            public void fun() {
        
                System.out.println("BEHIND：重写了fun()方法");
            }
        }, 
        LEFT() {
        
            public void fun() {
        
                System.out.println("LEFT：重写了fun()方法");
            }
        },
        RIGHT() {
        
            public void fun() {
        
                System.out.println("RIGHT：重写了fun()方法");
            }
        };
        
        public abstract void fun()[只需要把fun()方法修改为抽象方法，但不可以把Direction类声明为抽象类。];
    }

### 8.每个枚举类都有两个特殊方法 ###

### 9.实例 ###

/**
     * <p>
     * 枚举测试
     * </p>
     **/
    public enum EnumTest {
        
        ONE("aa", "test1", 33),
        TWO("bb", "test2", 66),
        Three("cc", "test3", 99);
        private String a;
        private String b;
        private int c;
     
        EnumTest(String a, String b, int c) {
        
            this.a = a;
            this.b = b;
            this.c = c;
        }
     
        @Override
        public String toString() {
        
            return "EnumTest{" +
                    "a='" + a + '\'' +
                    ", b='" + b + '\'' +
                    ", c=" + c +
                    '}';
        }
     
    //通过a获取枚举对象
        public static EnumTest fromA(String a) {
        
            for (EnumTest enumTest : EnumTest.values()) {
        
                if (a.equals(enumTest.getA())) {
        
                    return enumTest;
                }
            }
            return null;
        }
     
      //通过名字获取枚举对象
        public static EnumTest fromName(String name) {
        
            return EnumTest.valueOf(name);
        }
     
        public String getA() {
        
            return a;
        }
     
    }

[50024b5061e84fae9a3d9240084fdbde.png_pic_center]: https://img-blog.csdnimg.cn/50024b5061e84fae9a3d9240084fdbde.png#pic_center
[8a12e48d08984408bd78f568a836c1e1.png]: https://img-blog.csdnimg.cn/8a12e48d08984408bd78f568a836c1e1.png