小试里式替换原则

迷南。 2023-09-28 16:41 4阅读 0赞

## 定义 ##

子类对象（object of subtype/derived class）能够替换程序（program）中父类对象（object of base/parent class）出现的任何地方，并且保证原来程序的逻辑行为（behavior）不变及正确性不被破坏。

## 方式 ##

### 类 ###

1.  子类可以实现父类的抽象方法，但是不能覆盖父类的非抽象方法
2.  子类中可以增加自己独有的方法

### 方法 ###

#### 参数 ####

子类重载父类方法时，方法的入参要比父类的入参更宽松

#### 返回值 ####

子类方法实现（重载、重写、实现抽象方法）父类方法时，方法的返回值要比父类更严格或相等。

## 思考 ##

思考一：如果父类的方法是按照年龄升序，但是子类重写后是按照 ID 升序，这算违反里式替换了吗？

违反了啊，方法实现的功能都不一样了，都不用说实现方式了。

思考二：父类中有异常返回 null 无数据返回空集合，子类重写后异常抛异常无数据返回 null 算吗？

算啊。

思考三：如果父类提现方法不允许超过余额，子类重写后支持透支算吗？

算啊。

思考四：咋验证子类是否违反里式替换原则了呢？

拿父类的单元测试去验证子类的代码。如果某些单元测试运行失败，就有可能说明，子类的设计实现没有完全地遵守父类的约定，子类有可能违背了里式替换原则。

## 代码 ##

### 类 ###

#### 类的坏设计 ####

/**
     * 正方形
     *
     * @author mindartisan.blog.csdn.net
     * @date
     */
    public class Square extends Rectangle{
        
    
        /**
         * 边长
         */
        private long length;
    
        public long getLength() {
        
            return length;
        }
    
        public void setLength(long length) {
        
            this.length = length;
        }
    
        @Override
        public long getWidth() {
        
            return this.length;
        }
    
        @Override
        public void setWidth(long width) {
        
            setLength(width);
        }
    
        @Override
        public long getHeight() {
        
            return this.length;
        }
    
        @Override
        public void setHeight(long height) {
        
            setLength(height);
        }
    }
    /**
     * 矩形
     *
     * @author mindartisan.blog.csdn.net
     * @date
     */
    public class Rectangle {
        
    
        /**
         * 宽度
         */
        private long width;
    
        /**
         * 高度
         */
        private long height;
    
        public long getWidth() {
        
            return width;
        }
    
        public void setWidth(long width) {
        
            this.width = width;
        }
    
        public long getHeight() {
        
            return height;
        }
    
        public void setHeight(long height) {
        
            this.height = height;
        }
    }
    /**
     * 反例测试
     *
     * @author mindartisan.blog.csdn.net
     * @date
     */
    public class BadTest {
        
    
        public static void main(String[] args) {
        
            // Rectangle 没问题
            // Rectangle rectangle  = new Rectangle();
            // rectangle.setHeight(10);
            // rectangle.setWidth(20);
            // resize(rectangle);
    
            // Square 会出问题
            // Square square = new Square();
            // square.setLength(10);
            // resize(square);
        }
    
        public static void resize(Rectangle rectangle) {
        
            while (rectangle.getWidth() >= rectangle.getHeight()) {
        
                rectangle.setHeight(rectangle.getHeight() + 1);
                System.out.println("Width: " + rectangle.getWidth() + " & Height: " + rectangle.getHeight());
            }
            System.out.println("Resize End -> Width: " + rectangle.getWidth() + " & Height: " + rectangle.getHeight());
        }
    }

#### 类的好设计 ####

