抽象类 抽象方法 abstract

abstract:

 * abstract修饰类: 抽象类
 *       > 此类不能被实例化
 *       > 抽象类中一定要有构造器, 便于子类对象实例时调用(涉及子类对象实例化过程)
 *       > 开发中,都会提供抽象类的子类,让子类对象实例化.完成相关操作
 *
 *
 *
 * abstract修饰方法: 抽象方法
 *         > 只有方法的声明没有方法体
 *         > 如果类中有抽象方法 那么这个类必须也是抽象的(包含抽象方法的类一定是抽象类)
 *         > 若子类重写了父类中的所有的抽象方法后,方可实例化, 若子类没有重写父类中的抽象方法  则子类也是个抽象类 也需要abstract修饰

* abstract 不能用来修饰: 属性,  构造器等结构
* abstract 不能修饰:  私有方法  静态方法(加上static不认为是重写), final方法, final类

abstract class PP{
    int age;

    public  PP(){};

    public PP(int age){
        this.age = age;
    }

    public  abstract  void eat();  // 父类有抽象方法 子类必须重写这个方法
}

class Pson extends  PP{

    public  void  eat(){  // 重写父类的抽象方法

    }

}

由于abstract 抽象类不可以被实例化 那么我们还有一种方式是正常的这种看着像是实例化抽象类 其实不是实例化抽象类 而是建立了一个匿名对象,在匿名对象中重写了抽象类中的抽象方法

public class abstractTest {
    public static void main(String[] args) {
        // 创建一个匿名对象empty
        Empty empty = new Empty() {  //因为Empty是抽象类abstract 的 不可以被实例化 所以我们现在造的是匿名的Empty  对象
            @Override
            public void work() {
                System.out.println("我是匿名对象的work方法");
            }
        };
        method1(empty);  // 我是匿名对象的work方法
    }

    public static void method1(Empty empty){
        empty.work();
    }
}

abstract class Empty{
    private  String name;
    private  int id;
    private double salary;
    public Empty(){};
    public  Empty(String name, int id, double salary){
        super();
        this.name = name;
        this.id = id;
        this.salary = salary;
    }

    public abstract void work();  // 抽象方法必须要是无方法体的
}

class Mang extends  Empty{

    private  double bonus;
    public void work(){
        System.out.println("可以跑");
    }
}

class Wolk extends Empty{
    public void testOne(){
        System.out.println("test");
    }

    public  void work(){
        System.out.println("wolk的work");
    }
}

为什么abstract不可以修饰属性

被abstract修饰的内容都是暂未被实现的，比如类、方法。
属性之所以不能被abstract修饰，是因为属性不存在"尚未被实现"的状态。
比如你可能会联想到int age; 或是String name; 但可惜的是，在申明变量时，int会默认给age赋予初始值0，
String会默认给name赋予初始值""。因此属性达不到"尚未被实现的状态"，从而不能被abstract修饰

为什么不可以修饰私有方法和构造器

因为抽象类被继承后 子类要重写抽象类中的所有的抽象方法,但是私有的方法在权限上是不可以被调用重写的  所有不可以修饰私有方法不然子类无法重写此方法,构造器时子类要去调用的  而不是要重写完才去调用的 所以构造器也不可以被abstract

抽象类的使用场景

抽象类体现的就是一种模板模式的设计，抽象类作为多个子类的通用模 板，子类在抽象类的基础上进行扩展、改造，但子类总体上会保留抽象 类的行为方式

当功能内部一部分实现是确定的，一部分实现是不确定的。这时可以 把不确定的部分暴露出去，让子类去实现。
 换句话说，在软件开发中实现一个算法时，整体步骤很固定、通用， 这些步骤已经在父类中写好了。但是某些部分易变，易变部分可以抽 象出来，供不同子类实现。这就是一种模板模式

思考题:

1: 为什么抽象类不可以被final声明:

