(5) final, abstract class, interface, inner class

一、final 关键字（P394）

1. 基本介绍

final 中文意思：最后的,最终的

final 可以修饰类、属性、方法和局部变量

使用到 final 的情况：

（1）当不希望类被继承时,可以用final修饰.

（2）当不希望父类的某个方法被子类覆盖/重写（override）时,可以用final关键字修饰.

（3）当不希望类的的某个属性的值被修改,可以用final修饰.

（4）当不希望某个局部变量被修改,可以使用final修饰.

2. final 使用注意事项和细节

（1）final修饰的属性又叫常量,一般用XX_XX_XX来命名

（2）final修饰的属性在定义时,必须赋初值,并且以后不能再修改,赋值可以在如下位置之一：

① 定义时 
② 在构造器中
③ 在代码块中

（3）如果 final 修饰的属性是静态的,则初始化的位置只能是

① 定义时

② 在静态代码块

③ 不能在构造器中

（4）final类不能继承,但是可以实例化对象.

（5）如果类不是final类,但是含有final方法,则该方法虽然不能重写,但是可
以被继承.

（6）一般来说,如果一个类已经是final类了,就没有必要再将方法修饰成final方法.

（7）final不能修饰构造方法（即构造器）

（8）final和static往往搭配使用,效率更高,底层编译器做了优化处理.

（9）包装类（Integer、Double、Float、Boolean等都是final）,String也是final类.

二、抽象类（P398）

当父类的一些方法不能确定时,可以用 abstract 关键字来修饰该方法,这个方法就是抽象方法,用 abstract 来修饰该类就是抽象类.

1. 抽象类的介绍

（1）用abstract关键字来修饰一个类时,这个类就叫抽象类

（2）用abstract关键字来修饰一个方法时,这个方法就是抽象方法

（3）抽象类的价值更多作用是在于设计,是设计者设计好后,让子类继承并实现抽象类

2. 抽象类使用的注意事项和细节讨论

（1）抽象类不能被实例化

（2）抽象类可以没有抽象方法.

（3）有抽象方法的类一定是抽象类.

（4）abstract 只能修饰类和方法,不能修饰属性和其它的.

（5）抽象类可以有任意成员【因为抽象类本质还是类】,比如：非抽象方法、构造器、静态属性等等

（6）抽象方法不能有主体,即不能实现.

（7）如果一个类继承了抽象类,则它必须实现抽象类的所有抽象方法,除非它自己也声明为
抽象类.

（8）抽象方法不能使用 private、final 和 static 来修饰,因为这些关键字都是和重写相违背的.

三、接口（P403）

1. 基本介绍

接口就是给出一些没有实现的方法,封装到一起,到某个类要使用的时候,在根据具体情况把这些方法写出来.

语法：

interface接口名｛

        //属性

        //方法

｝

class 类名 implements 接口｛

                自己属性;
                自己方法：
                必须实现的接口的抽象方法

｝

小结：

（1）在 Jdk7.0 前接口里的所有方法都没有方法体
（2）在 Jdk8.0 Post-interface classes can have静态方法（static）,默认方法（default）,也就是说接口中可以有方法的具体实现.

2. 注意事项和细节

（1）接口不能被实例化

（2）接口中所有的方法是publicAn abstract method in a method interface,可以不用abstract修饰

（3）一个普通类实现接口,就必须将该接口的所有方法都实现

（4）抽象类实现接口,可以不用实现接口的方法

（5）一个类同时可以实现多个接口

（6）接口中的属性,只能是public static final 修饰符.

比如：inta=1;实际上是public static final int a = 1;（必须初始化）

（7）接口中属性的访问形式：接口名 . 属性名

（8）一个接口不能继承其它的类,但是可以继承多个别的接口

（9）接口的修饰符只能是 public 和默认,这点和类的修饰符是一样的

3. 实现接口vs继承类

接口和继承解决的问题不同

（1）继承的价值主要在于：解决代码的复用性和可维护性
（2）接口的价值主要在于：设计,设计好各种规范（方法）,让其它类去实现这些方法.

接口比继承更加灵活：
继承是满足 is-a 的关系,而接口只需满足 like-a 的关系

四、内部类（P413）

