java-枚举类、抽象类、接口、内部类

枚举类

Java 5引入的一种特殊的数据类型，用于定义一组固定的常量。它比传统的常量定义（使用final static）更安全、更强大。
写法：修饰符 enum 枚举类名{

名称1，名称2，名称3·····；

其他成员···

}

特点：枚举类中的第一行只能写枚举类的对象名称，且要用逗号隔开

而这些名称，本质是常量，每个常量都记住了枚举类的一个对象
应用场景：适合做信息分类和标志

复制代码

  package com.peiyao.enummodel;

import static java.nio.file.Files.move;

public class enumdemo {

public static void main(String[] args) {

enum_direction direction=enum_direction.up;//enum类不能实例化对象，直接调用

move2(direction);

}

public enum enum_direction {

up,down,right,left;

}

private static void move2(enum_direction direction) {

switch (direction){

case enum_direction.up:

System.out.println("向上");

case enum_direction.down:

System.out.println("向下");

case left:

System.out.println("向左");

case right:

System.out.println("向右");

}

这个enum_direction既可以写在一个类里面，可以单独做一个文件，感觉类似String类，只不过把变量内容定死了，只能从这里面选

抽象类

定义：用abstract关键字修饰的类，是不能被实例化的类，主要用来定义规范和提供部分实现
抽象类中可以没有抽象方法，但是有抽象方法必须在抽象类里
抽象方法：没有方法体（只有声明，没有实现）
抽象类不能创建对象，只能被子类继承并实现，如果一个类继承抽象类，那他必须重写抽象类的全部抽象方法（除非该子类也是抽象类）
- 因为抽象类中有抽象方法，他都没有方法体，对象怎么调用，肯定会报错
好处：
- 当父类知道子类都要实现某个行为，但每个子类实现的行为不一样时，可以将父类定义成抽象方法，子类去实现，就是为了更好的支持多态（但是不是必须的）
- 提供一个方法作为完成某类功能的模版，模版方法封装了每个实现步骤，但允许子类提供特定步骤的实现，可以提高代码的服用，并简化子类设计
- 在这里插入图片描述

接口

java提供了一个关键字interface定义出接口
演变历史
- Java 7及以前
  - 只能有抽象方法和常量
  - 所有方法隐式public abstract
  - 所有变量隐式public static final
- Java 8
  - 引入默认方法（default methods）
  - 引入静态方法
  - 支持函数式接口
- Java9
  - 引入私有方法
接口不能创建对象
接口是用来被类实现的，实现接口的类成为实现类，一个类可以同时实现多个接口
好处：
- 弥补了类单继承的不足，一个类同时可以实现多个接口，使类的角色更多，功能更强大
- 让程序可以面向接口编程，这样程序员可以灵活切换各种业务实现（更利于程序的解耦合）

抽象类和接口区别

相同点

都是抽象形式，都可以有抽象方法，都不能创建对象
都是派生子类的形式，抽象类是被子类继承使用，接口是被实现类实现
一个类继承抽象类或者实现接口，都必须重写所有的抽象方法，除非自己也是抽象类或者报错

不同点

抽象类中可以定义类的全部普通成员，但接口只能定义常量、抽象方法
抽象类只能被类单继承，但是接口可以被类多实现
一个类继承抽象类就不能再继承其他类（ps:单继承），一个类实现了接口还可以继其他类或者实现其他接口（ps:实现接口也还可以继承抽象类）
抽象类体现模版思想，更利于做父类，实现代码的复用性
接口更适合做功能的解耦合，解耦合性更强更灵活

代码块

类型

静态代码块
- 格式：static{}
- 特点：类加载是自动执行，由于类只会加载一次，所以静态代码块也只会执行一次，跟着类走
- 作用：完成类的初始化，例如：对静态变量的初始化赋值。

复制代码

  package com.peiyao.oop.code;

  public class codeDemo1 {

      static{
          System.out.println("静态代码块执行");
      }

      public static void main(String[] args) {
          System.out.println("执行main方法");
      }
      
  }

结果：

静态代码块执行

执行main方法
可以不用，一般用不太到

实例代码块：

格式：{}
特点: 每次创建对象时，执行实例代码块，并在构造器前执行，跟着对象走
作用：和构造器一样，都是用来完成对象的初始化的，例如：对实例变量进行初始化赋值
举例：

复制代码

  public class codeDemo1 {

  //    static{
  //        System.out.println("静态代码块执行");
  //    }
      {
          System.out.println("实例代码块执行了");
      }

      public static void main(String[] args) {
          System.out.println("执行main方法");
      }

  }

  结果：
  执行main方法,//原因是没有创建对象，所以不会执行

复制代码

  public class codeDemo1 {

  //    static{
  //        System.out.println("静态代码块执行");
  //    }
      {
          System.out.println("实例代码块执行了");
      }

      public static void main(String[] args) {
          System.out.println("执行main方法");
          new codeDemo1();
      }

  }
  结果：
  执行main方法
  实例代码块执行了

内部类

如果一个类定义在另一个类的内部，这个类就是内部类
场景：当一个类的内部，包含了一个完整的事物，且这个事物没有必要单独设计时，就可以把这个事物设计成内部类
类型：成员内部类、静态内部类、局部内部类、匿名内部类

成员内部类：无static修饰，属于外部类的对象持有的也就是说有了外部类对象才有了内部类对象

内部类的访问权限：
- 外部类可以访问内部类的所有成员（包括私有）
- 外部其他类访问内部类需要：outer.new Inner()
- 外部其他类不能直接访问内部类的私有成员
- 成员内部类中可以静态访问外部类的静态成员，也可以直接访问外部类的实例成员（其实也就类似于普通成员了）

复制代码

  package com.peiyao.oop.innerclass;

  public class demo1 {
      public static void main(String[] args) {
          People.Heart heart = new People().new Heart();

      }

  }
  class  People{
      private int heartbeat = 80;
      class Heart{
          private int heartbeat = 100;
          public void show(){
              int heartbeat=200;
              System.out.println(heartbeat);
              System.out.println(this.heartbeat);
              System.out.println(People.this.heartbeat);
          }

      }

  }

静态内部类
- 有static修饰的内部类，属于外部类自己持有
- - 这个new是new的outer
- 可以直接访问内部类的静态成员
- 实例变量属于具体的外部类对象，但是静态内部类并不属于外部类对象，他是独立存在的，所以，静态内部类不能访问外部类的实例变量，因为他不知道访问哪个对象的实例变量
- 简单点说就是静态内部类相当于类变量，实例变量是对象变量，所以没法访问
- ps:平常不会用
局部内部类：定义在方法中、代码块中、构造器等执行体中（了解即可）屁用没有

匿名内部类
- 所谓匿名：指的是程序员不需要为这个类声明名字，默认有个隐藏的名字，就比如cat
- image-20260109154921482
- 特点：匿名内部类本质就是一个子类，并且会立即创建出一个子类对象
- 作用：如果你需要创建多个cat对象，那cat类可以单独写，但是如果只是单独创建一个cat对象，那么用这个匿名内部类会更方便
- 我的理解就是在实例化对象的时候创建一个子类然后正好，创建这个子类对象
  
  public abstract class Animal {
  public abstract void cry();
  
  }
  
  public class demo {
  Animal a=new Animal() {
  @Override
  public void cry() {
  System.out.println("喵喵喵");
  复制代码
```
    }
};
```
  }
匿名类本质上有简化多态的作用