Day02 关键字接口枚举

代码块的总结
- 成员变量
- 成员方法
继承接口定义及使用
枚举的基础使用
JDK接口私有方法
- 枚举
static关键字：
final关键字：
权限关键字：
- 1. java语言中有哪些权限修饰符，访问范围分别是什么？
- 2. 如果不想别人创建对象，那么可以用什么修饰符去修饰构造方法？
代码块：
接口：
枚举：
今日内容
1 Java中的关键字
- 1.1 static关键字
1.2 final关键字
2 代码块
3 接口
4 枚举

代码块的总结

1.构造代码块怎么定义，怎么执行，怎么用？
定义：在类中方法外定义一个大括号
执行特点：会在每一个构造方法执行前，执行一次
作用：如果每个构造方法有重复的逻辑时，可以抽取到构造代码块中

2.静态代码块怎么定义，怎么执行，怎么使用？
定义：直接在构造代码块上加static
执行特点：随着类加载到内存，会执行一次，（类加载到方法区初始化的时候就会执行静态代码块）
作用：可以对静态变量，或者静态常量进行初始化值

3.局部代码块怎么定义，怎么执行怎么使用？
定义：任何局部代码块位置都可以定义局部代码块，就是一对大括号
静态代码块：构造代码块，构造方法中都可以定义局部代码块
作用：可以限定变量的作用域

成员变量

只能是常量
默认修饰符 public static final

构造方法
没有

成员方法

只能是抽象方法
publ sbstrar

接口默认的方法定义

public default 返回值类型方法名（参数列表）{}

public default void show(){}

继承接口定义及使用

第一步：
先定义一个interface名字起为功能使用的概述名字
定义各种功能如开始暂停结束。

public interface Player1 {
int num=2000;
void play();

void pause();

void stop();

}
第二步：
创建第一个需要使用该功能的类并继承接口的功能使用impplements拼接
而后调用刚刚所创建的功能并输入语句。

public class BigCar implements Player1 {
@Override
public void play() {
System.out.println(“大汽车出发！”);
}

@Override
public void pause() {
System.out.println(“大汽车刹车！”);
}

@Override
public void stop() {
System.out.println(“大汽车停止！”);
}
}
第三步：
创建第二个需要使用该功能的类并继承接口的功能使用impplements拼接
而后调用刚刚所创建的功能并输入语句。

public class SmartCar implements Player1{
@Override
public void play() {
System.out.println(“小汽车出发！”);
}

@Override
public void pause() {
System.out.println(“小汽车刹车！”);
}

@Override
public void stop() {
System.out.println(“小汽车停车！”);
}
}
第四部实现调用输出！
直接调用接口对面名即可输出。用new出来的新变量去点之前接口中所定义的方法。

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

BigCar b1 = new BigCar();
b1.play();
b1.pause();
b1.stop();
System.out.println(“价值”+Player1.num+”块钱”);
System.out.println();

SmartCar s1=new SmartCar();
s1.play();
s1.pause();
s1.stop();

}
}

枚举的基础使用

定义一个Enum文件名字起为各项常量的通用描述词例如（春夏秋冬：气候）（男女：性别）
switch语句每个case后面需要写 break避免发生穿透现象。
第一步:
public enum Time {
SPRING,SUMMER,AUTUMN,WINTER

}
第二步：
public class EnumDomeWork04 {
public static void main(String[] args) {
change(Time.SPRING);
// Time.values.var
Time[] values = Time.values();
}

public static void change(Time time) {
switch (time) {
case SPRING:
System.out.println(“春天”);
break;
case SUMMER:
System.out.println(“夏天”);
break;
case AUTUMN:
System.out.println(“秋天”);
break;
case WINTER:
System.out.println(“冬天”);
break;
}
}
}

注意事项：

默认方法不是抽象方法，所以不强制被重写。但是可以被重写重写的时候去掉default关键字

public 可以省略 depault不能省略

