java设计模式常用的有哪些?

TheDisguiser 2020-08-21 16:53:00 java常见问答 7938

选择适合的设计模式是写出一套优秀代码的根本,本篇文章小编就将带大家详细了解java中各种常见的设计模式。

单例模式

这是最常见的一种,单例设计是指一个类只允许产生一个实例化对象。

它也是最好理解的一种设计模式,分为懒汉式和饿汉式。

饿汉式:构造方法私有化,外部无法产生新的实例化对象,只能通过static方法取得实例化对象

class Singleton
{
    /**
     * 在类的内部可以访问私有结构,所以可以在类的内部产生实例化对象
     */
    private static Singleton instance = new Singleton();
    /**
     * private 声明构造
     */
    private Singleton()
    {}
    /**
     * 返回对象实例
     */
    public static Singleton getInstance()
    {
        return instance;
    }
    public void print()
    {
        System.out.println("Hello Singleton...");
    }
}

懒汉式:当第一次去使用Singleton对象的时候才会为其产生实例化对象的操作

class Singleton
{
    /**
     * 声明变量
     */
    private static volatile Singleton singleton = null;
    /**
     * 私有构造方法
     */
    private Singleton()
    {}
    /**
     * 提供对外方法
     * @return 
     */
    public static Singleton getInstance()
    {
        // 还未实例化
        if (singleton == null)
        {
            synchronized(Singleton.class)
            {
                if (singleton == null)
                {
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
    public void print()
    {
        System.out.println("Hello World");
    }
}

工厂模式

interface Sender
{
    void Send();
}
class MailSender implements Sender
{
    @Override
    public void Send()
    {
        System.out.println("This is mail sender...");
    }
}
class SmsSender implements Sender
{
    @Override
    public void Send()
    {
        System.out.println("This is sms sender...");
    }
}
public class FactoryPattern
{
    public static void main(String[] args)
    {
        Sender sender = produce("mail");
        sender.Send();
    }
    public static Sender produce(String str)
    {
        if ("mail".equals(str))
        {
            return new MailSender();
        }
        else if ("sms".equals(str))
        {
            return new SmsSender();
        }
        else
        {
            System.out.println("输入错误...");
            return null;
        }
    }
}

装饰模式

interface Shape
{
    void draw();
}
/**
 * 实现接口的实体类
 */
class Rectangle implements Shape
{
    @Override
    public void draw()
    {
        System.out.println("Shape: Rectangle...");
    }
}
class Circle implements Shape
{
    @Override
    public void draw()
    {
        System.out.println("Shape: Circle...");
    }
}
/**
 * 创建实现了 Shape 接口的抽象装饰类。
 */
abstract class ShapeDecorator implements Shape
{
    protected Shape decoratedShape;
    public ShapeDecorator(Shape decoratedShape)
    {
        this.decoratedShape = decoratedShape;
    }
    @Override
    public void draw()
    {
        decoratedShape.draw();
    }
}
/**
 *  创建扩展自 ShapeDecorator 类的实体装饰类。
 */
class RedShapeDecorator extends ShapeDecorator
{
    public RedShapeDecorator(Shape decoratedShape)
    {
        super(decoratedShape);
    }
    @Override
    public void draw()
    {
        decoratedShape.draw();
        setRedBorder(decoratedShape);
    }
    private void setRedBorder(Shape decoratedShape)
    {
        System.out.println("Border Color: Red");
    }
}
/**
 * 使用 RedShapeDecorator 来装饰 Shape 对象。
 */
public class DecoratorPattern
{
    public static void main(String[] args)
    {
        Shape circle = new Circle();
        Shape redCircle = new RedShapeDecorator(new Circle());
        Shape redRectangle = new RedShapeDecorator(new Rectangle());
        System.out.println("Circle with normal border");
        circle.draw();
        System.out.println("\nCircle of red border");
        redCircle.draw();
        System.out.println("\nRectangle of red border");
        redRectangle.draw();
    }
}

策略模式

策略模式中定义了一系列算法,并把每个算法封装起来,使它们可以相互替换,且算法的变化不会影响到使用算法的客户。

/**
 * 抽象算法的策略类,定义所有支持的算法的公共接口
 */
abstract class Strategy
{
    /**
     * 算法方法
     */
    public abstract void AlgorithmInterface();
}
/**
 * 具体算法A
 */
class ConcreteStrategyA extends Strategy
{
    //算法A实现方法
    @Override
    public void AlgorithmInterface()
    {
        System.out.println("算法A的实现");
    }
}
/**
 * 具体算法B
 */
class ConcreteStrategyB extends Strategy
{
    /**
     * 算法B实现方法
     */
    @Override
    public void AlgorithmInterface()
    {
        System.out.println("算法B的实现");
    }
}
/**
 * 具体算法C
 */
class ConcreteStrategyC extends Strategy
{
    @Override
    public void AlgorithmInterface()
    {
        System.out.println("算法C的实现");
    }
}
/**
 * 上下文,维护一个对策略类对象的引用
 */
class Context
{
    Strategy strategy;
    public Context(Strategy strategy)
    {
        this.strategy = strategy;
    }
    public void contextInterface()
    {
        strategy.AlgorithmInterface();
    }
}
/**
 * 客户端代码:实现不同的策略
 */
public class StrategyPattern
{
    public static void main(String[] args)
    {
        Context context;
        context = new Context(new ConcreteStrategyA());
        context.contextInterface();
        context = new Context(new ConcreteStrategyB());
        context.contextInterface();
        context = new Context(new ConcreteStrategyC());
        context.contextInterface();
    }
}

桥接模式

interface DrawAPI
{
    public void drawCircle(int radius, int x, int y);
}
class RedCircle implements DrawAPI
{
    @Override
    public void drawCircle(int radius, int x, int y)
    {
        System.out.println("Drawing Circle[ color: red, radius: " +
            radius + ", x: " + x + ", " + y + "]");
    }
}
class GreenCircle implements DrawAPI
{
    @Override
    public void drawCircle(int radius, int x, int y)
    {
        System.out.println("Drawing Circle[ color: green, radius: " +
            radius + ", x: " + x + ", " + y + "]");
    }
}
abstract class Shape
{
    protected DrawAPI drawAPI;
    protected Shape(DrawAPI drawAPI)
    {
        this.drawAPI = drawAPI;
    }
    public abstract void draw();
}
class Circle extends Shape
{
    private int x, y, radius;
    public Circle(int x, int y, int radius, DrawAPI drawAPI)
    {
        super(drawAPI);
        this.x = x;
        this.y = y;
        this.radius = radius;
    }
    public void draw()
    {
        drawAPI.drawCircle(radius, x, y);
    }
}
//客户端使用代码
Shape redCircle = new Circle(100, 100, 10, new RedCircle());
Shape greenCircle = new Circle(100, 100, 10, new GreenCircle());
redCircle.draw();
greenCircle.draw();

以上就是本篇文章的所有内容,更多详细java入门知识敬请关注本站了解详情。

推荐阅读:

微服务架构设计模式有哪些?有什么好处?

java多线程设计模式怎么实现?

MVC设计模式是什么?MVC框架是什么?