Java基础_抽象类、接口、内部类、枚举

抽象类

当我们通过面向对象的思维去分析事物时，会发现一些共性内容。而且定义这个共性的类时，有些方法我们并不需要它实现，只需要用它的声明，然后重写就行了。就比如，动物类有个 叫的方法，但每种动物的叫声都不一样。因此我们不必去实现这个叫的方法，而只把他定义为抽象方法，子类继承并重写它就完事了。而一些抽象方法的集合就是抽象类。

抽象类的定义
用abstract 关键字来修饰一个类时，这个类就被叫做抽象类；
用abstract 来修饰一个方法时，这个方法就被叫做抽象方法；

• 抽象方法必须放在抽象类中，但是抽象类可以不包含抽象方法。
• 抽象类被继承才有意义。抽象方法必须重写。
• 抽象类不能被实例化，但是有构造器。子类还是会调用抽象类的构造器，用于初始化

形式：【权限修饰符】abstract class 【类名】{
【权限修饰符】 abstract 【返回类型】【方法名】();
}
tips：抽象类可以包含具体的方法和属性。不想被实例化的类就可以声明为抽象类，即使它不包含抽象方法。
应用场景：

• 一个类中的多个方法时抽象方法时候。
• 当子类不能实现抽象类的所有抽象方法时候
• 当一个类实现一个接口，并且不能实现接口的所有抽象方法时。

接口

接口是抽象方法和静态常量值定义的集合

接口是一种特殊的抽象类，它只包含常量和抽象方法。没有变量。
使用interface来定义接口。
格式：【限定修饰符】interface 【接口名】{}
里面的方法 默认有public 和 abstract.
实现接口则用implements
同个类可以实现多个接口

特征

• 接口中声明的属性默认有public static final的，里面的属性也只能是这样修饰。

   因为接口不能自己实现方法，所以定义的属性必须是public的，不然没有意义。而且也不能new接口，所以必须是static的，并且如果是静态变量。都定义到实现自己的类中，不会定义再接口里面。因此属性是public static final的。
  

• 接口中只能定义抽象方法，而且默认是public abstract 也只能是这样修饰的。

• 接口可以继承其他接口，并添加新的常量和方法。

• 接口不能实现其他接口，但可以继承多个其他接口（多继承

• ）。

• 接口和继承的类之间可以使用多态。

• 接口只能用来声明

有些接口用来当作标识，比如Serializable 序列化。它没有任何的方法和常量。仅有一个空的主体，用来表示这个类可以被序列化。不需要被强制编程。

内部类

内部类定义非常简单，就是在内的内部定义一个类
作用：

使用内部类最吸引人的原因是：每个内部类都能独立地继承一个（接口的）实现，所以无论外围类是否已经继承了某个（接口的）实现，对于内部类都没有影响。

• 内部类可以很好的隐藏实现
  一般的非内部类，是不允许有 private 与protected权限的，但内部类可以
• 内部类拥有外围类的所有元素的访问权限 （相当于自动继承上层类）
• 可以用来实现多重继承。（套很多层内部类。）
• 匿名内部类优化代码。
• 内部类可以用多个实例，每个实例都有自己的状态信息，并且与其他外围对象的信息相互独立。
• 在单个外围类中，可以让多个内部类以不同的方式实现同一个接口，或者继承同一个类。
  

内部类有多种访问权限，public可以让所有类访问，private只能自身和外部类访问。

基础： 当我们去创建一个内部类，在无形中就会和外层类有一个联系。外部类的所有属性方法，内部类都可以去访问。相当于继承了外部类。这是因为我们创建外部类的内部类时，内部类会自动捕获一个外部类的引用指向。当使用外部类的方法时，自动根据指向去查找。
当我们编译成功内部类后，会生成两个.class文件，一个是外部类.class 文件，一个是外部类$内部类.class文件，他们是两个类，但是他们之间其实是有联系的。

成员内部类

成员内部类是最基础的内部类。他可以无限制的去访问外部类的成员。但外部类访问内部类成员就必须先实例化内部类对象。

注意：
第一：成员内部类中不能存在任何static的变量和方法

因为，内部类对象必须先实例化外部类对象然后才能实例化成员内部类对象。
而我们的静态变量和方法都会在类加载的时候就创建。但是此时并没有外部类对象。或者说，非static内部类，在外部类加载的时候，并不会去加载它那么所以它里面不能有静态的变量或方法。