实现了多个接口，多个接口中存在相同的方法声明，子类就必须对该方法重写

静态方法jdk8

public static 返回值类型方法名（参数列表）{}
public static void show(){}

静态的注意
静态方法只能通过接口名调用，不能通过类名和对象名调用
public 可以省略，static不能省略

JDK接口私有方法

格式
private 返回值类型方法名（参数列表）{}
private void shou(){}

private static void mothid(){}

接口使用思路：

如果发现一个类中所以方法都是抽象方法，那么久可以将该类，改进成为一个接口

1. 涉及到了接口的大面积更新方法，而不想去修改每一个实现类就可以将更新的方法，定义为带有方法体的默认方法

2.希望默认方法调用的更加简洁，可以考虑涉及为static静态方法（需要去掉default关键字）

3.接口在的方法出现了重复的代码，还不行被其他类访问，可以考虑抽取出一个私有方法。

类和接口的关系:

1. 类和类的关系：
只能是继承单继承，多层继承

2. 类和接口的关系：
实现关系，可以单实现，也可以多实现，还可以在继承一个类的同时实现多个接口

3. 接口和接口的关系
继承关系，可以单继承，也可以多继承

枚举

定义枚举：
权限修饰符 enum 枚举名称{
枚举项1，枚举项2，。。。；
}
枚举之间逗号分割，最后分号结束。
示例:

public enum Sex{
BOY,GIRL;
}
枚举使用：
通过枚举名直接引用枚举项即可，例如Sex.BOY,Sex.GIRL

注意每个枚举项都相当于枚举的对象！！！

枚举本质上就是一个类，每一个枚举项就是本枚举类型的一个对象：
反编译：cmd中找到字节码文件路径，可以执行：javap-p 字节码文件

//将所有的枚举对象返回
Pubilc static Sex[] valuse();
//将枚举的常量名字符串，转换为枚举对象
piblic static Sex valuof（java.lang.String）；
private Sex(); //构造方法
static{}; //静态代码块

枚举本质是一个final类，继承了Enum类

枚举是一个类，可以类中可以定义的成分，比如成员变量，构造方法，成员方法等

枚举的构造特点: 是私有的，外界无法调用，只能定义枚举的时候使用

枚举的实例方法使用：直接用枚举项调用
# 复习讨论

static关键字：

1. 静态关键字有什么作用？？？

修饰成员方法，修饰成员变量

2. 静态关键字修饰成员后该成员怎么称呼，格式怎么写，怎么进行访问？？？

被静态关键字修饰后的成员变量叫做静态变量。
可以通过类名直接调用

3. 静态变量有什么特点？

在内存中只有一份数据

4. 静态方法在访问本类成员时有什么特点？

随着类的加载而加载，优先于对象存在

5. 静态方法里面能有this么，如果要访问本类非静态成员可以怎么做？

只能访问静态成员静态中不能有this

final关键字：

1. final表示什么含义？

是最终最后的意思！

2. final可以修饰什么成分，各自有什么作用？

修饰（变量，方法，类）
修饰方法表明：该方法是最终方法，不能被重写
修饰变量：表明该变量是最终变量，不能被再次赋值！
修饰类表明：表明类是最终类不能被继承

3. 如果类不想被别人继承怎么办？

使用final修饰符进行修饰！

4. 如果方法不想让别人重写怎么办？

使用final对该方法进行修饰！

5. 如果变量定义好后不想让别人去更改值怎么办？

使用final对该变量进行修饰！

权限关键字：

1. java语言中有哪些权限修饰符，访问范围分别是什么？

public ：公共的，当前模块内部可以使用
protected ：受保护的，同一个包下都可以访问，其他包下只有子类可以访问
默认权限（package-private ）：也成为私有包，同一个包下可以，其他包不行
private：只有本类访问

2. 如果不想别人创建对象，那么可以用什么修饰符去修饰构造方法？

final去修饰构造方法

代码块：

