非零基础自学Java (老师：韩顺平) 第10章 面向对象编程(高级部分) 10.6 抽象类

非零基础自学Java (老师：韩顺平)

✈【【零基础 快速学Java】韩顺平 零基础30天学会Java】

第10章 面向对象编程(高级部分)

10.6 抽象类

10.6.1 看个问题

举个栗子

package com.dingjiaxiong.abstract_;

/**
 * ClassName: Abstract01
 * date: 2022/9/3 19:57
 *
 * @author DingJiaxiong
 */

public class Abstract01 {
    public static void main(String[] args) {

    }
}

abstract class Animal{
    private String name;

    public Animal(String name) {
        this.name = name;
    }

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

    public abstract void eat();
}
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

10.6.2 解决之道 —— 抽象类快速入门

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

10.6.3 抽象类的介绍

• 用abstract关键字来修饰一个类时,这个类就叫抽象类

  访问修饰符 abstract 类名{}
  1

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

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

• 抽象类的价值更多作用在于设计，设计者设计好后，交给子类去继承并实现抽象类

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

• 抽象类不能实例化【继承】
• 抽象类不一定要包含abstract方法，即抽象类可以没有abstract方法
• 一旦类中包含了abstract方法，则这个类必须声明为abstract。
• abstract只能修饰类和方法，不能修饰属性和其他的。

package com.dingjiaxiong.abstract_;

/**
 * ClassName: AbstractDetail01
 * date: 2022/9/3 20:06
 *
 * @author DingJiaxiong
 */

public class AbstractDetail01 {
    public static void main(String[] args) {
//        new A();
        //抽象类不能被实例化
    }
}

//抽象类可以没有abstract方法
abstract class A{
    public void hi(){
        System.out.println("hi");
    }
}

//一旦类包含了abstract方法，则这个类必须声明为abstract
abstract class B{
    public abstract void hi();
}

//abstract 只能修饰类和方法，不能修饰属性和其他
class C{
//    public abstract int n1 = 1;
}
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

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

• 抽象类可以有任意成员【本质还是类】。
• 抽象方法不能有主体，即不能进行实现【括号之后就分号】
• 如果一个类继承了抽象类,则它必须实现抽象类的所有抽象方法,除非它自己也声明为abstract类。
• 抽象方法不能使用private、final和static来修饰【这些关键字和重写相违背】

举个栗子

package com.dingjiaxiong.abstract_;

/**
 * ClassName: AbstractDetail02
 * date: 2022/9/3 20:12
 *
 * @author DingJiaxiong
 */

public class AbstractDetail02 {
    public static void main(String[] args) {
        System.out.println("Hello");
    }
}

抽象方法不能使用 private、final 和 static 来修饰，因为这些关键字都是和重写相违背的
abstract class H{
    public abstract void hi(); //抽象方法
}

///如果一个类继承了抽象类，则它必须实现抽象类的所有抽象方法，除非它自己也声明为 abstract类
abstract class E{
    public abstract void hi();
}

abstract class F extends E{

}

class G extends E{

    @Override
    public void hi() { //这里G就必须重写E中的方法

    }
}

//抽象类的本质还是类，所以可以有类的各种成员
abstract class D{
    public int n1 = 10;
    public static String name = "韩老师666";
    public void hi(){
        System.out.println("Hi");
    }
    
    public abstract void hello();
    
    public static void ok(){
        System.out.println("Ok");
    }
}
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
49
50
51