抽象类的使用

_雨_

于 2023-04-09 02:00:00 发布

阅读量970

点赞数

分类专栏： Java 文章标签： java 开发语言

本文链接：https://blog.csdn.net/weixin_53616401/article/details/129910926

版权

Java 专栏收录该内容

73 篇文章 0 订阅

订阅专栏

什么是抽象类

当父类的一些方法不能确定时，可以用abstract关键字来修饰该方法，这个方法就是抽象方法，用abstract来修饰该类就是抽象类。

抽象类的基本介绍

1)用abstract关键字来修饰一个类时，这个类就叫抽象类

访问修饰符 abstract 类名{

}

2)用abstract关键字来修饰一个方法时，这个方法就是抽象方法访问修饰符 abstract 返回类型方法名(参数列表)；//没有方法体

3)抽象类的价值更多作用是在于设计，是设计者设计好后，让子类继承并实现抽象类()

代码演示：

package idea.chapter10.abstract_;

/**
 * 演示抽象类的基本使用
 */
public class abstract01 {
    public static void main(String[] args) {
        /*
        什么是抽象类
        当父类的一些方法不能确定时，可以用abstract关键字来修饰该方法，这个方法就是抽象方法，用abstract来修饰该类就是抽象类。
        抽象类的基本介绍
        1)用abstract关键字来修饰一个类时，这个类就叫抽象类
        访问修饰符 abstract 类名{
        }
        2)用abstract关键字来修饰一个方法时，这个方法就是抽象方法访问修饰符 abstract 返回类型 方法名(参数列表)；//没有方法体
        3)抽象类的价值更多作用是在于设计，是设计者设计好后，让子类继承并实现抽象类()
         */
    }
}

/**
 * 注意当一个类中有一个方法是abstract修饰的，那么这个类就一定要是抽象类
 */

//这就是一个抽象类
abstract class A {
    
    //2)用abstract关键字来修饰一个方法时，这个方法就是抽象方法访问修饰符 abstract 返回类型 方法名(参数列表)；
    // 没有方法体
    public abstract void hi();
}


//继承A类
class B extends A {
    //重写父类的抽象方法
    @Override
    public void hi() {

    }


}

抽象类的注意事项和使用细节

1)抽象类不能被实例化 [举例]

2)抽象类不一定要包含abstract方法。也就是说，抽象类可以没有abstract方法[举例]

3)一旦类包含了abstract方法，则这个类必须声明为abstract [说明]

4)abstract只能修饰类和方法，不能修饰属性和其它的。[说明]

代码演示：

package idea.chapter10.abstract_;

/**
 * 演示抽象类的注意事项和使用细节1
 */
public class abstractDetail01 {
    public static void main(String[] args) {
        /*
        抽象类的注意事项和使用细节
        1)抽象类不能被实例化
        2)抽象类不一定要包含abstract方法。也就是说，抽象类可以没有abstract方法
        3)一旦类包含了abstract方法，则这个类必须声明为abstract
        4)abstract只能修饰类和方法，不能修饰属性和其它的
         */

        //1)抽象类不能被实例化
        //此时AA是一个抽象类，因为抽象类不能被实例化，所以当我们想去实例化一个抽象类的时候就会报错
        //AA aa = new AA();//这是错误的
    }
}

//定义了一个抽象类
abstract class AA {
    //4)abstract只能修饰类和方法，不能修饰属性和其它的
    //abstract 只能修饰类和方法，不能修饰属性和其它的
    //abstract int n1;

    //abstract void hi();

    //2)抽象类不一定要包含abstract方法。也就是说，抽象类可以没有abstract方法
    //这样也是正确的
    public void say() {

    }
}

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

5)抽象类可以有任意成员【因为抽象类还是类】，比如：非抽象方法、构造器、静态属性等等[举例]

6)抽象方法不能有主体，即不能实现.如图所示

7)如果一个类继承了抽象类，则它必须实现抽象类的所有抽象方法，除非它自己也声明为abstract类。[举例 A类，B类，C类]

8)抽象方法不能使用private、final和 static来修饰，因为这些关键字都是和重写相违背的。

代码演示：

package idea.chapter10.abstract_;

/**
 * 演示抽象类的注意事项和使用细节2
 */
public class abstractDetail02 {
    public static void main(String[] args) {
        /*
        5)抽象类可以有任意成员【因为抽象类还是类】，比如：非抽象方法、构造器、静态属性等等
        6)抽象方法不能有主体，即不能实现.
        7)如果一个类继承了抽象类，则它必须实现抽象类的所有抽象方法，除非它自己也声明为abstract类。[举例 A类，B类，C类]
        8)抽象方法不能使用private、final和 static来修饰，因为这些关键字都是和重写相违背的。
         */
    }
}

