引自 spring温故知新对几种设计模式讲解比较清晰
1:传统的编程方式
public class Robot {
public String name;
public String color;
public double height;
public double width;
public double weight;
public Robot(String name, String color, double height, double width,
double weight) {
this.name = name;
this.color = color;
this.height = height;
this.width = width;
this.weight = weight;
}
public void Speak(String msg) {
System.out.println(msg);
}
}
实现类
import com.iteye.bolide74.action.Robot;
public class IoCTester {
public static void main(String[] args) {
Robot robot0 = new Robot("robot0", "black", 80.000, 40.0000, 1000.0000);
robot0.Speak("Hello,World!");
}
}
2: 使用简单工厂
import com.iteye.bolide74.action.Robot;
class RobotFactory {
public Robot getRobot(int robotType) {
Robot robot;
switch (robotType) {
case 0:
robot = new Robot("robot0", "black", 80.000, 40.0000, 1000.0000);
break;
case 1:
robot = new Robot("robot1", "white", 90.000, 30.0000, 800.0000);
break;
default:
robot = new Robot("defaultRobot", "red", 10.000, 10.0000, 300.0000);
break;
}
return robot;
}
}
public class IoCTester {
public static void main(String[] args) {
RobotFactory robotFactory = new RobotFactory();
Robot robot = robotFactory.getRobot(0);
robot.Speak("Hello,World! My name is " + robot.name);
}
}
3:使用静态工厂
package com.iteye.bolide74.action;
public class Robot2 {
public String name;
public String color;
public double height;
public double width;
public double weight;
private Robot2(String name, String color, double height, double width,
double weight) {
this.name = name;
this.color = color;
this.height = height;
this.width = width;
this.weight = weight;
}
public static Robot2 getRobot(int robotType) {
Robot2 robot2;
switch (robotType) {
case 0:
robot2 = new Robot2("robot0", "black", 80.000, 40.0000, 1000.0000);
break;
case 1:
robot2 = new Robot2("robot1", "white", 90.000, 30.0000, 800.0000);
break;
default:
robot2 = new Robot2("defaultRobot", "red", 10.000, 10.0000, 300.0000);
break;
}
return robot2;
}
public void Speak(String msg) {
System.out.println(msg + ",我是" + this.name);
}
}
实现类
package com.iteye.bolide74.tester;
import com.iteye.bolide74.action.Robot2;
public class IoCTester {
public static void main(String[] args) {
Robot2 robot2 = Robot2.getRobot(1);
robot2.Speak("Hello,world!");
注意!这里有两个细节:
1) Robot2的构造方法是private的,这样的好处就是所有Robot2的使用者或者说是实现类在获取机器人的时
候,只能通过getRobot2来获取,这样就实现了规范化,而不是有些地方是直接new的,有些地方是用
getRobot方法来的(一个项目,不一定就是一个程序员写到老的...)。
2) Robot2获取实例的getRobot方法是static静态的(所以才叫静态工厂嘛~)!由于Robot2的构造函数是
private的了,不能直接new一个实例,那就更加不可能调用需要实例化才能使用的getRobot方法了,所以必须
要设置为static方法,就可以无需实例化直接调用!
现在为了解决简单工厂和静态工厂模式的缺陷,我们可以把Speak这个方法(或者可以称为功能模块)抽取出
来,作为一个接口来实现,这样只要People类和Robot类都实现这个接口,就能够通用了。
package com.iteye.bolide74.impl;
public interface ISpeaker {
public void Speak(String msg);
}
接下来是新的Robot类和People类,它们都同时实现了ISpeaker这个接口,两者都用了不同的Speak内容来区
分人类和机器人说话方式的不同:
package com.iteye.bolide74.action;
import com.iteye.bolide74.impl.ISpeaker;
public class Robot implements ISpeaker {
public String name;
public String color;
public double height;
public double width;
public double weight;
public Robot(String name, String color, double height, double width,
double weight) {
this.name = name;
this.color = color;
this.height = height;
this.width = width;
this.weight = weight;
}
@Override
public void Speak(String msg) {
System.out.println(msg + ",我是" + this.name + ",我的体重为" + this.weight);
}
}
package com.iteye.bolide74.action;
import com.iteye.bolide74.impl.ISpeaker;
public class People implements ISpeaker {
public String name;
public double height;
public double weight;:
public People(String name, double height, double weight) {
this.name = name;
this.height = height;
this.weight = weight;
}
@Override
public void Speak(String msg) {
System.out.println(msg + ",我是" + this.name + ",我就不告诉你我有多重!");
}
}
接下来就是工厂类和实现类了。这个工厂类就不是生产具体的实例对象了,而是生产一个通用的能够Speak的抽
象实例(某个能打招呼的东西,或许是人类,或许是机器人)
package com.iteye.bolide74.tester;
import com.iteye.bolide74.action.People;
import com.iteye.bolide74.action.Robot;
import com.iteye.bolide74.impl.ISpeaker;
class SpeakerFactory {
public ISpeaker getSpeaker(int speakerType) {
ISpeaker speaker;
switch (speakerType) {
case 0:
speaker = new Robot("robot0", "black", 80.000, 40.0000, 1000.0000);
break;
case 1:
speaker = new People("GirlFriend", 1.64, 99.99);
break;
default:
speaker = new Robot("defaultRobot", "red", 10.000, 10.0000,
300.0000);
break;
}
return speaker;
}
}
public class IoCTester {
public static void main(String[] args) {
SpeakerFactory speakerFactory = new SpeakerFactory();
ISpeaker speaker = speakerFactory.getSpeaker(1);
speaker.Speak("Hello,World!");
}
}
输出结果:
引用
Hello,World!,我是GirlFriend,我就不告诉你我有多重!
如此一来的话就很方便了,我们不用再像之前的简单工厂模式那样每次打招呼的时候都要重新实例化一个不同
的工厂,而是实例化了一个能生成某种类别不确定但是一定能够speak打招呼的对象的通用工厂,然后用统一
ISpeaker接口来实例化“打招呼”这个功能模块,至于打招呼是让机器人去还是让女朋友去就只要抽象工厂生
成的时候告诉它一下代号就行了。
这样的话就能够在尽可能少修改实现代码的前提下,尽可能的实现各种情况下的同一种功能。
4:单例模式
package com.iteye.bolide74.action;
public class Girlfriend {
private static Girlfriend girlfriend; //类的静态成员属性形式声明一个实例
public String name;
public double height;
public double weight;
private Girlfriend(String name, double height, double weight) {
this.name = name;
this.height = height;
this.weight = weight;
}
public static Girlfriend getGirlfriend() {
if (girlfriend == null)
girlfriend = new Girlfriend("GirlFriend", 1.64, 99.99);
return girlfriend;
}
public void Speak(String msg) {
System.out.println(msg + ",我是" + this.name + ",我是唯一的女朋友");
}
}
大家可以看到这个Girlfriend类,跟前面一篇的静态工厂模式非常像,它们的构造函数都是private私有的,都有
一个静态的实例生成方法。作用也是相同的,就是限制生成实例的办法只有一种,就是通过getGirlfriend()方法
来获取。
区别有两点:
1) 静态工厂生成的实例对象{Robot2 robot2;},都是在getRobot()这个生产实例的方法内部声明的,也就是说
这些引用对象都是局部变量。
而单例模式里生成的实例对象{private static Girlfriend girlfriend;},是在getGirlfriend()这个生产实例的方
法的外部声明,并且还加了static静态修饰词的,这就代表了它这个是类的静态成员属性,它是唯一的并且是无
需实例化就能使用的(因为是static的),只不过这里又加了一个private私有修饰词,不能被外部直接访问而已。
2) Girlfriend类里的getGirlfriend()方法内部,加了一个判断,作用是如果girlfriend这个静态类属性,同时也是
这个类的一个实例对象为null,那么就新建一个实例对象给它;如果不为null,也就是已经有实例了,那么就直
接返回已经存在的那个实例对象。
分享到:
相关推荐
工厂模式分为三种主要类型:简单工厂模式、工厂方法模式和抽象工厂模式。 1. **简单工厂模式** 简单工厂模式是最简单的工厂模式实现,它提供一个静态方法或者类来创建对象,这个类通常被称为“工厂”。用户只需要...
在软件设计模式中,工厂模式是一组非常基础且实用的设计模式,主要分为简单工厂模式、工厂方法模式和抽象工厂模式。这些模式都是为了解决对象创建的问题,通过封装对象的创建过程,使得代码更加灵活,易于扩展和维护...
**简单工厂模式**是软件设计模式中的一种,属于创建型模式。在Java编程中,它是一种用于创建对象的简便方法,将对象的实例化过程封装到一个单独的工厂类中,使得客户端代码无需直接调用具体类的构造函数,而是通过...
UML文档-简单工厂模式 简单工厂模式是一种专门负责将大量有共同接口的类实例化的模式,而不必事先知道每次是要实例化哪一个类的模式。它定义一个用于创建对象的接口,由子类决定实例化哪一个类。 简单工厂模式的...
java设计模式 简单工厂模式uml类图,一张图就让你秒懂简单工厂模式
简单工厂模式是一种创建型设计模式,它提供了一个创建对象的接口,但允许子类决定实例化哪一个类。这种模式使得代码能够将实例化的责任封装起来,使得客户端代码无需关心具体的对象实现,只需要知道一个公共接口即可...
"C#简单工厂模式女娲造人"这个标题和描述采用了一种形象的比喻,将创建对象的过程比作神话故事中的女娲造人,以帮助理解简单工厂模式的基本概念。 简单工厂模式是一种创建型设计模式,它的核心思想是提供一个工厂类...
**Android计算器(简单工厂模式)** 简单工厂模式是一种创建型设计模式,它提供了一种创建对象的最佳方式。在这个模式中,一个单独的类(被称为工厂)负责创建对象,客户端通过调用工厂方法来获取所需的对象,而无需...
本文将深入探讨"反射"以及两种常见的工厂模式:"简单工厂模式"和"工厂方法模式",并结合提供的文件名称来解析这些概念。 首先,我们来看"反射"。在Java等面向对象语言中,反射是一种强大的工具,它允许程序在运行时...
简单工厂模式是一种设计模式,它是创建型模式的一种,主要用于简化对象的创建过程。在这个模式中,有一个工厂类负责创建特定类型的对象,而客户端通过调用工厂的方法来获取所需的实例,无需关心具体的创建过程。这种...
简单工厂模式是一种创建型设计模式,它提供了一个创建对象的接口,但允许子类决定实例化哪一个类。这种类型的设计模式属于类创建模式,因为工厂类是基于类的。在简单工厂模式中,一个工厂类根据传入的参数来决定创建...
**简单工厂模式计算器** 在软件设计模式中,简单工厂模式是一种常用的创建型模式,它提供了一个创建对象的接口,但允许子类决定实例化哪一个类。在这个案例中,"C++制作的简单工厂模式计算器"就是一个运用了简单...
简单工厂模式是设计模式中的一种创建型模式,它提供了一种创建对象的最佳方式。在这个模式中,一个专门的类(称为工厂类)负责创建对象,客户端不再直接创建对象,而是通过调用工厂类的方法来得到所需的产品。这种...
本文将深入探讨三种工厂模式:简单工厂模式、工厂方法模式以及抽象工厂模式,并结合源码分析其应用场景和优缺点。 1. 简单工厂模式 简单工厂模式(Simple Factory Pattern)是一种静态工厂方法,它通过一个公共的...
简单工厂模式是软件设计模式中的一种创建型模式,它提供了一种创建对象的最佳方式。在简单工厂模式中,一个工厂类负责创建所有相关的对象,而客户端只需要知道具体的产品类型,无需了解如何创建这些对象的细节。这种...
简单工厂模式是一种创建型设计模式,它提供了一个创建对象的接口,但允许子类决定实例化哪一个类。这种模式使代码能够将实例化过程封装起来,使得客户端代码无需知道具体的产品类名,只需要知道产品类型即可。在C#中...
Java简单工厂模式是一种设计模式,它是创建型模式的一种,用于将对象的创建过程封装到一个独立的工厂类中,使得客户端代码无需关心具体的对象创建细节,只需要知道如何调用工厂方法即可得到所需的对象。这种模式在...
【Java 简单工厂模式】简单工厂模式是一种创建型设计模式,它的主要思想是提供一个工厂类,根据传入的参数动态地返回一个产品对象。这种模式将对象的创建与对象的使用分离,使得代码更加简洁且易于维护。 在Java中...