1. java中有哪些代码块？

构造代码块，静态代码块，局部代码块

2. 构造代码块格式怎么定义，执行特点，作用是什么？

定义：在类中方法外定义一个大括号
执行特点：会在每一个构造方法执行前，执行一次
作用：如果每个构造方法有重复的逻辑时，可以抽取到构造代码块中

3. 静态代码块格式怎么定义，执行特点，作用是什么？

定义：直接在构造代码块上加static
执行特点：随着类加载到内存，会执行一次，（类加载到方法区初始化的时候就会执行静态代码块）
作用：可以对静态变量，或者静态常量进行初始化值

4. 局部代码块格式怎么定义，执行特点，作用是什么？

定义：任何局部代码块位置都可以定义局部代码块，就是一对大括号
静态代码块：构造代码块，构造方法中都可以定义局部代码块
作用：可以限定变量的作用域

接口：

1. 简述，Java语言中接口类型存在的意义是什么？

1.规则的定义
2.程序的扩展性

2. 接口定义格式是怎样的，接口中可以哪些成员？

public default 返回值类型方法名（参数列表）{}
public default void show(){}

3. 接口可以实例化对象么，如果不行怎么用？

不可以，需要用方法重写！

4. JDK8，JDK9新增了哪些方法，可以怎么用？

JDK8 允许在接口中定义非抽象方法
public default 返回值类型方法名(参数列表) { }
public default void show() { }

JDK8 允许定义static静态方法
public static 返回值类型方法名(参数列表) { }
public static void show() { }

JDK9 允许接口中私有方法
private 返回值类型方法名(参数列表) { }
private void show() { }

5. 请说明类与类，类与接口，接口与接口的关系

1. 类和类的关系：
只能是继承单继承，多层继承

2. 类和接口的关系：
实现关系，可以单实现，也可以多实现，还可以在继承一个类的同时实现多个接口

3. 接口和接口的关系
继承关系，可以单继承，也可以多继承

6. 请简述下接口的使用思路，如何选择方法使用

如果发现一个类中所有的方法都是抽象方法，那么就可以将该类，改进为一个接口
涉及到了接口大面积更新方法，而不想去修改每一个实现类，就可以将更新的方法，定义为带有方法体的默认方法
希望默认方法调用的更加简洁，可以考虑设计为static静态方法。（需要去掉default关键字）
接口中的方法出现了重复的代码，还不想被其他类访问, 可以考虑抽取出一个私有方法。（需要去掉default关键字）

枚举：

1. 枚举的格式怎么定义，怎么使用？以Sex枚举为例

使用：枚举名直接调用枚举项即可
枚举格式如下可以结合switch进行使用：
public enum Sex {
BOY,GIRL;
}
public class TrafficLight {
public static void main(String[] args) {
change(Signal.GREEN);
}
public static void change(Signal color) {
switch (color) {
case GREEN:
System.out.println(“绿灯行”);
break;
case YELLOW:
System.out.println(“黄灯亮了等一等”);
break;
case RED:
System.out.println(“红灯停”);
break;
}
}
}

2. 枚举本质上是什么？里面可以有哪些成分？

枚举本质上是一个final类，继承了Enum类。

3. 定义尽可能多的枚举类（至少2个）

public enum Weather{
SPRING, SUMMER, AUTUMN，WINTER;
}
public class Season{
public static void main(String[] args) {
change(Weather.SPRING);
}   
public static void change(Weather distinction) {
switch (distinction) { 
case SPRING：
System.out.println("春天万物复苏");
break;
case SUMMER：
System.out.println("夏天很热");
break;   
case AUTUMN：
System.out.println("秋天果实丰收");
break;
case WINTER：
System.out.println("冬天下雪，滑雪！");
break;
}
}
}

今日内容

1 关键字

2 代码块

3 接口

4 枚举

1 Java中的关键字

1.1 static关键字

