设计模式中的设计原则

2023-12-21 23:23:17

开闭原则:扩展新的功能但不改变原有的程序设计。

public class test {
    public static void main(String[] args) {
        Car benz = new Car("Benz");
        benz.driver();
        //我们需要扩展方法
        benz.driver180();
    }
}
class Car{
    private String name;
    public Car(String name){
        this.name = name;
    }
    public void driver(){
        System.out.println("我最大速度是:120km/h");
    }
    //不改变原有的代码扩展新的方法
    public void driver180(){
        System.out.println("我最大速度是:180km/h");
    }
}

单一职责原则:一个类只干好一方面,专心做好一件事,不使代码臃肿。

//单一原则
//汽车、轮船、飞机还可继续细分,违背单一原则
class Vehicle {
    public void run(String type) {
        if (type.equals("car")) {
            System.out.println("在公路上行走。。。");
        } else if (type.equals("steamship")) {
            System.out.println("在水面上运行。。。。");
        } else if (type.equals("plane")) {
            System.out.println("在天空上飞行");

        }
    }
}

//分化为单一模块
class CarVehicle {
    public void run() {
        System.out.println("在公路上行走。。。");
    }
}
class SteamshipVehicle {
    public void run() {
        System.out.println("在水面上运行。。。。");
    }
}
class PlaneVehicle {
    public void run() {
        System.out.println("在天空上飞行");
    }
}

接口隔离原则:一个接口之中只做该接口需要的相关的功能,类似单一原则,不使代码臃肿

//接口隔离原则
//接口中定义的所有方法都是抽象方法,实现类需要实现接口中所有的抽象方法,不管需不需要
interface DataHandler {
    void save(String data);
    void load(String data);
    String getData();
    void setData(String data);
    void test(String data);
}
//实现类并不需要实现接口中所有的抽象方法,只需要实现接口中需要的方法即可,所以上面接口违背了接口隔离原则
class UserData implements DataHandler{
    public void save(String data) {
    }
    public void load(String data) {
    }
    public String getData() {
        return null;
    }
    public void setData(String data) {
    }
    public void test(String data) {
    }
}
//我们可以把当前接口用不到的功能,定义给需要的接口
interface DataHandler2{
    String getData();
    void setData(String data);
    void test(String data);
}
//实现类不会有冗余
class UserData implements DataHandler2{

    public String getData() {
        return null;
    }
    public void setData(String data) {
    }
    public void test(String data) {
    }
}

?里氏替换法:在有继承关系的代码开发中,如果需要进行功能的扩展,不要再子类中改变父类中已经实现的方法,而是通过新增方法来扩展父类的功能。

//不改变父类
class Caculate{
    private long height;
    private long width;
    public void setHeight(long height){
        this.height = height;
    }
    public void setWidth(long width){
        this.width = width;
    }
    public long getArea(){
        return height + width;
    }

}
//子类扩展需要方法
class Rectangle extends Caculate{
    private long height;
    private long width;
    public void setWidth(long width){
        this.width = width;
    }
    public void setheight(long height){
        this.height = height;
    }
    public long getArea(){
        return super.getArea() + height;
    }
    //需要扩展的代码
    public long getArea2(){
        return super.getArea() * height;
    }
}

依赖倒置法:我们定义类的成员遍历

文章来源:https://blog.csdn.net/weixin_45815520/article/details/135139814
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。