4.接口、内部类、枚举类

Java中的接口:

在Java中最小的程序单元就是类,接口其实是一个特殊的类.

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

定义类语法: [public] class 类名{}
定义接口语法: [public] interface 接口名{}

成功编译之后,和类一样,具有一份字节码.

接口存在的成员:

 1):接口中没有构造器,推论:接口不能创建对象(不能 new ),接口中不能定义普通方法.
 2):接口中定义的成员变量,实质是全局静态常量,默认使用  public static final来修饰.
          public static final String NAME = "龙17";
 3):接口中定义的方法都是公共的抽象方法,默认的使用  public abstract 来修饰方法.
          public abstract void walk();   一般的,我们在接口中定义方法,不喜欢使用修饰符.
 4):接口中定义的内部类都是公共的静态内部类,默认使用public  static来修饰内部类.
          public static interface ABC{}        

分类：

• 标志接口:接口中没有任何成员,就仅仅是一个接口的定义,就是一个标志,其他的类实现该接口,就属于该家族,我们可以通过第三方代码赋予该接口实现类特殊的功能(不推荐).
• 常量接口:有人喜欢使用接口来封装多个常量信息,我们称之为常量接口,其目的和常量类相同(不推荐).

咱们使用的接口,主要都包含了抽象方法.

接口的特点和接口的继承:

接口的特点：
①　没有构造方法，也不能显示定义构造器，不能实例化。
②　接口只能继承接口，不能继承类，且接口支持多继承(类是单继承关系)。
[修饰符] interface 接口名 extends 接口1,接口2
③　接口里的方法方法全是抽象的，默认修饰符是public abstract。
④　接口里的字段全是全局静态常量，默认修饰符是public static final。
⑤　接口里的内部类全是公共静态的，默认修饰符是public static。

继承：
类和类之间存在继承关系: 使用extends 来表示.
接口和接口之间只能是继承关系: 使用extends 来表示.
接口和实现类之间只能是实现关系(继承关系),使用implements来表示.

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

接口和实现

接口和实现类之间的关系,严格上称之为”实现关系”,使用implements来表示.
但是在开发,有时候为了方便也把这个实现关系称之为特殊继承关系.
所以可以这样理解:接口是实现类的父类,实现类就是接口的子类.
面向接口编程:
接口 变量 = 创建实现类对象;//体现了多态思想
接口和实现类的多态关系才是我们见的最多的.

---

类实现接口的语法: 一个类可以实现多个接口,从而也弥补了类的单继承问题.
[修饰符] class 实现类名 extends 父类 implements 接口1,接口2{}
例如：

import static java.util.Arrays.*;

interface Animal {
     public abstract  void walk();
}

class FlyAnimal {
}

class Bird extends FlyAnimal implements  Animal {
    public void walk(){
    }
}

注意:
接口中的方法是公共的抽象的,所以实现类必须覆盖接口中的方法,并且方法必须使用public修饰.

接口和抽象类的区别:

相同点：
1):都位于继承的顶端，用于被其他实现或继承。
2):都不能实例化。
3):都可以定义抽象方法，其子类/实现类都必须覆写这些抽象方法。

不同：
1):接口没有构造方法，抽象类有构造方法。
2):抽象类可包含普通方法和抽象方法，接口只能包含抽象方法(Java8之前);
3):一个类只能继承一个直接父类(可能是抽象类)，接口是多继承的并且只支持一个类实现多个接口(接口弥补了Java的单继承)。
4):成员变量：接口里默认是public static final，抽象类是默认包权限。
5):方法：接口里默认是public abstract，抽象类默认是默认包访问权限。
6):内部类：接口里默认是public static，抽象类默认是默认包访问权限。

如果接口和实现类可以完成相同的功能,尽量使用接口,面向接口编程.
设计模式:接口 和抽象类集合使用的(适配器模式).

---

---

内部类

内部类: 定义在类结构中的另一个类:

// 外部类
class Outter {
    // 内部类
    class Inner {
    }
    
}

类中的定义的成员:

• 字段
• 方法
• 内部类

为什么使用内部类：

1):增强封装，把内部类隐藏在外部类之内，不许其他类访问内部类。
2):内部类能提高代码的可读性和可维护性，把小型类嵌入到外部类中结构上代码更靠近。
3):内部类可以直接访问外部类的成员。

内部类种类

