Java基础之抽象类

1.java之抽象类的基本概念

普通类就是完善的功能类,直接生产对象并使用,其中的方法都已经实现完整(带有方法体"{}").抽象类的最大特点包含了抽象方法,抽象方法是只声明(没有方法体)的方法,抽象方法定义时使用abstract关键字完成,并且抽象方法一定要在抽象类中,抽象类要使用abstract关键字声明.

重点:在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。

抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和构造方法的访问方式和普通类一样。

由于抽象类不能实例化对象，所以抽象类必须被继承，才能被使用。也是因为这个原因，通常在设计阶段决定要不要设计抽象类

Demo:

package Study;

public class AbstractClassDemo {
    public static void main(String args[]) {
//        A a =new A();//抽象类不能实例化，构造对象
        B b = new B();
        b.method1();
        //利用抽象类来声明对象
        A a=new B();
        a.method1();
    }
}
//(如果一个类中有abstract抽象方法，那么这个类必须声明为abstract,但abstract(抽象)类里面不一定要有抽象方法)
abstract class A {
    abstract void method1();//抽象方法
}

class B extends A {
    //如果抽象类的子类(B)是一个完整类，那么它必须重写所有的抽象方法(少一个都不行)
    public void method1() {
        System.out.println("我是一个完整的方法");
    }
}

在实际开发中,抽象类使用原则如下.

1.抽象类必须有子类,使用extends继承,一个子类只能继承一个抽象类;
2.子类(如果不是抽象类)必须覆写抽象中的全部抽象方法；
3.抽象类对象可以使用对象的向上转型,通过子类来进行实例化操作.

Demo需求:程序员有姓名,学号,工资,职位,而项目经理有姓名，学号，工资，职位，奖金，利用抽象类简化声明项目经理类的代码量

[从需求可以知道项目经理只比程序员多奖金这个属性]

package Study;

//需求:程序员有姓名,学号,工资,职位,而项目经理有姓名，学号，工资，职位，奖金，利用抽象类简化声明项目经理类的代码量
public class AbstractDemo {
    public static void main(String args[]) {
        Manager manager = new Manager();
        //子类Manager继承抽象类ITworkers的method 1,2,3,4方法
        manager.method1();
        manager.method2();
        manager.method3();
        manager.method4();
        //Manager自己定义的方法
        manager.award();
    }

}

abstract class ITworkers {
    String name;
    int Id;
    int salary;
    String contents;

    abstract void method1();

    abstract void method2();

    abstract void method3();

    abstract void method4();
}

class Manager extends ITworkers {
    int award = 9000;

    @Override
    void method1() {
        System.out.println(name = "小陈");
    }

    @Override
    void method2() {
        System.out.println(Id = 12);
    }

    @Override
    void method3() {
        System.out.println(salary = 9000);
    }

    @Override
    void method4() {
        System.out.println(contents = "项目经理");
    }

    public void award() {
        System.out.println("奖金" + award);
    }
}

AbstactDemo2

package Study;

/**抽象类abstract
抽象类里面可以包含正确的方法和抽象方法
抽象方法可以包含构造方法，但是不能被实例
----------------------------------------------------
构造方法的作用是让子类对父类里面的数据进行初始化
抽象类的子类还可以是一个抽象类(不用实现抽象方法)
抽象类的子类(正常类)必须实现抽象类中的所有抽象方法
 **/
public class AbstactDemo2 {
    public static void main(String args[]) {
        workers workers = new workers("张三", 2, 5000);
        workers.work();
        workers.singnIn();
        System.out.println(workers.name = " " + workers.Id + " " + workers.salary);
        Programmer programmer = new Programmer("李四", 1, 2000);
        programmer.work();
        programmer.singnIn();
        System.out.println(programmer.name + " " + programmer.Id + " " + programmer.salary);
    }
}

abstract class Employee {
    String name;
    int Id;
    int salary;

    //抽象类使用构造方法，给抽象类属性初始化，,而在属性没有初始化前,类中所有的属性都是对应数据类型的默认值
    public Employee(String name, int id, int salary) {
        this.name = name;
        Id = id;
        this.salary = salary;
    }

    abstract void work();

    public void singnIn() {
        System.out.println(name + "签到");
    }
}

class workers extends Employee {

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

    @Override
    void work() {
        System.out.println("IT开发人员");
    }
}

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

    @Override
    void work() {
        System.out.println("项目经理");
    }
}

抽象类abstract

抽象类里面可以包含正确的方法和抽象方法
抽象方法可以包含构造方法，但是不能被实例

构造方法的作用是让子类对父类里面的数据进行初始化
抽象类的子类还可以是一个抽象类(不用实现抽象方法)
抽象类的子类(正常类)必须实现抽象类中的所有抽象方法
**/