AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

【JavaSE】抽象类基本使用

2022-03-08 145
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 【JavaSE】抽象类基本使用

1. 先看一个问题

在这里插入图片描述

  • 小结:

当父类的某些方法，需要声明，但是又不确定如何实现时，可以将其声明为抽象方法，那么这个类就是抽象类。

  • 当父类的一些方法不能确定时，可以用abstract关键字来修饰该方法，这个方法就是抽象方法，用abstract来修饰该类就是抽象类。
  • 如何把Animal做成抽象类，并让子类Cat类实现。
public class Abstract01 {
    public static void main(String[] args) {

    }
}

abstract class Animal {
    private String name;

    public Animal(String name) {
        this.name = name;
    }

    //思考：这里 eat 方法实现了，其实没什么意义
    //即：父类方法不确定性的问题
    // ==> 考虑将该方法设计为抽象方法(abstract)
    // ==> 所谓抽象方法就是没有实现的方法，就是指没有方法体
    // ==> 当一个类中存在抽象方法，需要将该类声明为 abstract 类
    // ==> 一般，抽象类会被继承，有其子类来实现抽象方法

    /*public void eat() {
        System.out.println("这是一个动物，但是不知道吃什么...");
    }*/

    public abstract void eat();
}

2. 抽象类快速入门

  • 当父类的一些方法不能确定时,可以用abstract关键字来修饰该方法，这个方法就是抽象方法,用abstract来修饰该类就是抽象类。
  • 如何把Animal做成抽象类，并让子类Cat类实现
abstract class Animal
    String name;
    int age;
    abstract public void cry() {
    }

3. 抽象类的介绍

  1. 用abstract关键字来修饰一个类时，这个类就叫抽象类
访问修饰符 abstract 类名 {
}
  • 用abstract关键字来修饰一个方法时，这个方法就是抽象方法
访问修饰符 abstract 返回类型方法名(参数列表); //没有方法体
  1. 抽象类的价值更多作用是在于设计，是设计者设计好后，让子类继承并实现抽象类()
  2. 抽象类，是考官比较爱问的知识点,在框架和设计模式使用较多

4. 抽象类使用的注意事项和细节讨论1

AbstractDetail01.java
1) 抽象类不能被实例化
2) 抽象类不一定要包含 abstract方法。也就是说，抽象类可以没有abstract方法，还可以有实现的方法。
3) 一旦类包含了abstract方法，则这个类必须声明为abstract
4) abstract 只能修饰类和方法，不能修饰属性和其它的。

public class AbstractDetail01 {
    public static void main(String[] args) {
        //1.抽象类，不能被实例化
        //new A();
    }
}

//2.抽象类不一定要包含abstract方法。也就是说,抽象类可以没有abstract方法,还可以有实现的方法。
abstract class A {
    public void hi() {
        System.out.println("hi");
    }
}

//3.一旦类包含了abstract方法,则这个类必须声明为abstract
abstract class B {
    public abstract void hi();
}

//4.abstract 只能修饰类和方法，不能修饰属性和其它的
class C {
   // public abstract int n1 = 1;
}

5. 抽象类使用的注意事项和细节讨论2

AbstractDetail02.java

  1. 抽象类可以有任意成员【抽象类本质还是类】，比如:非抽象方法、构造器、静态属性等等
  2. 抽象方法不能有主体，即不能实现，如图所示
abstract void aaa() { } //错误
  1. 如果一个类继承了抽象类，则它必须实现抽象类的所有抽象方法，除非它自己也声明为abstract类。
  2. 抽象方法不能使用private、final 和 static来修饰，因为这些关键字都是和重写相违背的
public class AbstractDetail02 {
    public static void main(String[] args) {
        System.out.println("hello");
    }
}


//5.抽象类的本质还是类，所以可以有类的各种成员
abstract class D {
    public int n1 = 10;
    public static  String name = "兮动人";
    public void hi() {
        System.out.println("hi");
    }
    public abstract void hello();
    public static void ok() {
        System.out.println("ok");
    }
}