static关键字 :
- 静态的意思 , 可以修饰变量 , 也可以修饰方法 , 被static修饰的成员 , 我们叫做静态成员
  静态成分属于类可以直接用类名调用。
  静态变量【类变量】
  静态方法【类方法】
  非静态成分属于对象，必须使用对象才能访问调用。
  非静态变量【实例变量】
  非静态方法【实例方法】
  实例==对象
static特点 :
- 静态成员被所在类的所有对象共享（静态成分在类中只有一个数据，适合做数据的共享）
- 随着类的加载而加载 , 优先于对象存在
- 可以通过对象调用 , 也可以通过类名调用 , 建议使用类名

public class Student {
String name;
int age;
static String school;
public void show() {
    System.out.println(name + "---" + age + "---" + school);
}
}
/*
static关键字的特点 :
    1 静态成员被该类的所有对象的进行共享
    2 静态成员可以通过类名调用 , 也可以通过对象进行调用 , 推荐使用类名
    3 静态成员随着类的加载而加载 , 优先于对象存在
*/
public class StudentTest {
public static void main(String[] args) {
    Student.school = "传智专修学院";
    Student s = new Student();
    s.name = "张三";
    s.age = 23;
    s.show();
    Student s2 = new Student();
    s2.show();
}
}

static内存图解
static关键字的注意事项
- 在静态方法所在类内部，静态方法中只能调用静态成员（静态只能访问静态）
- 在静态方法所在类之外，可以直接用类名调用
- 非静态方法所在类内部，该方法可以以调用任何成员
- 静态方法中不能存在this关键字（this在方法中指定是调用该方法的对象，静态方法不属于对象不能存在this）

1.2 final关键字

final关键字 : 翻译中文代表最终的意思 , 是java的一个关键字也是一个修饰符 , 可以修饰类 , 可以修饰方法 , 也可以修饰变量
final关键字修饰的特点
- final修饰的类 : 不能被继承 , 没有子类(太监类)
- fina修饰的方法 : 不能被重写
- final修饰的变量：（值不能变量）
  - 基本数据类型 : 值不能改变
  - 引用数据类型 : 地址不可发生改变 , 对象的属性可改变
  - 注意 :
    - 被final修饰的变量 , 我们叫做自定义常量 , 命名规范 : 每个字母需要大写 , 多个单词之间用下划线分割
    - final修饰成员变量需要注意初始化时机的问题 , 1) 直接赋值 , 2) 在构造方法执行完毕前赋值

10 20 3.14 “Hello” 值常量（字面量）
final成员变量符号常量，直接赋值
符号常量 = 值。
静态常量（常用）
非静态常量/实例常量

```java package com.itheima.final_demo;

/* final的特点 final修饰的类 , 不能被继承, 也就是没有子类 final修饰的方法 , 不能被重写 final修饰的变量基本数据类型 : 值不可以发生改变引用数据类型 : 地址不可发生改变 , 对象的内容可以发生改变

    注意 :
        1 被final修饰的变量 , 我们叫做自定义常量 , 命名规范 : 每个字母需要大写 , 多个单词之间用下划线分割
        2 final修饰成员变量需要注意初始化时机的问题
          1) 直接赋值
          2) 在构造方法执行完毕前赋值

*/ public class FinalDemo1 { public static void main(String[] args) { // final修饰的基本数据类型变量 , 值不能被修改 // final int num = 10; // num = 20; // System.out.println(num);

    final int[] arr = {1, 2, 3, 4, 5};
    // final修饰的引用数据类型 , 地址不可改发生改变
    // arr = new int[3];
    // final修饰的引用数据类型 , 对象中的内容可以发生改变
    arr[0] = 100;
}

}

// final修饰的类 , 不能被继承, 也就是没有子类 //final class Person { // //}

class Person { // final修饰的方法 , 不能被重写 public final void eat() {

}

class Student extends Person { // final修饰成员变量需要注意初始化时机的问题 // 要么直接赋值 , 要么在构造方法执行完毕前赋值 // final int num = 10; final int num;

public Student() {
    num = 100;
}
//    @Override

// public void eat() { // super.eat(); // } }


<a name="56e5e510"></a>
### 1.3 Java中的权限修饰符
-  public > protected > 默认的包私有 > private
- ![image.png](https://cdn.nlark.com/yuque/0/2022/png/26714721/1650956091451-171c2e08-de63-4fe2-a032-e8f1f2bff753.png#clientId=ude46290e-7c8b-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=100&id=u8be48390&margin=%5Bobject%20Object%5D&name=image.png&originHeight=200&originWidth=507&originalType=binary&ratio=1&rotation=0&showTitle=false&size=15513&status=done&style=none&taskId=u10095ff1-09dd-47ae-bb02-1cd1499cb81&title=&width=253.5)
```java
package com.itheima.permissions_demo1;
/*
    public -- protected -- 默认的 -- private
 */
