软件开发人员需要知晓的设计模式有哪些?

开课吧小白2021-08-05 14:16

软件开发其实有一些工作内容是可以一次做好重复使用的,比如说设计模式,软件设计模式就有一些通用的,相当于处理事情的一个模版。有一些设计模式是最基本的,开发人员都应该了解的,主要有以下几种:

1、单例模式

模式用于保证一个类仅有一个实例。需要声明一个私有构造函数,以防止从类外部实例化。另外,它需要声明一个singleton类型的静态字段。

public class SingletonDemo {
   private static SingletonDemo instance = null;
   private SingletonDemo() {
   }
   public static SingletonDemo getInstance() {
      if(instance == null) {
         instance = new SingletonDemo();
      }
      return instance;
   }
}

上面的代码中的getInstance()方法在运行时只创建这个类的一个实例,首选的场景:类只有一个实例,包括缓存、线程池和注册表。

单例模式的getInstance()方法并不是线程安全的。它可以被实例化不止一次,可以通过在方法上加同步调用来解决,但是这会使方法变慢。

2、工厂模式

DemoClass demoClassObject = new DemoClass();

上述方法的问题是代码使用了具体的对象DemoClass。使用new创建对象也可以,但是它将代码紧密地耦合到了具体的类。可以通过如下的工厂模式解决该问题:

public interface Notification{
    String getType();
}
public class Call implements Notification{
    public String getType(){
        return "call"
    }
}
public class Message implements Notification{
    public String getType(){
        return "message"
    }
}
public class NotificationFactory {
    private static Map<String, Notification> instances;
    static {
        instances = new HashMap<>();
        instances.put("call", new Call());
        instances.put("message", new Message());
    }
public static <T extends Notification> T getNotification(String   type)
    {
        return (T) instances.get(type); 
    }
}
Notification notif = NotificationFactory.getNotification("call");

当一个类无法预料要创建哪种类的对象或是一个类需要由子类来指定创建的对象时,可以考虑使用工厂模式另外,开发人员可能不知道要构造哪种类型,例如在针对基本类型或接口进行编码时,也可以使用工厂模式。

工厂模式可以扩展系统中类的总数。每个具体的类还需要一个具体的对象,但是你可以通过参数化的Factory Method来避免。

3、建造者模式

建造者模式是用于构建对象,有时我们创建的对象可能很复杂,由多个子对象组成,或者需要复杂的构造过程。

建造者模式用于逐步构造一个复杂的对象,最后一步将返回该对象。构造对象的过程应该是通用的,以便可以用来创建同一对象的不同表示形式。

public class Product {
    private String id;
    private String name;
    private String description;
    private Double value;
    private Product(Builder builder) {
        setId(builder.id);
        setName(builder.name);
        setDescription(builder.description);
        setValue(builder.value);
    }
    public static Builder newProduct() {
        return new Builder();
    }
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getDescription() {
        return description;
    }
    public void setDescription(String description) {
        this.description = description;
    }
    public Double getValue() {
        return value;
    }
    public void setValue(Double value) {
        this.value = value;
    }
    public static final class Builder {
        private String id;
        private String name;
        private String description;
        private Double value;
        private Builder() {
        }
        public Builder id(String id) {
            this.id = id;
            return this;
        }
        public Builder name(String name) {
            this.name = name;
            return this;
        }
        public Builder description(String description) {
            this.description = description;
            return this;
        }
        public Builder value(Double value) {
            this.value = value;
            return this;
        }
        public Product build() {
            return new Product(this);
        }
    }
}
Product product = Product.newProduct()
                       .id(1l)
                       .description("TV 46'")
                       .value(2000.00)
                       .name("TV 46'")
                   .build();

建造者模式非常类似于工厂模式,他们的主要区别在于,当你需要构建对象时,建造者模式会非常有帮助。

在建造者模式中,代码行的数量至少增加了一倍,但是在设计灵活性和可读性方面,建造者模式的优势又是很明显的。

4、适配器模式

这种模式将一个类的接口转换成另外一个类的的接口,它充当翻译者的角色,当两个不说共同语言的领导见面时,通常会有一位口译员坐在两者之间,翻译对话,从而实现交流。

