Java基础知识（十五）（面向对象--6）抽象类与多态

最新推荐文章于 2024-07-30 16:33:53 发布
最新推荐文章于 2024-07-30 16:33:53 发布
阅读量248 收藏 1
点赞数
分类专栏： java 文章标签： java 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45986314/article/details/122523863
版权

1、抽象类

      我们把一个不具体的功能，叫做抽象方法，而如果一个类中有抽象方法，

      我们就把这个类称之为抽象类。

2、抽象类的特点：
      (1)抽象类和抽象方法都要用一个关键字修饰：abstract
                    修饰一个类 放在class的前面
                        举例： abstract class Animal3{}
                    修饰一个方法 一般是放在权限修饰符后面
                        定义一个抽象的show方法
                        举例：public abstract void show();
     (2)有抽象方法的类一定要是抽象类，抽象类不一定要有抽象方法，具体的类中不能有抽象方                法，抽象类中既可以存在抽象方法,也可以存在有方法体的方法。
     (3)抽象类不能被实例化
                    既然不能被实例化，那写在抽象类中的方法如何被调用呢？
                    抽象类如何创建呢？
                    通过多态的形式，使用具体的子类去实例化调用方法，专业术语称之为：抽象多态
   (4)如果继承抽象类的是一个具体的子类，需要重写该抽象类中所有的抽象方法
       如果继承抽象的也是一个抽象类，可以不去重写父类中的抽象方法，也可以选择性的去重写。

//定义了一个抽象类，叫Animal3
abstract class Animal3{
    //注意：
    //抽象方法没有方法体{}，连大括号都没有，直接以分号结尾
    //java: 抽象方法不能有主体
//    public abstract void eat(){};
    public abstract void eat();

    public abstract void drink();
}

class Dog3 extends Animal3{
    @Override
    public void eat() {
        System.out.println("狗吃肉");
    }

    @Override
    public void drink() {
        System.out.println("狗喝水");
    }
}

//class Demo2{
//    public abstract void fun1();
//}

abstract class Demo2{
    public abstract void fun();
    public abstract void fun2();
}

abstract class Demo3 extends Demo2{
    @Override
    public void fun() {
        System.out.println("抽象类Demo3中重写了fun方法");
    }
}

public class AbstractDemo1 {
    public static void main(String[] args) {
        //java: com.shujia.wyh.day11.Demo2是抽象的; 无法实例化
//        Demo2 demo2 = new Demo2();

        //利用具体子类多态形式创建对象
        //抽象多态的形式
        Animal3 a = new Dog3();
        a.eat();
        a.drink();


    }
}

3、抽象类的成员的特点：
        （1）成员变量：
            既可以是变量，也可以是常量
        （2）构造方法：
            可以存在构造方法，我们上一个程序中，才总结出抽象类不能被实例化，这里构造方法意               义是什么？
            我们之前在继承中还说过要想初始化子类，必须先初始化父类，所以这里构造方法是提供              初始化父类的作用
       （3）成员方法：
            可以是抽象方法，但是具体的子类必须要重写该方法
            也可以不是抽象方法，提高代码的复用性。

abstract class Animal4{
    int a = 20;
    final int b = 100;
    Animal4(){
        System.out.println("这是Animal4中无参构造方法");
    }

    public abstract void eat();

    public void show(){
        System.out.println("父类中不是抽象方法的show");
    }

}

class Cat4 extends Animal4{

    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

public class AbstractDemo2 {
    public static void main(String[] args) {
        Animal4 a = new Cat4();
        System.out.println(a.a);
        System.out.println(a.b);
        a.eat();
        a.show();
    }
}

4、 (1)一个类如果没有抽象方法，也可以定义为抽象类
      (2)抽象类中可以没有抽象方法
      (3)抽象类不能被实例 

      (4)抽象类中可以存在哪些关键字？
        abstract关键字不能和哪些关键字共存？
            private
            static
            final

abstract class YeTi{
    //Java中的所有的类都有一个共同的父类：Object
//    YeTi(){
//        // super()
//    }

    //abstract可以和public关键字共存
    public abstract void show();


    //private和abstract关键字冲突
//    private abstract void show2(); // java: 非法的修饰符组合: abstract和private

