java笔记 Day 16 —— final关键字、抽象类

一、final关键字

• 基本介绍

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

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

  在有以下需求的时候，就会使用到final：

  1. 当不希望类被继承的时候，可以使用 final来修饰[final class 类名]
  2. 当不希望父类的某个方法被子类覆盖/重写（Override）时，可以使用final关键字来修饰[访问修饰符 final 返回类型 方法名]
  3. 当不希望类的某个属性的值被修改，可以使用 final来修饰[ public final double TAB_RATE = 0.08]
  4. 当不希望某个局部变量被修改，可以使用 final修饰[final double TAX_RATE = 0.08]

• 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方法，则该方法虽然不能重写，但是可以被继承，即仍然遵守继承

     public class FinalDetail01{
         public static void main(String[] args){
             new EE.cal();//创建EE的匿名对象调用cal()方法是可以的
         }
     }
     
     class DD{
         public final void cal(){
             System.out.println("cal()方法")
         }
     }
     
     class EE extends DD{
         
     }
     

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

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

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

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

二、抽象类（abstract）

• 引入：当父类方法不确定的话

  ​ 就将该方法设计为抽象方法，

  ​ 所谓的抽象方法就是没有实现的方法，

  ​ 所谓没有实现就是指，没有方法体

  ​ 当一个类中存在抽象方法时，需要将该类声明为 abstract类

  ​ 一般来说，抽象类会被继承，由其子类来实现抽象方法

  abstract class Animal{
      private String name;
      
      public Anmial(String name){
          this.name = name;
      }
      //思考：这里eat 里面啥都没实现，其实是没有意义的
      //即：父类方法不确定性
      //当父类方法不确定的话
  	//就将该方法设计为抽象方法，
      //所谓的抽象方法就是没有实现的方法
      //所谓没有实现就是指，没有方法体
      //当一个类中存在抽象方法时，需要将该类声明为 abstract类
      
      public abstract void eat();
  }
  

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

• 介绍：

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

     访问修饰符 abstract 类名{
         
     }
     

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

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

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

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

• 细节：

  1. 抽象类不能被实例化

  2. 抽象类不一定要包含 abstract 方法，也就是说，抽象类可以没有 abstract 方法，还可以有实现的方法。

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

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

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

  6. 抽象类方法不能有主体，即不能有{}

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

     abstract class E{
         public abstract void hi();
     }
     
     //1.自己声明为抽象类
     abstract class F extends E{
         
     }
     //2.实现继承的抽象的所有方法
     class G extends E{
         public void hi(){ // 相当于子类G实现了父类E的抽象方法，加了{}就是实现了方法，写不写东西都是实现了方法体。
             
         }
     }
     

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

抽象类的最佳实践—模板设计模式

• 需求：

  1. 有多个类，完成不同的任务job
  2. 要求能够得到各自完成任务的时间

• 作用：

  可以提高代码的复用性