//7.如果一个类继承了抽象类，则它必须实现抽象类的所有抽象方法，除非它自己也声明为abstract类
abstract class E {
    public abstract void hi();
}
abstract class F extends E {

}
class G extends E {
    @Override
    public void hi() { //这里相等于G子类实现了父类E的抽象方法，所谓实现方法，就是有方法体

    }
}

//8.抽象方法不能使用private、final 和 static来修饰，因为这些关键字都是和重写相违背的
abstract class H {
    // private abstract void hi();//抽象方法
}

6. 练习

1) 题1，思考: abstract final class A() 能编译通过吗?
错误，final是不能继承
2) 题2，思考: abstract public static void test2(); 能编译通过吗?
错误，static关键字和方法重写无关.
3) 题3，思考: abstract private void test3();能编译通过吗?
错误，private的方法不能重写
4) 编写一个Employee类，声明为抽象类，包含如下三个属性： name,id,salary.提供必要的构造器和抽象方法: work()。对于Manager类来说，他既是员工，还具有奖金(bonus)的属性。请使用继承的思想，设计CommonEmployee类和Manager类，要求类中提供必要的方法进行属性访问,实现work()，提示"经理/普通员工名字工作中...”，OOP的继承+抽象类

  • 抽象类：Employee
abstract public class Employee {
    String name;
    int id;
    double salary;

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

    public abstract void work();

    public String getName() {
        return name;
    }

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

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }
}
  • 经理：Manager
public class Manager extends Employee{

    private double bonus;

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

    public double getBonus() {
        return bonus;
    }

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

    @Override
    public void work() {
        System.out.println("经理" + getName() + "工作中...");
    }
}
  • 普通员工：CommonEmployee
public class CommonEmployee extends Employee{

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

    @Override
    public void work() {
        System.out.println("普通员工" + getName() + "工作中...");
    }
}
  • 测试：
public class AbstractExercise01 {
    public static void main(String[] args) {
    
        Manager xdr = new Manager("xdr", 01, 80000);
        xdr.work();
        
        CommonEmployee jack = new CommonEmployee("jack", 02, 10000);
        jack.work();

    }
}

在这里插入图片描述

7. 抽象类最佳实践--模板设计模式

7.1 基本介绍

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

7.2 模板设计模式能解决的问题

1) 当功能内部一部分实现是确定，一部分实现是不确定的。这时可以把不确定的部分暴露出去，让子类去实现。
2) 编写一个抽象父类，父类提供了多个子类的通用方法，并把一个或多个方法留给其子类实现，就是一种模板模式.

7.3 最佳实践

  • 需求：

1) 有多个类，完成不同的任务job
2) 要求统计得到各自完成任务的时间
3) 请编程实现 TestTemplate.java

  1. 先用传统的方法实现

任务1：计算1+2+...+800000 所需时间

public class AA {

    public void job() {
        //开始的时间
        long start = System.currentTimeMillis();
        long num = 0;
        for (int i = 0; i < 800000; i++) {
            num += i;
        }
        //结束的时间
        long end = System.currentTimeMillis();

        System.out.println("AA执行时间" + (end - start));
    }
    
}

任务2：计算12...*800000 所需时间

public class BB {

    public void job() {
        //开始的时间
        long start = System.currentTimeMillis();
        long num = 0;
        for (int i = 0; i < 800000; i++) {
            num *= i;
        }
        //结束的时间
        long end = System.currentTimeMillis();

        System.out.println("BB执行时间" + (end - start));
    }

}

public class TestTemplate {
    public static void main(String[] args) {
        
        AA aa = new AA();
        aa.job();
        
        BB bb = new BB();
        bb.job();
        
    }
}

在这里插入图片描述

  • 把公用的方法提取出来

AA

public class AA {