public class Fu {
    public void method1() {
    }
    protected void method2() {
    }
    void method3() {
    }
    private void method4() {
    }
    // 同一个包中同一个类
    public void show(){
        method1();
        method2();
        method3();
        method4();
    }
}
===================================================
package com.itheima.permissions_demo1;
public class Test {
    // 同一个包中 , 无关类
    public void show(){
        Fu f = new Fu();
        f.method1();
        f.method2();
        f.method3();
        // f.method4();
    }
}
====================================================
package com.itheima.permissions_demo1;
public class Zi extends Fu {
    // 用一个包中 , 有子类父关系
    public void show(){
        method1();
        method2();
        method3();
        // method4();
    }
}

package com.itheima.permissions_demo2;
import com.itheima.permissions_demo1.Fu;
public class Test {
    // 不同包中 , 无关类
    public void show(){
        Fu f = new Fu();
        f.method1();
        // f.method2();
        // f.method3();
        // f.method4();
    }
}
======================================
package com.itheima.permissions_demo2;
import com.itheima.permissions_demo1.Fu;
public class Zi extends Fu {
    // 不同包中 , 有子类父关系
    public void show(){
        method1();
        method2();
        // method3();
        // method4();
    }
}

2 代码块

2.1 构造代码块

构造代码块【实例代码块】 : 用一对大括号表示, 定义在类中方法外
执行时机 : 每次构造方法执行前, 都会执行构造代码块
作用 : 抽取构造方法中共性内容

package com.itheima.code_block;
/*
    构造代码块
 */
public class Student {
    final int NUM;
    {
        NUM = 10;
        System.out.println("构造代码块...");
    }
    public Student() {
        System.out.println("空参构造...");
    }
    public Student(int a) {
        System.out.println("有参构造...");
    }
}
class StudentTest {
    public static void main(String[] args) {
        Student s = new Student();
        Student s2 = new Student(10);
    }
}

2.2 静态代码块

静态代码块 : 在一对大括号前加上static关键字 , 定义在类中方法外
执行时机 : 随着类的加载而加载 , 只加载一次

作用 : 一般用于给静态成员初始化

package com.itheima.code_block.static_demo;
/*
静态代码块 :
   1 定义的位置 : 在一对大括号前加上static , 定义在类中方法外
   2 执行时机 ; 随着类的加载而执行, 只加载一次
   3 可以给类中的静态成员进行初始化数据
*/
public class Test {
public static void main(String[] args) {
   new Student();
   new Student(10);
}
}

class Student {
static {
System.out.println(“静态代码块”);
}

public Student() {
    System.out.println("空参构造");
}
public Student(int a) {
    System.out.println("有参构造");
}

}

2.3 局部代码块

成员代码块 : 用一对大括号表 , 可以定义在任何的局部位置 , 方法中居多
执行时机 : 正常执行(从上往下依次执行)
控制变量的局部变量的生命周期（作用域）

