关于里氏替换原则， 子类在同名方法中，放大或者缩小输入参数类型的研究

已于 2024-04-22 00:27:47 修改
阅读量73 收藏
点赞数 2
文章标签： java c++ 开发语言
于 2024-04-21 23:31:17 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hbbert/article/details/138049774
版权

关于int,Integer 作为传入参数，子类方法调用的问题

之前一道面试题，把我搞蒙蔽了。 形如下列代码（相关问题和答案写在注释里面了)

package groupId.test;

/**
 * 关于传入int和Integer参数，调用有啥区别？
 * 答： 对于 子类Son来说，因为继承的关系，同时 存在 M(int n)，M(Integer n) 两个方法，
 * 根据传入的的参数来调用不同的方法。
 * 对于 F f = new Son() 这种情况下，对象f完成上转型，不在视作Son类。
 * 此时父类F只有一个方法 M(int n) 或者 M(Integer n)，
 * 无论传入int或者Integer，它都先执行拆装箱，再传入对应的父类方法FM中。
 */

public class temp {
    public static void main(String[] args) {
        Son s = new Son();
        Father f = new Son();
        Son2 s2 = new Son2();
        Father2 f2 = new Son2();
        // 子类//拆箱
        s.doSomething(new Integer(1)); //父类 被执行。。。。1
        s.doSomething(1); //子类 被执行。。。。。1
        f.doSomething(new Integer(1)); //父类 被执行。。。。1
        f.doSomething(1); //父类 被执行。。。。1

        // 子类//装箱
        s2.doSomething(new Integer(1)); //子类2 被执行。。。。。1
        s2.doSomething(1); //父类2 被执行。。。。1
        f2.doSomething(new Integer(1)); //父类2 被执行。。。。1
        f2.doSomething(1); //父类2 被执行。。。。1
    }
}

class Father{
    public void doSomething(Integer n){
        System.out.println("父类 被执行。。。。"+n);

    }
}

class Son extends Father{
    //拆箱
    public  void doSomething(int n){
        System.out.println("子类 被执行。。。。。"+n);

    }
}


class Father2{
    public void doSomething(int n){
        System.out.println("父类2 被执行。。。。"+n);
    }
}

class Son2 extends Father2{
    //装箱
    public  void doSomething(Integer n){
        System.out.println("子类2 被执行。。。。。"+n);
    }
}

索性，扩展一下：

放大或缩小父类的参数类型（即用它的父类或者子类做参数）