    //static和abstract关键字冲突
//    static abstract void show3();  // java: 非法的修饰符组合: abstract和static

    //final和abstract关键字冲突
//    final abstract void show4();  // java: 非法的修饰符组合: abstract和final




}

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

    }
}

5、抽象类改进猫狗案例

abstract class Animal5{
    //定义一个吃饭的抽象方法，不给出具体的实现
    public abstract void eat();

    //定义一个睡觉的抽象方法，不给出具体的实现
    public abstract void sleep();
}

//alt+enter
class Dog5 extends Animal5{

    @Override
    public void eat() {
        System.out.println("狗吃肉");
    }

    @Override
    public void sleep() {
        System.out.println("狗侧着睡");
    }
}

class Cat5 extends Animal5{

    @Override
    public void eat() {
        System.out.println("猫吃🐟");
    }

    @Override
    public void sleep() {
        System.out.println("🐱趴着睡");
    }
}

public class AbstractTest1 {
    public static void main(String[] args) {
        //抽象多态创建一个对象
        Animal5 a = new Dog5();
        a.eat();
        a.sleep();

        //抽象多态创建第二个对象
        Animal5 c = new Cat5();
        c.eat();
        c.sleep();

    }
}

6、老师案例
            具体事物：十五期老师，十四期老师
            共性：姓名，年龄，讲课。

abstract class Teacher{
    private String name;
    private int age;

    public Teacher() {
    }
    public Teacher(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public abstract void teach();
}

class FourteenTeacher extends Teacher{

    public FourteenTeacher() {
    }

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

    @Override
    public void teach() {
        System.out.println("教Hive知识");
    }
}

class FifteenTeacher extends Teacher{
    public FifteenTeacher() {
    }

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

    @Override
    public void teach() {
        System.out.println("教JavaSE");
    }
}



public class AbstractTest2 {
    public static void main(String[] args) {
        //多态创建14期老师对象
        Teacher t1 = new FourteenTeacher("阿杰",20);
        t1.teach();

        //多态创建15期老师对象
        Teacher t2 = new FifteenTeacher("阿豪",18);
        t2.teach();
    }
}

7、学生案例
                具体事务：14期学员，15期学员
                共性：姓名，年龄，班级，学习，吃饭

abstract class Student2{
    private String name;
    private int age;

    public Student2() {
    }

    public Student2(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    //将学习定义为抽象方法
    public abstract void study();

    //吃饭是具体的方法
    public void eat(){
        System.out.println("吃米饭");
    }

}

class FifteenStudent extends Student2{
    public FifteenStudent() {
    }

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

    @Override
    public void study() {
        System.out.println("学习JavaSE");
    }
}

class FourteenStudent extends Student2{
    public FourteenStudent() {
    }

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

    @Override
    public void study() {
        System.out.println("学习Hive知识");
    }
}

public class AbstractTest3 {
    public static void main(String[] args) {
        //多态创建第一个对象
        Student2 s1 = new FifteenStudent("阿杰",18);
        s1.study();

        Student2 s2 = new FourteenStudent("阿豪",19);
        s2.study();

    }
}

8、假如我们在开发一个系统时需要对员工类进行设计，员工包含3个属性：姓名、工号以及工资。
            经理也是员工，除了含有员工的属性外，另为还有一个奖金属性。
            请使用继承的思想设计出员工类和经理类。要求类中提供必要的方法进行属性访问。

            分析：
                普通员工：
                    成员变量：姓名，工号，工资
                    成员方法：工作（敲代码）
                经理
                    成员变量：姓名，工号，工资，奖金
                    成员方法：工作（做PPT）

abstract class Staff{
    private String name;
    private String id;
    private int salary;

    public Staff() {
    }

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

    public String getName() {
        return name;
    }

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

    public String getId() {
        return id;
    }

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

    public int getSalary() {
        return salary;
    }

    public void setSalary(int salary) {
        this.salary = salary;
    }

    public abstract void work();
}

class CommonStaff extends Staff{
    public CommonStaff() {
    }

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

    @Override
    public void work() {
        System.out.println("敲代码");
    }
}

class Manager extends Staff{
    //特有的属性 奖金
    private int bonus;

    public Manager(int bonus) {
        this.bonus = bonus;
    }

