javase复习day14多态

于 2024-09-04 17:01:54 发布
阅读量262 收藏 11
点赞数 9
文章标签： java servlet 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_72625929/article/details/141870038
版权

多态

什么是多态

package Demo1;

public class Person {
    private String name;
    private int age;

    public void work(){
        System.out.println("工作");
    }

    public void look(){
        System.out.println(name+"年龄"+age);
    }


    public Person() {
    }

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

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     * @return age
     */
    public int getAge() {
        return age;
    }

    /**
     * 设置
     * @param age
     */
    public void setAge(int age) {
        this.age = age;
    }

    public String toString() {
        return "Person{name = " + name + ", age = " + age + "}";
    }
}

package Demo1;

public class student extends Person{
    @Override
    public void look() {
        System.out.println("学生的信息："+getName()+","+getAge());
    }
}

package Demo1;

public class teacher extends Person{
    @Override
    public void look() {
        System.out.println("老师的信息："+getName()+","+getAge());
    }
}

package Demo1;

public class admin extends Person{
    @Override
    public void look() {
        System.out.println("管理员的信息："+getName()+","+getAge());
    }
}

package Demo1;

public class Test {
    public static void main(String[] args) {
        student s = new student();
        s.setName("小李");
        s.setAge(18);

        teacher t = new teacher();
        t.setName("小王");
        t.setAge(30);
        admin a = new admin();
        a.setName("admin");
        a.setAge(50);

        show(s);
        show(t);
        show(a);
    }

    //写一个方法用于调用

    public static void show(Person p){
        p.look();
    }
}

运行结果：

学生的信息：小李,18
老师的信息：小王,30
管理员的信息：admin,50

多态调用成员的特点

调用成员变量：

  • 编译看左边：javac编译时会看左边的父类中有没有这个变量，如果有，编译成功，没有则编译失败。
  • 运行也看左边：运行代码实际上获取的是左边父类中的成员变量的值。

调用成员方法

  • 编译看左边：javac编译时会看左边的父类中有没有这个方法，如果有，编译成功，没有则编译失败。
  • 运行看右边：运行代码实际上运行子类中的方法。

理解：

例如：Anomal a = new Dog();

现在用a 去调用变量和方法，而a是Animal类型的所以默认从Animal这个类中找

成员变量：在子类的对象中会把父类的变量继承

成员方法：如果子类进行了方法重写则在虚方法表中会覆盖父类的方法。

多态调用成员的内存图

多态的优势

多态的弊端：

不能调用子类特有的方法。

可以进行强转来调用。如下：

package Demo.Demo2;

public class Test {
    public static void main(String[] args) {
        //多态
        Animal a = new Dog();
        //只能使用Animal中的方法而无法使用Dog中的方法
        a.eat();
        //如果想使用可以进行强转,强转要考虑转换的类型，类型不正确则报错
        Dog d = (Dog) a;
//        Cat c = (Cat) a;//运行时报错
        //要判断a的类型可以使用
        if (a instanceof Dog){
            Dog d1 = (Dog) a;
            d1.lookhome();
        } else if (a instanceof Cat) {
            Cat c = (Cat) a;
            c.catchmocer();
        }else {
            System.out.println("没用对应的类型");
        }

        //jdk14的新特性,将判断和转换放在一起
        if (a instanceof Dog d2){
            d2.lookhome();
        } else if (a instanceof Cat c2) {
            c2.catchmocer();
        }else {
            System.out.println("没用对应的类型");
        }

    }
}

package Demo.Demo2;

public class Animal {
    String name;
    public void eat(){
        System.out.println("吃东西");
    }
}
class Dog extends Animal{
    @Override
    public void eat() {
        System.out.println("狗吃东西");
    }
    public void lookhome(){
        System.out.println("狗看门");
    }
}
class Cat extends Animal{
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
    public void catchmocer(){
        System.out.println("猫抓老鼠");
    }
}

多态优劣的总结：

多态综合练习

练习一：

