面向对象 抽象（abstract）

面向对象 抽象（abstract）

抽象类的概述

• A:抽象类概述
  
  • 抽象就是看不懂的
• B:抽象类特点
  
  • a:抽象类和抽象方法必须用abstract关键字修饰
    
    • abstract class 类名 {}
    • public abstract void eat();
  • b:抽象类不一定有抽象方法，有抽象方法的类一定是抽象类或者是接口
  • c:抽象类不能实例化那么，抽象类如何实例化呢?
    
    • 按照多态的方式，由具体的子类实例化。其实这也是多态的一种，抽象类多态。
  • d:抽象类的子类
    
    • 要么是抽象类
    • 要么重写抽象类中的所有抽象方法
• C:案例演示
  
  • 抽象类特点

抽象类成员特点

• A:抽象类的成员特点
  
  • a:成员变量：既可以是变量，也可以是常量。abstract是否可以修饰成员变量?不能修饰成员变量
  • b:构造方法：有。
    
    • 用于子类访问父类数据的初始化。
  • c:成员方法：既可以是抽象的，也可以是非抽象的。
• B:案例演示
  
  • 抽象类的成员特点
• C:抽象类的成员方法特性：
  
  • a:抽象方法 强制要求子类做的事情。
  • b:非抽象方法 子类继承的事情，提高代码复用性。

抽象类 之 葵花宝典

public class Test_葵花宝典 {

public static void main(String[] args) {
    岳不群  小岳子 = new 岳不群();
    小岳子.自宫();

}

}
abstract class 葵花宝典{  //可以了理解为 葵花宝典是抽象的武功
public abstract void 自宫();  //想要练成葵花宝典  必须自宫，由于自宫方法很多所以用到抽象方法
}

class 岳不群 extends 葵花宝典{
public void 自宫(){
    System.out.println("用牙签");
}   
}

class 林平之 extends 葵花宝典{
public void 自宫(){
    System.out.println("用指甲刀");
}
}

抽象类 之 猫狗

• 具体事物：猫，狗

  • 共性：姓名，年龄，吃饭
  • 猫的特性:抓老鼠
  • 狗的特性:看家

  public class Text_2{

  public static void main(String[] args) {
  
  Cat c = new Cat("加菲",8);
  System.out.println(c.getName()+ "..." + c.getAge());
  c.eat();
  c.catchMousr();
  
  Dog d = new Dog("八公",30);
  System.out.println(d.getName() + "..." + d.getAge());
  d.eat();
  d.lookHome();
  }
  }
  
  abstract class Animal{
  private String name;
  private int age;
  
  
  public Animal(){}
  
  public Animal(String name,int age){
      this.name = name;
      this.age = age;
  }
  public void setName(String name){ //设置姓名
      this.name =name;
  }
  public String getName(){   // 获取姓名
      return name;
  }
  public void setAge(int age){ //设置年龄
      this.age = age;
  }
  public int getAge(){  //获取年龄
      return age;
  }
  public abstract void eat(); // 吃饭      由于不同的动物的吃饭方法不同，所以这里定义吃饭这个方法为abstract方法，因此，Animal类亦应该定义为abstract类
  }
  
  
      class Cat extends Animal{
      public Cat(){}
  
      public Cat(String name,int age){
      super(name,age);
  }
  
  public void eat(){                                  //猫的吃饭法方法
      System.out.println("猫吃鱼");
  }
  public void catchMousr(){                    //猫的抓老鼠方法
      System.out.println("抓老鼠");
  }
  
  
  class Dog extends Animal{             
  public Dog(){}
  public Dog(String name,int age){
          super(name,age);
  }
  
  public void eat(){                                         //狗的吃饭法方法
      System.out.println("狗吃肉");
      }
  public void lookHome(){                              //狗的看家方法
  System.out.println("看家");
      }
  

  }

抽象类 之 老师

• 具体事物：基础班老师，就业班老师
  
  • 共性：姓名，年龄，讲课。
  • 具体事物:基础班学生,就业班学生
  • 共性:姓名,年龄,学习

public class Text_Teacher {

public static void main(String[] args) {
    BaseTeacher bt = new BaseTeacher("黄家驹",32);
    bt.teach();
}
}
abstract class Teacher {

private String name;
private int age;

public Teacher(){}  //空参构造

public Teacher(String name,int age){  //有参构造
    this.name = name;
    this.age = age;
}

public void setName(String name){ //设置姓名
    this.name = name;
}
public String getName(){  //获取姓名
    return name;
}

public void setAge(int age){ // 设置年龄
    this.age = age;
}

public int getAge(){ // 获取年龄
    return age;
}

public abstract void teach();//由于不同类型的老师讲课的方式不同，所以这里的teach方法定义成abstract类型。由于这里的teach方法为抽象类型，所以这里的Teach类也得定义成abstract类。

}

class BaseTeacher extends Teacher{
public BaseTeacher(){}

public BaseTeacher(String name,int age){
    super(name,age);
}

public void teach(){
    System.out .println("我的姓名是：" + this.getName() + "   我的年龄是：" + this.getAge() + "  讲的内容是Java基础。");
}
}

抽象类 之 经理与员工

• 假如我们在开发一个系统时需要对程序员类进行设计，程序员包含3个属性：姓名、工号以及工资。
  
  • 经理，除了含有程序员的属性外，另为还有一个奖金属性。
  • 请使用继承的思想设计出程序员类和经理类。要求类中提供必要的方法进行属性访问。

public class Test_Employee {

    public static void main(String[] args) {
        Coder c =new Coder("德玛西亚","007",8000);
        c.work();

        Manager m = new Manager("苍老师","9527",3000,20000);
        m.work();
    }

    }
    abstract class Employee{//先定义成员变量
    private String name;  //姓名
    private String id;    //工号
    private double salary;//工资

    public Employee(){}   //空参构造

    public Employee(String name,String id,double salary){
        this.name = name;
        this.id = id;
        this.salary = salary;
    }

    public void setName(String name){  //设置姓名
        this.name = name;
    }
    public String getName(){           //获取姓名
        return name;
    }
    public void setId (String id){     //设置id
        this.id = id;
    }
    public String getId(){             //获取id
        return id;
    }
    public void setSalary(double salary){//设置工资
        this.salary =salary; 
    }
    public double getSalary(){           //获取工资
        return salary;
    }

    public abstract void work();
    }
    //程序员
    class Coder extends Employee{
    public Coder(){}   //空参构造

    public Coder(String name,String id,double salary){
        super(name,id,salary);
    }
    public void work(){
        System.out.println("我的姓名是:"+ this.getName() + "，我的工号是"  + this.getId() + "，我的工资是：" + this.getSalary() + "，我的工作内容是敲代码");
    }   
    }

    //项目经理
    class Manager extends Employee{
    private int bonus;    //奖金
    public Manager (){}   //空参构造

    public Manager(String name,String id,double salary,int bonus){
        super(name,id,salary);
        this.bonus=bonus;
    }
    public void work(){
        System.out.println("我的姓名是:"+ this.getName() + "，我的工号是"  + this.getId() + "，我的工资是：" + this.getSalary() +"我的奖金是："+bonus+ "，我的工作内容是管理");
    }   
    }