package com.itheima.code_block.local_demo;
/*
    局部代码块 :
        1 位置 : 可以定义任何的局部的位置 , 方法中居多
        2 执行时机 : 正常执行(从上往下依次执行)
        3 作用 : 控制变量的生命周期 , 变量在使用完毕, 及时释放内存
 */
public class Test {
    public static void main(String[] args) {
        int num1 = 10;
        System.out.println(num1);
        // 局部代码块
        {
            int num2 = 20;
            System.out.println(num1);
            System.out.println(num2);
        }
        System.out.println(num1);
//        System.out.println(num2);// 作用域不够 , 报错
    }
}

3 接口

3.1 接口的介绍

接口 : 如果一个类中都是抽象方法 , 那么这个类应该是定义规范的类 , 我们应该把此类定义成接口,
接口是一种引用数据类型（类，数组，接口，枚举，注解）
作用 :
- 用于定义规则（规范【方法】）
- 程序的扩展性

3.2 接口的定义和特点

定义接口的关键字使用interface
- public interface 接口名{ … }
类与接口之间的关系是实现关系 , 用关键字implements进行连接
实现也是继承的一种方式
```
public class 类名 implements 接口名 { ... }
```
接口不能实例化
接口的子类我们叫做实现类
1. 要么重写接口中所有的抽象方法【一般做法】
2. 要么实现类是一个抽象类
注意 : 类与接口的关系是实现关系 , 一个类可以实现多个接口,调用逗号分隔 , 还可以继承一个类的同时 , 实现多个接口

package com.itheima.interface_demo;
public interface Inter {
    public abstract void show();
    public abstract void method();
}
interface Inter2 {
}

package com.itheima.interface_demo;
public class InterImpl extends Object implements Inter ,Inter2{
    @Override
    public void show() {
    }
    @Override
    public void method() {
    }
}

package com.itheima.interface_demo;
/*
    1 定义接口的关键字使用interface
      public interface 接口名{ ... }
    2 类与接口的关系是实现关系 , 使用implements进行连接
      public class 类名 implements 接口名{ ... }
    3 接口不能实例化(不能创建对象)
    4 接口的子类,我们叫做实现类
        要么重写接口中所有的抽象方法
        要么这个实现类是一个抽象类
    注意 : 类与接口的关系是实现关系 , 一个类可以实现多个接口
    还可以继承一个类的同时 , 实现多个接口
 */
public class InterfaceDemo1 {
    public static void main(String[] args) {
        // 接口不能实例化(不能创建对象)
        // Inter inter = new Inter();
    }
}

3.3 接口的成员特点

成员变量 : 都是常量 , 默认修饰符 public static final
构造方法 : 没有构造方法
成员方法 : 只能是抽象方法 , 默认修饰符public abstract
- 关于JDK8和JDK9版本对接口增加了一些方法新特性
  JDK8新增默认方法，静态方法
  JDK9新增私有方法

package com.itheima.interface_demo;
public interface Inter {
    // 是一个常量 , 默认修饰符 public static final
    public static final int num = 10;
    // 不存在构造方法
    // public Inter(){}
    public abstract void show();
    public abstract void method();
}
interface Inter2 {
}

public class InterfaceDemo1 {
    public static void main(String[] args) {
        // 接口不能实例化(不能创建对象)
        // Inter inter = new Inter();
        // 成员变量被static修饰
        System.out.println(Inter.num);
        // 是一个常量 , 只能赋值一次
        // Inter.num = 20;
    }
}

3.4 接口的案例

package com.itheima.interface_demo.interface_test;
public interface Player {
    public abstract void play();
    public abstract void pause();
    public abstract void stop();
}

package com.itheima.interface_demo.interface_test;
public class MP3 implements Player {
    @Override
    public void play() {
        System.out.println("MP3开始播放音乐");
    }
    @Override
    public void pause() {
        System.out.println("MP3开始暂停");
    }
    @Override
    public void stop() {
        System.out.println("MP3开始关闭音乐");
    }
}

