java——final关键字；abstract抽象类；implement接口

一、final关键字

1.1、final的基本介绍

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

在某些情况下，有以下需求，就会使用到final：

1、当不希望类被继承时，可以用final修饰

2、当不希望父类的某个方法被子类覆盖/重写(override)时，可以用final关键字修饰。 

3、当不希望类的某个属性的值被修改，可以用final修饰

public final double TAX_RATE = 0.08;

4、当不希望某个局部变量被修改，可以使用final修饰

final double TAX_RATE=0.08;

1.2、final使用注意事项和细节讨论

1、final修饰的属性又叫常量，一般用XX_XX_XX来命名

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

1）定义时：如 public final double TAX_RATE=0.08;

2）在构造器中

3）在代码块中

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

1）定义时

2）在静态代码块，不能在构造器中赋值。

4、final类不能继承，但是可以实例化对象。

5、类不是final类，但是含有final方法，则该方法虽然不能重写，但是可以被继承。

6、一般来说，如果一个类已经是final类了，就没有必要再将方法修饰成final方法。

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

8、final 和 static 往往搭配使用，效率更高，不会导致类加载。底层编译器做了优化处理。

9、包装类(Integer,Double,Float,Boolean等都是final)，String也是final类。

---

二、抽象类

2.1、抽象类的定义

当父类的某些方法，需要声明，但是又不确定如何实现时，可以将其声明为抽象方法，那么这个类就是抽象类

2.2、基本介绍

1、用abstract关键字来修饰一个类时，这个类就叫抽象类

访问修饰符 abstract 类名{}

2、用abstract 关键字来修饰一个方法时，这个方法就是抽象方法

访问修饰符 abstract 返回类型 方法名（参数列表）;//没有方法体{}

3、抽象类的价值更多作用是在于设计，是设计者设计好后，让子类继承并实现抽象类()

4、抽象类的知识点比较重要，在框架和设计模式使用较多

2.3、抽象类的使用注意事项和细节讨论

1、抽象类不能被实例化

2、抽象类不一定要包含abstract方法。也就是说，抽象类可以没有abstract方法

3、一旦类包含了abstract方法，则这个类必须声明为abstract

4、abstract 只能修饰类和方法，不能修饰属性和其它的

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

6、抽象方法不能有主体，即不能实现

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

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

2.4、抽象类最佳实践-模板设计模式

1、基本介绍

抽象类体现的就是一种模板模式的设计，抽象类作为多个子类的通用模板，子类在抽象类的基础上进行扩展、改造，但子类总体上会保留抽象类的行为方式

2、模板设计模式能解决的问题

1）当功能内部一部分实现是确定，一部分实现是不确定的。这时可以把不确定的部分暴露出去，让子类去实现

2）编写一个抽象父类，父类提供了多个子类的通用方法，并把一个或多个方法留给其子类实现，就是一种模板模式

---

三、接口

3.1、基本介绍

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

3.2、基本语法

interface 接口名{
//属性；
//抽象方法；
}

class 类名 implements 接口{
//自己属性；
//自己方法；
//必须实现的接口的抽象方法；
}

小结：接口是更加抽象的类，抽象类里的方法可以有方法体，接口里的 所有方法都没有方法体【JDK7.0】。接口体现了程序设计的多态和高内聚低偶合的设计思想。

特别说明：类JDK8.0后接口可以有静态方法，默认方法，也就是说接口中可以有方法的具体实现(前加default)

3.3、使用注意事项和细节讨论

1、接口不能被实例化

2、接口中所有的方法是public方法，接口中抽象方法，可以不用abstract 修饰：void aa();实际上是 abstract void aa();

3、一个普通类实现接口，就必须将该接口的所有方法都实现。快捷键Alt+Enter

4、抽象类实现接口，可以不用实现接口的方法。

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

class A implements B,C{}

6、接口中的属性，只能是final的，而且是public static final修饰符。比如：

int a = 1;
//实际上是public static final int a = 1;(必须初始化）

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

8、接口不能继承其它的类，但是可以继承多个别的接口

interface A extends B,C(){}

9、接口的修饰符只能是 public和默认，这点和类的修饰符是一样的。

3.4、实现接口VS继承类

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

1）继承的价值主要在于

解决代码的复用性和可维护性。

2）接口的价值主要在于

设计，设计好各种规范（方法），让其它类去实现这些方法。即更加的灵活

2、接口比继承更加灵活

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

3、接口在一定程度上实现代码解耦【即：接口规范性+动态绑定机制】

3.5、接口的多态特性

1、多态参数（前面案例体现）

usb既可以接收手机对象，又可以接收相机对象，就体现了接口多态

（接口引用可以指向实现了接口的类的对象）

public class InterfacePolyParameter {
    public static void main(String[] args) {
        //接口类型的变量 if01 可以指向 实现了IF接口类的对象实例
        IF if01 = new Monster();
        if01 = new Car();
        //继承体现的多态
        //父类类型的变量 a 可以指向 继承AAA的子类的对象实例
        AAA a = new BBB();
        a = new CCC();
    }
}

interface IF {}

class Monster implements IF{}

class Car implements  IF{}

class AAA {}

class BBB extends AAA {}

class CCC extends AAA {}

2、多态数组

给Usb数组中，存放 Phone 和 相机对象，Phone类还有一个特有的方法call（），请遍历Usb数组，如果是Phone对象，除了调用Usb接口定义的方法外，还需要调用Phone特有方法call（运用instanceOf 比较操作符）

public class InterfacePolyArr {
    public static void main(String[] args) {
        //多态数组 -> 接口类型数组
        Usb[] usbs = new Usb[2];
        usbs[0] = new Phone_();
        usbs[1] = new Camera_();
        /*
        给Usb数组中，存放 Phone  和  相机对象，Phone类还有一个特有的方法call（），
        请遍历Usb数组，如果是Phone对象，除了调用Usb 接口定义的方法外，
        还需要调用Phone 特有方法 call
         */
        for(int i = 0; i < usbs.length; i++) {
            usbs[i].work();//动态绑定..
            //和前面一样，我们仍然需要进行类型的向下转型
            if(usbs[i] instanceof Phone_) {//判断他的运行类型是 Phone_
                ((Phone_) usbs[i]).call();
            }
        }

    }
}

interface Usb{
    void work();
}

class Phone_ implements Usb {
    public void call() {
        System.out.println("手机可以打电话...");
    }

    @Override
    public void work() {
        System.out.println("手机工作中...");
    }
}

class Camera_ implements Usb {
    @Override
    public void work() {
        System.out.println("相机工作中...");
    }
}

3、接口存在多态传递现象

interface a{};
class b implement a{};
class c extends b{};
//则c类也实现了接口a

public class InterfacePolyPass {
    public static void main(String[] args) {
        //接口类型的变量可以指向，实现了该接口的类的对象实例
        IG ig = new Teacher();
        //如果IG 继承了 IH 接口，而Teacher 类实现了 IG接口
        //那么，实际上就相当于 Teacher 类也实现了 IH接口.
        //这就是所谓的 接口多态传递现象.
        IH ih = new Teacher();
    }
}

interface IH {
    void hi();
}

interface IG extends IH{ }
class Teacher implements IG {
    @Override
    public void hi() {
    }
}