根据需求完成代码:

    1.定义狗类

        属性：

            年龄，颜色

        行为:

            eat(String something)(something表示吃的东西)

            看家lookHome方法(无参数)

    2.定义猫类

        属性：

            年龄，颜色

        行为:

            eat(String something)方法(something表示吃的东西)

            逮老鼠catchMouse方法(无参数)

    3.定义Person类//饲养员

        属性：

            姓名，年龄

        行为：

            keepPet(Dog dog,String something)方法

                功能：喂养宠物狗，something表示喂养的东西

        行为：

            keepPet(Cat cat,String something)方法

                功能：喂养宠物猫，something表示喂养的东西

        生成空参有参构造，set和get方法  

    4.定义测试类(完成以下打印效果):

        keepPet(Dog dog,String somethind)方法打印内容如下：

            年龄为30岁的老王养了一只黑颜色的2岁的狗

            2岁的黑颜色的狗两只前腿死死的抱住骨头猛吃

        keepPet(Cat cat,String somethind)方法打印内容如下：

            年龄为25岁的老李养了一只灰颜色的3岁的猫

            3岁的灰颜色的猫眯着眼睛侧着头吃鱼

    5.思考：      

        1.Dog和Cat都是Animal的子类，以上案例中针对不同的动物，定义了不同的keepPet方法，过于繁琐，能否简化，并体会简化后的好处？

        2.Dog和Cat虽然都是Animal的子类，但是都有其特有方法，能否想办法在keepPet中调用特有方法？

package Demo.Demo3;

public class Animal {
    private int age;
    private String color;

    public Animal() {
    }

    public Animal(int age, String color) {
        this.age = age;
        this.color = color;
    }

    public void eat(String something){
        System.out.println(something+"被吃了");
    }


    /**
     * 获取
     * @return age
     */
    public int getAge() {
        return age;
    }

    /**
     * 设置
     * @param age
     */
    public void setAge(int age) {
        this.age = age;
    }

    /**
     * 获取
     * @return color
     */
    public String getColor() {
        return color;
    }

    /**
     * 设置
     * @param color
     */
    public void setColor(String color) {
        this.color = color;
    }

    public String toString() {
        return "Animal{age = " + age + ", color = " + color + "}";
    }
}

package Demo.Demo3;

public class Dog extends Animal{

    public Dog() {
    }

    public Dog(int age, String color) {
        super(age, color);
    }

    public void lookHome(){
        System.out.println("看家");
    }

    @Override
    public void eat(String something) {
        System.out.println(getAge()+"岁的"+getColor()+"颜色的狗两只前腿死死的抱着"+something+"猛吃");
    }
}

package Demo.Demo3;

public class Cat extends Animal{

    public Cat() {
    }

    public Cat(int age, String color) {
        super(age, color);
    }

    public void catchMouse(){
        System.out.println("抓老鼠");
    }
    @Override
    public void eat(String something) {
        System.out.println(getAge()+"岁的"+getColor()+"颜色的猫眯着眼睛侧着头吃"+something+"猛吃");
    }
}

package Demo.Demo3;

public class Person {
    private String name;
    private int age;

    public void keepPet(Animal a,String something){
        //判断输入的类型
        if (a instanceof Dog d){
            System.out.println("年龄为"+age+"岁的"+name+"养了一只"+d.getColor()+"色的"+d.getAge()+"岁的狗");
            d.eat(something);

        } else if (a instanceof Cat c) {
            System.out.println("年龄为"+age+"岁的"+name+"养了一只"+c.getColor()+"色的"+c.getAge()+"岁的猫");
            c.eat(something);
        }else {
            System.out.println("输入的类型有误");
        }
    }

    public Person() {
    }

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

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     * @return age
     */
    public int getAge() {
        return age;
    }

    /**
     * 设置
     * @param age
     */
    public void setAge(int age) {
        this.age = age;
    }

    public String toString() {
        return "Person{name = " + name + ", age = " + age + "}";
    }
}

public class Test {
    public static void main(String[] args) {
//        Animal a = new Dog();
//        a.setAge(3);
//        a.setColor("灰");
//        Person p = new Person();
//        p.setName("老李");
//        p.setAge(30);
//        p.keepPet(a,"头骨");
//        Animal a = new Cat();
//        a.setAge(3);
//        a.setColor("灰");
//        Person p = new Person();
//        p.setName("老李");
//        p.setAge(30);
//        p.keepPet(a,"巨骨舌鱼");
        //父类的形参可以传入子类
        Person p = new Person("老赵",30);
        Dog d = new Dog(3,"黑");
        Cat c = new Cat(3,"黑");
        p.keepPet(d,"骨头");
        p.keepPet(c,"鱼");
    }
}

运行结果：

年龄为30岁的老赵养了一只黑色的3岁的狗
3岁的黑颜色的狗两只前腿死死的抱着骨头猛吃
年龄为30岁的老赵养了一只黑色的3岁的猫
3岁的黑颜色的猫眯着眼睛侧着头吃鱼猛吃

shift+F6 为批量修改

包和final、权限修饰符、代码块

包

什么是包

使用其他类的规则

  • 使用同一个包中的类时，不需要导包
  • 使用java.long 包中的类时，不需要导包
  • 其他情况都需要导包
  • 如果同时使用两个包中的同名类，需要使用全类名。

包入门小结：

final关键字（最终）

常量：

常量总结：

权限修饰符