package groupId;

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class LspOverriedOrOverwriteTest {
    public static void main(String[] args) {
        //invoke1();//父类1 被执行。。。。
        //invoke11();//父类1 被执行。。。。 放大输入类型参数，重载，调用的还是父类的方法
        //invoke2();//父类2 被执行。。。。。
        //invoke21();// 子类21 被执行。。。。缩小输入类型参数， 覆写
        // 子类21 缩小参数输入范围，子类重载了父类方法，子类行为不同于父类，在设计角度父类无法预料子类的行为，
        // 这是非常危险的

        //invoke3(); //父类3 被执行。。。。
        //invoke31();//子类31 被执行。。。。。 缩小或等于输出类型参数，  此时相当于覆写了父类方法
        //invoke4(); //父类4 被执行。。。。
        //invoke41(); //父类4 被执行。。。。//放大输出类型参数，编译不通过 ,所以执行的还是父类的方法
        //invoke5(); //父类5 被执行。。。。1
        //invoke51();//输入类型 子类参数 Integer，"装箱"，，父类5 被执行。。。。1 (子类传入 1)    子类51 被执行。。。。。1 （子类传入new Integer（1））

        //invoke6(); //父类6 被执行。。。。1
        //invoke61();//输入类型 子类 参数 int，"拆箱"，子类61 被执行。。。。1 (子类传入 1)    父类5 被执行。。。。。1 （子类传入new Integer（1））
        //invoke7(); //父类7 被执行。。。。1
        //invoke71(); //父类7 被执行。。。。1 输出值 "拆箱"，编译不通过 即 方法名，参数类型，个数，位置相同，不允许出现返回值不同的方法
        //invoke8(); //父类8 被执行。。。。1
        //invoke81(); //父类8 被执行。。。。1 输出值 "装箱"，编译不通过 即 方法名，参数类型，个数，位置相同，不允许出现返回值不同的方法

        invoke9(); //父类9 被执行。。。。
        invoke91(); //父类9 被执行。。。。 在子类的输出参数缩小，输入参数放大的情况下,执行父类方法，{重载}

        /**
         * 总结，针对输出参数，子类的返回值在只能缩小或等于父类的情况下，整体上 子类是趋向于{覆写}父类方法的，
         * 所以一般返回值类型视作相同。
         * 针对输入参数，子类的输入参数在放大父类的情况下，或者多于父类同名方法的参数个数，或者参数位置调整情况，
         * 整体子类是{重载}的，
         * 子类调用父类的同签名方法，执行的是父类的方法，形如 father.dosomething(? supper Father T)
         *
         * 子类子类的输入参数在小于等于父类的情况下，{覆写} 父类方法
         *
         * 同时，1， int与Integer做两个测试； int与Integer作为输入参数，视作两个不同的参数类型
         * 不会收到 jvm 默认拆装箱的影响， 同样 作为返回类型 他们不能同时存在子类相同方法名上，编译会报错。
         * 又java规定 方法名，参数类型，个数，位置相同，不允许出现返回值类型不同的方法，故作为参数时，
         * int 与Integer是两个完全不同的参数，其他原始类型与包装类型 类似。
         * 补： F f = new Son() 这种情况下：若父类F只有一个方法 FM(int n) 或者 FM(Integer n)，
         * 无论传入int或者Integer，它都先执行拆装箱，再传入对应的父类方法FM中。
         * 2，在子类的输出参数缩小，输入参数放大的情况下：
         *  invoke91() 执行父类方法，{重载} . 说明 一般情况下，无需考虑返回类型，子类的行为
         *  取决于输入参数的类型， 输入参数类型>父类的，{重载}，调用父类方法
         *  输入参数<= 父类的，{覆写} ，调用子类方法、
         *  
         *  因为输出参数>父类的，编译报错，所以不考虑 子类的输出参数放大，输入参数缩小的情况。
         */
    }
    public static void invoke1(){
        //父类存在的地方，子类就应该能够存在
        Father1 f = new Father1();
        HashMap map = new HashMap();
        f.doSomething(map);
    }

    public static void invoke11(){
        //父类存在的地方，子类就应该能够存在
        Son1 f = new Son1();
        HashMap map = new HashMap();
        f.doSomething(map);
    }

    public static void invoke2(){
        //父类存在的地方，子类就应该能够存在
        Father2 f = new Father2();
        HashMap map = new HashMap();
        f.doSomething(map);
    }
    public static void invoke21(){
        //父类存在的地方，子类就应该能够存在
        Son2 f = new Son2();
        HashMap map = new HashMap();
        f.doSomething(map);
    }

    public static void invoke3(){
        //父类存在的地方，子类就应该能够存在
        Father3 f = new Father3();
        HashMap map = new HashMap();
        f.doSomething(map);
    }
    public static void invoke31(){
        //父类存在的地方，子类就应该能够存在
        Son3 f = new Son3();
        HashMap map = new HashMap();
        f.doSomething(map);
    }

    public static void invoke4(){
        //父类存在的地方，子类就应该能够存在
        Father4 f = new Father4();
        HashMap map = new HashMap();
        f.doSomething(map);
    }
    public static void invoke41(){
        //父类存在的地方，子类就应该能够存在
        Son4 f = new Son4();
        HashMap map = new HashMap();
        f.doSomething(map); //放大输出类型参数，编译不通过 ,所以执行的还是父类的方法
    }


    public static void invoke5(){
        //父类存在的地方，子类就应该能够存在
        Father5 f = new Father5();

        f.doSomething(1);
    }
    public static void invoke51(){
        //父类存在的地方，子类就应该能够存在
        Son5 f = new Son5();
        HashMap map = new HashMap();
        f.doSomething(new Integer(1)); //装箱
        //f.doSomething(1); //装箱
    }

    public static void invoke6(){
        //父类存在的地方，子类就应该能够存在
        Father6 f = new Father6();

        f.doSomething(1);
    }
    public static void invoke61(){
        //父类存在的地方，子类就应该能够存在
        Son6 f = new Son6();
        HashMap map = new HashMap();
        //f.doSomething(new Integer(1)); //装箱
        f.doSomething(1); //装箱
    }

    public static void invoke7(){
        //父类存在的地方，子类就应该能够存在
        Father7 f = new Father7();

        f.doSomething(1);
    }
    public static void invoke71(){
        //父类存在的地方，子类就应该能够存在
        Son7 f = new Son7();
        HashMap map = new HashMap();
        //f.doSomething(new Integer(1)); //装箱
        f.doSomething(1); //装箱
    }

    public static void invoke8(){
        //父类存在的地方，子类就应该能够存在
        Father8 f = new Father8();

        f.doSomething(1);
    }
    public static void invoke81(){
        //父类存在的地方，子类就应该能够存在
        Son8 f = new Son8();
        HashMap map = new HashMap();
        //f.doSomething(new Integer(1)); //装箱
        f.doSomething(1); //装箱
    }



    public static void invoke9(){
        //父类存在的地方，子类就应该能够存在
        Father9 f = new Father9();
        HashMap map = new HashMap();
        f.doSomething(map);
    }
    public static void invoke91(){
        //父类存在的地方，子类就应该能够存在
        Son9 f = new Son9();
        HashMap map = new HashMap();
        f.doSomething(map); //放大输出类型参数，编译不通过 ,所以执行的还是父类的方法
    }



}
class Father1{
    public Collection doSomething(HashMap map){
        System.out.println("父类1 被执行。。。。");
        return map.values();
    }
}
class Son1 extends Father1{
    //放大输入类型参数
    public Collection doSomething(Map map){
        System.out.println("子类11 被执行。。。。。");
        return map.values();
    }
}

