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 可以修饰类和方法

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

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

View Code

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

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

    View Code 

    3. 声明抽象类，并包含抽象方法。测试类中创建一个继承抽象类的匿名子类的对象
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();
}





4. 抽象类和接口有哪些共同点和区别？


相同点：不能实例化，都可以被继承
不同点：抽象类：有构造器。 接口：不能声明构造器
            多继承vs 单继承  抽象类是单继承接口是多继承


5. 如何创建静态成员内部类和非静态成员内部类的对象？
Person  static Dog   Bird
Person.Dog dog = new Person.Dog();
Person p = new Person();
Person.Bird bird = p.new Bird();

     

 

版权声明：本文为zhaoyunlong原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/zhaoyunlong/p/11683710.html