软件体系结构期末类图及代码总结

软件设计模式与体系结构这本书很多内容都比较杂，考试时进行了很长时间的整理，真的太累了，所以我想把我在学习过程中发现的问题和思考发上来，也算不白复习一次，哈哈。

书名：《软件设计模式与体系结构》高等教育出版社

创建型软件设计模式简单工厂模式

特点

只有一个工厂类静态工厂方法不满足开闭原则（OCP）

1.针对单产品的情况

public class Creator{
	public static Product factory(){
		return new ProductX();
	}
}


public interface Product{
	public void operation();//问题：为什么没写abstract
}


public class ProductX extends Product{
	public void operation(){}
}


class Client{
	public static void main(String[] args){
		Product p = Creator.factory();
		p.operation();
	}
}

2.针对多个产品（只需要改动一下factory的运作方式即可）

public class Creator{
	public static Product factory(String option){
		Product p = null;
		if(option.equals("ProductA"))
		p = new ProductA();
		else if(option.equals("ProductB"))
		p = new ProductB();
		//.....以下省略
		return p;
	}
}


public class Client{
	public static void main(String[] args){
		Product p = Creator.factory("ProductA");
		p.operation();
	}
}

问题回答：接口中的方法默认是抽象类型，不用写abstract

开闭原则：对扩展开放，对修改关闭

字符串判断是否相等的两种写法：

option.equals(“xxx”)：相等返回trueoption.compareTo(“xxx”)==0：相等返回0

静态方法特点：

归类所有（可以用类名直接访问该方法）只能访问类中的静态成员不能用this（this代表调用这个对象的引用，但静态方法是属于类的，不是对象）不自动销毁可以被继承，但不能被重写

工厂方法模式

特点

解决了增加新产品的问题(创建一个工厂和一个新产品即可)符合开闭原则一个工厂创建一个产品

public interface Creator{
	public Product factory();
}


public class CreatorA extends Creator{
	public Product factory(){
		return new ProductA();
	}
}


public class CreatorB extends Creator{
	public Product factory(){
		return new ProductB();
	}
}


public interface Product{
	public void operation();
}


public class ProductA extends Product{
	public void operation(){}
}


public class ProductB extends Product{
	public void operation(){}
}


public class Client{
	public static void main(String[] args){
		Creator c = new CreatorA();
		Product p = c.factory();
		p.operation();
	}
}

抽象工厂模式

特点

无法增加新产品，可增加新产品族一个工厂可以创建一个产品族的产品符合开闭原则（但加入getCreator会导致每次增加新产品族要重写一遍Creator,就不符合开闭原则了（笑））

public interface Creator{
	public Product factoryA();
	public Product factoryB();
}



public class Creator1 extends Creator{
	public Product factoryA(){
		return new ProductA1();
	}

	public Product factoryB(){
		return new ProductB1();
	}
}


public class Creator2 extends Creator{
	public Product factoryA(){
		return new ProductA2();
	}

	public Product factoryB(){
		return new ProductB2();
	}
}


//这是不重要的第一坨
public interface ProductA{
	public void operation();
}

public class ProductA1 extends ProductA{
	public void operation(){}
}

public class ProductA2 extends ProductA{
	public void operation(){}
}


//第二坨，简单看，快速过
public interface ProductB{
	public void operation();
}

public class ProductB1 extends ProductB{
	public void operation(){}
}

public class ProductB2 extends ProductB{
	public void operation(){}
}


public class Client{
	public static void main(String[] args){
		Creator c1 = new Creator1();
		ProductA pa = c1.factoryA();
		ProductB pb = c1.factoryB();
		
	}
}

interface可以有的组成部分：
1.抽象方法
2.常量
3.默认方法（JDK8）
4.静态方法（JDK8）//据我观察，这个书应该使用的是JDK8版本，所以在使用静态方法的时候要注意
5.私有方法（JDK9）
//这里引用了这条链接：接口中可以包含的组成部分，里面有详细说明，感兴趣的可以去看一下。