class Father2{
    public Collection doSomething(Map map) {
        System.out.println("父类2 被执行。。。。。");
        return map.values();
    }
}
class Son2 extends Father2{
    //缩小输入参数范围
    public Collection doSomething(HashMap map){
        System.out.println("子类21 被执行。。。。");
        return map.values();
    }
}

class Father3{
    public Iterable doSomething(Map map){
        System.out.println("父类3 被执行。。。。");
        return  map.values();
    }
}
class Son3 extends Father3{

    //缩小或等于输出类型参数
    public  Collection doSomething(Map map){
        System.out.println("子类31 被执行。。。。。");
        return map.values();
    }
}

class Father4{
    public Collection doSomething(Map map){
        System.out.println("父类4 被执行。。。。");
        return  map.values();
    }
}
class Son4 extends Father4{
    //放大输出类型参数，编译不通过
    /*public Iterable doSomething(Map map){
        System.out.println("子类41 被执行。。。。。");
        return map.values();
    }*/

}


class Father5{
    public Collection doSomething(int n){
        System.out.println("父类5 被执行。。。。"+n);
        return  new HashMap().values();
    }
}
class Son5 extends Father5{

    //装箱
    public  Collection doSomething(Integer n){
        System.out.println("子类51 被执行。。。。。"+n);
        return new HashMap().values();
    }
}
class Father6{
    public Collection doSomething(Integer n){
        System.out.println("父类6 被执行。。。。"+n);
        return  new HashMap().values();
    }
}
class Son6 extends Father6{

    //拆箱
    public  Collection doSomething(int n){
        System.out.println("子类61 被执行。。。。。"+n);
        return new HashMap().values();
    }
}

class Father7{
    public Integer doSomething(Integer n){
        System.out.println("父类7 被执行。。。。"+n);
        return  n;
    }
}
class Son7 extends Father7{

    //输出值 拆箱，编译不通过 即 方法名，参数类型，个数，位置相同，不允许出现返回值不同的方法
    /*public  int doSomething(Integer n){
        System.out.println("子类71 被执行。。。。。"+n);
        return n.intValue();
    }*/