第二：成员内部类是依附于外部类的，所以只有先创建了外部类才能够创建内部类。

实例方式：外部类.内部类 【类名】 = new 外部类（）.new 内部类();

内部类变量的访问方式：内部类在没有和外部类重名的情况下。内部类直接访问外部类成员，但是有重名的情况下，会发生隐藏反应，内部变量会覆盖外部的变量。而此时想访问外部变量则需要 【外部类】.this.【变量名】 ，访问自身变量可以用this.【变量名】

TIPS：推荐使用getxxx()来获取成员内部类，尤其是该内部类的构造函数无参数时 。

局部内部类

局部内部类和局部变量一样不能有public protected private关键字。

有这样一种内部类，它是嵌套在方法和作用于内的，对于这个类的使用主要是应用与解决比较复杂的问题，想创建一个类来辅助我们的解决方案，到那时又不希望这个类是公共可用的，所以就产生了局部内部类，局部内部类和成员内部类一样被编译，只是它的作用域发生了改变，它只能在该方法和属性中被使用，出了该方法和属性就会失效。
可以看以下示例 摘自think in java

public class Parcel5 {
    public Destionation destionation(String str){
        class PDestionation implements Destionation{
            private String label;
            private PDestionation(String whereTo){
                label = whereTo;
            }
            public String readLabel(){
                return label;
            }
        }
        return new PDestionation(str);
    }
    
    public static void main(String[] args) {
        Parcel5 parcel5 = new Parcel5();
        Destionation d = parcel5.destionation("chenssy");
    }
}

静态内部类

static 可以用来修饰类，这个类必须是内部类，非静态内部类在编译完成之后会有个引用来指向他的外部类，但是静态内部类并没有这个。因此。他的创建并不需要外部类加载。相对来说它也不能去使用外部类的非static方法和属性。
实例化： 【外部类】.【内部类】 属性名= new 外部类.内部类()；
或者 【内部类】 属性名 = new 【内部类】();

匿名内部类

因为匿名内部类没有名称

构建方式：new 【父类构造器】（参数列表）或者【实现接口】{
//内部类的类体。
}
注意
第一：匿名内部类必须继承一个类或者 实现一个接口。也是仅仅只能这样。
第二：匿名内部类中是不能定义构造器的。实际上匿名内部类的定义构造和第一次使用都发生在同个地方
第三：匿名内部类中不能有任何的静态成员
第四：匿名内部类就是局部内部类。
虽然匿名内部类中没有构造器，但是可以通过构造块来达到构造器一样的效果。

枚举

枚举是一种特殊的java的类。他默认继承java.lang.Enum抽象类。因此枚举类不能再继承别的类（单继承）。

枚举中每一个数据（枚举项）都是枚举类的一个实例，枚举项不宜太多。多一种多例模式。

定义方式： enum 【枚举名称】{//枚举项，枚举项……；}

枚举项之间使用“ ，”隔开 并且最后一个枚举使用“；”如果枚举类里只有枚举项，那么分号可以不加。但建议都加上。

枚举类型可以用在switch语句中，但是再switch语句中不能使用枚举类型名称，因为编译器会根据switch()中给出的类型去判断 就相当于默认加了【枚举类型**.**】如果这个时候case后的语句再加枚举类型.枚举项，就会报错，因为前面已经给出了类型，重复语句。

枚举因为继承自Enum接口。因此有一些父类的方法

• String name(); 返回枚举项的名称
• int ordinal()：返回枚举项在枚举类中声明的序号，第一个枚举常量序号为0
• static T valueOf(Class enumType, String name) 将字符串转换成枚举项。不含则报错
• static T valueOf(String name);根据字符串找到枚举项。不含则报错
• static T[] values(); 返回包含所有枚举项的数组

枚举类构造器
枚举类有自己的构造器，不过必须声明为private 不加限定符默认为private，加载类时候就会创建实例，有几个枚举项就创建几个。枚举类和普通类一样可以定义方法，属性。每个枚举类的实例都可以调用到其公开的方法。并且每个枚举项的属性都和创建一个对象一样，都属于自身。不同枚举项之间不共用。

枚举类中还可以有抽象方法，如果有抽象方法，则每个枚举项都必须实现该抽象方法