因为抽象类是需要被继承的  如果被final声明就不可以被继承此类就是个无用类了

2: 一个抽象类可以定义构造器吗?

可以, 因为抽象类虽然不可以实例化 ,但是子类实例化的时候需要调用父类的构造器

3:

编写一个Employee类，声明为抽象类， 包含如下三个属性:name，id，salary。 提供必要的构造器和抽象方法:work()。 对于Manager类来说，他既是员工，还具有奖金(bonus)的属性。
请使用继承的思想，设计CommonEmployee类和Manager类，要求类 中提供必要的方法进行属性访问。

abstract class Empty{
    private  String name;
    private  int id;
    private double salary;
    public Empty(){};
    public  Empty(String name, int id, double salary){
        super();
        this.name = name;
        this.id = id;
        this.salary = salary;
    }

    public abstract void work();  // 抽象方法必须要是无方法体的
}

class Mang extends  Empty{

    private  double bonus;
    public void work(){
        System.out.println("可以跑");
    }
}

结果

作业:

编写工资系统，实现不同类型员工(多态)的按月发放工资。如果当月出现某个 Employee对象的生日，则将该雇员的工资增加100元。
实验说明:
(1)定义一个Employee类，该类包含:
        private成员变量name,number,birthday，其中birthday 为MyDate类的对象; abstract方法earnings();
        toString()方法输出对象的name,number和birthday。
(2)MyDate类包含:   
        private成员变量year,month,day ; toDateString()方法返回日期对应的字符串:xxxx年xx月xx日 
(3)定义SalariedEmployee类继承Employee类，实现按月计算工资的员工处理。
          该类包括:private成员变量monthlySalary; 实现父类的抽象方法earnings(),该方法返回monthlySalary值;toString()方法输 出员工类型信息及员工的name，number,birthday。

(4)参照SalariedEmployee类定义HourlyEmployee类，实现按小时计算工资的 员工处理。该类包括:
           private成员变量wage和hour; 实现父类的抽象方法earnings(),该方法返回wage*hour值; toString()方法输出员工类型信息及员工的name，number,birthday。 
(5)定义PayrollSystem类，创建Employee变量数组并初始化，该数组存放各 类雇员对象的引用。利用循环结构遍历数组元素，
           输出各个对象的类 型,name,number,birthday,以及该对象生日。当键盘输入本月月份值时，如果本 月是某个Employee对象的生日，还要输出增加工资信息。
提示:
//定义People类型的数组People c1[]=new People[10];
//数组元素赋值
c1[0]=new People("John","0001",20);
c1[1]=new People("Bob","0002",19); //若People有两个子类Student和Officer，则数组元素赋值时，
可以使父类类型的数组元素指向子类 c1[0]=new Student("John","0001",20,85.0);
c1[1]=new Officer("Bob","0002",19,90.5);

解答:

import java.util.Date;

public abstract class Emplpyee {
    private String name;  // 名字
    private double number; // 工作时间
    private MyDate birthday;  //生日

    abstract double earnings();

    public String getName() {
        return name;
    }

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

    public double getNumber() {
        return number;
    }

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

    public MyDate getBirthday() {
        return birthday;
    }

    public void setBirthday(MyDate birthday) {
        this.birthday = birthday;
    }

    public Emplpyee(){}
    public Emplpyee(String name, int number, MyDate birthday){
        this.name = name;
        this.number = number;
        this.birthday = birthday;
    }

    @Override
    public String toString() {
        return
                "name='" + name + '\'' +
                ", number=" + number +
                ", birthday=" + birthday.toDateString() ;  // 要去调用我们自定义的  DateString 不然就是显示的内存地址值了
    }

}

class MyDate {
    private int year;
    private int month;
    private int day;

    public int getYear() {
        return year;
    }

    public void setYear(int year) {
        this.year = year;
    }

    public int getMonth() {
        return month;
    }

