抽象类和抽象方法

抽象方法和抽象类

当父类的某些方法，需要声明，但是又不确定如何实现时，可以用abstract关键字修饰该方法这个方法就变成了抽象方法。
同理用abstract修饰类该类就是抽象类。抽象方法只能存在抽象类中

1. 用abstract修饰一个类，那么该类就是抽象类
2. 用abstract修饰一个方法，这个方法就是抽象方法。抽象方法没有方法体
3. 抽象类的价值定位是在于设计，设计好之后让子类去实现

抽象方法

举例说明：
现在有一个Animal类，这是一个动物类，所有的动物都有一个行为，就是吃。所以定义一个eat方法，但是由于现在不知道它是什么动物 ，所以不知道它吃什么。也就是父类的不确定性，此时就需要使用abstract修饰eat方法，使其可以不被实现，也就是不用写方法体。

abstract class  Animal{
    private String name;
    public abstract void eat();
}
1
2
3
4

上面将Animal类变成了一个抽象类，将eat变成了一个抽象方法。所以eat可以不用具体实现，没有方法体。
那么一般抽象类的抽象方法一般是由子类去实现的。

抽象类注意事项

1. 抽象类不能被实例化
2. 抽象类可以没有抽象方法，但是抽象方法必须在抽象类中
3. 一旦方法被声明为abstract抽象方法，那么该类必须也声明abstract为抽象类
4. abstract只能修饰类和方法，不能修饰其他
5. 抽象类本质上还是一个类，也可以有任意成员：非抽象方法，构造器，静态属性…
6. 抽象方法不能有主体
7. 如果一个类继承了抽象类，则该类必须实现抽象类的所有抽象方法，除非该类也声明为一个抽象类

就相当于老板布置了目标，交给主管，主管比较懒不想完成，所以又交给了底层员工。总之只要继承了抽象类，只有也变成抽象类，或者实现抽象方法。两条路

8. 抽象方法不能和 private final static关键字一起使用，因为抽象方法需要子类重写实现，但是这三个关键字会 阻止子类重写
   private ：除了本类，其他地方无法调用。自然子类无法进行重写
   final：final声明在方法就是意味着 这是最终的了，不可以被改动。子类也无法重写
   static：因为抽象类是无法被实例化的，也就是无法被分配内存。而static在加载的时候就已经会分配内存。于此static和abstract会产生冲突。所以无法一起使用

抽象类练习

1. abstract final class A{}能编译通过吗 ？

不能，因为final修饰的方法，子类不可以重写

2. abstract public static void test2();能编译通过吗 ？

不能，因为static和abstract会产生冲突

3. abstract private void test3();能编译通过吗 ？

不能，因为private修饰的，子类无法重写

4. 编写一个Employee类，声明为抽象类，包含如下三个属性：name id salary 提供构造器和抽象方法work()，对于Manager类来说，他即是员工，还具有奖金bonus的属性。请设计CommonEmployee类和Manager类，要求类中提供必要的方法进行属性访问，实现work()。

public class test12 {
    public static void main(String[] args) {
        Manager wang = new Manager("王中",2333,10000,2999);
        wang.work();
        CommonEmployee li = new CommonEmployee("李三",899,9000);
        li.work();
    }
}
abstract class  Employee{
    private String name;
    private int id;
    private double sal;
    public abstract void work();
    public Employee(String name, int id, double sal) {
        this.name = name;
        this.id = id;
        this.sal = sal;
    }
    public String getName() {
        return name;
    }
    public int getId() {
        return id;
    }
    public double getSal() {
        return sal;
    }
}
class Manager extends Employee{
    private double bonus;
    public Manager(String name, int id, double sal, double bonus) {
        super(name, id, sal);
        this.bonus = bonus;
    }
    @Override
    public void work() {
        System.out.println("经理:"+getName()+"正在工作中");
    }
}
class CommonEmployee extends Employee{
    public CommonEmployee(String name, int id, double sal) {
        super(name, id, sal);
    }
    @Override
    public void work(){
        System.out.println("普通员工:"+getName()+"正在工作中");
    }
}
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

抽象类体现实践

1. 设计一个类Template
2. 编写一个抽象方法job
3. 编写一个Time（）方法可以计算job方法完成的时间是多少
4. A类和B类都是Template的子类，A类的job方法计算1+…70000，B类的job计算1+…80000
5. 计算一下A和B的job方法完成需要多少时间
   System.currentTimeMills();可以获取时间，分别获取两次，相减即可获得差

public class Test {
    public static void main(String[] args) {
        A a = new A();
        a.Time();
        B b = new B();
        b.Time();

    }
}
abstract class Template{
    public abstract void job();
    public void Time(){
        long start = System.currentTimeMillis();
        job();
        long end = System.currentTimeMillis();
        System.out.println("完成时间为:"+(end - start));
    }
}
class A extends Template{
    @Override
    public void job(){
        for (int i = 1; i <=700000 ; i++) {
            i+=i;
        }
    }
}
class B extends Template{
    @Override
    public void job(){
        for (int i = 1; i <=900000 ; i++) {
            i+=i;
        }
    }
}
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

---