interface Bird 
{ 
   // birds implement Bird interface that allows 
   // them to fly and make sounds adaptee interface 
   public void fly(); 
   public void makeSound(); 
}
class Sparrow implements Bird 
{ 
   // a concrete implementation of bird 
   public void fly() 
   { 
     System.out.println("Flying"); 
   } 
   public void makeSound() 
   { 
     System.out.println("Chirp Chirp"); 
   } 
}
interface ToyDuck 
{ 
   // target interface 
   // toyducks dont fly they just make 
   // squeaking sound 
   public void squeak(); 
}
class PlasticToyDuck implements ToyDuck 
{ 
   public void squeak() 
   { 
     System.out.println("Squeak"); 
   } 
}
class BirdAdapter implements ToyDuck 
{ 
   // You need to implement the interface your 
   // client expects to use. 
   Bird bird; 
   public BirdAdapter(Bird bird) 
   { 
     // we need reference to the object we 
     // are adapting 
     this.bird = bird; 
   }
   public void squeak() 
   { 
     // translate the methods appropriately 
     bird.makeSound(); 
   } 
}
class Main 
{ 
 public static void main(String args[]) 
 { 
  Sparrow sparrow = new Sparrow(); 
  ToyDuck toyDuck = new PlasticToyDuck();
  // Wrap a bird in a birdAdapter so that it 
  // behaves like toy duck 
  ToyDuck birdAdapter = new BirdAdapter(sparrow);
  System.out.println("Sparrow..."); 
  sparrow.fly(); 
  sparrow.makeSound();
  System.out.println("ToyDuck..."); 
  toyDuck.squeak();
  // toy duck behaving like a bird 
  System.out.println("BirdAdapter..."); 
  birdAdapter.squeak(); 
} 
}

如果你有两个应用程序,其中一个以XML格式输出,另一个则需要JSON输入(或其他格式),那么你将需要在两者之间使用适配器模式来无缝运行。但是适配器不能与Adaptee或Target的子类一起使用。

5、状态模式

这种模式有助于我们表示对象的几种状态,假设有一个广播类的对象。它可以处于两种状态,即打开或关闭。这些状态可以用状态模式表示。

public class Radio {
    private boolean on;
    private RadioState state;

    public Radio(RadioState state){
        this.state = state;
    }

    public void execute(){
        state.execute(this);
    }

    public void setState(RadioState state){
        this.state = state;
    }

    public void setOn(boolean on){
        this.on = on;
    }

    public boolean isOn(){
        return on;
    }

    public boolean isOff(){
        return !on;
    }
}
public interface RadioState {
    void execute(Radio radio);
}
public class OnRadioState implements RadioState {
    public void execute(Radio radio){
        //throws exception if radio is already on
        radio.setOn(true);
    }
}
public class OffRadioState implements RadioState {
    public void execute(Radio radio){
        //throws exception if radio is already off
        radio.setOn(false);
    }
}
Radio radio = new Radio(new OffRadioState()); //initial status
radio.setState(new OnRadioState());
radio.execute(); //radio on
radio.setState(new OffRadioState());
radio.execute(); //radio off

上面的示例用状态模式表示无线电的不同状态。

当我们需要表示对象内部发生变化的几种状态时,在不使用状态模式的情况下,代码会变得很僵硬,并带有if-else条件语句。

Java

给大家推荐一节高质量公开课,《零基础也能写出符合大厂规范的代码》点击课程名立即免费领取

课程内容包括:计算机和Java语言编写;变量和运算符的学习;流程控制和数组;讲解大厂的编程规范;综合案例分析。

以上就是开课吧广场小编为大家整理发布的“软件开发人员需要知晓的设计模式有哪些? ”一文,想要了解提升更多内容,前往开课吧广场-Java问答查看!

免责声明:本站所提供的内容均来源于网友提供或网络搜集,由本站编辑整理,仅供个人研究、交流学习使用。如涉及版权问题,请联系本站管理员予以更改或删除。
有用
分享