/**
     * 四边形
     *
     * @author mindartisan.blog.csdn.net
     * @date
     */
    public interface Quadrangle {
        
    
        /**
         * 宽度
         *
         * @return long
         */
        long getWidth();
    
        /**
         * 高度
         *
         * @return long
         */
        long getHeight();
    }
    /**
     * 矩形
     *
     * @author mindartisan.blog.csdn.net
     * @date
     */
    public class Rectangle implements Quadrangle {
        
    
        /**
         * 宽度
         */
        private long width;
    
        /**
         * 高度
         */
        private long height;
    
        @Override
        public long getWidth() {
        
            return width;
        }
    
        public void setWidth(long width) {
        
            this.width = width;
        }
    
        @Override
        public long getHeight() {
        
            return height;
        }
    
        public void setHeight(long height) {
        
            this.height = height;
        }
    }
    /**
     * 正方形
     *
     * @author mindartisan.blog.csdn.net
     * @date
     */
    public class Square implements Quadrangle {
        
    
        /**
         * 边长
         */
        private long length;
    
        @Override
        public long getWidth() {
        
            return this.length;
        }
    
        @Override
        public long getHeight() {
        
            return this.length;
        }
    
        public long getLength() {
        
            return length;
        }
    
        public void setLength(long length) {
        
            this.length = length;
        }
    }
    /**
     * 正例测试
     *
     * @author mindartisan.blog.csdn.net
     * @date
     */
    public class GoodTest {
        
    
        public static void main(String[] args) {
        
            // Rectangle 没问题
            Rectangle rectangle  = new Rectangle();
            rectangle.setHeight(10);
            rectangle.setWidth(20);
            resize(rectangle);
    
            // Square 会出问题
            Square square = new Square();
            square.setLength(10);
            resize(square);
    
            // Quadrangle 会出问题
            Quadrangle quadrangle = new Square();
            square.setLength(10);
            resize(quadrangle);
        }
    
    
        /**
         * 重绘
         *
         * 入参由 Rectangle 改成 Quadrangle 之后，Quadrangle 没有 setHeight 方法，确保此方法只能传入 Rectangle
         * @param rectangle 矩形
         */
        public static void resize(Rectangle rectangle) {
        
            while (rectangle.getWidth() >= rectangle.getHeight()) {
        
                rectangle.setHeight(rectangle.getHeight() + 1);
                System.out.println("Width: " + rectangle.getWidth() + " & Height: " + rectangle.getHeight());
            }
            System.out.println("Resize End -> Width: " + rectangle.getWidth() + " & Height: " + rectangle.getHeight());
        }
        /**
         * 重绘
         *
         * 入参由 Rectangle 改成 Quadrangle 之后，Quadrangle 没有 setHeight 方法，确保此方法只能传入 Rectangle
         * @param rectangle 矩形
         */
        public static void resize1(Quadrangle quadrangle) {
        
            while (quadrangle.getWidth() >= quadrangle.getHeight()) {
        
                quadrangle.setHeight(quadrangle.getHeight() + 1);
                System.out.println("Width: " + quadrangle.getWidth() + " & Height: " + quadrangle.getHeight());
            }
            System.out.println("Resize End -> Width: " + quadrangle.getWidth() + " & Height: " + quadrangle.getHeight());
        }
    }

### 方法 ###

#### 针对参数的 ####

/**
     * 子类
     *
     * @author mindartisan.blog.csdn.net
     * @date
     */
    public class SubClass extends SuperClass{
        
    
        public void method(Map map){
        
            System.out.println("SubClass's method executed");
        }
    }
    /**
     * 父类
     *
     * @author mindartisan.blog.csdn.net
     * @date
     */
    public class SuperClass {
        
        public void method(HashMap hashMap) {
        
            System.out.println("SuperClass's method executed");
        }
    }
    /**
     * 参数测试：当子类的方法重载父类的方法时，方法的前置条件（即方法的输入、入参）要比父类方法的输入参数更宽松。
     *
     * @author mindartisan.blog.csdn.net
     * @date
     */
    public class ParamsTest {
        
        public static void main(String[] args) {
        
    
            HashMap hashMap = new HashMap();
    
            SubClass subClass = new SubClass();
            // 输出：SuperClass's method executed
            subClass.method(hashMap);
    
            SuperClass subClass1 = new SubClass();
            // 输出：SuperClass's method executed
            subClass1.method(hashMap);
    
            SuperClass superClass = new SuperClass();
            // 输出：SuperClass's method executed
            superClass.method(hashMap);
    
    
        }
    }

#### 针对返回值的 ####

/**
     * 子类
     *
     * @author mindartisan.blog.csdn.net
     * @date
     */
    public class SubClass extends SuperClass {
        
        // 此处的返回值不能是 Object 类型，IDE 会提示。原因：当子类的方法实现父类的方法时（重写、重载或实现抽象方法），方法的后置条件（即方法的输出、返回值）要比父类更严格或相等。
        @Override
        public HashMap method() {
        
            HashMap hashMap = new HashMap();
            hashMap.put("SubClass","Method");
            System.out.println(hashMap);
            return hashMap;
        }
    
        // 其实这里不应该这样做：因为在里式替换原则中「子类可以实现父类的抽象方法，但是不能覆盖父类的非抽象方法」
        // @Override
        // public HashMap method() {
        
        //     HashMap hashMap = new HashMap();
        //     hashMap.put("SubClass","Method");
        //     System.out.println(hashMap);
        //     return hashMap;
        // }
    }
    /**
     * 父类
     *
     * @author mindartisan.blog.csdn.net
     * @date
     */
    public abstract class SuperClass {
        
    
        // 不好的演示：因为在里式替换原则中「子类可以实现父类的抽象方法，但是不能覆盖父类的非抽象方法」
        // public Map method() {
        
        //     Map map = new HashMap();
        //     map.put("SuperClass","method");
        //     return map;
        // }
        public abstract Map method();
    }
    /**
     * 返回值测试：当子类的方法实现父类的方法时（重写、重载或实现抽象方法），方法的后置条件（即方法的输出、返回值）要比父类更严格或相等。
     *
     * @author mindartisan.blog.csdn.net
     * @date
     */
    public class ReturnValueTest {
        
        public static void main(String[] args) {
        
            SubClass subClass = new SubClass();
            subClass.method();
        }
    }