抽象类

 

4、抽象类案例 

需求：开发团队中有程序员和经理两种角色，他们都有姓名、工资、工号等属性，都有工作的行为，经理还有奖金属性，请使用继承思想设计出上述需求的类，并分别创建对象使用。

package com.wang.duixiang;

public class AbstractDemo03 {
    public static void main(String[] args) {
      TeamWorker t=new ItWorker();
      t.setID("123456");
      t.setName("王迎婧");
      t.setSalary(7000);
      t.work();
        System.out.println("-----------------------------------------");
      Manager manager=new Manager();
      manager.setID("654321");
      manager.setName("fewof");
      manager.setSalary(10000);
      manager.setBonus(3000);
      manager.work();
        System.out.println("---------------------------------------------");
      //快速实例化
        ItWorker itWorker1=new ItWorker("张三",8000,"009");
        System.out.println("姓名："+itWorker1.getName());
        System.out.println("工资："+itWorker1.getSalary());
        System.out.println("工号："+itWorker1.getID());
        Manager manager1=new Manager("李四",30000,"001",5000);
        System.out.println("姓名："+manager1.getName());
        System.out.println("工资："+manager1.getSalary());
        System.out.println("工号："+manager1.getID());
        System.out.println("奖金："+manager1.getBonus());
}}
class ItWorker extends TeamWorker{
    public ItWorker(){}
    public ItWorker(String name,int salary,String ID){
        super(name, salary, ID);
    }
    @Override
    public void work(){
        System.out.println(getName()+"负责开发程序，他的月工资为"+getSalary()+"元");
    }
}
class Manager extends TeamWorker{
     private int bonus;//奖金

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

    public int getBonus() {
        return bonus;
    }
    //在实际开发中，子类一般都有两个构造方法
    //子类的空参构造访问父类的空参构造，子类的全参构造访问父类的全参构造
public Manager(){}
    public Manager(String name,int salary,String ID,int bonus){
        super(name, salary, ID);
        this.bonus=bonus;
    }
    public void work(){
        System.out.println(getName()+"是一名经理，负责管理，月工资为："+getSalary()+"元，奖金为"+getBonus());
    }
}
abstract class TeamWorker{
    private String name;
    private int salary;
    private String ID;
    public TeamWorker(){}
    public TeamWorker(String name,int salary,String ID){
        this.name=name;
        this.salary=salary;
        this.ID=ID;}
public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

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

    public int getSalary() {
        return salary;
    }

    public void setID(String ID) {
        this.ID = ID;
    }

    public String getID() {
        return ID;
    }
public abstract void work();
}

1、概念

包含抽象方法的类，用abstract修饰。

只有方法声明，没有方法体的方法就是抽象方法

当需要定义一个方法，但是不明确具体实现时，可以将方法定义为abstract，具体实现延迟到子类

public abstract class Animal{//因为包含抽象方法，所以它是抽象类
    private String name;
    public abstract void eat()//抽象方法。因为是动物就一定得吃饭，所以{}中是否写东西无所谓就去掉了
}

public class AbstractDemo01 {
    public static void main(String[] args) {
       Dog5 dog5=new Dog5();
       dog5.setName("哈士奇");
       dog5.eat();
        System.out.println("-----------------------------------------");
        //通过多态进行测试
        Animal5 animal5=new Dog5();
        animal5.setName("huahua");
        animal5.eat();
    }
}
class Dog5 extends Animal5{
    @Override
    public void eat(){
        System.out.println(getName()+"吃骨头");
    }}
abstract class Animal5{
    private String name;

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

    public String getName() {
        return name;
    }
    //抽象方法：要求子类必须重写
    public abstract void eat();
}

2、抽象类的特点

①修饰符：必须用abstract关键字修饰    修饰符 abstract class 类名{}

②抽象类不能被实例化，即不能new，只能创建子类对象

③抽象类子类的两个选择：重写父类的所有抽象方法或者也定义为抽象类

3、抽象类成员的特点：

①可以是普通的成员变量也可以是成员常量final

②可以有普通方法也可以有抽象方法

③像普通类一样有构造方法，且可以重载

 

public class AbstractDemo02 {
    public static void main(String[] args) {
        //Animal6 animal6 = new Animal6();这样写是错误的，因为Animal6是抽象类，不能实例化
        Animal6 animal6= new Dog6();
        animal6.setName("哈士奇");
        //animal6.AGE=70;常量值不能发生改变
        System.out.println(animal6.AGE);

    }
}
abstract class Cat1 extends Animal6{//不重写父类抽象方法时可以把子类也写成抽象类

}
class Dog6 extends Animal6{
    @Override
    public void eat(){
        System.out.println(getName()+"吃骨头");
    }
    @Override
    public void sleep(){
        System.out.println(getName()+"正在睡觉");
    }
}
abstract class Animal6{
    private String name;
    //成员常量
    final int AGE=30;
    //构造方法
    public Animal6(){}
    public Animal6(String name){
        this.name=name;
    }
    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
return name;
    }
    //抽象方法
    public abstract void eat();
    public abstract void sleep();
    //非抽象方法
    public void call(){
        System.out.println("动物会叫");
    }
}

抽象类比普通类多一种抽象方法