在Java开发中，多态性是一种非常重要的特性，它可以让我们以一种统一的方式处理不同类型的对象。设计模式是一种被广泛应用的软件设计方法，它可以帮助我们解决常见的设计问题。本文将结合Java多态性和设计模式的概念，介绍几种常见的设计模式，并通过代码演示来说明它们的用法。

1. 策略模式

策略模式是一种行为型设计模式，它定义了一系列的算法，并将每个算法封装在独立的类中，使它们可以相互替换。通过使用策略模式，我们可以在运行时动态地选择具体的算法实现，而不需要在代码中显式地使用条件语句。

下面是一个使用策略模式的例子。假设我们需要编写一个图形绘制程序，支持绘制圆形和矩形。我们可以定义一个抽象的图形类，并在其中定义一个抽象的绘制方法。然后，我们可以为圆形和矩形分别实现具体的绘制方法。最后，在客户端代码中，我们可以根据需要选择具体的绘制算法。 


public abstract class Shape {
    public abstract void draw();
}

public class Circle extends Shape {
    public void draw() {
        System.out.println("绘制圆形");
    }
}

public class Rectangle extends Shape {
    public void draw() {
        System.out.println("绘制矩形");
    }
}

public class Client {
    public static void main(String[] args) {
        Shape shape = new Circle();
        shape.draw();
        
        shape = new Rectangle();
        shape.draw();
    }
}

在上面的例子中，我们通过继承抽象类Shape并实现draw方法来定义具体的绘制算法。然后，在客户端代码中，我们可以根据需要创建Circle或Rectangle的实例，并调用draw方法进行绘制。这种方式可以让我们动态地选择绘制算法，而无需在客户端代码中使用条件语句。

2. 工厂模式

工厂模式是一种创建型设计模式，它定义了一个用于创建对象的接口，但将具体的创建逻辑延迟到子类中。通过使用工厂模式，我们可以将对象的创建与使用解耦，使代码更加灵活和可扩展。

下面是一个使用工厂模式的例子。假设我们需要创建不同类型的图形对象，例如圆形和矩形。我们可以定义一个抽象的图形工厂类，并在其中定义一个用于创建图形对象的工厂方法。然后，我们可以为圆形和矩形分别实现具体的图形工厂类。最后，在客户端代码中，我们可以通过调用工厂方法来创建具体的图形对象。 


public abstract class Shape {
    public abstract void draw();
}

public class Circle extends Shape {
    public void draw() {
        System.out.println("绘制圆形");
    }
}

public class Rectangle extends Shape {
    public void draw() {
        System.out.println("绘制矩形");
    }
}

public abstract class ShapeFactory {
    public abstract Shape createShape();
}

public class CircleFactory extends ShapeFactory {
    public Shape createShape() {
        return new Circle();
    }
}

public class RectangleFactory extends ShapeFactory {
    public Shape createShape() {
        return new Rectangle();
    }
}

public class Client {
    public static void main(String[] args) {
        ShapeFactory factory = new CircleFactory();
        Shape shape = factory.createShape();
        shape.draw();
        
        factory = new RectangleFactory();
        shape = factory.createShape();
        shape.draw();
    }
}

在上面的例子中，我们通过继承抽象类ShapeFactory并实现createShape方法来定义具体的图形工厂类。然后，在客户端代码中，我们可以根据需要创建CircleFactory或RectangleFactory的实例，并调用createShape方法来创建具体的图形对象。这种方式可以将对象的创建与使用解耦，使代码更加灵活和可扩展。

3. 观察者模式

观察者模式是一种行为型设计模式，它定义了一种一对多的依赖关系，使多个观察者对象能够同时监听某个主题对象的状态变化。通过使用观察者模式，我们可以实现对象之间的松耦合，使其更易于维护和扩展。

下面是一个使用观察者模式的例子。假设我们需要实现一个简单的气象站程序，可以实时地获取温度和湿度数据，并将其显示在不同的观察者界面上。我们可以定义一个抽象的主题类，并在其中定义添加和删除观察者、通知观察者等方法。然后，我们可以为具体的观察者界面实现具体的观察者类。最后，在客户端代码中，我们可以创建主题对象，并添加多个观察者，以实现数据的实时更新。 


import java.util.ArrayList;
import java.util.List;

public abstract class Subject {
    private List observers = new ArrayList<>();

    public void addObserver(Observer observer) {
        observers.add(observer);
    }

    public void removeObserver(Observer observer) {
        observers.remove(observer);
    }

    public void notifyObservers() {
        for (Observer observer : observers) {
            observer.update();
        }
    }
}

public interface Observer {
    void update();
}

public class TemperatureDisplay implements Observer {
    public void update() {
        System.out.println("温度数据更新");
    }
}

public class HumidityDisplay implements Observer {
    public void update() {
        System.out.println("湿度数据更新");
    }
}

public class WeatherStation extends Subject {
    public void dataChanged() {
        System.out.println("数据发生变化");
        notifyObservers();
    }
}

public class Client {
    public static void main(String[] args) {
        WeatherStation station = new WeatherStation();
        station.addObserver(new TemperatureDisplay());
        station.addObserver(new HumidityDisplay());
        
        station.dataChanged();
    }
}

在上面的例子中，我们通过继承抽象类Subject并实现Observer接口来定义具体的主题类和观察者类。然后，在客户端代码中，我们可以创建主题对象WeatherStation，并添加多个观察者TemperatureDisplay和HumidityDisplay。当数据发生变化时，主题对象会通知所有的观察者进行更新。这种方式可以实现对象之间的松耦合，使其更易于维护和扩展。

4. 单例模式

单例模式是一种创建型设计模式，它保证一个类只有一个实例，并提供一个全局的访问点。通过使用单例模式，我们可以在整个应用程序中共享一个对象，而不需要重复创建多个实例。

下面是一个使用单例模式的例子。假设我们需要创建一个日志记录器，用于记录应用程序的运行日志。由于日志记录器是一个全局的对象，我们希望在整个应用程序中共享同一个实例。我们可以使用单例模式来实现这个需求。 


public class Logger {
    private static Logger instance;
    private String log;

    private Logger() {
        log = "";
    }

    public static Logger getInstance() {
        if (instance == null) {
            instance = new Logger();
        }
        return instance;
    }

    public void appendLog(String message) {
        log += message + "\n";
    }

    public void printLog() {
        System.out.println(log);
    }
}

public class Client {
    public static void main(String[] args) {
        Logger logger = Logger.getInstance();
        logger.appendLog("日志信息1");
        logger.appendLog("日志信息2");
        logger.printLog();
    }
}

在上面的例子中，我们使用私有的构造函数和静态的getInstance方法来创建日志记录器的实例，并提供一个全局的访问点。当需要使用日志记录器时，我们可以通过调用getInstance方法来获取实例，并调用相应的方法进行日志的追加和打印。这种方式可以保证在整个应用程序中共享同一个日志记录器实例，而不需要重复创建多个实例。