    //输出值 不同，编译不通过 即 方法名，参数类型，个数，位置相同，不允许出现返回值不同的方法
    /*public  boolean doSomething(Integer n){
        System.out.println("子类71 被执行。。。。。"+n);
        return n.intValue();
    }*/
}


class Father8{
    public int doSomething(Integer n){
        System.out.println("父类8 被执行。。。。"+n);
        return  n.intValue();
    }
}
class Son8 extends Father8{

    //输出值 装箱，编译不通过, 即 方法名，参数类型，个数，位置相同，不允许出现返回值不同的方法
    /*public  Integer doSomething(Integer n){
        System.out.println("子类81 被执行。。。。。"+n);
        return n.intValue();
    }*/
}


class Father9{
    public Iterable doSomething(HashMap map){
        System.out.println("父类9 被执行。。。。");
        return  map.values();
    }
}
class Son9 extends Father9{
    //测试 子类的输出参数缩小，输入参数放大的情况
    public  Collection doSomething(Map map){
        System.out.println("子类91 被执行。。。。。");
        return map.values();
    }
}
hbbert
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
设计模式-里氏替换原则(接口反转原则)
qq_45205390的博客
02-25 340
设计模式-接口发转原则相关详细论述
PHP面向对象之里氏替换原则简单示例
12-19
里氏替换原则是实现开闭原则的重要方式之一，由于使用基类对象的地方都可以使用子类对象，因此在程序中尽量使用基类类型来对对象进行定义，而在运行时再确定其子类类型，用子类对象来替换父类对象。 使用里氏替换...
里氏替换原则
fry3309的博客
03-21 2001
里氏替换原则有4层含义。 子类必须完全实现父类的方法。 子类可以有自己的个性。 覆盖或实现父类的方法时输入参数可以被放大。 覆写或实现父类的方法时输出结果可以被缩小。
关于里氏替换原则
weixin_34293141的博客
11-14 193
在面向对象的语言中，继承是必不可少的、非常优秀的语言机制，它有如下优点： ● 代码共享，减少创建类的工作量，每个子类都拥有父类的方法和属性； ● 提高代码的重用性； ● 子类可以形似父类，但又异于父类，“龙生龙，凤生凤，老鼠生来会打洞”是说子拥有 父的“种”，“世界上没有两片完全相同的叶子”是指明子与父的不同； ● 提高代码的可扩展性，实现父类的方法就可...
设计模式之里氏替换原则示例
Mario_3的博客
03-09 1415
设计模式之里氏替换原则示例 　里氏替换原则强调的是设计和实现要依赖于抽象而非具体；子类只能去扩展基类，而不是隐藏或者覆盖基类，它包含4层含义. 一、里氏替换4原则 　　1、子类可以实现父类的抽象方法，但不能覆盖父类的非抽象方法 　　子类可以实现父类的抽象方法，但不能覆盖父类的非抽象方法，父类中凡是已经实现好的方法（相对于抽象方法而言），实际上是在设定一系列的规范和契约，虽然它不强制要求所有的子类必须遵从这些契约，但是如果子类对这些非抽象方法任意修改，就会对整个继承体系造成破坏...
设计模式 之 里氏替换原则
01-20
如果对每一个类型为T1的对象o1，都有类型为T2的对象o2，使得以T1定义的所有程序P在所有的对象o1都替换成o2时，程序P的行为没有变化，那么类型T2是类型T1的子类型。 定义很完备，但也不太好理解。说白了，其实就是...
c++里氏替换原则说明1
08-08
c++里氏替换原则说明1
举例解析Java的设计模式编程中里氏替换原则的意义
09-02
主要介绍了Java的设计模式中里氏替换原则的意义,文中举例来说明里氏替换原则中强调的继承特性方面可能带来的问题,需要的朋友可以参考下
PHP面向对象五大原则之里氏替换原则(LSP)详解
10-18
主要介绍了PHP面向对象五大原则之里氏替换原则(LSP),较为详细的分析了里氏替换原则(LSP)的概念、原理并结合实例形式分析了php里氏替换原则(LSP)的简单使用方法,需要的朋友可以参考下
【数据结构】二叉树
最新发布
m0_73911405的博客
05-05 419
前序：根，左子树，右子树中序：左子树，根，右子树后序：左子树，右子树，根N代表空元素前序 1 2 3 N N N 4 5 N N 6 N N中序 N 3 N 2 N 1 N 5 N 4 N 6 N后序 N N 3 N 2 N N 5 N N 6 4 1层序 1 2 4 3 5 6一层层从左到右一个树分成根和子树，子树再分为根和子树。
Spring Cloud——LoadBalancer
????
05-01 1716
这里只是简单的讲解了一下LoadBalancer如何使用，因为实际上我们使用的不是很多，主要还是使用OpenFeign。
链表刷题集
yajunjiao的专栏
04-30 688
本文主要列举了一些刷的题，不多，有那么几道，也建议各位去建立自己的刷题集。积少成多。
d15(136-148)-勇敢开始Java，咖啡拯救人生
m0_73459387的博客
04-28 1266
对象哈希值的特点：同一个对象调用hashCode()返回的哈希值相同；HashMap的键依赖hashCode方法和equals方法保证键的唯一，存储自定义类型的对象时，重写这两个方法。实际上，Set系列集合的底层就是基于Map实现的，只是Set集合中的元素要键数据，不要值数据。当12个位置都占满时就会扩容，大约扩容为原来的二倍，再把原数组数据转移到新数组。使用迭代器遍历集合时，又同时在删除集合中的数据，程序就会出现并发修改异常的错误。基于哈希表实现，每个键值对额外多了一个双链表的机制，记录元素顺序（保证。
Java解决最长公共前缀
无人罪的博客
04-28 552
编写一个函数来查找字符串数组中的最长公共前缀。如果不存在公共前缀，返回空字符串""。
【一步一步了解Java系列】：探索Java基本类型与C语言的区别
2302_81249757的博客
04-29 1059
​​喜欢的一句话： 常常会回顾努力的自己，所以要为自己的努力留下足迹。作者：小闭。
Spring cloud原理详解
qq_33449977的博客
04-28 637
想象一下，你开了一家餐馆，一开始只卖汉堡，后来生意火了，你又增加了炸鸡、披萨、冰淇淋各种摊位，每个摊位就是一个微服务，它们各自独立工作，但又得相互配合。有时候，某个服务可能太忙了，电话老打不通，这时候Spring Cloud还有个叫Hystrix的断路器，它会说：“嘿，别打了，那边线路忙，我给你个备用方案或者告诉你稍后再试。至于餐馆运营情况，Spring Cloud Sleuth和Zipkin这些工具，就像监控摄像头，记录服务间的每一次交互，方便你查看哪里出了问题，优化服务流程。
Nacos 配置中心实例分析实践
m0_73557631的博客
05-03 897
​ 浏览器: http://localhost:5000/nacos/config/ip。先创建e-commerce-nacos-config-client5000 模块。​ 启动e-commerce-nacos-config-client5000。​ 启动Nacos Server。
公考学习平台|基于SprinBoot+vue的公考学习平台(源码+数据库+文档)
weixin_66413741的博客
04-30 1195
本共享汽车管理系统有管理员和用户。管理员功能有个人中心，用户管理，投放地区管理，汽车信息管理，汽车投放管理，汽车入库管理，使用订单管理，汽车归还管理。用户可以在注册登录，可以对汽车进行使用产生订单，还可以归还。因而具有一定的实用性。本站是一个B/S模式系统，采用Spring Boot框架，MYSQL数据库设计开发，充分保证系统的稳定性。系统具有界面清晰、操作简单，功能齐全的特点，使得共享汽车管理系统管理工作系统化、规范化。
里氏替换原则java
01-05
里氏替换原则是面向对象设计中的一个重要原则，它要求子类对象能够替换父类对象并且不会产生任何错误或异常。换句话说，子类应该能够在不改变程序正确性的前提下，扩展父类的功能。 在Java中，遵循里氏替换原则的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值