两种设计模式运用到一段程序中
设计模式是指在软件设计中，针对一些经常出现的问题，总结出一些通用性的解决方案。它是软件开发中的一种可复用的设计，通常为某个问题提供了一个清晰、明确的解决方案，使开发者能够在设计和开发过程中更加高效地完成工作。在本文中，我们将会讨论两种设计模式的应用——工厂模式和观察者模式。
工厂模式是一种创建对象的模式，它提供了一种依赖于接口的途径，以便在创建对象时能够将接口的实现类与应用程序的代码分离。可以将对象的创建委托给工厂类，从而达到了将代码解耦的目的。在这种模式下，我们需要一个工厂类，一个基础接口和它的实现类。下面就是一个创建人的例子：
首先建立Person接口的代码。
```java
public interface Person {
void sayHello();
}
```
然后我们在接口中规定了一个方法。
接着，实现Person接口的两个实现类——Male和Female：
```java
public class Male implements Person {
@Override
public void sayHello() {
System.out.println("Hello, I'm a Male.");
}
}
```
```java
public class Female implements Person {
@Override
public void sayHello() {
System.out.println("Hello, I'm a Female.");
}
}
```
这里，我们实例化了两个不同的人，一个是男性，一个是女性。代码如下：
```java
public class PersonFactory {
public Person createPerson(String gender) {
if ("male".equals(gender.toLowerCase())) {
return new Male();
} else if ("female".equals(gender.toLowerCase())) {
return new Female();
} else {
return null;
}
}
}
```
注意，在createPerson()方法中，我们根据参数gender决定创建哪个对象并返回。这种方法可以使代码更加灵活，同时也更加易于维护。
接下来，我们来介绍第二个设计模式：观察者模式。观察者模式是一种行为型设计模式，它定义了一种一对多的依赖关系，使得当对象发生改变时，所有依赖于它的对象都会得到通知并自动更新。观察者模式可以增加应用程序的灵活性和可重用性，能够增加对象之间的松耦合性，因此广泛应用于Java编程。
下面是一个发布订阅例子，其中发布者对象将通知它关注的订阅者对象。
```java
import java.util.ArrayList;
import java.util.List;
public class Publisher implements IPublisher {
private List
@Override
public void subscribe(ISubscriber subscriber) {
subscribers.add(subscriber);
}
@Override
public void unsubscribe(ISubscriber subscriber) {
subscribers.remove(subscriber);
}
@Override
public void notifySubscribers(String message) {
for (ISubscriber subscriber : subscribers) {
subscriber.update(message);
}
}
}
```
我们在Publisher类中定义了一个subscribe()方法，当订阅者关注发布者时，它将订阅者加入到一个数组中。unsubscribe()方法将已关注者从数组中移除。最后，notifySubscribers()方法通过对数组中每个元素进行遍历的方式，通知所有已关注者。
现在我们将上述两种设计模式结合起来，写一个程序。假设我们需要设计一个动物园类，它需要向访问者介绍动物。我们将使用工厂模式制作具有不同特征的动物，然后通过观察者模式实现访问者对这些动物的观察和介绍。
首先定义Animal接口，代码如下：
```java
public interface Animal {
void introduce();
}
```
然后创建AbstractAnimal类作为Animal接口实现的抽象类。
```java
public abstract class AbstractAnimal implements Animal {
private String name;
private String color;
private int age;
AbstractAnimal(String name, String color, int age) {
this.name = name;
this.color = color;
this.age = age;
}
@Override
public void introduce() {
System.out.println("My name is " + name + " .");
System.out.println("I am " + color + " .");
System.out.println("I am " + age + " years old.");
}
}
```
这里，我们将名字，颜色和年龄等信息作为动物的特征，在AbstractAnimal类中进行实现。
ExampleDog是一个实现了Animal接口的狗类，包含三个构造方法，可以通过这些构造方法来设置具有不同特征的狗。
```java
public class ExampleDog extends AbstractAnimal {
public ExampleDog(String name) {
super(name, "black", 3);
}
public ExampleDog(String name, String color) {
super(name, color, 2);
}
public ExampleDog(String name, String color, int age) {
super(name, color, age);
}
}
```
接着，我们创建一个动物访问者类：
```java
public class AnimalObserver implements Observer {
@Override
public void update(Observable o, Object arg) {
if (arg == null) {
System.out.println("No new animals arrived.");
return;
}
Animal animal = (Animal) arg;
animal.introduce();
}
}
```
AnimalObserver实现了Observer接口，当动物园有新的动物时，它将更新动物清单。
在Main类中，我们可以通过让Animal对象继承AbstractAnimal类并设置不同属性，创建具有不同特征的动物。然后通过Observable和Observer基类，将这些动物传递给访问者们进行观察。
程序核心代码如下：
```java
public class Main {
public static void main(String[] args) {
Animal dogs = (new ExampleDog("Jack"));
Observable zoo = new Zoo(dogs);
Observer guestA = new AnimalObserver();
zoo.addObserver(guestA);
zoo.notifyObservers();
dogs = new ExampleDog("Lucy", "brown");
zoo = new Zoo(dogs);
zoo.addObserver(guestA);
zoo.notifyObservers();
dogs = new ExampleDog("Tom", "white", 5);
zoo = new Zoo(dogs);
zoo.addObserver(guestA);
zoo.notifyObservers();
}
}
```
以上就是结合工厂模式和观察者模式所写的程序。当我们使用工厂模式创建动物对象时，我们可以轻松地实现不同特征的动物。这些动物可以很容易地被添加到动物园中，观察者们可视化这些动物，并在新动物到来时及时向游客们展示。
