关键字 final , 抽象abstract

一，final关键字

　　final中文意思是：最后的，最终的

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

　　在某些情况下，程序员可能有以下需求，就会使用final

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

　　　　2）当不希望父类的某个方法被子类覆盖或重写时，可以使用final关键字修饰

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

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

　　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和static 往往搭配使用，效果更高，不会导致类加载，底层编译器做了优化处理

　　　　　　class Demo{

　　　　　　　　public static final int i= 16;

　　　　　　　　static{

　　　　　　　　　　System.out.print("阿文你好“）;

　　　　　　　　}

　　　　　　}

　　　8) 包装类（Integer, Double,   Float...等都是final).String 也是final 类。

　　3. final 修饰变量

　　　　1. 基本类型，是值不能被改变

　　　　2. 引用类型，是地址不能改变

　　　　final 修饰变量的初始化时机  在对象构造完毕前即可

二，抽象类  abstract

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

　　

//我们看如何把Animal做成抽象类，并让子类Cat类实现
abstract class Animal{
    String name;
    int age;
    abstract public void cry();
}

　　　　1.抽象类的介绍

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

　　　　　　　　访问修饰符  abstract   类名{}

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

　　　　　　　　访问修饰符  abstract    返回值类型   方法名（参数列表）； 没有方法体

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

　　　　　　4）抽象类，是考官比较爱问的知识点，在框架和设计模式使用较多

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

　　　　　　1）抽象类不能被实力化

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

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

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

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

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

　　　　　　　　abstract void aaa();

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

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

　　　　3.  抽象类最佳实践 ---模板模式

　　　　　　1）.基本介绍

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

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

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

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

　　　　　　3）最佳实践

　　　　　　　　需求， 有多个类完成不同任务job                          要求统计得到各自完成任务的时间       编写

 

 

 　　　　　　　　

public class AAA {        
    public void h1(){
        long num = 0;
        long start = System.currentTimeMillis();//开始时间
        for (long i = 0; i < 800000; i++) {
            num += i;
        }
        long eng = System.currentTimeMillis();
        System.out.println("AAA结束时间" + (eng - start));
    }
}
//----------------------------------------------------------------
public class BBB {
    public void h1(){
        long num1 = 0;
        long start = System.currentTimeMillis();//开始时间
        for (long i = 0; i < 8000000; i++) {
            num1 += i;
        }
        long eng = System.currentTimeMillis();
        System.out.println("BBB结束时间" + (eng - start));
    }
}
//===============================
public class Template {
    public static void main(String[] args) {
        AAA aaa = new AAA();
        aaa.h1();
        BBB bbb = new BBB();
        bbb.h1();
    }
}

　　　　　　相同的方法  不同的实现方式  ，相同的代码提取出来  做成一个抽象类  然后去继承   这就是抽象的好处

　　　　　　

abstract class Template{
    public abstract void job();
    public void caleTimes(){
        long start = System.currentTimeMillis();
        job();
        long end = System.currentTimeMillis();
        System.out.println("耗时" + (end - start));
    }
}