Java基础(六) -- Final、抽象类、接口

发表于 | 分类于

Final

  • 不希望别被其他类继承

    1
    2
    3
    final class A {

    }

  • 不希望父类的某个方法被子类修改则使用final修饰

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    class A{
        public final void h1(){

        }
    }

    class B extends A{
        @override
        public void h1(){
            // 覆写不被允许
        }
    }

  • 当某个属性不希望被修改时

    1
    2
    3
    class A{
        public final int count = 10;
    }

  • 当某个局部变量不希望被修改时

  • 注意项：

    1. final修饰的属性又叫常量，一般用 XX_XX_XX 来命名
    2. final修饰的属性在定义时，必须赋初值，并且不能再修改，赋值可以加在如下位置
      • 定义时：如 public final double TAX_RATE=0.08;
      • 在构造器中
      • 在代码块中
    3. 如果final修饰的属性是静态的，则初始化的位置只能是 【定义时、在静态代码块、不能在构造器中赋值】
    4. final类不能继承但是可以实例化对象
    5. 如果类不是final类，但是包含final方法，则该方法是可以被继承的，但不能被重写
    6. final不能修饰构造方法
    7. final和static搭配使用往往效率更高，不会导致类加载 
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      24
      25
              class Person{
                  // public static final int count;
                  public static final int count = 100;

                  static {
                          // count = 100;
                          System.out.println("static 代码块执行"); //不被输出，但是当在static代码块中初始化数据时会执行代码块的内容
                      }
                  }
              ```    

      # 抽象类 [abstract]

      * 定义 类中包含不确定如何实现的方法的类叫做抽象类，使用abstract 修饰
          ```java
          abstract class Person{
              public abstract void eat();
          }

          class Stu extends Person{
              @Override
              public void eat() {

              }
          }

  • 细节

    1. 抽象类不能被实例化
    2. 抽象类不一定包含抽象方法
    3. 一点类中包含抽象方法，则这个类一定要声明为抽象类
    4. abstract 只能修饰类和方法不能修饰属性和其他的
    5. 抽象类中可以有任意类型的成员，抽象类本质上还是类
    6. 抽象方法不能有主体 
      1
      2
      3
      4
      abstract class Person{
          //不正确，因为抽象类不能包含方法体
          //public abstract void eat(){};
      }
    7. 如果一个类继承了一个抽象类则该类需要实现抽象类中的所有抽象方法，或者这个类本身声明为一个抽象类
    8. 抽象方法不能使用private、final和static来修饰，因为这些关键字都是和重写相违背的

  • 应用 模板设计模式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
public class AbstractTemp {
    public static void main(String[] args) {
        AA aa = new AA();
        aa.cal();

        BB bb = new BB();
        bb.cal();
    }
}

abstract class BaseCal{
    public String name;
    public void cal(){
        long start = System.currentTimeMillis();
        job();
        long end = System.currentTimeMillis();
        System.out.println(this.name+"执行时间"+(end - start));
    }

    public abstract void job();
}

class AA extends BaseCal{
    public AA() {
        this.name = "AA";
    }

    @Override
    public void job() {
        int sum = 0;
        for (int i = 0; i < 800000; i++) {
            sum += i;
        }
    }
}

class BB extends BaseCal{
    public BB(){
        this.name = "BB";
    }
    @Override
    public void job() {
        int sum = 1;
        for (int i = 0; i < 80000; i++) {
            sum *= i;
        }
    }
}

接口 interface

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
public interface UsbInterface {
    void start();
    void stop();
}

class Mouse implements UsbInterface{
    @Override
    public void start() {
        System.out.println("鼠标开始工作");
    }

    @Override
    public void stop() {
        System.out.println("鼠标暂停工作");
    }
}

class Keyboard implements UsbInterface{
    @Override
    public void start() {
        System.out.println("键盘开始工作");
    }

    @Override
    public void stop() {
        System.out.println("键盘停止工作");
    }
}
  • 注意事项

  1. 接口不能实例化

  2. 接口中所有方法都是public方法

  3. 普通类实现接口需要将接口的所有方法都实现

  4. 抽象类实现接口时可以不用实现接口的全部方法

  5. 一个类可以实现多个接口

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    interface IB{
       void hi();
    }

    interface IC{
       void say();
    }

    class Pid implements IB,IC{

       @Override
       public void hi() {
           
       }

       @Override
       public void say() {

       }
    }

  6. 接口中的属性只能是final的，而且是 public static final 变量，例如 int a = 1;实际是public static final int a = 1;

  7. 接口中的属性访问 接口名.属性名

  8. 接口不能继承其他的类但是可以继承其他的接口
    inteface A extends B,C{}

  9. 接口的修饰符只能是 public或默认的，和类的修饰符一样

  10. 接口中被 default 修饰的默认方法可以不被，实现类重写