Java笔记整理 —— final、抽象类

final 

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

使用

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

2. 当不希望父类的某个方法被子类 重写 时，可以用final关键字修饰。

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

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

     public void test(){
         final int a = 10;
         a= 20;   //报错
     }

注意事项

1. final修饰的属性又叫常量，一般用 XX_XX_XX命名（比如 TAX_RATE），常量名使用全大写。

public final static TAX_RATE = 0.2;

2. final修饰的属性在定义时，必须赋初值，并且以后不能再修改，赋值可以在下列位置之一：(1)定义时  (2) 在构造器中  (3) 在代码块中（代码块相当于构造器的补充）

3. 如果final修饰的属性是静态的，则初始化位置只能是：(1) 定义时  (2) 在静态代码块，不能在构造器中赋值（因为可以用类名调用静态属性，并没有调用构造器）。

4. final类不能继承，但是可以创建对象（实例化）。

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

    public static void main(String[] args) {
        Student a = new Student();
        a.test();  //输出父类的test方法
    } 

6. 一般来说，如果一个类已经是final类了，就没有必要再将方法修饰成final方法（因为根本就无法继承，也就没办法重写方法了）。

7. final不能修饰构造器。

8. final和static往往搭配使用，效率更高，不会导致类加载，底层编译器做了优化处理，可以使用 static final 设置一个类常量，类常量的定义位于main方法的外部。

public class Person {
     public static final double PI = 3.14;
     static{
         System.out.println("类加载，调用静态代码块");
     }
}

public class Test {
    public static void main(String[] args) {
        System.out.println(Person.PI);   //只输出 3.14，不调用静态代码块
    }
}

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

抽象类

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

abstract public class Person {
     public abstract void say();  //加分号
}

    所谓抽象方法就是没有实现的方法（没有方法体），当一个类中存在抽象方法时，需要将该类声明为abstract方法。一般来说，抽象类会被继承，由其子类来实现抽象方法。

简介

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

访问修饰符 abstract 类名{}

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

访问修饰符 abstract 返回类型 方法名(参数列表); //没有方法体

3. 抽象类的价值更多作用是在于设计，设计者设计好后，让子类继承并实现抽象类，在框架和设计模式使用较多（常考）。

注意事项

1. 抽象类不能被实例化。

2. 抽象类可以没有abstract方法，但只要类是abstract，那么它的方法即使不写abstract，也是抽象方法。

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

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

5. 抽象类可以有任意成员（因为抽象类还是类），比如：非抽象方法，构造器，静态属性等等。

6. 抽象方法不能有主体，即不能有大括号。

     public abstract void say(){}; //报错，不能有大括号

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

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

private不能重写，static与重写无关。 

关于static可以看这个博客：关于abstract为什么不能和static连用_sinat_36695865的博客-CSDN博客

模板设计模式

abstract public class Template { //抽象类-模板设计模式
    public abstract void job(); //抽象方法
    public void calculateTime(){  //主体方法
        long start = System.currentTimeMillis();
        job();
        long end = System.currentTimeMillis();
        System.out.println("执行时间为:"+(end-start));
    }
}

public class AA extends Template{
    @Override
    public void job() {   //重写抽象方法
        int sum = 0;
        for (int i = 0; i < 1000000; i++) {
            sum += i;
        }
    }
}

public class Test {
    public static void main(String[] args) {
         AA a = new AA();
         a.calculateTime();  //直接调用方法
    }
}

    这个设计模式的好处就是 —— 把需要重写的方法做成 抽象方法写在抽象父类中，子类只需要把不同的代码重写即可，相同部分的方法写在抽象类中， 子类不需要动，在测试类中实例化对象直接调用即可。