abstract class BB {
    //5)抽象类可以有任意成员【因为抽象类还是类】，比如：非抽象方法、构造器、静态属性等等
    private String name;
    private int age;

    //静态属性
    private static double sum;

    //构造器
    public BB(String name, int age) {
        this.name = name;
        this.age = age;
    }

    //非抽象方法
    public void hi() {

    }

    //抽象方法不能有主体，即不能实现
    //这样是错误的，不能实现
//    abstract void say(){
//        System.out.println();
//    }

    //这样才是正确的
    abstract void say();

}

//因为cc继承了BB类所以需要实现BB类中的抽象方法
class CC extends BB {

    public CC(String name, int age) {
        super(name, age);
    }

    @Override
    void say() {

    }
}

//如果类的本身就是抽象方法就不用实现父类的抽象方法
abstract class DD extends BB {

    public DD(String name, int age) {
        super(name, age);
    }
}

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

    abstract protected void hi02();

    abstract void hi03();

    //这个是错误的，不用使用private,final,static修饰
    //abstract private void hi04();
    //abstract static void hi05();
    //abstract final void hi06();
}

抽象类习题

第一题

思路分析：

抽象方法不能使用private、final 和 static来修饰，因为这些关键字都是和重写相违背的

//1)题1，思考：abstract final class Af{}译通过吗，why?
// 因为抽象类和final不能一起出现
//2)题2，思考：abstract public static void test2(0；能编译通过吗，why?
  //不能 因为抽象类和static一起出现
// 3，思考：abstract private void test3(0;能编译通过吗，why?
    //因为抽象类和private 不能一起出现

第二题

思路分析：

1.因为Employee类是一个抽象类也是父类，所以在子类去继承父类时候，不仅要实现父类的抽象方法，也要指定构造器，因为父类的无参构造器被覆盖了

abStractExercise类

package idea.chapter10.abstract_;

/**
 * 演示抽象类的习题
 */
public class abstractExercise {
    public static void main(String[] args) {
//        4)编写一个Employee类，声明为抽象类，包含如下三个属性：name，id，salary。
//        提供必要的构造器和抽象方法：work()。对于Manager类来说，他既是员工，还具有奖金(bonus)的属性。
//        请使用继承的思想，设计CommonEmployee类和Manager类，要求类中提供必要的方法进行属性访问，实现work()，提示“经理/普通员工 名字 工作中....”

        Manager manager = new Manager("jack", 10, 1000);
        manager.work();

        CommonEmployee tom = new CommonEmployee("tom", 20, 100);
        tom.work();


    }
}

CommonEmployee类

package idea.chapter10.abstract_;

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

    @Override
    void work() {
        System.out.println("工人" + super.getName() + "工作中");
    }
}

Employee类

package idea.chapter10.abstract_;

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

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

    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;
    }

    abstract void work();
}

Manager类

package idea.chapter10.abstract_;

public class Manager extends Employee {
    private double bonus;

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

    @Override
    void work() {
        System.out.println("经理" + super.getName() + "工作中");
    }
}

抽象模板设计模式

思路分析：

Template类

package idea.chapter10.abstract_;

/**
 * 抽象类模板时间模式
 */
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));
    }
}

AAA类

package idea.chapter10.abstract_;

public class AAA extends Template{
    @Override
    public void job() {
        long sum=0;
        for (long i = 0; i < 1000000; i++) {
            sum+=i;
        }
    }
}

BBB类

package idea.chapter10.abstract_;

public class BBB extends Template {
    @Override
    public void job() {
        long sum = 0;
        for (long i = 0; i < 1000000; i++) {
            sum += i;
        }
    }
}

test类

package idea.chapter10.abstract_;

public class test {
    public static void main(String[] args) {
        AAA aaa = new AAA();
        aaa.job();

        BBB bbb = new BBB();
        bbb.job();
    }
}

_雨_

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
抽象类的使用

1)用abstract关键字来修饰一个类时，这个类就叫抽象类访问修饰符 abstract 类名{2)用abstract关键字来修饰一个方法时，这个方法就是抽象方法访问修饰符 abstract 返回类型方法名(参数列表)；//没有方法体3)抽象类的价值更多作用是在于设计，是设计者设计好后，让子类继承并实现抽象类()/*** 演示抽象类的基本使用*//*什么是抽象类。
复制链接

扫一扫