1. 基本介绍

一个类的内部又完整的嵌套了另一个类结构.被嵌套的类称为内部类（inner class）,嵌套其他类的类称为外部类（outer class）.内部类最大的特点就是可以直接访问私有属性,并且可以体现类与类之间的包含关系.

 

2. 内部类的分类

定义在外部类局部位置上（比如方法内）：

（1）局部内部类（有类名）

（2）匿名内部类（没有类名,重点）

定义在外部类的成员位置上：

（1）成员内部类（没用static修饰）

（2）静态内部类（使用static修饰）

3. 局部内部类的使用

说明：局部内部类是定义在外部类的局部位置,比如方法中,并且有类名

（1）可以直接访问外部类的所有成员,包含私有的
（2）不能添加访问修饰符,但是可以使用final修饰
（3）作用域：仅仅在定义它的方法或代码块中

（4）外部类---访问---->局部内部类的成员
访问方式：创建对象,再访问（注意：必须在作用域内）

（5）外部其他类---不能访问----->局部内部类

（6）如果外部类和局部内部类的成员重名时,默认遵循就近原则.If you want to access the success of the outer class
员,则可以使用（外部类名.this.成员）去访问.

4. 匿名内部类

（1）本质是类（2）内部类（3）该类没有名字（4）同时还是一个对象

说明：匿名内部类是定义在外部类的局部位置,并且没有类名.

4.1 匿名内部类使用细节：

（1） 基本语法

new 类或接口（参数列表）｛

        类体

｝;

（2）匿名内部类的语法比较奇特.因为匿名内部类既是一个类的定义,同时它本身也是一个对象.因此从语法上看,它既有定义类的特征,也有创建对象的特征

（3）可以直接访问外部类的所有成员,包含私有的.

（4）不能添加访问修饰符,Because of its status一个局部变量.

（5）作用域：仅仅在定义它的方法或代码块中.

（6）匿名内部类---访问---->外部类成员 [访问方式：直接访问]

（7）外部其他类---不能访问----->匿名内部类

（8）如果外部类和匿名内部类的成员重名时,默认遵循就近原则.If you want to access the success of the outer class
员,则可以使用（外部类名.this.成员）去访问.

5. 成员内部类

说明：成员内部类是定义在外部类的成员位置,并且没有static修饰.

（1）可以直接访问外部类的所有成员,包含私有的.

（2）可以添加任意访问修饰符（public、protected、默认、private）,Because of its status一个成员.

（3）作用域：和外部类的其他成员一样,为整个类体.Create an inner class object in a member method of the outer class,再调用方法.

（4）成员内部类---访问---->外部类成员【访问方式：直接访问】

（5）外部类---访问------>成员内部类【访问方式：创建对象,再访问】

（6）外部其他类---访问---->成员内部类

// 外部其他类
public class Demo {

    public static void main(String[] args) {

        Waibu waibu = new Waibu();
        // 方式一
        Waibu.Neibu neibu1 = waibu.new Neibu();
        // 方式二
        Waibu.Neibu neibu2 = waibu.getNeibu();
    }
}


// 外部类
class Waibu{

    // 内部类
    class Neibu{}

    public Neibu getNeibu(){
        return new Neibu();
    }
}

6. 静态内部类

说明：静态内部类是定义在外部类的成员位置,并且有static修饰

（1）可以直接访问外部类的所有静态成员,包含私有的,但不能直接访问非静态成员
（2）可以添加任意访问修饰符（public、protected、默认、private）,Because of its status
一个成员.
（3）作用域：同其他的成员,为整个类体

（4）静态内部类---访问---->外部类 【访问方式：直接访问所有静态成员】
（5）外部类---访问------>静态内部类【访问方式：创建对象,再访问】

（6）外部其他类---访问---->静态内部类

// 外部其他类
public class Demo {

    public static void main(String[] args) {

        // 方式一
        Waibu.Neibu neibu = new Waibu.Neibu();
        // 方式二
        Waibu.Neibu neibu2 = Waibu.getNeibu();


    }
}

// 外部类
class Waibu{

    // 静态内部类
    public static class Neibu{}

    public static Neibu getNeibu(){
        return new Neibu();
    }
}