Java基础抽象类详解

类到对象是实例化。对象到类是抽象。

抽象类：
1、什么是抽象类？

• 类和类之间具有共同特征，将这些共同特征提取出来，形成的就是抽象类。
• 类本身是不存在的，所以抽象类无法创建对象《无法实例化》。

2、抽象类属于什么类型？

• 抽象类也属于引用数据类型。

3、抽象类怎么定义？

	语法：
				[修饰符列表] abstract class 类名{
					类体;
				}
1
2
3
4

4、抽象类是无法实例化的，无法创建对象的，所以抽象类是用来被子类继承的。

5、final和abstract不能联合使用，这两个关键字是对立的。

6、抽象类的子类可以是抽象类。也可以是非抽象类。

7、抽象类虽然无法实例化，但是抽象类有构造方法，这个构造方法是供子类使用的。

8、抽象类关联到一个概念：抽象方法。什么是抽象方法呢？

抽象方法表示没有实现的方法，没有方法体的方法。例如：
				public abstract void doSome();
				抽象方法特点是：
					特点1：没有方法体，以分号结尾。
					特点2：前面修饰符列表中有abstract关键字。
1
2
3
4
5

9、抽象类中不一定有抽象方法，抽象方法必须出现在抽象类中。

10、抽象类中不一定有抽象方法，抽象方法必须出现在抽象类中。

11、抽象类继承 ，如果 子类 也是一个 抽象类 ，并不要求一定 重写父类方法 。 如果 子类不是抽象类 ，则要求 子类 一定要实现 父类 中的 抽象方法 。

12、抽象类本类中抽象方法无法使用方法重载

重要结论：

一个非抽象的类继承抽象类，必须将抽象类中的抽象方法实现了。
	   这是java语法上强行规定的，必须的，不然编译器就报错了
	   
	   这里的覆盖或者说重写，也可以叫做实现.(对抽象的实现)
1
2
3
4

示例代码01：

public class AbstractTest01{
	public static void main(){
		// new Account();//Account是抽象的；无法实例化
	}
}

/* final abstract class Account{//非法的修饰符组合：abstract和final
	
} */

abstract class Account{
	//如果不写无参构造方法会报错
	/* public Account(String s){
	
	} */
	public abstract void doOther();
	
	public void sumInt(){}//编译通过，抽象类中可以有普通方法
}

abstract class CreditAccount extends Account{//编译通过
	/* public CreditAccount(){
		super();//不写的话会自动会有一个构造方法并且第一行会自带一个super关键字
	} */
}

/* class A{
	public abstract void a(){};//编译报错，抽象类只能出现在抽象方法中
} */
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

示例代码02：

public class AbstractTest02{
	public static void main(String[] args){
       
	   //多态，向上转型，父类型引用指向子类型对象
	   //面向抽象编程，不要面向具体编程，降低程序的耦合度，提高程序的扩展力
	   //这种编程思想符合OCP原则
	   Animal a = new Bird();
	   a.move();
	   
	   Animal b = new Cat();
	   b.move();
	}
}

//动物类(抽象类)
abstract class Animal{
	//抽象方法
	public abstract void move();
	
}

/* abstract class Bird extends Animal{
	public abstract void move();
} */

//子类(非抽象的)
class Bird extends Animal{//如果不重写方法会编译报错，错误：Bird不是抽象的，并且未覆盖Animal中的抽象方法move();
	public void move(){
		System.out.println("鸟儿在飞翔！");
	}
}

class Cat extends Animal{
	public void move(){
	System.out.println("小猫在步行！");
	}
}
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

例题：

例题代码：

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

        //创建圆形对象
        Circular c = new Circular();
        c.Area(15.2);

        //创建长方形对象
        Rectangle r = new Rectangle();
        r.findArea(12.4,56.3);

        //创建正方形对象
        Square s = new Square();
        s.findArea(15.9);
    }
}
public abstract class Type{//抽象类本类中抽象方法无法使用方法重载
    public abstract void findArea();
    public abstract void Area(double a);
    public abstract void findArea(double x,double y);
    public abstract void findArea(double v);
}
class Circular extends Type{
    public static final double PI = 3.14;//常量π

    @Override//此关键字在抽象类的子类中可有可无
    public void findArea() {

    }

    @Override
    public void Area(double a) {
        double c = PI * a * a;
        System.out.println("圆形的面积是：" + c);
    }

    @Override
    public void findArea(double x, double y) {

    }

    @Override
    public void findArea(double v) {

    }
}
class Rectangle extends Type{
    @Override
    public void findArea() {

    }

    @Override
    public void Area(double a) {

    }

    public void findArea(double x, double y){
     double z = x * y;
        System.out.println("长方形的面积是：" + z);
    }

    @Override
    public void findArea(double v) {

    }
}
class Square extends Type{
    @Override
    public void findArea() {

    }

    @Override
    public void Area(double a) {

    }

    @Override
    public void findArea(double x, double y) {

    }

    public void findArea(double v){
        double d = v * v;
        System.out.println("正方形的面积是：" + d);
    }
}
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
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88

运行结果：