Java高级技术实验报告
实验1：创建型模式应用实验
一、实验目的：
（1）了解5种创建型模式的定义、特点和工作原理。
（2）理解5种创建型模式的结构、实现和应用场景。
（3）学会应用5种创建型模式进行软件开发。
二、实验要求：
（1）体现相关设计模式的工作原理。
（2）尽量符合面向对象的七条设计原则。
（3）每个实例要有类图、源代码和运行结果。
（4）上交实验报告电子文档（文档包含源程序，以班级、学号后两位、姓名依次出现组成的字符串标识文档如“计算机20-1班01张三实验1”，以班级为单位上交）。
三、实验内容：
1、某班需要班长主持班会，应用单例模式（分别用懒汉式单例和饿汉式单例两种实现形式）产生班长，模拟班会举行。
（1）类图
（2）源代码
package banzhang;
public class hungery {
private static volatile hungery instance = new hungery();
private hungery() {
System.out.println("饿汉班长主持班会");
}
public static hungery getInstance() {
return instance;
}
public void holdMeeting() {
System.out.println("班会现在开始。");
// 进行班会的代码放在这里。
System.out.println("班会结束。");
}
}
package banzhang;
public class lazy {
private static volatile lazy instance = null;
private lazy() {
System.out.println("懒汉班长主持班会");
}
public static lazy getInstance() {
if (instance == null) {
instance = new lazy();
}
return instance;
}
public void holdMeeting() {
System.out.println("班会现在开始。");
// 进行班会的代码放在这里。
System.out.println("班会结束。");
}
}
package banzhang;
import banzhang.hungery;
import banzhang.lazy;
public class test {
public static void main(String[] args) {
System.out.println("******************懒汉式****************！");
//懒汉式
lazy l=lazy.getInstance();
l.holdMeeting();
System.out.println("******************饿汉式****************！");
//饿汉式
hungery h=hungery.getInstance();
h.holdMeeting();
}
}（3）运行结果
2、假设有一个水果工厂，能够生成各种各样的水果。目前能生产的水果包括苹果，葡萄和草莓。（1）用简单工厂模式生产这些水果。（2）如果此水果工厂还要生成桔子，试用简单工厂模式解决。
(1)
a.类图
b.源代码
package Simplefactory;
public class Apple implements Fruit {
@Override
public void grow() {
System.out.println("苹果正在生长");
}
@Override
public void harvest() {
System.out.println("苹果已经成熟，可以收获了");
}
}
package Simplefactory;
// 水果接口
public interface Fruit {
void grow(); // 水果生长
void harvest(); // 收获水果
}
package Simplefactory;
public class FruitFactory {
public static Fruit produceFruit(String type) {
Fruit fruit = null;
switch (type) {
case "apple":
fruit = new Apple();
break;
case "grape":
fruit = new Grape();
break;
case "strawberry":
fruit = new Strawberry();
break;
case "Orange":
fruit = new Orange();
break;
default:
System.out.println("没有这种水果");
break;
}
return fruit;
}
}
package Simplefactory;
public class Grape implements Fruit {
@Override
public void grow() {
System.out.println("葡萄正在生长");
}
@Override
public void harvest() {
System.out.println("葡萄已经成熟，可以收获了");
}
}
package Simplefactory;
class Orange implements Fruit {
@Override
public void grow() {
System.out.println("桔子正在生长...");
}
@Override
public void harvest() {
System.out.println("桔子已经成熟，可以收获了！");
}
}
package Simplefactory;
public class Strawberry implements Fruit {
@Override
public void grow() {
System.out.println("草莓正在生长");
}
@Override
public void harvest() {
System.out.println("草莓已经成熟，可以收获了");
}
}
package Simplefactory;
//测试
public class Main {
public static void main(String[] args) {
Fruit apple = FruitFactory.produceFruit("apple");
if (apple != null) {
apple.grow();
apple.harvest();
}
Fruit grape = FruitFactory.produceFruit("grape");
if (grape != null) {
grape.grow();
grape.harvest();
}
Fruit strawberry = FruitFactory.produceFruit("strawberry");
if (strawberry != null) {
strawberry.grow();
strawberry.harvest();
}
Fruit orange = FruitFactory.produceFruit("Orange");
if (orange != null) {
orange.grow();
orange.harvest();
}
}
}
c.运行结果
(2)
要生成桔子在水果工厂中加入桔子，只需要修改工厂类 FruitFactory 的代码，添加对桔子的支持即可。代码和运行已经在（1）中展示。
3、将第2题用工厂模式解决完成。
（1）类图
（2）源代码
package factory;
// 水果接口
public interface Fruit {
void grow(); // 水果生长
void harvest(); // 收获水果
}
package factory;
//抽象工厂
public interface FruitFactory {
Fruit createFruit();
}
package factory;
public class Apple implements Fruit {
@Override
public void grow() {
System.out.println("苹果正在生长");
}
@Override
public void harvest() {
System.out.println("苹果已经成熟，可以收获了");
}
}
package factory;
public class Grape implements Fruit {
@Override
public void grow() {
System.out.println("葡萄正在生长");
}
@Override
public void harvest() {
System.out.println("葡萄已经成熟，可以收获了");
}
}
package factory;
class Orange implements Fruit {
@Override
public void grow() {
System.out.println("桔子正在生长...");
}
@Override
public void harvest() {
System.out.println("桔子已经成熟，可以收获了！");
}
}
package factory;
public class Strawberry implements Fruit {
@Override
public void grow() {
System.out.println("草莓正在生长");
}
@Override
public void harvest() {
System.out.println("草莓已经成熟，可以收获了");
}
}
package factory;
public class AppleFactory implements FruitFactory {
@Override
public Fruit createFruit() {
return new Apple();
}
}
package factory;
public class GrapeFactory implements FruitFactory {
@Override
public Fruit createFruit() {
return new Grape();
}
}
package factory;
public class OrangeFactory implements FruitFactory {
@Override
public Fruit createFruit() {
return new Orange();
}
}
package factory;
public class StrawberryFactory implements FruitFactory {
@Override
public Fruit createFruit() {
return new Strawberry();
}
}
package factory;
public class test {
public static void main(String[] args) {
FruitFactory appleFactory = new AppleFactory();
Fruit apple = appleFactory.createFruit();
apple.grow();
apple.harvest();
FruitFactory grapeFactory = new GrapeFactory();
Fruit grape = grapeFactory.createFruit();
grape.grow();
grape.harvest();
FruitFactory strawberryFactory = new StrawberryFactory();
Fruit strawberry = strawberryFactory.createFruit();
strawberry.grow();
strawberry.harvest();
FruitFactory orangeFactory = new OrangeFactory();
Fruit orange = orangeFactory.createFruit();
orange.grow();
orange.harvest();
}
}（3）运行结果
三、实验心得：
通过本次实验我了解5种创建型模式的定义、特点和工作原理，理了5种创建型模式的结构、实现和应用场景。
同时我进一步了解了简单工厂模式和工厂模式的区别。简单工厂模式和工厂模式的主要区别在于抽象工厂接口的存在与否。在简单工厂模式中，只有一个工厂类，它负责创建所有的产品对象，客户端只需要传入相应的参数即可获得所需的产品对象。而在工厂模式中，每个产品都对应一个具体的工厂类，客户端需要选择相应的工厂类来创建所需的产品对象。
因此，工厂模式相比于简单工厂模式更加灵活，能够满足更多的需求。但是工厂模式的实现也更加复杂，需要为每个产品都定义一个对应的工厂类，增加了系统的复杂度。因此，在实际应用中，我们需要根据具体的需求来选择合适的模式。
3257
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
