Java--抽象类的基础知识

抽象类的概念

• 在Java中，一个没有方法体的方法应该定义为抽象方法，而类中如果有抽象方法，该类必须定义为抽象类。
• 抽象类和抽象方法用abstract关键字来修饰
  • 抽象类： abstract class 类名{}
  • 抽象方法： pubic abstract void eat();//抽象方法中没有方法体
• 抽象类中不一定有抽象方法，但是有抽象方法的类必须为抽象类；
• 抽象类不能实例化；
• 抽象类中可以有构造方法，用于子类访问父类时的数据初始化；
• 抽象类由具体的子类进行实例化；
• 子类必须对父类中的所有抽象方法进行重写
• 案例演示：

class MyTest2 {
    public static void main(String[] args) {
        A a = new B();//对子类B进行初始化，那么先要对父类A进行初始化
        a.show();//编译看左边，运行看右边
        a.hehe();
        System.out.println(a.AA);//调用变量时，编译运行都看左边
        System.out.println(a.num);
    }
}

abstract class A {

    int num = 20;
    public final int AA = 20;

    public A() {
        System.out.println("抽象类的空参构造执行了");
    }

    public abstract void show();

    public void hehe() {
        System.out.println("hehe");
    }
}

class B extends A {
    int num = 600;

    public B() {
        System.out.println("子类的空参构造执行了");
    }

    @Override
    public void show() {
        System.out.println("子类show");
    }

    @Override
    public void hehe() {
        System.out.println("子类hehe");
    }
}
运行结果为：
抽象类的空参构造执行了
子类的空参构造执行了
子类show
子类hehe
20
20

抽象类的案例演示：

• 需求：假如我们在开发一个系统时需要对员工(Employee)类进行设计，员工包含3个属性：姓名、工号以及工资(salary)。
  经理(Manager)也是员工，除了含有员工的属性外，另为还有一个奖金(bonus)属性。
  然后定义工作的方法.
  请使用继承的思想设计出员工类和经理类。

public abstract class Employee {
    private String name;
    private int number;
    private int salary;
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getNumber() {
        return number;
    }

    public void setNumber(int number) {
        this.number = number;
    }

    public int getSalary() {
        return salary;
    }

    public void setSalary(int salary) {
        this.salary = salary;
    }


    public abstract void work();//定义工作的抽象方法
}
class Manager extends Employee{
    public int getBonus() {
        return bonus;
    }

    public void setBonus(int bonus) {
        this.bonus = bonus;
    }

    private int bonus;
    @Override
    public void work() {
        System.out.println("经理需要做战略决策");
    }
}
class Test{
    public static void main(String[] args) {
        Employee employee=new Manager();
        employee.setName("老王");
        employee.setNumber(001);
        employee.setSalary(3000);
        Manager manager=(Manager)employee;
        manager.setBonus(1000);
        System.out.println("名字："+employee.getName()+"工号："+employee.getNumber()+"工资是："
                +employee.getSalary()+"奖金是："+((Manager) employee).getBonus());
        manager.work();
    }
}

abstract关键字不能和哪些关键字共存

	private    冲突   abstract的方法必须被子类重写，而private不能被继承
	final      冲突    final修饰的方法，变量都不能修改，而abstract修饰的方法必须被重写
	static     不能共存 无意义   static 是静态的，abstract方法中无方法体，无法调用。