package com.itheima.interface_demo.interface_test;
public class MP4 implements Player {
    @Override
    public void play() {
        System.out.println("MP4播放音乐");
    }
    @Override
    public void pause() {
        System.out.println("MP4暂停音乐");
    }
    @Override
    public void stop() {
        System.out.println("MP4关闭音乐");
    }
}

package com.itheima.interface_demo.interface_test;
/*
   需求 :
   1  创建一个播放接口 player
   2  定义三个抽象方法 , 播放(play),暂停(pause),停止(stop)
   3  定义MP3类,MAP4类,手机类,实现接口,重写抽象方法
 */
public class PlayerTest {
    public static void main(String[] args) {
        MP3 mp3 = new MP3();
        mp3.play();
        mp3.pause();
        mp3.stop();
        System.out.println("=============");
        MP4 mp4 = new MP4();
        mp4.play();
        mp4.pause();
        mp4.stop();
    }
}

3.5 接口中成员方法的特点

DK8版本之前 : 只能是抽象方法
JDK8版本 :
- 默认方法
  - JDK8可以在接口中定义非抽象方法(带有方法体的方法) , 需要使用default进行修饰 , 其实就是默认方法
  - 作用 : 将所有实现类相同功能的抽取
  - 格式 :
```
public default 返回值类型 方法名(参数) { ... }
```
  - 注意事项 :
    - 默认方法不是抽象方法 , 可以继承 , 也可以重写 , 重写需要去掉default关键字
    - public 可以省略 , default不能省略
    - 如果实现类实现了多个接口 , 有相同默认方法 , 那么实现类必须重写该方法
- 静态方法
  - JDK8可以在接口中定义静态方法 , 也是有方法体的方法
  - 作用 : 方便调用此功能
  - 格式 :
```
public static 返回值类型 方法名(参数){ ... }
```
  - 注意事项
    - 静态方法只能通过接口名调用 , 不能通过实现类名字和对象调用
    - public可以省略 , static不能省略
JDK9版本 :
- 私有方法
  - JDK9中新增私有方法
  - 作用 : 抽取默认方法中共性内容
  - 格式 : private 返回值类型方法名(参数){ … }
  - 注意 : 要想抽取静态方法中的共性内容 , 需要对私有方法加上关键字static

4 枚举

枚举 : 有几种固定可能的取值时，就可以把这些固定数据定义为枚举类型的数据
作用 : 更贴切 , 加见名之意方便列举数据

定义 :

public enum 枚举名{ 
 枚举项1,枚举项2,....;
}

使用 : 通过枚举类型名直接引用枚举项即可，例如Sex.BOY、Sex.GIRL
注意 : 每个枚举项都相当于枚举的对象
案例代码
```java package com.itheima.enum_demo;

public enum Sex { // 每一个枚举项都是枚举的对象 GIRL(“女孩”), BOY(“男孩”), YAO;

// 成员变量
private String name;
// 空参构造方法
private Sex() {
}
// 有参构造方法
private Sex(String name) {
    this.name = name;
}
// 成员方法
public String getName() {
    return name;
}

}

class Test { public static void main(String[] args) { System.out.println(Sex.GIRL.getName()); System.out.println(Sex.BOY.getName()); System.out.println(Sex.YAO.getName()); } } ```

枚举的本质 :
- 枚举其实本质上是一个类，每一个枚举项是本枚举类类型的一个对象。我们可以使用JDK提供的反编译命令，将枚举的字节码进行反编译查看
  - 枚举本质上就是最终类
  - 枚举项，就是枚举类的对象，而且是静态的常量。
  - 有私有的构造方法
  - 静态代码块
  - 继承了lang包下的Enum
组成部分 :
- 构造器，成员方法，成员变量等 , 但是定义的成分一定要在枚举项之后，而且最后一个枚举项必须要有分号结束。

Day02 关键字 接口 枚举