    public void setMonth(int month) {
        this.month = month;
    }

    public int getDay() {
        return day;
    }

    public void setDay(int day) {
        this.day = day;
    }

    public MyDate(){};
    public MyDate(int year ,int month, int day){
        this.year = year;
        this.month = month;
        this.day = day;
    }

    public String toDateString(){
        return year + "年" + month + "月" + day + "日";
    }
}

Employee

public class SalariedEmployee extends Emplpyee {
    private double monthlySalary;  // 月工资

    public SalariedEmployee(String name, int number, MyDate birthday) {
        super(name, number, birthday);
    }

    public SalariedEmployee(String name, int number, MyDate birthday, double monthlySalary) {
        super(name, number, birthday);
        this.monthlySalary = monthlySalary;
    }

    @Override
    public double earnings() {
        return monthlySalary;
    }

    @Override
    public String toString() {
        return "SalariedEmployee[" + super.toString() + "]";
    }

    public double getMonthlySalary() {
        return monthlySalary;
    }

    public void setMonthlySalary(double monthlySalary) {
        this.monthlySalary = monthlySalary;
    }
}

SalariedEmployee

public class HourlyEmployee extends Emplpyee {
    private int wange; // 月工资
    private int hour;  //月小时数目

    public HourlyEmployee(String name, int number, MyDate birthday) {
        super(name, number, birthday);
    }

    public HourlyEmployee(String name, int number, MyDate birthday, int wange, int hour) {
        super(name, number, birthday);
        this.wange = wange;
        this.hour = hour;
    }

    public double earnings() {
        return wange * hour;
    }

    @Override
    public String toString() {
        return "HourlyEmployee[" + super.toString() + "]";
    }
}

HourlyEmployee

import java.util.Scanner;

public class PayrollSystem {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int month = scanner.nextInt();
        Emplpyee emplpyee [] = new Emplpyee[2];
        emplpyee[0] = new SalariedEmployee("老王", 30, new MyDate(1995, 9, 30), 12000);
        emplpyee[1] = new HourlyEmployee("隔壁老王", 160, new MyDate(1992, 5, 25),50, 260 );

        for(int i = 0; i < emplpyee.length; i++){
            System.out.println(emplpyee[i]);
            double salary = emplpyee[i].earnings();
            System.out.println("月薪资为:"+salary);

            if(month == emplpyee[i].getBirthday().getMonth()){
                System.out.println("生日快乐 奖励100");
            }
        }
    }
}

PayrollSystem

Practise

1. abstract 能修饰哪些结构？ 修饰以后，有什么特点？

abstract 可以修饰类和方法

修饰后 类不可以实例化 需要提供子类来实例化 这个抽象类要有构造器来便于子类的实例化

抽象方法 只有方法的声明没有方法体具体的执行，需要子类去实现

1. 接口是否能继承接口? 抽象类是否能实现(implements)接口? 抽象类是否能继承非抽象的类?

   能 接口的继承用extends来继承 抽象类能实现接口，抽象来能继承非抽象类

   . 声明抽象类，并包含抽象方法。测试类中创建一个继承抽象类的匿名子类的对象
   abstract AA{
   public abstract void m();
   }
   main(){
       AA a = new AA(){
           public void m(){
   
   }
   };
   a.m();
   
   }
   
   class Person{
     String name;
       public void eat(){}
   }
   
   main(){
       Person p = new Person(){
           public void eat(){}
   };
       p.eat();
   }
   
   . 抽象类和接口有哪些共同点和区别？
   
   相同点：不能实例化，都可以被继承
   不同点：抽象类：有构造器。 接口：不能声明构造器
               多继承vs 单继承  抽象类是单继承接口是多继承
   
   . 如何创建静态成员内部类和非静态成员内部类的对象？
   Person  static Dog   Bird
   Person.Dog dog = new Person.Dog();
   Person p = new Person();
   Person.Bird bird = p.new Bird();