设计模式是软件开发中经常用到的一种解决问题的方法。在Java编程中，设计模式是一个非常重要的概念。在我的Java编程经历中，我学习了许多有用的设计模式，并在我的代码实现中使用了它们。在本文中，我将介绍三个常用的Java设计模式和它们的代码实现。

1. 工厂模式

工厂模式是一种创建设计模式，它通过工厂方法来创建对象，并将对象的创建过程隐藏在该方法中。这种模式通常用于创建复杂的对象，而在代码实现中使用简单的接口。下面是一个简单的工厂模式示例:

public interface Shape {
  void draw();
}
public class Rectangle implements Shape {
  @Override
  public void draw() {
   System.out.println("Drawing Rectangle");
  }
}
public class Square implements Shape {
  @Override
  public void draw() {
   System.out.println("Drawing Square");
  }
}
public class ShapeFactory {
  public Shape getShape(String shapeType){
   if(shapeType == null)
     return null;
       
   if(shapeType.equalsIgnoreCase("RECTANGLE")){
     return new Rectangle();
   } else if(shapeType.equalsIgnoreCase("SQUARE")){
     return new Square();
   }
   return null;
  }
}
public class FactoryPatternDemo {
  public static void main(String[] args) {
   ShapeFactory shapeFactory = new ShapeFactory();
   Shape shape1 = shapeFactory.getShape("RECTANGLE");
   shape1.draw();
   
   Shape shape2 = shapeFactory.getShape("SQUARE");
   shape2.draw();
  }
}

2. 观察者模式

观察者模式是一种行为设计模式，用于在对象之间建立发布-订阅关系。在此模式中，一个或多个对象（称为观察者）监视另一个对象（称为主题）并在主题发生更改时自动接收通知。下面是一个简单的观察者模式示例：

public class Subject {
  private List
  observers = new ArrayList 
  
   ();
  
 
  private int state;
  public int getState()
   return state;
 
  public void setState(int state) {
   this.state = state;
   notifyAllObservers();
  }
  public void attach(Observer observer){
   observers.add(observer);   
  }
  public void notifyAllObservers(){
   for (Observer observer : observers) {
     observer.update();
   }
  } 
}
public abstract class Observer {
  protected Subject subject;
  public abstract void update();
}
public class BinaryObserver extends Observer{
  public BinaryObserver(Subject subject){
   this.subject = subject;
   this.subject.attach(this);
  }
  @Override
  public void update() {
   System.out.println( "Binary String: "
   + Integer.toBinaryString( subject.getState() ) );
  }
}
public class OctalObserver extends Observer{
  public OctalObserver(Subject subject){
   this.subject = subject;
   this.subject.attach(this);
  }
  @Override
  public void update() {
   System.out.println( "Octal String: "
   + Integer.toOctalString( subject.getState() ) );
  }
}
public class HexaObserver extends Observer{
  public HexaObserver(Subject subject){
   this.subject = subject;
   this.subject.attach(this);
  }
  @Override
  public void update() {
   System.out.println( "Hex String: "
   + Integer.toHexString( subject.getState() ).toUpperCase() );
  }
}
public class ObserverPatternDemo {
  public static void main(String[] args) {
   Subject subject = new Subject();
   new HexaObserver(subject);
   new OctalObserver(subject);
   new BinaryObserver(subject);
   System.out.println("First state change: 15");  
   subject.setState(15);
   System.out.println("Second state change: 10");  
   subject.setState(10);
  }
}

3. 单例模式

单例模式是一种创造设计模式，该模式确保只有一个类的单个实例，并提供全局访问该实例的方式。单例是一种节省资源的方法，因为它避免了重复的实例化过程。下面是一个简单的单例模式示例：

public class Singleton {
  private static Singleton instance = new Singleton();
  private Singleton(){}
  public static Singleton getInstance()
   return instance;
 
  public void showMessage(){
   System.out.println("Hello World!");
  }
}
public class SingletonPatternDemo {
  public static void main(String[] args) {
   Singleton object = Singleton.getInstance();
   object.showMessage();
  }
}

综上所述，工厂模式、观察者模式和单例模式是Java编程中最常用的设计模式之一。通过使用这些模式，我们可以更好地组织我们的代码，并更有效地解决程序设计中的问题。在实际的应用程序开发中，我们应考虑使用这些模式，以提高代码的可维护性和可扩展性。

相似文章
• ECMAScript和 Javascript的关系
  ECMAScript和 Javascript的关系
  
  

友情链接
• 网站定制开发
• 帮你发
• 小蓄群站获客
• 雅圣洁家政