Java 接口与枚举

本是古典何须时尚 2021-12-13 04:46 353阅读 0赞

### 一、Java中的接口 ###

**1、接口**

**多个抽象类的抽象就是接口**。用 interface 来声明接口。

在Java中最小的程序单元是类，接口其实是一个特殊的类.，编译之后,和类一样具有一份字节码

Java中接口表示规范,用于定义一组抽象方法,表示某一类事物必须具备的功能,要求实现类必须来实现该接口并提供方法实现.

**定义接口语法: **   \[public\]   interface   接口名\{\}

**接口存在的成员:**

1）接口中没有构造器,推论:接口不能创建对象(不能 new ),接口中不能定义普通方法.

2）接口中定义的成员变量,实质是全局静态常量,默认使用  public static final来修饰.

3）接口中定义的方法都是公共的抽象方法,默认的使用  public abstract 来修饰方法.

4）接口中定义的内部类都是公共的静态内部类,默认使用public  static来修饰内部类.

Java8 允许在接口中定义默认方法用 default 修饰、类方法用 static 修饰

** 2、接口的特点 **

1）没有构造方法，也不能显示定义构造器，不能实例化。

2）接口只能继承接口，不能继承类，且接口支持多继承(类是单继承关系)。

\[修饰符\] interface  接口名   extends   接口1,接口2

3）接口中的方法，默认修饰符是public abstract。

4）接口里的字段全是全局静态常量，默认修饰符是public static final。：

5）接口里的内部类全是公共静态的，默认修饰符是public static。

**3、接口的继承**

类和类之间存在是继承关系，使用 extends 来表示.

接口和接口之间只能是继承关系， 使用 extends 来表示.

接口和实现类之间只能是实现关系，使用 implements 来表示.

接口的实现类.

接口仅仅只是定义了某一类事物应该具有某些功能,但是没有提供任何实现。此时,我们得提供实现类,再让该类去实现接口,并覆盖接口中的抽象方法,从而实现接口中定义的功能.

类实现接口的语法:  一个类可以实现多个接口,从而也弥补了类的单继承问题.

\[修饰符\] class   实现类名   extends  父类 implements 接口1,接口2\{\}

注意：实现类覆盖接口中的抽象方法,并且其方法必须使用 public 修饰.

**4、接口和抽象类的区别**

相同点：

1）都位于继承的顶端，用于被其他实现或继承。

2）都不能实例化。

3）都可以定义抽象方法，其子类/实现类都必须覆写这些抽象方法。

不同点：

1）接口没有构造方法，抽象类有构造方法。

2）一个类只能继承一个直接父类(可能是抽象类)，接口是多继承并且只支持一个类实现多个接口(接口弥补了Java的单继承)。

3）成员变量：接口里默认是public static final，抽象类是默认包权限。

4）抽象方法：接口里默认是public abstract，抽象类默认是默认包访问权限。

5）内部类：接口里默认是public static，抽象类默认是默认包访问权限。

**5、面向接口编程**

面向接口编程: **多态的好处；把实现类对象赋给接口类型变量，屏蔽了不同实现类之间的实现差异，从而可以做到通用编程.**

如果接口和实现类可以完成相同的功能,尽量使用接口,面向接口编程.。接口和实现类的多态关系项目中见的是最多的.

**接口  变量 =   创建实现类对象;** //体现多态思想

public interface Human {
        String name = "Human";
        void study();
    }
    
    public class Student implements Human{
        @Override
        public void study() {
            System.out.println("Studnet study...");
        }
        public static void main(String[] args) {
            Human human = new Student();
            human.study(); // Studnet study...
            System.out.println(Human.name); // Human
        }
    }

### 二、JDK8中的接口增强 ###

在 Java8 允许在接口中定**义方法的具体实现**，但是定义具体的方法实现是有限制的，

它只能定义 **default** 和 **static** 类型的方法。除了关键字修饰，其他跟普通的方法定义并没有什么不同。

如何调用

**1）default 方法调用**：定义一个类实现该接口，new该类的实例，调用即可。

**　2）static 方法调用**：类名.方法名() 调用，这跟以前的静态方法调用方式一样。

应用场景

