下载文档原格式
java最常用的六种设计模式及举例设计模式是在软件开发过程中经验总结的一种编码和设计方式，它们可以帮助我们更好地组织代码，提高代码的可维护性和可复用性。
下面是 Java 中最常用的六种设计模式及其举例：1. 单例模式：单例模式确保一个类只有一个实例，并提供一个全局访问点。
典型的例子是 `ng.Runtime` 类，在整个 JVM 中只有一个运行时实例。
2. 工厂模式：工厂模式通过一个工厂类来创建其他类的对象，将对象的创建和使用分离，降低了代码的耦合度。
比如，`java.util.Calendar` 类使用了工厂模式来创建 `Calendar` 对象，其中的 `getInstance()` 方法返回一个 `Calendar` 实例。
3. 观察者模式：观察者模式定义了对象之间的一对多的依赖关系，当一个对象状态发生改变时，其相关依赖对象会收到通知并自动更新。
一个典型的例子是使用 `java.util.Observable` 类和 `java.util.Observer`接口进行监听和通知。
4. 装饰者模式：装饰者模式通过动态地将新功能附加到对象上，为对象提供了灵活的扩展方式，不需要修改原始对象的结构。
比如，`java.io` 包中的各种装饰者类可以用来扩展输入输出功能。
5. 策略模式：策略模式定义了一组算法，并将每个算法封装到可互换的对象中，使得算法的变化不会影响到使用算法的客户端。
一个常见的例子是使用 `parator` 接口来实现不同的比较策略。
6. 适配器模式：适配器模式将一个类的接口转换成客户端所期望的另一个接口，使得原本不兼容的类可以一起工作。
比如，`java.util.Arrays` 类中的 `asList()` 方法返回的是一个适配器，可以将数组转换成 List。
通过学习这些设计模式，我们可以更好地组织和设计代码，提高代码的可读性和可维护性。
在实际的开发中，我们可以针对具体的需求选择合适的设计模式，并根据需要进行一定的修改和定制。
1、工厂模式：客户类和工厂类分开。
消费者任何时候需要某种产品，只需向工厂请求即可。
消费者无须修改就可以接纳新产品。
缺点是当产品修改时，工厂类也要做相应的修改。
如：如何创建及如何向客户端提供。
2、建造模式：将产品的内部表象和产品的生成过程分割开来，从而使一个建造过程生成具有不同的内部表象的产品对象。
建造模式使得产品内部表象可以独立的变化，客户不必知道产品内部组成的细节。
建造模式可以强制实行一种分步骤进行的建造过程。
3、工厂方法模式：核心工厂类不再负责所有产品的创建，而是将具体创建的工作交给子类去做，成为一个抽象工厂角色，仅负责给出具体工厂类必须实现的接口，而不接触哪一个产品类应当被实例化这种细节。
4、原始模型模式：通过给出一个原型对象来指明所要创建的对象的类型，然后用复制这个原型对象的方法创建出更多同类型的对象。
原始模型模式允许动态的增加或减少产品类，产品类不需要非得有任何事先确定的等级结构，原始模型模式适用于任何的等级结构。
缺点是每一个类都必须配备一个克隆方法。
5、单例模式：单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例单例模式。
单例模式只应在有真正的“单一实例”的需求时才可使用。
6、适配器(变压器)模式：把一个类的接口变换成客户端所期待的另一种接口，从而使原本因接口原因不匹配而无法一起工作的两个类能够一起工作。
适配类可以根据参数返还一个合适的实例给客户端。
7、桥梁模式：将抽象化与实现化脱耦，使得二者可以独立的变化，也就是说将他们之间的强关联变成弱关联，也就是指在一个软件系统的抽象化和实现化之间使用组合/聚合关系而不是继承关系，从而使两者可以独立的变化。
8、合成模式：合成模式将对象组织到树结构中，可以用来描述整体与部分的关系。
合成模式就是一个处理对象的树结构的模式。
合成模式把部分与整体的关系用树结构表示出来。
合成模式使得客户端把一个个单独的成分对象和由他们复合而成的合成对象同等看待。
第1篇一、实验背景随着软件工程的不断发展，设计模式作为一种解决软件开发中常见问题的有效方法，越来越受到广泛关注。
本次实验旨在通过学习设计模式，提高编程能力，掌握解决实际问题的方法，并加深对设计模式的理解。
二、实验目的1. 理解设计模式的基本概念和分类；2. 掌握常见设计模式的原理和应用；3. 提高编程能力，学会运用设计模式解决实际问题；4. 培养团队协作精神，提高项目开发效率。
三、实验内容本次实验主要涉及以下设计模式：1. 创建型模式：单例模式、工厂模式、抽象工厂模式、建造者模式；2. 结构型模式：适配器模式、装饰者模式、桥接模式、组合模式、外观模式；3. 行为型模式：策略模式、模板方法模式、观察者模式、责任链模式、命令模式。
四、实验过程1. 阅读相关资料，了解设计模式的基本概念和分类；2. 分析每种设计模式的原理和应用场景；3. 编写代码实现常见设计模式，并进行分析比较；4. 将设计模式应用于实际项目中，解决实际问题；5. 总结实验经验，撰写实验报告。
五、实验结果与分析1. 创建型模式（1）单例模式：通过控制对象的实例化，确保一个类只有一个实例，并提供一个访问它的全局访问点。
实验中，我们实现了单例模式，成功避免了资源浪费和同步问题。
（2）工厂模式：定义一个用于创建对象的接口，让子类决定实例化哪一个类。
实验中，我们使用工厂模式创建不同类型的交通工具，提高了代码的可扩展性和可维护性。
（3）抽象工厂模式：提供一个接口，用于创建相关或依赖对象的家族，而不需要指定具体类。
实验中，我们使用抽象工厂模式创建不同类型的计算机，实现了代码的复用和扩展。
（4）建造者模式：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
实验中，我们使用建造者模式构建不同配置的房屋，提高了代码的可读性和可维护性。
2. 结构型模式（1）适配器模式：将一个类的接口转换成客户期望的另一个接口，使原本接口不兼容的类可以一起工作。
【精品实验报告】软件体系结构设计模式实验报告软件体系结构设计模式实验报告学生姓名: 所在学院: 学生学号: 学生班级: 指导老师: 完成日期:一、实验目的熟练使用PowerDesigner和任意一种面向对象编程语言实现几种常见的设计模式，包括组合模式、外观模式、代理模式、观察者模式和策略模式，理解每一种设计模式的模式动机，掌握模式结构，学习如何使用代码实现这些模式，并学会分析这些模式的使用效果。
二、实验内容使用PowerDesigner和任意一种面向对象编程语言实现组合模式、外观模式、代理模式、观察者模式和策略模式，包括根据实例绘制模式结构图、编写模式实例实现代码，运行并测试模式实例代码。
(1) 组合模式使用组合模式设计一个杀毒软件(AntiVirus)的框架，该软件既可以对某个文件夹(Folder)杀毒，也可以对某个指定的文件(File)进行杀毒，文件种类包括文本文件TextFile、图片文件ImageFile、视频文件VideoFile。
绘制类图并编程模拟实现。
(2) 组合模式某教育机构组织结构如下图所示:北京总部教务办公室湖南分校行政办公室教务办公室长沙教学点湘潭教学点行政办公室教务办公室行政办公室教务办公室行政办公室在该教育机构的OA系统中可以给各级办公室下发公文，现采用组合模式设计该机构的组织结构，绘制相应的类图并编程模拟实现，在客户端代码中模拟下发公文。
(注:可以定义一个办公室类为抽象叶子构件类，再将教务办公室和行政办公室作为其子类;可以定义一个教学机构类为抽象容器构件类，将总部、分校和教学点作为其子类。
)(3) 外观模式某系统需要提供一个文件加密模块，加密流程包括三个操作，分别是读取源文件、加密、保存加密之后的文件。
读取文件和保存文件使用流来实现，这三个操作相对独立，其业务代码封装在三个不同的类中。
现在需要提供一个统一的加密外观类，用户可以直接使用该加密外观类完成文件的读取、加密和保存三个操作，而不需要与每一个类进行交互，使用外观模式设计该加密模块，要求编程模拟实现。
Java设计模式常用设计模式及其应用场景设计模式是软件工程中常用的一种解决问题的方案，它提供了一套被广泛接受和验证的解决方案，用于解决在软件设计过程中遇到的各种问题。
Java作为一种广泛应用的编程语言，有许多常用的设计模式可以应用到Java开发中。
本文将介绍几种常用的Java设计模式以及它们的应用场景。
一、单例模式单例模式是一种在整个应用程序中只允许创建一个实例的设计模式。
它主要解决的问题是对资源的共享访问以及避免重复创建对象。
在Java中，单例模式的应用场景非常多，比如用于创建数据库连接池、线程池等资源池。
使用单例模式可以保证这些资源的唯一性，避免资源的浪费。
二、工厂模式工厂模式是一种通过创建工厂类来实例化对象的设计模式。
它主要解决的问题是创建对象的过程复杂，需要通过工厂类来封装这个复杂的过程。
在Java中，工厂模式常用于创建对象时需要根据条件来判断具体需要创建哪种类型的对象的情况。
比如，根据用户的输入来创建不同类型的图形对象，可以使用工厂模式。
三、观察者模式观察者模式是一种对象间的一对多依赖关系，当一个对象的状态发生变化时，它的所有依赖对象都会收到通知并自动更新。
在Java中，观察者模式被广泛应用于事件监听和消息传递。
比如，一个网站上的用户注册功能，当用户成功注册后，可以通过观察者模式通知其他相关的模块进行相应的操作。
四、策略模式策略模式是一种将算法封装起来并使其可以互相替换的设计模式。
它主要解决的问题是为同一种问题提供多种解决方案，并且使这些解决方案可以相互替换，互不影响。
在Java中，策略模式可以用于实现不同的排序算法、不同的计算方式等。
比如，一个商场的折扣活动可以采用策略模式，根据不同的折扣策略计算折扣后的价格。
五、装饰者模式装饰者模式是一种通过为对象添加新的功能来扩展其功能的设计模式，它不改变对象的结构。
在Java中，装饰者模式常用于对已有的类进行功能扩展或者改造。
比如，对一个已有的文件读写类进行包装，增加加密、压缩等额外功能，而不改变原有类的结构和接口。
Java中常见设计模式面试题一、设计模式的分类一般来说，设计模式分为三类：创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。
结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。
共有11种行为模式：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访客模式、调解者模式和口译员模式。
1.请列举出在jdk中几个常用的设计模式？Singleton模式用于运行时、日历和其他应用程序一些类中。
工厂模式（factorypattern）被用于各种不可变的类如boolean，像boolean.valueof，观察者模式（observerpattern）被用于swing和很多的事件监听中。
装饰器设计模式（decoratordesignpattern）被用于多个javaio类中。
2.什么是设计模式？您是否在代码中使用过任何设计模式？设计模式是世界上各种程序员用来解决特定设计问题的尝试和测试方法。
设计模式是代码可用性的扩展3.java中什么叫单例设计模式？请用java写出线程安全的单例模式单例模式侧重于在整个系统中共享一些资源消耗对象。
整个应用程序中只维护一个特定的类实例，所有组件都使用它。
JAVA运行时是单例模式的经典例子。
从Java5开始，可以使用enum实现线程安全的单例。
4.在java中，什么叫观察者设计模式（observerdesignpattern）？观察者模式是基于对象的状态变化和观察者之间的通信，以便他们能够进行相应的操作。
一个简单的例子是天气系统。
当天气变化时，它必须反映在向公众展示的视图中。
这个视图对象是一个主体，而不同的视图是观察者。
5.使用工厂模式最主要的好处是什么？在哪里使用？factory模式的最大优点是在创建对象时提高封装级别。
如果使用工厂创建对象，则可以使用更高级、更高性能的实现替换原始产品实现或类，而无需在调用级别进行任何修改。
实验（上机）九观察者模式实验（上机）目的1、练习使用行为型设计模式；2、练习使用观察者模式的设计思路；3、练习使用观察者模式实现“游戏中战队成员之间的联动”案例的实现。
实验（上机）课时2学时实验（上机）环境JDK1.8\Eclipse Mars预备知识1、观察者模式概述2、观察者模式的结构与实现3、观察者模式的应用实例4、观察者模式与.NET中的委托事件模型5、观察者模式与MVC6、观察者模式的优缺点与适用环境实验（上机）内容在某多人联机对战游戏中，多个玩家可以加入同一战队组成联盟，当战队中的某一成员受到敌人攻击时将给所有其他盟友发送通知，盟友收到通知后将做出响应。
现使用观察者模式设计并实现该过程，以实现战队成员之间的联动。
新建解决方案，新建一个控制台应用程序，编写观察者模式实现代码，实现以上需求的案例，要求编写为控制台应用程序，并能调试运行。
实验（上机）步骤1、本实例类图：AllyControlCenter{abstract}# #allyNameplayers: string: List<IObserver>+ + + + +SetAllyName (string allyName)GetAllyName ()Join (IObserver obs)Quit (IObserver obs)NotifyObserver (string name)...: void: string: void: void: voidIObserver+Name: string++Help ()BeAttacked (AllyControlCenter acc)...: void: voidPlayer-+<<PropertyImplementation>><<Property>>nameName: string: string+++++<<Setter>><<Getter>>Player (string name)set_Name (string value)get_Name ()Help ()BeAttacked (AllyControlCenter acc)...: void: string: void: void ConcreteAllyControlCenter++ConcreteAllyControlCenter (string allyName)NotifyObserver (string name)...: void............2创建ObserverSample的工程，并根据模式的角色创建对应的包。
java 面向对象的常用设计模式java 面向对象的常用设计模式有：1、观察者模式观察者模式又称为发布-订阅模式，定义了对象之间一对多依赖关系，当目标对象(被观察者)的状态发生改变时，它的所有依赖者(观察者)都会收到通知。
2、抽象工厂模式抽象工厂模式主要用于创建相关对象的家族。
当一个产品族中需要被设计在一起工作时，通过抽象工厂模式，能够保证客户端始终只使用同一个产品族中的对象；并且通过隔离具体类的生成，使得客户端不需要明确指定具体生成类；所有的具体工厂都实现了抽象工厂中定义的公共接口，因此只需要改变具体工厂的实例，就可以在某种程度上改变整个软件系统的行为。
3、单例设计模式单例设计模式可以确保系统中某个类只有一个实例，该类自行实例化并向整个系统提供这个实例的公共访问点，除了该公共访问点，不能通过其他途径访问该实例。
4、策略模式将类中经常改变或者可能改变的部分提取为作为一个抽象策略接口类，然后在类中包含这个对象的实例，这样类实例在运行时就可以随意调用实现了这个接口的类的行为。
比如定义一系列的算法，把每一个算法封装起来，并且使它们可相互替换，使得算法可独立于使用它的客户而变化，这就是策略模式。
5、适配器模式适配器模式主要用于将一个类或者接口转化成客户端希望的格式，使得原本不兼容的类可以在一起工作，将目标类和适配者类解耦；同时也符合“开闭原则”，可以在不修改原代码的基础上增加新的适配器类；将具体的实现封装在适配者类中，对于客户端类来说是透明的，而且提高了适配者的复用性，但是缺点在于更换适配器的实现过程比较复杂。
6、命令模式命令模式的本质是将请求封装成对象，将发出命令与执行命令的责任分开，命令的发送者和接收者完全解耦，发送者只需知道如何发送命令，不需要关心命令是如何实现的，甚至是否执行成功都不需要理会。
命令模式的关键在于引入了抽象命令接口，发送者针对抽象命令接口编程，只有实现了抽象命令接口的具体命令才能与接收者相关联。
Java设计模式及应用场景1. 概述设计模式是一种通用的解决问题的模板或蓝图，它提供了解决常见软件设计问题的经验。
在软件开发过程中，设计模式可以提高软件的可维护性、可扩展性和重用性。
Java语言是一种面向对象的编程语言，提供了一些常见的设计模式，并且在Java开发领域有广泛的应用。
本文将对Java中的一些常见设计模式及其应用场景进行深入探讨。
2. 创建型设计模式创建型设计模式主要关注对象实例化的方式，目标是提供一种灵活、可扩展的对象创建机制。
2.1 工厂方法模式（Factory Method Pattern）工厂方法模式是一种常见的创建型设计模式，它定义了一个用于创建对象的接口，但将具体的对象创建操作延迟到子类。
工厂方法模式可以隐藏对象的具体创建方式，使得客户端代码与具体对象解耦。
应用场景•当需要创建的对象有共同的接口或基类，并且需要根据具体情况选择其中一个对象时，可以使用工厂方法模式。
•当对象的创建过程比较复杂或需要根据不同的条件创建不同的对象时，可以使用工厂方法模式。
示例代码// 定义产品接口interface Product {void doSomething();}// 具体产品类1class ConcreteProduct1 implements Product {public void doSomething() {// 具体产品1的实现}}// 具体产品类2class ConcreteProduct2 implements Product { public void doSomething() {// 具体产品2的实现}}// 定义工厂接口interface Factory {Product createProduct();}// 具体工厂类1class ConcreteFactory1 implements Factory { public Product createProduct() {return new ConcreteProduct1();}}// 具体工厂类2class ConcreteFactory2 implements Factory { public Product createProduct() {return new ConcreteProduct2();}}// 客户端代码public class Client {public static void main(String[] args) {Factory factory = new ConcreteFactory1(); Product product = factory.createProduct(); product.doSomething();}}2.2 抽象工厂模式（Abstract Factory Pattern）抽象工厂模式是一种创建型设计模式，它提供了一个创建一系列相关或相互依赖对象的接口，而无需指定具体的类。
实验二策略模式、观察者模式和组合模式一、实验目的：（1）学习和掌握策略模式；（2）学习和掌握观察者模式；（3）学习和掌握组合模式；（4）学习和掌握使用这些模式解决实际问题；二、实验内容1. 请使用策略模式实现下列编程要求：已知几何形状家族有圆形、矩形、椭圆形、三角形等形状。
请用Java语言定义一个抽象类MyShape表示形状这样概念，MyShape抽象类中提供了计算面积、周长、显示形状信息的抽象方法，然后分别定义它的子类MyCircle（圆形）、MyRectangle（矩形）、MyEllipse（椭圆形）、MyTriangle（三角形）等特定几何形状。
并绘制这些定义的几何家族的所有形状。
2．请用观察者模式实现功能：学校发布信息，学生可以订阅，老师可以订阅，行政人员也可以订阅。
提示：定义主题接口，观察者接口，定义Notice、学生、老师和行政人员类，定义测试类。
其中Notice类实现主题接口，老师、学生和行政人员实现观察者接口。
思考，如果要求实现学生和老师均可以订阅多个信息，即除了订阅学校发布信息，也可以订阅所属系发送的信息，请编程实现。
3．定义一个游戏地图。
地图是由每个方块拼合起来。
地图上有墙等障碍物，也有可以通行的基本图元构成。
请使用组合模式，绘制一个游戏地图，地图的内容自行定义，也可以类似图3形式：图3游戏地图4．已知有一个二维数组数据如图1所示，请结合策略模式、观察者模式和组合模式实现一个MVC结构的应用程序。
要求：如果用户移动滑块，可以修改二维数组的值，并在运行的用户界面中显示出来。
其中，饼状图和柱状图中的区域分布为二位数组每一维的总和。
运行结果如图4和图5所示。
60 50 9090 40 3010 20 70图4 数据模型图5运行结果三、实验环境1、PC微机；2、DOS操作系统或 Windows 操作系统；3、jdk程序集成环境Eclipse四、源代码、测试结果及UML图一：1.UML图2.源程序代码：package course.strategy.shape;import java.awt.Graphics;import java.util.ArrayList;import java.util.List;import javax.swing.JPanel;//绘制所有图形@SuppressWarnings("serial")public class DrawShape extends JPanel{private List<MyShape> shapes;public DrawShape() {shapes=new ArrayList<MyShape>();}public void addShape(MyShape shape){ //添加图形if(shape!=null) shapes.add(shape);}public void paintComponent(Graphics g){ //依次绘制图形for(MyShape ms:shapes){ms.draw(g);System.out.println(ms);}}} 、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、package course.strategy.shape;import java.awt.Graphics;//形状家族public abstract class MyShape {public abstract float area();public abstract float perimeter();public abstract void draw(Graphics g);} 、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、package course.strategy.shape;import java.awt.Color;import java.awt.Graphics;//圆形public class MyCircle extends MyShape {private static final float PI=3.14f;private int radius; //定义圆形半径private int x,y; //定义起点（x,y）坐标public MyCircle(int x,int y,int radius){ //构造函数super();this.x=x;this.y=y;this.radius = radius;}@Overridepublic float area() { //求面积// TODO 自动生成的方法存根return PI*radius*radius;}@Overridepublic float perimeter() { //求周长// TODO 自动生成的方法存根return 2*PI*radius;}@Overridepublic String toString() {return "MyCircle [radius=" + radius + ", x坐标=" + x + ", y坐标=" + y + "]"+" 面积="+area()+",周长="+perimeter();}@Overridepublic void draw(Graphics g) { //绘制图形// TODO 自动生成的方法存根g.setColor(Color.blue);g.fillOval(x, y, 2*radius, 2*radius);}} 、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、package course.strategy.shape;import java.awt.Color;import java.awt.Graphics;//矩形public class MyRectangle extends MyShape {private int x,y; //定义起点（x,y）坐标private int width,height; //定义矩形的宽和高public MyRectangle(int x,int y,int width, int height) {super();this.x=x;this.y=y;this.width = width;this.height = height;}@Overridepublic float area() {// TODO 自动生成的方法存根return width*height;}@Overridepublic float perimeter() {// TODO 自动生成的方法存根return 2*(width+height);}@Overridepublic String toString() {return "MyRectangle [x坐标=" + x + ", y坐标=" + y + ", 矩形宽=" + width+ ", 矩形高=" + height + "]"+" 面积="+area()+",周长="+perimeter();}@Overridepublic void draw(Graphics g) {// TODO 自动生成的方法存根g.setColor(Color.green);g.fillRect(x, y, width, height);}} 、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、package course.strategy.shape;import java.awt.Color;import java.awt.Graphics;//椭圆形public class MyEllipse extends MyShape {private static final float PI=3.14f;private int x,y; //定义起点（x,y）坐标private int aLong,bShort; //定义椭圆的长轴和短轴public MyEllipse(int x, int y,int aLong, int bShort) {super();this.x = x;this.y = y;this.aLong = aLong;this.bShort = bShort;}@Overridepublic float area() {// TODO 自动生成的方法存根return 1.0f/4*PI*aLong*bShort;}@Overridepublic float perimeter() {// TODO 自动生成的方法存根return PI*bShort+2*(aLong-bShort);}@Overridepublic String toString() {return "MyEllipse [x坐标=" + x + ", y坐标=" + y + ", 长轴=" + aLong+ ", 短轴=" + bShort + "]"+" 面积="+area()+",周长="+perimeter();}@Overridepublic void draw(Graphics g) {// TODO 自动生成的方法存根g.setColor(Color.red);g.fillOval(x, y, aLong, bShort);}} 、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、package course.strategy.shape;import java.awt.Color;import java.awt.Graphics;//三角形public class MyTriangle extends MyShape {private int a,b,c,n;private int[] xPoints;private int[] yPoints;public MyTriangle( int[] xPoints, int[] yPoints,int n,int a,int b,int c) {super();this.xPoints = xPoints;this.yPoints = yPoints;this.n = n;this.a=a; this.b=b; this.c=c;}@Overridepublic float area() {// TODO 自动生成的方法存根float p=(a+b+c)/2;return (float)Math.sqrt(p*(p-a)*(p-b)*(p-c));}@Overridepublic float perimeter() {// TODO 自动生成的方法存根return a+b+c;}@Overridepublic String toString() {return "MyTriangle [a=" + a + ", b=" + b + ", c=" + c + "]"+" 面积="+area()+",周长="+perimeter();}@Overridepublic void draw(Graphics g) {// TODO 自动生成的方法存根g.setColor(Color.yellow);g.fillPolygon(xPoints, yPoints, n);}} 、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、package course.strategy.shape;import javax.swing.JFrame;//测试程序public class Test { //测试绘制所有形状/*** @param args*/public static void main(String[] args) {// TODO自动生成的方法存根JFrame frame=new JFrame();DrawShape ds=new DrawShape();ds.addShape(new MyCircle(20,20,60));ds.addShape(new MyRectangle(200,20,120,100));ds.addShape(new MyEllipse(40,200,150,100));int xPoints[]={300,240,370};int yPoints[]={200,280,300};ds.addShape(new MyTriangle(xPoints,yPoints,3,9,12,15));frame.getContentPane().add(ds);frame.setTitle("绘制图形演示");frame.setSize(500,400);frame.setVisible(true);frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);}}3.测试结果图：二：1.UML图：Subject+registerObserver(ob server:Observer):void +removeObserver(ob server:Observer):void +notifyAllObservers( ):voidObserver+getNotice(message:St ring):voidDepartmentNotice -observers:List<Observer> -message:String+DepartmentNotice() +registerObserver(obser ver:Observer):void+removeObserver(obser ver:Observer):void+notifyAllObservers():v oid+setMessage（str:String）:void+getMessage():StringNotice-observers:List<Observer>-message:String+Notice()+registerObserver(observer:Observer):void+removeObserver(observer:Observer):void+notifyAllObservers():void+setMessage（str:String）:void+getMessage():StringTeacher+getNotice(message:String):voidStudent+getNotice(message:String):voidAdministrator+getNotice(message:String):void2.源代码：package course.observer.notice;//主题public interface Subject {public void registerObserver(Observer observer);public void removeObserver(Observer observer);public void notifyAllObservers();} 、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、package course.observer.notice;import java.util.ArrayList;import java.util.Iterator;import java.util.List;//学校通知public class Notice implements Subject {private List<Observer> observers;private String message;public Notice(){observers=new ArrayList<Observer>();}@Overridepublic void registerObserver(Observer observer) {// TODO 自动生成的方法存根if(!observers.contains(observer))observers.add(observer);}@Overridepublic void removeObserver(Observer observer) {// TODO 自动生成的方法存根if(observers.contains(observer))observers.remove(observer);}@Overridepublic void notifyAllObservers() {// TODO 自动生成的方法存根for(Iterator<Observer> it=observers.iterator();it.hasNext();){Observer o=it.next();o.getNotice(getMessage());}}public void setMessage(String str){this.message=str;}public String getMessage(){return message;}} 、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、package course.observer.notice;import java.util.ArrayList;import java.util.Iterator;import java.util.List;//学院通知public class DepartmentNotice implements Subject {private List<Observer> observers;private String message;public DepartmentNotice(){observers=new ArrayList<Observer>();}@Overridepublic void registerObserver(Observer observer) {// TODO 自动生成的方法存根observers.add(observer);}@Overridepublic void removeObserver(Observer observer) {// TODO 自动生成的方法存根observers.remove(observer);}@Overridepublic void notifyAllObservers() {// TODO 自动生成的方法存根for(Iterator<Observer> it=observers.iterator();it.hasNext();){Observer o=it.next();o.getNotice(getMessage());}}public void setMessage(String str){this.message=str;}public String getMessage(){return message;}} 、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、package course.observer.notice;//观察者public interface Observer {public void getNotice(String message);} 、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、package course.observer.notice;//具体观察者，教师public class Teacher implements Observer {@Overridepublic void getNotice(String message) {// TODO自动生成的方法存根System.out.println("教师收到通知："+message);}} 、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、package course.observer.notice;//具体观察者，学生public class Student implements Observer {@Overridepublic void getNotice(String message) {// TODO自动生成的方法存根System.out.println("学生收到通知："+message);}} 、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、package course.observer.notice;//具体观察者，行政人员public class Administrator implements Observer {@Overridepublic void getNotice(String message) {// TODO自动生成的方法存根System.out.println("行政人员收到通知："+message);}} 、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、package course.observer.notice;//测试程序public class Test {/*** @param args*/public static void main(String[] args) {// TODO自动生成的方法存根Notice notice=new Notice();DepartmentNotice depart=new DepartmentNotice();Observer tea,stu,admin;tea=new Teacher();stu=new Student();admin=new Administrator();notice.registerObserver(tea);notice.registerObserver(stu);notice.registerObserver(admin);depart.registerObserver(tea);depart.registerObserver(stu);notice.setMessage("学校通知：五一全体放假七天。