    public void calculateTime() {

        //开始的时间
        long start = System.currentTimeMillis();

        job();

        //结束的时间
        long end = System.currentTimeMillis();

        System.out.println("执行时间" + (end - start));

    }

    public void job() {

        long num = 0;
        for (int i = 0; i < 800000; i++) {
            num += i;
        }

    }

}

BB

public class BB {

    public void calculateTime() {

        //开始的时间
        long start = System.currentTimeMillis();

        job();

        //结束的时间
        long end = System.currentTimeMillis();

        System.out.println("执行时间" + (end - start));

    }

    public void job() {

        long num = 0;
        for (int i = 0; i < 800000; i++) {
            num *= i;
        }

    }

}
  • 测试：
public class TestTemplate {
    public static void main(String[] args) {

        AA aa = new AA();
        aa.calculateTime();

        BB bb = new BB();
        bb.calculateTime();

    }
}

在这里插入图片描述

  1. 分析问题，使用模板设计模式来实现
  • 定义一个抽象模板类Template
  • 把 job 任务方法定义为 抽象方法
  • 把 calculateTime 方法提取出来放在抽象类的模板中，调用 job 抽象方法
  • AA、BB 分别继承抽象类 Template，分别实现抽象类中的 job 方法

AA

public class AA extends Template{

    public void job() { //实现了Template类抽象方法job

        long num = 0;
        for (int i = 0; i < 800000; i++) {
            num += i;
        }

    }

}

BB

public class BB extends Template {

    public void job() {

        long num = 0;
        for (int i = 0; i < 800000; i++) {
            num *= i;
        }

    }

}

Template：抽象模板类

abstract public class Template {

    public abstract void job();//抽象方法

    public void calculateTime() {//实现方法，调用job抽象方法

        //开始的时间
        long start = System.currentTimeMillis();

        job();//动态绑定机制

        //结束的时间
        long end = System.currentTimeMillis();

        System.out.println("执行时间" + (end - start));

    }
}

测试：

public class TestTemplate {
    public static void main(String[] args) {

        AA aa = new AA();
        aa.calculateTime();

        BB bb = new BB();
        bb.calculateTime();

    }
}

在这里插入图片描述

文章标签：
Java
设计模式
兮动人
目录
相关文章
Designer小郑
|
Java
【JavaSE专栏64】抽象类和接口，不能被实例化的类有什么用？
【JavaSE专栏64】抽象类和接口，不能被实例化的类有什么用？
Designer小郑
197 0
小胡_不糊涂
|
Java 编译器
【JAVASE】继承 中
【JAVASE】继承
小胡_不糊涂
51 0
爱吃大白菜.
|
Java 程序员 编译器
【JavaSE】一起学继承
【JavaSE】一起学继承
爱吃大白菜.
81 0
Mylvzi
|
6月前
|
Java 编译器
JavaSE学习之--继承和多态（三）
JavaSE学习之--继承和多态（三）
Mylvzi
62 0
Mylvzi
|
6月前
|
Java
JavaSE学习之--继承和多态（二）
JavaSE学习之--继承和多态（二）
Mylvzi
69 0
Mylvzi
|
6月前
|
Java 编译器
JavaSE学习之--继承和多态（一）
JavaSE学习之--继承和多态
Mylvzi
62 0
小胡_不糊涂
|
Java
【JAVASE】继承 下
【JAVASE】继承
小胡_不糊涂
37 0
爱打拳的程序猿
|
Java 编译器 程序员
【JavaSE】继承
本文讲解：继承。
爱打拳的程序猿
55 0
IT辰柒_Java
|
安全 Java 编译器
【JavaSE】抽象类与接口（上篇）
【JavaSE】抽象类与接口（上篇）
IT辰柒_Java
133 0
【JavaSE】抽象类与接口（上篇）
IT辰柒_Java
|
Java 编译器
【JavaSE】抽象类与接口(下篇)
【JavaSE】抽象类与接口(下篇)
IT辰柒_Java
76 0
【JavaSE】抽象类与接口(下篇)