精华内容
下载资源
问答
  • 软件体系结构与设计模式笔记专门摘录重点
  • 软件体系结构与设计模式_复习
  • 适用于大学生期末考试(软件体系结构)。软件体系结构是具有一定形式的结构化元素,即构件的集合,包括处理构件、数据构件和连接构件。处理构件负责对数据进行加工,数据构件是被加工的信息,连接构件把体系结构的...
  • 定义对象间的一种一对多的依赖关系,当一个对象的状态发生变化时,所有依赖于它的对象都得到通知并被自动更新。
  • MVC设计模式 模型层: 数据对象封装 model.bean/domain 数据库操作类 model.dao 数据库 model.db 视图层: 相关工具类 view.utils 自定义view view.ui 控制层 应用界面相关 controller.activity ...

    MVC设计模式

    MVC是常用的设计模式之一,将整个程序分为三个层次:视图模型层,控制器层,数据模型层。这种将程序输入输出、数据处理,以及数据的展示分离开来的设计模式,使程序结构变的灵活而且清晰,同时也描述了程序各个对象间的通信方式,降低了程序的耦合性。

    在这里插入图片描述

    在这里插入图片描述

    1. 模型层(model):主要处理数据

    数据对象封装 model.bean/domain
    数据库操作类 model.dao
    数据库 model.db

    2. 控制层(controller):处理业务逻辑

    应用界面相关 controller.activity
    存放fragment controller.fragment
    显示列表的适配器 controller.adapter
    服务相关的 controller.service
    抽取的基类 controller.base

    3. 视图层(view):显示数据

    相关工具类 view.utils
    自定义view view.ui


    4. 案例:新手项目(客户信息管理系统)

    • 大体需求:【该系统能够实现对客户对象的插入、修改和删除(用数组实现),并能够打印客户明细表】
    • 每个客户的信息被保存在Customer对象中;
    • 以一个Customer类型的数组来记录当前所有的客户;
    • 每次“添加客户”(菜单1)后,客户(Customer)对象被添加到数组中;
    • 每次“修改客户”(菜单2)后,修改后的客户(Customer)对象替换数组中原对 - 象;
    • 每次“删除客户”(菜单3)后,客户(Customer)对象被从数组中清除;
    • 执行“客户列表”(菜单4)时,将列出数组中所有客户的信息;

    • CustomerView 为主模块,负责菜单的显示和处理用户操作
    • CustomerList 为Customer对象的管理模块,内部用数组管理一组Customer对象,并提供相应的添加、修改、删除和遍历方法,供CustomerView调用
    • Customer 为实体对象,用来封装客户信息
      在这里插入图片描述
    展开全文
  • 仅供参考,以下是个人的课堂笔记,只有设计模式部分,这门课的sk老师非常负责,在学生中口碑很好,如果认真听课,课后及时总结,最后会更易读懂代码的架构以及为何这样设计的原因,对编程也有很大的帮助。...

    这门课是考试课+实验课,开卷考试题量大有点难,实验认真做,实验源代码见:

    https://download.csdn.net/download/qq_41997479/10911963

    仅供参考,以下是个人的课堂笔记,只有设计模式部分,这门课的sk老师非常负责,在学生中口碑很好,如果认真听课,课后及时总结,最后会更易读懂代码的架构以及为何这样设计的原因,对编程也有很大的帮助。

     

    What is 设计模式:

    每个模式有三部分原则:

    1. 特定的上下文
    2. 一个问题
    3. 一个解决方案

    定义:A solution to a problem in a context

     

    Why 设计模式

    设计模式好处:

    1. 不那么专业的人能做出好的设计
    2. 促进设计修改
    3. 提升设计文档水平
    4. 提升设计的可理解性

     

    设计模式的问题:有舍有得,你用工具,不是工具用你

     

    软件模式的分类:

    1. 分析
    2. 设计
    3. 分类
    4. ……

     

    设计模式分类:(记住)

    1. 创建型
      1. 抽象工厂(CH 7 介绍)
      2. 建造者
      3. 工厂方法(CH 6 介绍)
      4. 单例模式(CH 9 介绍)
    2. 结构型
      1. 适配器(CH 11介绍)
      2. 桥接
      3. 组合(CH15介绍)
      4. 装饰器(CH 8 介绍)
      5. 门面(CH 12介绍)——实际上属于架构模式
      6. 享元(CH 18介绍)
      7. 代理
    3. 行为型
      1. 责任链
      2. 命令(CH 10介绍)
      3. 解释器
      4. 迭代器(CH 14介绍)
      5. 中介者
      6. 备忘录
      7. 观察者(CH4 介绍)
      8. 状态(CH 16介绍)
      9. 策略(CH5介绍)
      10. 模板方法(CH 13介绍)
      11. 访问者

     

    提纲:

    • UML notation
      • 类图:静态数据结构,展示类的属性和方法
    • 面向对象设计原则(必须理解)
      • 七宗罪
        • 僵化:很难改
        • 脆弱:easy to break
        • 固化:hard to reuse
        • 粘滞:hard to do the right thing
        • 非必要复杂性:over design
        • 非必要重复:
      • 7种原则

    • SRP单一职责原则
      • 一个类允许只有一个改变的原因,最好只有一个功能
      • 增加内聚性,一个模块组成元素之间的功能相关性
      • 一个类若有多个职责,增加耦合性
      • 做机器人,不能做头类,因为眼睛、鼻子等大小可变
      • 不足:增加负担,本来一个类封装好了,再拆开增加工作量
    • OCP开放封闭原则
      • 对扩展开放,对修改关闭
      • 不破坏原有功能
      • 已经经过了测试的代码段就不用改了
      • 在不重新设计的前提下系统支持什么样的变化
      • 实现:抽象,多态,继承
    • LSP里氏替换原则
      • S是T的一个子类,凡是T出现的地方都能用S替换
      • 任何基类出现的地方,子类也可以出现
      • 子类的实例 IS A 超类的实例
      • 实现:契约式设计——前置条件和后置条件
      • 正方形和矩形is a 四边形,而不能是正方形(边长:a)是矩形(长:a,宽:b)
      • 要聚合不要继承,has a 比is a要好
      • 子类可扩展父类的功能,但不能改变父类的功能
         
    • ISP接口分离原则
      • 要最小的接口
      • 单一职责的接口版本,即实现出来的内聚性就高
      • 为了避免client之间不必要的耦合性
    • DIP依赖倒置原则(好莱坞原则)
      • 依赖:A类方法中使用了B类,则A类依赖于B类
      • 高层模块不应该依赖于低层模决,二者都应该

    依赖于抽象。进一步的,抽象不应该依赖于细

    节,细节应该依赖于抽象。

    • 例子:猎人拿枪类和斧子类,变为玩家类拿武器类
    • 优点:降低僵化,灵活,增加松耦合
    • 实现:高层实现所需服务的接口,低层实现这些接口
      • 上层通过这些接口使用下层的服务,因此上层不依赖于下层
    • 规则:
      • 参数中的类不应该是具体类,应该是一个接口或者抽象类
      • 抽象类往上去,具体data和具体类往下去
    • 核心:
      • DIP 主要用于解耦
      • 针对接口编程,不针对实现编程
      • 在继承的层次结构层次中:
        • 共享代码应该移动到抽象级别(更高层次结构级别)的抽象类
        • 私有数据应该移动到实现级别(更低层次结构级别)的具体类
    • 如果需求稳定,抽象类意义不大
    • 接口应该由服务请求者确定,而不是服务提供者
    • SOLID代表以上5个设计原则使软件可理解、可维护、可扩展(flexible)
      • CRP组合/聚合复用原则
        • 多用组合/聚合,少用继承
        • 聚合/组合代表has a
        • 继承复用是白盒复用,强耦合,子类知道父类的具体实现
        • 聚合复用是黑盒复用,低依赖,被包含对象的细节对于客户机是不可见的
      • PLK最小知识原则(也叫Law of Demeter,LoD)
        • 每个单元只跟有限的对象有耦合
        • 我的朋友很少,但是少而精
        • 不要让太多的类耦合在一起,否则系统某一部分的修改会影响到其他部分
        • 易于维护理解
    • 23种经典设计模式
    • 总结

     

    展开全文
  • 根据上课内容整理的设计模式与软件体系结构思维导图
  • Java软件体系结构设计模式之结构模式(11种)  结构模式主要用来:  1)处理把责任委托给其他对象的对象。这样一来会引入一种耦合度低的分层体系结构;  2)在不同情况下方便对象间的通信。比如说某个对象通过...
  • 第一篇分为8章,介绍了软件体系结构的基础理论,包括软件体系结构的概念及演化、软件建模基础、软件体系结构的形式化、软件体系结构的风格、体系结构的描述语言、软件质量建模、设计模式等内容。第二篇分为4章,首先...
  • 软件体系结构设计模式作业

    热门讨论 2009-06-01 00:35:16
    软件体系结构设计模式作业。作业程序,设计模式。。。
  • java 软件体系结构设计模式 标准指南
  • 设计模式是编程人员必不可少的知识,更是软件体系结构中必不可少的内容
  • 本资源可以作为《软件设计模式与体系结构》的复习使用,包含几种常见的设计模式的样例及其代码,需要的朋友可以下载哦!
  • 软件体系结构与架构五大设计模式

    千次阅读 2019-11-28 20:22:50
    五大设计模式 最关键的软件开发工具是受过良好设计原则训练的思维 一、单例模式 Singleton类定义一个个getInstance()操作,允许客户端访问他的唯一实例,getInstance()是一个静态的方法,主要创建自己的一个唯一...

    五大设计模式

    最关键的软件开发工具是受过良好设计原则训练的思维

    一、单例模式

    Singleton类定义一个个getInstance()操作,允许客户端访问他的唯一实例,getInstance()是一个静态的方法,主要创建自己的一个唯一实例。

    比如我们希望整个应用程序只有一个连接数据库connection实例。

    又比如要求一个应用程序中只存在某个用户数据结构的唯一结构。
    某个类只有一个实例,具体的代码实现:

    class ClassicSingleton {
    	private static ClassicSingleton instance;
    	private ClassicSingleton(){
    		//构造方法为“私有”,阻止了外界用new创建本类实例的可能
    	}
    	public static synchronized ClassicSingleton getInstance(){
    		if(instance==null){
    		instance = new ClassicSingleton();
    		//return new ClassicSingleton();  
    		}
    		return instance;
    	}
    }
    
    /**
     * 
     * @author Yue
     * @version 0.1
     *
     */
    public class TestSingleton {
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		ClassicSingleton s1 = ClassicSingleton.getInstance();
    		ClassicSingleton s2 = ClassicSingleton.getInstance();
    		System.out.println(s1==s2);//这个是相等的
    	}
    }
    

    二、工厂模式(简单工厂、工厂模式、抽象工厂)

    所有的产品和产品接口组成一个产品群,这个就是“简单工厂”,只有一个工厂。

    工厂和产品最好在一个包里,产品类就可以不是public的,这样只有工厂才可以访问产品,其他不在这个包里就无法直接访问这些产品,起到屏蔽产品类的作用。

    可以看着下面的代码来理解一下简单工厂模式具体代码说明

    //产品接口(如果在接口这个抽象类中需要包含属性数据,则将接口改为抽象类Abstract)
    public interface ProductInterface   {
    	public void method();
    }
    //衣服产品
    public class Clothes implements ProductInterface   {
    	public void method(){
    	
    	}
    }
    //裤子产品
    public class Trousers implements ProductInterface {
    	public void method(){
    	
    	}
    }
    //帽子产品
    public class Cap implements ProductInterface   {
    	public void method(){
    	
    	}
    }
    
    public class Factory {
    	public ProductInterface createProduct(String productname){
    		ProductInterface product = null;
    		if(productname == "clothes"){
    			product = new Clothes();
    		}
    		if(productname == "trousers"){
    			product = new Trousers();
    		}		
    		if(productname == "cap"){
    			product = new Cap();
    		}
    		return product;
    	}
    }
    //要生产哪种产品,需要告诉工厂,即给工厂方法传递一个参数“productname”,
    //工厂方法变为有参数的方法。
    //工厂类不管是生产一种产品还是生产几种产品,都只有一个工厂,这种工厂叫“简单工厂”。
    public class XYZ {  // 客户端代码
    	private ProductInterface product;
    	private Factory factory;
    	public void work(){
    		factory = new Factory();
    		product = factory.createProduct("clothes");
    		product.method();
    	}
    }
    

    这样做的优点:我们可以对创建的对象进行一些 “加工” ,而且客户端并不知道,因为工厂隐藏了这些细节。如果,没有工厂的话,那我们是不是就得自己在客户端上写这些代码,这就好比本来可以在工厂里生产的东西,拿来自己手工制作,不仅麻烦以后还不好维护。

    但是缺点也很明显:如果需要在方法里写很多与对象创建有关的业务代码,而且需要的创建的对象还不少的话,我们要在这个简单工厂类里编写很多个方法,每个方法里都得写很多相应的业务代码,而每次增加子类或者删除子类对象的创建都需要打开这简单工厂类来进行修改。这会导致这个简单工厂类很庞大臃肿、耦合性高,而且增加、删除某个子类对象的创建都需要打开简单工厂类来进行修改代码也违反了开-闭原则。

    这时候就需要工厂模式
    工厂模式实现如下
    1.首先,先定义一个工厂接口

    public interface Factory {
     
        public ProductInterface createProduct() ;
     
    }
    

    2.然后是具体的工厂类

    
    // 衣服类工厂
    public class ClothesFactory implements Factory{
     
        public ProductInterface createProduct() {
            System.out.println("生产衣服");
            return new Clothes();
        }
    }
     
    // 鞋类工厂
    public class ShoeFactory implements Factory{
     
        public ProductInterface createProduct() {
            System.out.println("生产鞋子");
            return new Shoes();
        }
    }
    ........
    

    3.工厂接口与产品的内容与简单一样
    4.客户端

    public class Client {
     
        public static void main(String[] args) throws Exception {
     
            // 使用反射机制实例化工厂对象,因为字符串是可以通过变量改变的
            Factory ClothesFactory = (Factory) Class.forName("org.zero01.factory.ClothesFactory ").newInstance();
            Factory ShoseFactory=(Factory) Class.forName("org.zero01.factory.ShoseFactory").newInstance();
     
            // 通过工厂对象创建相应的实例对象
            ProductInterface clothes= ClothesFactory .createProduct();
            ProductInterface shoes= ShoseFactory.createProduct();
     
            System.out.println(clothes.methods());
            System.out.println(shoes.methods());
        }
    }
    

    工厂模式中,要增加产品类时也要相应地增加工厂类,客户端的代码也增加了不少。工厂方法把简单工厂的内部逻辑判断转移到了客户端代码来进行。

    你想要加功能,本来是改工厂类的,而现在是修改客户端。而且各个不同功能的实例对象的创建代码,也没有耦合在同一个工厂类里,这也是工厂方法模式对简单工厂模式解耦的一个体现。工厂方法模式克服了简单工厂会违背开-闭原则的缺点,又保持了封装对象创建过程的优点。

    但工厂方法模式的缺点是每增加一个产品类,就需要增加一个对应的工厂类,增加了额外的开发量。

    有兴趣的可以参考这个文件深入了解简单工厂模式,工厂模式以及抽象工厂模式(具体)

    三、适配器模式

    适配器模式主要应用于希望复用一些现存的类,但是接口又与复用环境要求不一致的情况。当希望复用的类接口不对时,采用适配器使控制之外的一个原有对象与某个接口匹配。
    在这里插入图片描述

    代码实现

    //客户端:
    public class XYZ {
    	public void work()
    	{
    		Target tag = new RealizeClass();
    		tag.Request(); 
    	}
    }
    //服务接口:
    public interface Target 
    {
    	public void Request();
    }
    // 客户端想要的服务:
    public class Service 
    {
    	public void SpecificRequest()     //但是接口不匹配
    	{
    		//具体操作方法
    	}
    }
    
    //重写服务端实现类,作为适配器,代码为:
    public class RealizeClass implements Target
    {
    	private Service service;
    	public void Request()
    	{
    		service = new Service();
    		service.SpecificRequest();   //进行适配
    	}
    }
    
    // 例子2
    public interface Duck{     //鸭子具有呱呱叫和飞行功能
    	public void quack();
    	public void fly();
    } 
    
    Public class MallardDuck implements Duck{
    	public void quack(){
    		System.out.println(“Quack”);
    	}
    	 public void fly(){
    		System.out.println(“I am flying”);
    	}
    }
    
    public interface Turkey{     //火鸡具有咯咯叫和飞行功能
    	public void gobble();
    	public void fly();
    } 
    
    Public class WildTurkey implements Turkey{
    	public void gobble(){
    		System.out.println(“Gobble gobble”);
    	}
    	 public void fly(){
    		System.out.println(“I am flying a short distance”);
    	}
    }
    
    /**
    * 假设你缺少鸭子对象,想用一些火鸡对象来冒充
    * 因为火鸡的接口不同,所以我们不能公然拿来用,写个适配器	
    **/
    public class TurkeyAdapter implements Duck{ //实现想转化的类型
    	Turkey turkey;
    	//利用构造器取得适配器的构造引用
    	public TurkeyAdapter (Turkey turkey){
    		this.turkey = turkey;
    	}
    	public void quack(){ 
    		 turkey.gobble();
    	}
    	public void fly(){  //火鸡飞行距离短,所以需要5次飞行对应鸭子的飞行
    		forint i=0;i<5;i++{
    			turkey.fly();
    		}
    	}
    
    }
    
    public class DuckTestDrive{
    	public static void main(String[] args){
    		MallardDuck duck = new MallardDuck();
    		WildTurkey turkey = new WildTurkey();
    		// 把火鸡放进火鸡适配器,让它看起来像个鸭子
    		Duck turkeyAdapter = new TurkeyAdapter(turkey);
    		
    		System.out.println(“The turkey says…”);
    		turkey.gobble();
    		turkey.fiy();
    
    		System.out.println(“\nThe Duck says…”);
    		testDuck(duck);
    
    		System.out.println(“\nThe TurkeyAdapter says…”);
    		testDuck(turkeyAdapter);
    
    	}
    	static void testDuck(Duck duck){
    		duck.quack();
    		duck.fly();
    	}
    }
    
    结果:
    The turkey says…
    Gobble gobble 
    I am flying a short distance 
    
    The Duck says…
    Quack
    I am flying 
    
    The TurkeyAdapter says…
    Gobble gobble
    I am flying a short distance
    I am flying a short distance
    I am flying a short distance
    I am flying a short distance
    I am flying a short distance 	
    

    四、模板模式

    模板模式 :解决某类事情的步骤有些是固定的,有些是会发生变化的,那么这时候我们可以为这类事情提供一个模板代码,从而提高效率。
    通过定义一个算法骨架,而将算法中的步骤延迟到子类,这样子类就可以复写这些步骤的实现来实现特定的算法。

    是类的一种行为,只需要准备一个抽象类,将逻辑用具体方法和构造函数的形式来表现,后声明一些抽象方法来迫使子类必须实现其逻辑,不同的子类可以实现不同的方法,从而可以让剩余的逻辑有不同的实现。即可以定义抽象的方法,让子类实现剩余的逻辑。

    分类:

    抽象模版:定义的数量和类型,定义了一个抽象操作让子类实现,定义并实现了一个模版方法,该模版方法一般是一个具体方法,同时给出了顶层逻辑的框架,具体的步骤在相应的抽象操作中,具体的业务逻辑延迟到子类实现。(只有一个抽象基类)
    具体模版:模版方法的数量,实现父类定义的一个或多个抽象方法,每个抽象模版的角色都可以由任意多个具体模版角色与之对应。即不是一对一,而是多对多。

    例如:
    1.办理银行业务:

    • 进门取号
    • 填写单据(每个客户填写的单据都不一样,因业务不同而不同)
    • 等待叫号
    • 窗口办理

    2.使用场景

    • 多个子类公有的方法,并且逻辑基本相同时
    • 重要、复杂的算法,可以把核心算法设计为模版方法
    • 重构时,模版方法模式是一个经常使用的模式

    3.UML结构图:

    在这里插入图片描述
    详情可以参考这个文档

    来一个例子:

    
    public class Coffce{
    	void prepareRecipe(){
    		boilWater();
    		brewCoffeeGrinds(); // 冲泡咖啡
    		pourInCup();
    		addSugarAndMilk();
    	}
    	public void boilWater(){
    		// …
    	}
    	public void brewCoffeeGrinds(){
    		//…
    	}
    	public void pourInCup(){
    		//…
    	}
    	public void addSugarAndMilk(){
    		//…
    	}
    } 
    public class Tea{
    	void prepareRecipe(){
    		boilWater();
    		steepTeaBag(); //浸泡茶包
    		pourInCup();
    		addLemon();
    	}
    	public void boilWater(){
    		// …
    	}
    	public void steepTeaBag(){
    		//…
    	}
    	public void pourInCup(){
    		//…
    	}
    	public void addLemon(){
    		//…
    	}
    } 
    

    有公共函数,该如何设计?

    void prepareRecipe(){
    		boilWater();
    		brewCoffeeGrinds();
    		pourInCup();
    		addSugarAndMilk();
    	}
    void prepareRecipe(){
    	boilWater();
    	steepTeaBag();
    	pourInCup();
    	addLemon();
    }
    //生成抽象类CaffeineBeverage
    Public abstract class CaffeineBeverage{ //咖啡因饮料
    	final void prepareRecipe(){
    		boilWater();
    		brew();
    		pourInCup();
    		addCondiments();
    	}
    	public void boilWater(){ // 此处是否还可以改进?
    		// …
    	}
    	abstract void brew();
    	public void pourInCup(){
    		//…
    	}
    	abstract void addCondiments();
    } 
    //实现抽象类
    public class Tea extends CaffeineBeverage{
    	public void brew(){
    		// …
    	}
    	public void addCondiments(){
    		//…
    	}
    } 
    
    
    public class Coffee extends CaffeineBeverage{
    	public void brew(){
    		// …
    	}
    	public void addCondiments(){
    		//…
    	}
    } 
    
    

    如果我不想加任何添加,怎么办?

    //   引入钩子方法   
    Public abstract class CaffeineBeverage{ //咖啡因饮料
    	public final void prepareRecipe(){
    		boilWater();
    		brew();
    		pourInCup();
    		if(isCustomerWantsCondiments()){
    			 addCondiments(); 
    		}	
    	}
    	private void boilWater(){ 
    		// …
    	}
    	protected abstract void brew();
    	private void pourInCup(){
    		//…
    	}
    	protected abstract void addCondiments();
    	// 询问用户是否加入调料 Hook方法(钩子方法)
    	// 有一个默认输出,子类决定是否挂钩(覆盖其父类的方法)
    	protected boolean isCustomerWantsCondiments(){
    		return true;
    	}
    } 
    
    //   使用钩子
    Public class CoffeeWithHook extends CaffeineBeverage{ //咖啡因饮料
    	//…省略子类中覆盖的其他方法
    	public boolean isCustomerWantsCondiments(){
    		String answer = getUserInput();
    		if(answer.toLowerCase().startsWith(“y”)){
    			return true;
    		}else{
    			return false;
    		}
    	}
    	private String getUserInput(){
    		String answer = null;
    		BufferedReader in = new BufferedReader
    					(new InputStreamReader(System.in));
    		try{
    			answer = in.readLine();
    		}catch(IOException ioe){
    			// 做io异常处理
    		}	
    		if(answer == null){return “no”;}
    		return answer;
    	}
    } 
    

    五、(代理、门面)

    利用门面模式实现各层之间的关联与协作。

    如:某层中的各个组件需要访问另一层中的不同组件,导致层与层之间出现“多对多”的关联形式

    在这里插入图片描述
    解决办法: 用“门面架构模式”分离“多对多”的关联。

    在这里插入图片描述
    门面模块与中介的区别:
    门面模块:门面组件之后的各个组件之间有可能仍有相互之间的关联。
    中介模块:中介模块引入后,使与中介关联的各个组件之间的关联被断绝,他们都只与中介打交道,如下面中介模式的图所示在这里插入图片描述

    展开全文
  • 软件设计模式与体系结构课后习题代码,孙玉山版本
  • 本资源可以作为《软件设计模式体系结构》的期末复习提纲,需要的朋友可以下载哦!
  • 软件体系结构设计模式的java运行代码案例,包括各种模式的简单代码。 包括使用UML插件刻画类图
  • Java软件体系结构设计模式标准指南 压缩文档包括(PDF + PPT + 课程源代码 + chm文档) 第一部分 设计模式简介 第二部分 URL 第三部分 基本模式 第四部分 创建模式 第五部分 集合模式 第六部分 结构模式 第七部分 ...
  • 关于软件体系结构设计模式的总结

    千次阅读 2014-05-28 22:27:56
    因为软件体系结构设计模式太多了,如果用的不多,shi

    因为软件体系结构的设计模式太多了,如果用的不多,实践的不多,很难记住原理。当你考软考的时候,当问到这个编程代码用到了什么体系模式,如果思路不清晰或压根不知道那些模式的区别,要做出那道题挺难的,因此我对我觉得比较重要的设计模式做了简短总结:

    1.单例模式:确保一个类仅有一个唯一的实例,并且提供一个全局的访问点。

    2.工厂模式:开闭原则:必须修改工厂类的源代码,所以不支持开闭原则。

    3.生成器模式:将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示。

    4.适配器模式:类适配器模式:继承关系;对象适配器模式:调用。

    5.组合模式:将对象组合成树形结构,以表示“整体-部分”的层次结构,组合模式使得用户对单个对象和组合对象的使用具有一致性。

    6.外观模式:用来隐藏一个软件系统的缩影内部细节,只提供给客户类一个外观类,也叫做接口类。

    7.桥接模式:将抽象部分与它的实现部分分离,使它们可以独立地变化。

    8.迭代器模式:能够提供一种方法按照顺序访问一个聚合对象中的所有元素,而又不需要暴露该对象的内部表示。

    9.访问者模式:指作用于一个对象结构体上的元素的操作。访问者可以使用户在不改变该结构体中的类的基础上定义一个新的操作。

    10.命令模式:解除调用者与接收者类之间的耦合。

    11.中介者模式:将所有对象之间的交互细节抽象到一个独立的类中,这个类叫做中介者类。

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

    13.状态模式:允许一个对象在其内部状态改变时改变它的行为。这个对象看起来修改了它的类。

    展开全文
  • 本资源可以作为《软件设计模式与体系结构》的复习中的一个样例试卷使用,包含选择题、填空题、简答题、编程题(画类图、写代码)等。比较全,需要的朋友可以下载哦!!!!!!!!!!!!!!!!!!!!!
  • 本资源可以作为《软件设计模式与体系结构》的期末复习的“简答题”的背诵,需要的朋友可以下载哦!
  • 软件设计模式与体系结构的课堂练习的一点小题目的资源
  • 下篇:软件体系结构例子代码  【例6.4】结构化设计-文件更新-C源代码  【例6.5】面向对象设计架构-文件更新  【例6.7】顺序批处理架构-文件更新  【例6.8】顺序批处理架构-图像处理  【例6.9】管道过滤器...
  • 软件体系结构实验报告(设计模式):包含策略模式,代理模式,观察者模式,外观模式,组合模式,抽象工厂,单例,工厂方法,简单工厂,适配器模式,附有代码实例和类图
  • 【《软件设计模式与体系结构》学习笔记】软件设计模式的概念软件设计模式是对软件设计经验的总结,是对软件设计中反复出现的设计问题的已被验证的成功解决之道。大量的软件设计模式都是之前从事软件设计开发的前人...
  • 非常不错的课件,com、ejb、CORBA组件和设计模式介绍的非常详细!

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 133,477
精华内容 53,390
关键字:

软件体系结构与设计模式