当多个类实现一个接口的某个方法时，方法的具体实现代码相同，这样就会造成代码重复问题。接口增强就相当于把公共的代码抽离出来，放入接口定义中，这样实现类对于该方法就不用重新定义，直接调用即可，这很好的解决了实现该接口的子类代码重复的问题。

public interface Human {
        String name = "Human";
        void study();
    
        // default 和 static 方法的出现为了解决实现该接口的子类代码重复的问题
        default void defaultMethod() {
            System.out.println("default method invoked! ");
        }
        static void staticMethod() {
            System.out.println("static method invoked! ");
        }
    }
    
    public class Student implements Human{
        @Override
        public void study() {
            System.out.println("Studnet study...");
        }
        public static void main(String[] args) {
            Human human = new Student();
            human.study(); // Studnet study...
            System.out.println(Human.name); // Human
            // 调用 default 和 static 方法
            human.defaultMethod(); // default method invoked!
            Human.staticMethod(); // static method invoked!
        }
    }

### 三、枚举 ###

**1、枚举类定义**

枚举是从 Java5 开始提供的一种新的数据类型，是一个特殊的类，就是固定的多个常量对象的集合.

自定义的枚举类型，在编译(在底层)都是直接继承于java.lang.Enum类的，Enum是所有枚举的父类。自定义枚举类不能使用 extends 关键字继承其他类（java是单继承）。

/**
     * 定义格式:
     * [修饰符] enum  枚举类名
     * {
     *       常量A,常量B,常量C;
     * }
     */
    public enum Weekday {
        MON, TUE, WED, THU, FRI, SAT, SUN;
    }

编译后

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDAyODU0_size_16_color_FFFFFF_t_70][]

**2、枚举类的特点**

1）枚举的直接父类java.lang.Enum，但是**不能显示继承Enum。**

2）枚举就相当于一个类，可以定义构造方法、成员变量、普通方法和抽象方法。

3）默认私有构造方法，即使不写访问权限也是 private。

4）每个实例分别用一个全局常量表示，枚举类的对象是固定的，实例个数有限，不能使用new关键字。

5）枚举实例必须位于枚举体中的最开始部分，枚举实例列表的后用分号与其他成员相分隔。

6）枚举实例后有花括号时，该实例是枚举类的匿名内部类对象(查看编译后的class文件)。

**3、枚举的使用**

1）枚举中都是全局公共的静态常量，可以直接使用枚举类名调用.

Weekday weekday= Weekday.MON;

2）因为java.lang.Enum类是所有枚举类的父类,所以创建的枚举对象可以调用Enum类中的方法.

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDAyODU0_size_16_color_FFFFFF_t_70 1][]

3）编译器生成的枚举类的静态方法(从反编译代码中):

枚举类型\[\]  values();  // 返回当前枚举类型所有的常量,使用一个数组封装起来.

枚举类型  valueof(String name);  //把一个指定名称字符串转换为当前枚举类中同名的常量.

4）从 java5 开始出现枚举，switch也支持操作枚举类型.

支持枚举是因为底层使用的枚举对象的 ordinal，而 ordinal 的类型依然是int类型.

public static void main(String[] args) {
            Weekday weekday = Weekday.MON;
            System.out.println(weekday); // MON
            System.out.println(weekday.name()); // MON
            System.out.println(weekday.ordinal());// 0
            //编译器生成枚举类的静态方法
            Weekday[] ws = Weekday.values();
            Weekday day = Weekday.valueOf("MON");
            switch (day) {
                case MON:
                    System.out.println("今天是星期一");
                    break;
                case TUE:
                    System.out.println("今天是星期二");
                    break;
                default:
                    System.out.println("其他");
                    break;
            }
            // 今天是星期一
        }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDAyODU0_size_16_color_FFFFFF_t_70 2][]

使用很简单，理解其思想

ends ~

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDAyODU0_size_16_color_FFFFFF_t_70]: /images/20211210/0a541c22b01e4d2bbbb818b2d840fdea.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDAyODU0_size_16_color_FFFFFF_t_70 1]: /images/20211210/7524f49a0dc340b3a532799d78ab1017.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDAyODU0_size_16_color_FFFFFF_t_70 2]: /images/20211210/93f3c8cfd8594af282fca213f98979a3.png