内部类根据使用不同的修饰符或者定位的位置不同,分成四张:
①　实例内部类： 内部类没有使用static修饰.
②　静态内部类： 内部类使用了static修饰.
③　局部内部类： 在方法中定义的内部类.
④　匿名内部类适合于仅使用一次使用的类,属于局部内部类的特殊情况

外部类的访问修饰符:要么使用public,要么就缺省.
内部类看做是外部类的一个成员,好比字段,那么内部类可以使用public/缺省/protected/private修饰.
还可以是static修饰.

（1）.实例内部类:

没有使用static修饰内部类,说明内部类属于外部类的对象,不属于外部类本身.
特点:
1:创建实例内部类前,必须存在外部类对象,通过外部类对象创建内部类对象(当存在内部类对象时,一定存在外部类对象).
Outter.Inner in = new Outter().new Inner();
2:实例内部类的实例自动持有外部类的实例的引用,内部类可以直接访问外部类成员.
3:外部类中不能直接访问内部类的成员,必须通过内部类的实例去访问.
4:实例内部类中不能定义静态成员,只能定义实例成员.
5:如果实例内部类和外部类存在同名的字段或方法abc,那么在内部类中:
this.abc:表示访问内部类成员.
外部类.this.abc:表示访问外部类成员.

（2）.静态内部类:

使用static修饰的内部类.
特点:
1):静态内部类的实例不会自动持有外部类的特定实例的引用,在创建内部类的实例时,不必创建外部类的实例.
Outter.Inner in = new Outter.Inner();
2):静态内部类可以直接访问外部类的静态成员,如果访问外部类的实例成员,必须通过外部类的实例去访问.
3):在静态内部类中可以定义静态成员和实例成员.
4):测试类可以通过完整的类名直接访问静态内部类的静态成员.

（3）.局部内部类

不要用

---

---

枚举类

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

[修饰符] enum  枚举类名
{
      常量A,常量B,常量C;
}

---

我们自定义的枚举类型,在编译(在底层)都是直接继承于java.lang.Enum类的,Enum是所有枚举的父类
例如：

enum AnimalType {
    Dog, Cat, Bird;
}

编译后变为

final class AnimalType extends  Enum {
    public static final AnimalType Dog = new AnimalType("Dog", 0);
    public static final AnimalType Cat = new AnimalType("Cat", 1);
    public static final AnimalType Bird = new AnimalType("Bird", 2);
    
    public static AnimalType[] values() {
        return (nimalType[])$Values.clone();
    }
    
    public static AnimalType valueOf(String name){
        return (AnimalType)Enum.valueOf(AnimalType, name);
    }
    
    private AnimalType(String name, int index) {
        super(name, index);
    }
    
    static {
        $Values = (new AnimalType[] {
            Dog, Cat, Bird;
        });
    }
}

枚举类的特点:

①　枚举的直接父类java.lang.Enum，但是不能显示继承Enum。
②　枚举就相当于一个类，可以定义构造方法、成员变量、普通方法和抽象方法。
③　默认私有的构造方法，即使不写访问权限也是private(假构造器,底层没有无参数构造器)。
④　每个实例分别用一个全局常量表示，枚举类的对象是固定的，实例个数有限，不能使用new关键字。
⑤　枚举实例必须位于枚举体中的最开始部分，枚举实例列表的后要有分号与其他成员相分隔。
⑥　枚举实例后有花括号时，该实例是枚举类的匿名内部类对象(查看编译后的class文件)。

枚举的使用:

1):枚举中都是全局公共的静态常量,可以直接使用枚举类名调用.
Weekday day = Weekday.SATURDAY;

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

     String   name = 枚举对象.name();  //返回枚举对象的常量名称
     int      ordinal = 枚举对象.ordinal();//返回枚举对象的序号,从0开始.
     String  str       =  枚举对象.toString():返回枚举对象的常量名称

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

     枚举类型[]  values();
      Weekday[] ws   = Weekday.values();:返回当前枚举类型所有的常量,使用一个数组封装起来.
     枚举类型  valueof(String name);
      Weekday  day = Weekday.valueOf("MONDAY");//把一个指定名称字符串转换为当前枚举类中同名的常量.

4):从java5开始出现枚举,switch也支持操作枚举类型.
switch只支持int类型,支持枚举是因为底层使用的枚举对象的ordinal,而ordinal的类型依然是int类型.