抽象类总结

本文思路：

一、概念

在Java中，一个没有方法体的方法应该定义为抽象方法，而类中如果有抽象方法，则必须定义为抽象类。

二、抽象类的特点：

A：抽象类和抽象方法必须用abstract关键字修饰。

B：抽象类中不一定有抽象方法，但是有抽象方法的类必须定义为抽象类。

C：抽象类不能实例化。因为它不是具体的。

      但是抽象类有构造方法，不能实例化，那么构造方法的作用是什么呢？

      用于子类访问父类数据的初始化。

D：抽象的子类

      如果不想重写父类的抽象方法，该子类是一个抽象类；

      重写所有的抽象方法，这个时候子类是一个具体的类。

抽象类的实例化其实是靠具体的子类实现的，是多态的体现。

三、抽象类的成员特点：

（1）成员变量

      既可以是变量，也可以是常量。

（2）构造方法

       有，用于子类访问父类数据的初始化。

（3）成员方法

       既可以是抽象的，也可以是具体的。

四、抽象类的成员访问特点：

     A：抽象方法：强制要求子类做的事情。

      B：非抽象方法：子类继承的事情，提供代码的复用性。

abstract class Animals {
    public int num=10;
    public final int num2=200;

    public Animals(){}
    public Animals(String name,int age){}

    public abstract void show();

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

class Dogs extends Animals {
    public void show(){
        System.out.println("Show Dog");
    }
}

public class Chouxiang {
    public static void main(String args[]) {
        //创建对象
        Animals a = new Dogs();
        a.num=100;
        System.out.println(a.num);
        System.out.println(a.num2);
        System.out.println("---------------");
        a.show();//show Dog
        a.method();//method
    }
}

五、案例：员工案例：

     * 分析：

     *  普通员工类

     *      成员变量：姓名、工号、以及工资

     *      成员方法：工作

     *  经理类：

     *      成员变量：姓名、工号、以及工资，奖金属性

     *      成员方法：工作

     * 实现：

     *  员工类：

     *  普通员工类：

     *  经理类：

abstract class Employee {
    private String name;
    private String id;
    private int salary;

    public Employee() {}

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

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

    public String getId(){
        return id;
    }
    public void setId(String id){
        this.id=id;
    }

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

    //工作
    public abstract void work();
}

//普通员工类
class Programmer extends Employee {
    public Programmer(){}

    public Programmer(String name,String id,int salary){
        super(name,id,salary);
    }

    public void work(){
        System.out.println("按照需求写代码");
    }

}

//经理类
class Manager extends Employee {
    //奖金
    private int bonus;

    public Manager(){}

    public Manager(String name,String id,int salary,int bonus){
        super(name,id,salary);
        this.bonus=bonus;
    }

    public void work(){
        System.out.println("跟客户谈需求");
    }

    public int getBonus(){
        return bonus;
    }

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

public class AbstractTest4 {

    public static void main(String[] args) {
        //测试普通员工
        Employee emp = new Programmer();
        emp.setName("林青霞");
        emp.setId("00001");
        emp.setSalary(80000);
        System.out.println(emp.getName()+"---"+emp.getId()+"---"+emp.getSalary());
        emp.work();
        System.out.println("--------------");
        emp=new Programmer("林青霞","00001",8000);
        System.out.println(emp.getName()+"---"+emp.getId()+"---"+emp.getSalary());
        emp.work();
        System.out.println("--------");

        //测试经理类
        //由于子类有特有的内容，所以我们用子类来测试
        Manager m = new Manager();
        m.setName("刘意");
        m.setId("00002");
        m.setSalary(9000);
        m.setBonus(2000);
        System.out.println(m.getName()+"----"+m.getId()+"---"+m.getSalary()+"---"+m.getBonus());
        m.work();

        //通过构造方法赋值
        m=new Manager("刘意","00002",9000,2000);
        System.out.println(m.getName()+"----"+m.getId()+"---"+m.getSalary()+"---"+m.getBonus());
        m.work();
    }

}

这里注意经理类中有自己独有的属性，此时则不能采用多态。

五、抽象类中注意的两个小问题

1、一个类如果没有抽象方法，可以可以定义为抽象类？有什么意义？

      可以；不让创建对象。

2、abstract关键字不能和哪些关键字共存？

      Private 冲突

      final 冲突

      Static 无意义

六、总结

本文主要总结的是关于抽象类的一些知识，抽象方法是没有方法体的，有抽象方法的类一定是抽象类，抽象类的特点以及抽象类中的成员访问特点是重点知识，要掌握，此外，抽象类的实例化时靠多态实现的，但是当子类中有自己新的成员变量或者方法时，要实例化子类，调用子类自身的变量和方法。