    public Manager(String name, String id, int salary, int bonus) {
        super(name, id, salary);
        this.bonus = bonus;
    }

    @Override
    public void work() {
        System.out.println("做PPT");
    }
}


public class AbstractTest4 {
    public static void main(String[] args) {
        //创建第一个对象
        Staff s1 = new CommonStaff("阿杰","KZ0080",100000);
        s1.work();

        //创建第二个对象
        Staff s2 = new Manager("阿豪","SJ00030",200000,1000000);
        s2.work();

    }
}


 

L缶神
关注
专栏目录
Java 面向对象 -- Java 语言的封装、继承、多态、内部类和 Object 类
栗筝i的博客
06-12 2670
在我们对 Java 语言进行基本介绍之后，本篇文章将带领大家深入了解 Java 的面向对象编程（OOP）概念。我们将探讨封装、继承和多态这三大核心概念，以及内部类的使用和 Object 类的重要性。通过对这些内容的学习，读者将能够更好地设计和实现复杂的 Java 应用程序。
Java中抽象类实现多态
Rain
08-19 2966
不能new出抽象类对象，但可以定义一个抽象类的引用。 可以把一个子类对象的地址赋给抽象类的引用，然后通过抽象类的引用调用子类从父类继承过来的方法，即抽象类也可以实现多态 假设A是抽象类，B是A的子类且完全实现了A的所有抽象方法，则 A aa = new A(); //error A aa = new B(); //OK abstract class A { public abstrac
java 抽象类 多态_Java抽象类\多态
weixin_42299566的博客
02-13 408
1抽象类什么时候使用?当某个父类只是知道子类应该包含怎么样的方法，但是无法准确知道子类如何实现这些方法。比如一个图形类应该有一个求周长的方法，但是不同的图形求周长的算法不一样。那该怎么办呢？(分析事物时，发现了共性内容，就出现向上抽取。会有这样一种特殊情况，就是方法功能声明相同，但方法功能主体不同。那么这时也可以抽取，但只抽取方法声明，不抽取方法主体。那么此方法就是一个抽象方法。)2抽象类： 包含...
Java--多态和抽象类
最新发布
m0_51821434的博客
07-30 1152
这篇文章讲述了面向对象的最后一特性--多态，同时还对抽象类进行了介绍。
Java_4.使用接口和抽象类实现多态
m0_74019992的博客
04-16 1150
"狗"和"猫"都是"动物"的子类，它们重写了"发出声音"方法，但是"狗"发出"汪汪"声音，"猫"发出"喵喵"声音。实现接口的类必须要提供这些方法的具体实现。接口的主要作用是实现代码的解耦，即接口定义了规范和约束，实现类需要按照接口的规范来实现接口中的方法。我们可以定义一个角色接口，包含所有角色所需实现的方法，比如攻击和防御，我们定义它的攻击和防御方法，然后在每个角色类中实现这些方法，以满足游戏的需求。，默认方法则是在Java 8中引入的，它们允许接口有默认的实现，而不需要实现类来提供具体的实现。
Java 多态的理解（使用抽象类）
u012289441的专栏
09-19 1415
多态性是指允许不同类的对象对同一消息作出响应。多态性包括参数化多态性和包含多态性。多态性语言具有灵活、抽象、行为共享、代码共享的优势，很好的解决了应用程序函数同名问题。 多态有两种表现形式：重载和覆盖 首先说重载（overload），是发生在同一类中。与什么父类子类、继承毫无关系。 标识一个函数除了函数名外，还有函数的参数（个数和类型）。也就是说，一个类中可以有两个或更多的函数，叫
day14-面向对象-多态&final&抽象类
12-12
* 多态是面向对象中的一大特征 * 多态的发生前提：必须有继承或实现关系、有方法的重写、父类引用指向子类的对象 * 多态可以分为两种形式：方法多态和成员变量多态 Java 中的 final 关键字： * final 关键字可以...
java面向对象-多态.docx
05-10
进行本实验之前，需要具备一定的Java基础知识，包括但不限于： - 变量、数据类型和运算符的基础知识。 - 控制流语句（如if、for、while等）的使用。 - 类和对象的概念，包括类的定义、对象的创建等。 - 继承和封装的...
Java软件开发实战 Java基础与案例开发详解 6-9 继承和多态 章节练习 共4页.pdf
07-07
根据给定文件的信息，我们可以提炼出以下关于Java继承与多态的重要知识点： ### 6-0 继承和多态 #### 6-1 继承 - **定义**: 继承是面向对象编程的一个核心特性，允许创建一个新的类（子类）来继承现有类（父类）的...
头歌--Java面向对象 - 封装、继承和多态
热门推荐
m0_56638814的博客
04-10 1万+
头歌实践--Java面向对象 - 封装、继承和多态
抽象类实现多态
weixin_34194702的博客
03-18 668
　　 一：什么是多态? 多种形态，既不同的对象对于同一个操作做出的相应不同。 二：.抽象类的几个注意事项 1，抽象类使用abstract修饰 2，抽象方法只能位于抽象类中 3，抽象类不能实例化 4，抽象方法没有方法体 5，抽象类不能是静态类或者密封类 6，子类必须重写父类的所有抽象方法，除非子...
java面向对象抽象能力_Java面向对象编程——抽象类、接口、多态
weixin_31132687的博客
02-27 162
继封装和继承之后，抽象类、接口和多态同样是面向对象编程的重点。抽象类抽象类：不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。由于抽象类不能实例化对象，所以抽象类必须被继承，才能被使用。类的其它功能依然存在，成员变量、成员方法和构造方法的访问方式和普通类一样。抽象方法：抽象类和接口中具有的特殊方法，与一般方法相比，抽象方法只需要声明而不需要实现...
2020-12-09抽象类的继承和创建/适配器/对象运行时的多态
Easynight的博客
12-09 159
java 核心编程思想是面向对象 面向对象核心编程思想是面向抽象 抽象类的定义 抽象类通常应包含抽象方法，也可以包含非抽象方法 抽象类不能使用final关键字修饰 抽象类自身不能够实例化，必须依赖子类进行创建 抽象类就是用来被继承的 抽象类的继承和创建 抽象类被非抽象类继承必须对所有抽象方法提供实现 抽象类被抽象类继承可以不实现父类的抽象方法 抽象类对象的实例化必须通过非抽象子类进行创建 抽象类对象都是上转型对象 final修饰的方法不能在子类中被重写，抽象方法不能用final修饰 适配器 1.为抽象类定义
C#封闭方法和封闭类：sealed
六斤的小猪猪呀
05-07 465
C#中的封闭方法和封闭类 一、封闭类 使用sealed修饰符修饰的类为封闭类，表示该类不可被继承。故，该修饰符不可与abstract一起使用，因为抽象类的方法需要继承的实体类做具体实现，必须被继承才有意义。 using System; namespace Test { public sealed class Transformer { private static...
JAVA基础学习笔记
Apiao9的博客
10-25 1254
Java初级知识点总结
Java abstract 抽象类的详解介绍
阿博的博客
06-15 2000
抽象类的概念，及抽象类的特点，及抽象类的成员特点
抽象类
a584898的博客
06-07 195
普通类的特征是：类的结构很完整，而且可以直接产生实例化对象并使用。但是普通类之中所定义的方法都是具备方法体的“{}”，但是如果所现在一个类之中的某些方法希望被子类强制进行重写，则可以将其定义为抽象方法，抽象方法使用abstract关键字声明，而且声明时没有方法体，而包含抽象方法的类称为抽象类，抽象类也要使用abstract关键字进行定义abstract class Aa{ private Stri...
面向接口编程
TheLtalianGun的博客
06-21 199
接口 意义： （1）是一种数据类型（引用数据） （2）由interface定义 （3）只能包含常量和抽象方法 （4）不能被实例化 （5）接口是需要被实现/继承的，实现类/派生类：必须重写接口中的所有抽象方法 （6）一个类可以实现多个接口，用逗号分隔 若又继承又实现时，应先继承后实现 （7）接口可以继承接口 作用： 将部分派生类中所共有的行为，抽到接口中(用implements实现接口，可实现...
Java面向对象基础：抽象类与多态
本资源着重介绍了Java中的面向对象编程，特别是关于抽象类的相关知识点。 1. **抽象类**: - **概念**: Java中的抽象类是指那些包含至少有一个抽象方法（即没有具体实现的方法）的类。抽象方法是由`abstract`关键字...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值