空着不写被叫做默认或缺省。

  • private 私房钱，只能自己用。
  • 缺省 自己家里的钱，只能自己家用。
  • protected 自己家和私生子能用。
  • public 公共的，所有人都能用。
权限修饰符使用规则：

代码块

  • 局部代码块
  • 构造代码块
  • 静态代码块

局部代码块

局部：写在代码里的

作用：提前结束变量的生命周期。

好处：节约内存。

构造代码块：

  1. 生成成员位置的代码块
  2. 作用：可以把多个构造方法中重复的代码抽取出来
  3. 执行时间：我们在创建本类对象的时候会先执行构造代码块在执行构造方法
  4. 逐渐被淘汰
public class Student {
    private String name;
    private int age;
    //构造代码块
    {
        System.out.println("构造代码块执行");
    }

    public Student() {
    }

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

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     * @return age
     */
    public int getAge() {
        return age;
    }

    /**
     * 设置
     * @param age
     */
    public void setAge(int age) {
        this.age = age;
    }

    public String toString() {
        return "Student{name = " + name + ", age = " + age + "}";
    }
public class Test {
    public static void main(String[] args) {
        Student s = new Student();
        Student s1 = new Student("小李",18);
    }
}

如果有构造方法不需要加入该公共代码时的处理方法：

静态代码块：

总结：

未命名冀
关注
  • 9
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【JavaSE】继承和多态重点语法知识汇总
qq_68993495的博客
09-26 734
JavaSE之继承和多态，本部分属于语法中的难点，希望这篇文章对你有所帮助！
JavaSE基础:多态、final关键字-27
11-10
JavaSE是Java标准版的简称，它是Java编程的基础，涵盖了面向对象编程的核心概念和技术。在这个主题中，我们将深入探讨多态、final关键字以及与之相关的访问控制权限、package和import的使用。 首先，多态...
JavaSE进阶 面向对象多态
11-12
JavaSE 进阶 面向对象多态 在 JavaSE 中，面向对象多态是指同一个对象可以具有多种形态，例如一个人可以是老师、丈夫、父亲等。这种多态性是通过方法的重写和重载来实现的。 多态的形式有很多，例如： 1. 方法...
JavaSE之多态体系
07-21
JavaSE中的多态是面向对象编程的一个核心特性，它允许我们使用父类类型的引用操作子类对象，从而实现更灵活的代码设计。多态的概念简单来说就是“一个接口，多种形态”。这种特性使得程序在设计时能够保持抽象，提高...
JavaSE复习.md
12-23
JavaSE复习
浅析synchronized锁升级的原理与实现 1
水w的博客
09-01 1181
浅析synchronized锁升级的原理与实现
SpringBoot 项目集成 xxl-job
qq_58159506的博客
09-03 554
SpringBoot 项目集成 xxl-job
nmt---Docker-compose自动化部署
qq_69920145的博客
09-03 695
static-rr 权重, leastconn 最少连接, source 请求IP, 轮询 roundrobin。# 这⾥是容器中的IP地址，由于配置的是轮询roundrobin，weight 权重其实没有⽣效。# 这⾥是容器中的IP地址，由于配置的是轮询roundrobin，weight 权重其实没有⽣效。# 在 mysql 创建⼀个没有权限的haproxy⽤户，密码为空。# 在 mysql 创建⼀个没有权限的haproxy⽤户，密码为空。10. docker-compose移除容器。
在Java Web开发中，如何保障应用的安全性？请列举常见的安全策略和措施。请解释Spring框架中的事务管理，包括声明式事务和编程式事务。
最新发布
weixin_53180424的博客
09-03 667
在实际开发中，声明式事务管理因其非侵入性和易维护性而更受欢迎。它允许开发者将注意力集中在业务逻辑上，而不是事务管理的细节上。然而，在某些特殊场景下，编程式事务管理可能提供更灵活的控制力。因此，在选择事务管理方式时，应根据实际需求和场景来决定。
计算机毕业设计选题推荐-任务管理系统-项目任务分配系统-Java/Python项目实战
IT研究室的博客
09-03 555
随着信息化技术的迅猛发展，各类企业和组织越来越依赖于高效的任务管理系统以保证其日常运营的顺利进行。根据IDC（国际数据公司）发布的报告显示，全球企业在数字化转型上的投入已达数千亿美元，其中相当一部分资金用于提升企业内部的管理效率。任务管理系统作为企业信息化的重要组成部分，能有效帮助企业分配、监控和反馈任务，从而提高工作效率。然而，尽管市场上已有多种任务管理系统，它们在功能、用户体验和适用性上存在显著差异。
操作系统原子操作
zzt_is_me的博客
08-28 8679
所谓的原子操作就是不可被拆分的操作，对于多线程对全局变量进行操作时，就再也不用再线程锁了，和pthread_mutex_t保护作用是一样的，也是线程安全的，有些编译器在使用时需要加-march=i686编译参数。2、type只能是整数相关的类型，浮点型和自定义类型无法使用。功能：把value赋值给*ptr,并返回*ptr的旧值。功能：以上操作返回的是*ptr与value计算后的值。使用原子操作实现一个线程安全的无锁队列。1、该功能并不通用，有些编译器不支持。功能：以上操作返回的是*ptr的旧值。
Java设计模式之建造者模式详细讲解和案例示范
weixin_39996520的博客
08-28 5661
建造者模式是一种创建型设计模式，允许用户通过一步步地构造复杂对象的方式来避免直接使用大量的构造函数或复杂的初始化过程。它通过将对象的创建过程分解为多个步骤，并允许这些步骤以链式调用的方式来执行，最终生成一个完全构建的对象。首先，我们定义一个Order类，该类包括了多个字段，如订单ID、客户信息、商品列表、配送地址等。// Getter方法省略...在这个例子中，类提供了构建Order对象所需的各个方法，每个方法返回实例，以便进行链式调用。
MapStruct-Java实体转换利器
m0_63622279的博客
09-02 396
MapStruct 是一个用于生成映射器接口的代码生成库，主要用于简化 Java 对象之间的转换过程。在处理不同模型之间数据转换时，MapStruct 可以自动生成实现类减少手工转换逻辑的工作量。使用场景：各种模型之间的转换。BODTOVOPOJO引入mapstruct的pom依赖定义mapper接口（注意，这里不是MyBatis的Mapper哦），使用@Mapper注解标记，并在接口中声明映射方法。编写映射方法，（从xxxO转换为yyyO,模型之间的转换）在业务层中使用Mapper。
JavaWeb（基于SpringBoot开发）全总结（1）
2302_81420820的博客
09-02 840
再到spring boot中去设置，当我们遇到报错不要紧，我们直接再复制我们在DG上面写的sql语句，到idea那个数据库那里再运行一次，2.由于使用不同开发工具开发出来的略有不同，导致不能够互通，所以国际规定，使用maven创建的项目为统一标准结构，也就是下图所示的结构。还有我们写的案例里面的mapper层写的sql语句的新增，删除，等等操作，都是基于mybatis来实现的。例如：传入的是路径参数，json格式的参数等等，根据不同的参数我们使用不同的注解。
输入三个正整数，找出不大不小的值
laocooon的博客
08-30 1681
/ 找出最大值，找出最小值，然后不是最大值也不是最小值的。// 2、输入三个正整数，找出不大不小的值。
SpringBoot SSM vue在线作业考试系统
yinjl123456的博客
08-30 1230
使用技术: SpringBoot或SSM + Mybaits + Mysql + vue(前端)后台管理 登录注册 个人中心 教师信息管理 学生信息管理 学院信息管理 专业信息管理。班级信息管理 作业信息管理 作业提交管理 通知公告管理 试卷管理 试题管理。系统管理 管理员管理 考试管理。
Java 虚方法表（虚函数）
一心向阳，光芒万丈
08-31 668
虚方法表是一个类的内部数据结构，用于支持方法的动态绑定（即运行时多态）。每个类在加载时会生成一个虚方法表，其中包含了类中所有虚方法的地址。方法地址的存储：虚方法表存储了类的所有方法（包括继承自父类的方法）的内存地址或指针。这些方法在虚方法表中的顺序与它们在类中声明的顺序一致。动态绑定：当方法调用发生时，JVM 会根据对象的实际类型（而不是声明类型）来查找并调用正确的方法实现。这种机制允许程序在运行时决定调用哪个方法，从而实现多态。被privatestaticfinal。
计算机毕业设计选题推荐-公司考勤管理系统-Java/Python项目实战
IT研究室的博客
09-01 1114
随着企业规模的不断扩大和员工数量的增加，传统的人工考勤管理方式已经无法满足现代企业对高效、精准和自动化管理的需求。根据《人力资源管理杂志》2022年的统计数据，超过70%的中大型企业表示，考勤管理系统已经成为企业日常管理中不可或缺的工具。然而，仍有近40%的企业采用人工或半自动化的方式进行考勤管理，这不仅耗费了大量的人力资源，还容易出现错误和遗漏，导致考勤数据不准确，影响企业的人事管理和员工的工作体验。此外，随着远程办公和弹性工作制的普及，企业对灵活、智能化的考勤管理系统的需求愈发强烈。
Java学习高级六
weixin_45730243的博客
09-02 180
【代码】Java学习高级六。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值