abstract组成：抽象方法和非抽象方法都可以有，也可以没有抽象方法

单例模式

原理：确保一个类仅有一个唯一的实例，并且提供一个全局的访问点特点

私有的构造方法提供静态共有方法getInstance()提供私有属性，静态类型，指向本类对象 1. 饿汉式解析：饿汉很饿，所以上来就new了一个大面包（Singleton实例），每次要吃的时候只要getInstance就能直接获取这个面包

public class Singleton{
	private static Singelton instance = new Singleton();
	private Singleton(){}
	public static Singleton getInstance(){
		return instance;
	}
}


public class Client{
	public static void main(String[] args){
		Singleton c1 = Singleton.getInstance();
	}
}

2. 懒汉式解析：懒汉很懒，所以懒汉只有在真的饿的不行的时候才new个面包吃

public class Singleton{
	private static Singelton instance = null;
	private Singleton(){}
	public static Singleton synchronized getInstance(){//问题：为什么使用synchronized？
		if(instance == null)
		instance = new Singleton();
		return instance;
	}
}


public class Client{
	public static void main(String[] args){
		Singleton c1 = Singleton.getInstance();
	}
}

懒汉式特点：线程安全

问题回答：synchronized用于同步，即确保每个执行该方法的线程只有在彻底执行完之后，才允许第二个线程执行

3. 静态内部类

public class Singelton{
	private Singelton(){}
	private static class Inner{
		private static final Singelton instance = new Singleton();
	}
	public static Singleton getInstance(){
		return instance;
	}
}

静态内部类：当外部类被加载时，不会创建instance实例对象，只有在调用getInstance方法时，Inner类被加载，instance才会被创建。

原型模式（简单记一下就可） 1. 原理：通过复制一个已经存在的实例来获得新的实例 2. 实现方法：

 （1）浅复制--引用复制：
			Type t1 = new Type();
			Type t2 = (Type)t1.clone()
 （1）深复制--对象复制：
 			s.birthday = (Date)this.birthday.clone();

之后的在施工中，暂时别看 建造者/生成器模式

原理：由Director指导Builder进行生产制造

聚合（空心菱角）：
一堆对一个，准确说是整体和个体
eg:班级和学生
组合（实心菱角）：
一对一，一种强拥有关系，*不能更换
eg:鸟和翅膀

public class Director{
	private Builder b = null;
	public void setBuilder(String option){
		if(option.equals("Builder1"))
		b = new Builder1();
		else if(option.equals("Builder2"))
		b = new Builder2();
	}	

	public void construct(){
		b.createComponentA();
		b.createComponentB();
	}
	
	public void getProduct(){
		return b.getObject();
	}
}
		
	
public interface Builder{
	public void createComponentA();	
	public void createComponentB();
	public Product getObject();
}

public class Builder1 extends Builder{//这里书上写的有点奇怪，我没查到构造器里面能写函数的知识点，就按自己理解改了一下，如果谁知道咋回事评论区@我
	private Product c = new Product();
	public void createComponentA(){}//不重要，就是调用Product的set方法设置参数
	public void createComponentB(){}
	public Product getObject(){
		return c；
	}
}

public class Builder2 extends Builder{
	private Product c = new Product();
	public void createComponentA();	
	public void createComponentB();
	public Product getObject(){
		return c；
	}
}

public class Product{//考试时不用写，仅供了解
	private String componentA;
	private String componentB;
	
	public setComponentA(String s){
	componentA = s;
	}
	public setComponentB(String s){
	componentB = s;
	}
	//...get方法

	public void operation(){}
}

public class Client{
	public static void main(String[] args){
		Director d = new Director();
		d.setBuilder("Builder1");
		d.construct();
		Product p = d.getProduct();
		p.operation();
	}
}

结构型软件设计模式组合模式

桥接模式

适配器模式装饰者模式行为型软件设计模式访问者模式策略模式状态模式观察者模式

软件体系结构期末类图及代码总结

Java相关栏目本月热门文章