设计模式第一次作业

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

类图：

增加控制台日志记录后的类图：

代码：

//主函数
public static void main(String[] args) {
    LogFactory factory=new FileLogFactory();
    Log log=factory.createLog();
    log.writeLog();
}

//接口
public interface Log {  
    public void writeLog();  
}   
public interface LogFactory {  
    public Log createLog();  
}  


//文件
public class FileLog implements Log{  
    public void writeLog() {
        System.out.println("写文件日志");  
    }  
}  

public class FileLogFactory implements LogFactory{  
    public Log createLog() {    
        return new FileLog();  
    }  
}  


//数据库
public class DatabaseLog implements Log{  
    public void writeLog() {  
        System.out.println("写数据库日志");  
    }  
}   
  
public class DatabaseLogFactory implements LogFactory{  
    public Log createLog() { ;  
        return new DatabaseLog();  
    }  
}  

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

类图：

代码：

//主函数
public static void main(String[] args) {
    DatabaseFactory factory=new DB1Factory(); 
    Connection connection=factory.CreateConnection();
    Statement statement=factory.CreateStatement();
    connection.CreateConnection();
    statement.CreateStatement();
}

//抽象工厂类
public class abstract DatabaseFactory {
    public abstract Connection CreateConnection();
    public abstract Statement CreateStatement();
}

//statement对象类
public abstract class Statement {
    public  void CreateStatement();
}

//connection对象类
public abstract class Connection {
    public  void CreateConnection();
}

//DB1工厂类
public class DB1Factory implements DatabaseFactory{
	@Override
	public Connection CreateConnection() {
	    return new Connection1();
	}

	@Override
	public Statement CreateStatement() {
		return new Statement2();
	}
}

//DB1连接对象
public class Connection1 extends Connection{
	@Override
	public void CreateConnection() {
	    System.out.println("Connection");
	}
}
//DB1语句对象
public class Statement1 extends Statement{
	@Override
	public void CreateStatement() {
		System.out.println("Statement");
	}
}

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

类图：

代码：

//主函数
public static void main(String[] args) {
      Waiter waiter=newWaiter(mealBuilder);
      MealBuilder mealBuilder=new MealBuilder();
      waiter.setMealBuilder(mealBuilder);
      Meal meal=Waiter.construct();
}

/*Director*/
public class Waiter {
    private MealBuilder mealBuilder;
    public void setMealBuilder(MealBuilder mealBuilder){
	    this.mealBuilder=mealBuilder;  
    }
    public Meal construct(){
	    mealBuilder.BuildFood();
	    mealBuilder.BuildDrink();
	    return mealBuilder.getMeal();
    }
}


/* builder*/
public abstract class MealBuilder {
    protected Meal  meal=new Meal();
    public abstract void BuildFood();
    public abstract void BuildDrink();
    public Meal getMeal(){
	    return meal;
    }
}

//builderA
public class MealBuilderA extends MealBuilder{
	@Override
	public void BuildFood() {
		this.setFood("chicken");
	}
	@Override
	public void BuildDrink() {
		this.setDrink("coco");
	}
}

//产品
public class Meal {
    private String food;
    private String drink;
    public String getFood() {
	    return food;
    }
    public void setFood(String food) {
	    this.food = food;
    }
    public String getDrink() {
	    return drink;
    }
    public void setDrink(String drink) {
	    this.drink = drink;
    }
}

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

类图：

代码：

//Game
public class Game{
    RoleBuilder rolebuilder;
    MapBuilder mapbuilder;
    Map map;
    List<Role> RoleList;
    public void Game(RoleBuilder rb,MapBuilder mb){
        rolebuilder=rb;
        mapbuilder=mb;
        RoleList=new List<Role>();
    }
    public void BuildMap(){ 
        mapbuilder.buildBackground();
        mapbuilder.buildObstacle();
        map=mapbuilder.getMap();
    }
    public void AddRole(int type){
        if(type==0) rolebuilder=new Player();
        else rolebuilder=new Enemy();
        RoleList.Add(rolebuilder.GetRole());
    }
}

//builder
public class RoleBuilder{
    public Role role;
    public abstract void  buildeBody();
    public abstract void buildeWeapon();
    public abstract void buildeClothes();
    public Role getRole(){
        return role;
    }
}

//builder
public abstract class MapBuilder{
    private Map map;
    public abstract void builSky();
    public abstract void buildGround();
    public abstract void buildBackground();
    public Map getMap(){
        return map;
    }
}

//实体类
public class Map{
    private string sky; 
    private string ground;
    private string background;
    public void setSky(string sky) {this.sky = sky;}
    public string getSky() {return sky; }
    public void setGround(string ground){this.ground = ground;}
    public string getGround(){ return ground;}
    public void setBackGround(string background){this.background = background;}
    public string getBackGround(){return background;}
}

//实体类
public class Role{
    private string body;
    private string cloth;
    private string weapon;

    public void setBody(string body)
    {
        this.body = body;
    }
    public string getBody()
    {
        return body;
    }
    public void setCloth(string cloth)
    {
        this.cloth = cloth;
    }
    public string getCloth()
    {
        return cloth;
    }
    public void setWeapon(string weapon)
    {
        this.weapon= weapon;
    }
    public string getWeapon()
    {
        return weapon;
    } 
}

public class System:MapBuilder{
    public override void buildeBackground(){}
    public override void buildeGround(){}
    public override void buildeSky(){}
    public System(){
        buildeBackground();
        buildeGround();
        buildeSky();
    }
}


public class Player:RoleBuilder{
    public override void buildeClothes(){}
    public override void buildeBody(){}
    public override void buildeWeapon(){}
    public Player(){
        buildeBody();
        buildeClothes();
        buildeWeapon();
    }
}

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

类图：

代码：

//数据操作抽象类
public abstract class DataEncrypt{
    private String psw;
    public String PassWord{
        get { return psw; }
        set { psw = value; }
    }
    public abstract String Encrypt(String psw);
}
    
//加密适配器A
public class EncryptAdapter_A : DataEncrypt{
    Encrypt_A encrypt;
    public EncryptAdapter_A(){
        encrypt = new Encrypt_A();
    }
    public override string Encrypt(string psw){
        return encrypt.Encrypt(psw);
    }
}

//加密适配器B
public class EncryptAdapter_B : DataEncrypt{
    Encrypt_B encrypt;
    public EncryptAdapter_B()
    {
        encrypt = new Encrypt_B();
    }
    public override string Encrypt(string psw)
    {
        return encrypt.Encrypt(psw);
    }
}

//加密算法A
public class Encrypt_A{
    public String Encrypt(string psw){
        return "EncryptA";
    }
}
   
//加密算法B
public class Encrypt_B{
    public String Encrypt(string psw){
        return "EncriptB";
    }
}

//主函数
static void Main(string[] args){
    DataEncrypt data_en;
    data_en = new EncryptAdapter_A();
    data_en.PassWord = "helloworld";
    Console.WriteLine(data_en.Encrypt(data_en.PassWord));
    data_en = new EncryptAdapter_B();
    data_en.PassWord = "helloworld";
    Console.WriteLine(data_en.Encrypt(data_en.PassWord));
    return;
}