设计模式第一次作业

1、要求：某系统日志记录器要求支持多种日志记录方式，如文件记录、数据库记录等；用户可以根据要求动态选择日志记录方式。使用Factory模式来设计；如果系统中增加一个日志记录方式—控制台日志记录（ConsoleLog），类图将如何改变？

工厂方法模式

类图

//日志类
abstract class Log
{
    function __construct($pa)
    {

    }
}

class Logger_file extends Log
{
    function __construct($pa)
    {

    }
}

class Logger_database extends Log
{
    function __construct($pa)
    {

    }
}

//工厂类

//创建工厂接口
interface FactoryLog
{
    function logSytle();
}

//创建文件记录的方式
class FactoryFileLog implements FactoryLog
{
    function logSytle($type)
    {
        return new Logger_file();
    }
}

//创建数据库记录的方式
class FactoryDatabaseLog implements FactoryLog
{
    function logSytle($type)
    {
        return new Logger_database();
    }
}

//客户类
class User
{
    private $Log;
    function selectLogStyle($type)
    {
        switch ($type)
        {
            case file:
                $Logger_file = new FactoryFileLog();
                return $Logger_file->logSytle();
            case database:
                $Logger_database = new FactoryDatabaseLog();
                return $Logger_database->logSytle();
        }
    }
}

2、要求：某系统为了改进数据库操作的性能，自定义数据连接对象Connection和语句对象Statement，可针对不同类型的数据库提供不同的连接对象和语句对象；用户可以通过配置文件等方式根据实际需要动态更换系统数据库；使用Abstract Factory模式来设计。

• 抽象工厂模式

类图

//类型
abstract class Style
{
    function __construct($pa)
    {

    }
}

class Connection extends Style
{
    function __construct($pa)
    {

    }
}

class Statement extends Style
{
    function __construct($pa)
    {

    }
}

//工厂类

//创建工厂接口
interface FactoryStyle
{
    function selSytle();
}

//创建文件记录的方式
class ConnectionF implements FactoryStyle
{
    function selSytle($type)
    {
        return new ConnectionF();
    }
}

//创建数据库记录的方式
class StatementF implements FactoryStyle
{
    function selSytle($type)
    {
        return new StatementF();
    }
}

//客户类
class User
{
    private $Style;
    function selectStyle($type)
    {
        $class = new ReflectionClass('FactoryStyle'.$type);
        $instance = $class->newInstance();
        $this->Style = $instance->Sytle();
    }
}

3、要求：KFC套餐是一个复杂对象，一般包括主食（如汉堡、鸡肉卷等）和饮料（如果汁、可乐等）组成部分，不同套餐有不同组成部分；KFC服务员要根据顾客要求，装配这些组成部分，构造一个完整套餐，返回给顾客；使用Builder模式来设计。

类图

Builder

public abstract class Builder
{
    public abstract void buildFood();
    public abstract void buildDrink();

    public abstract Product GetProduct();
}

Product

import java.util.*;

public class Product
{
    private List<String> parts = new ArrayList<String>();

    public void Add(String part)
    {
        parts.add(part);
    }
    public void Show()
    {
        for(int i = 0;i < parts.size();i++)
        {
            System.out.println("食品："+parts.get(i));
        }

        System.out.println("食品套餐已备好！");
    }
}

Director

public class Director
{
    public void Construct(Builder builder)
    {
        builder.buildFood();
        builder.buildDrink();
    }
}

ConcreteBuilder

public class ConcreteBuilder extends Builder
{
    Product product = new Product();

    @Override
    public void buildFood()
    {
        product.Add("组装Food");
    }

    @Override
    public void buildDrink()
    {
        product.Add("组装Drink");
    }

    @Override
    public Product GetProduct()
    {
        return product;
    }
}

Pattern

public class Pattern
{
    public static void main(String[] args) 
    {
        Director director = new Director();
        Builder builder = new ConcreteBuilder();

        director.Construct(builder);

        Product product = builder.GetProduct();

        product.Show();
    }
}

4、要求：游戏中的地图：包括天空、地面、背景；人物包括人体、服装、装备等组成部分，如采用Builder模式如何设计？

类图

builder

public abstract class AbstractBuilder {
    public abstract void buildPartA();
    public abstract void buildPartB();
    public abstract void buildPartC();
    public abstract Product getProduct();
}

ConcreteBuilder

public class ConcreteBuilderA extends AbstractBuilder{
    private Product product = new Product();
    @Override
    public void buildPartA() {
        product.setPartA("A");
    }

    @Override
    public void buildPartB() {
        product.setPartB("B");
    }

    @Override
    public void buildPartC() {
        product.setPartA("C");
    }

    @Override
    public Product getProduct() {
        return product;
    }
}

Product

public class Product {
    private String partA;
    private String partB;
    private String partC;

    public String getPartA() {
        return partA;
    }

    public void setPartA(String partA) {
        this.partA = partA;
    }

    public String getPartB() {
        return partB;
    }

    public void setPartB(String partB) {
        this.partB = partB;
    }

    public String getPartC() {
        return partC;
    }

    public void setPartC(String partC) {
        this.partC = partC;
    }
}

Director

public class Director {
    private AbstractBuilder builderA;

    public Director(AbstractBuilder builderA) {
        this.builderA = builderA;
    }

    public Product getProductA() {
        this.builderA.buildPartA();
        this.builderA.buildPartB();
        this.builderA.buildPartC();
        return this.builderA.getProduct();
    }

}

Client

public class Client {
    public static void main(String[] args) {
        System.out.println("利用Director类获得不同组装方式的产品A");
        ConcreteBuilderA builderA = new ConcreteBuilderA();
        Director director = new Director(builderA);
        director.getProductA();
    }
}

5、某系统需要提供一个加密模块，将用户信息（如密码等）加密之后再存储在数据库中，系统已经定义好数据库操作类。为了提高开发效率，现要重用已有的加密算法，这些算法由第三方提供，没有源码。如采用Adapter模式如何设计？

Adapter

public class EncryptionAdapter extends Encryption {
    private ThirdPartyEncryption adaptee;

    public EncryptionAdapter(ThirdPartyEncryption adaptee) {
        this.adaptee = adaptee;
    }

    @Override
    public String encrypt(String str) {
        return adaptee.encrypt(str);
    }
}

转载于:https://www.cnblogs.com/maskerk/p/7770571.html