Java学习笔记——设计模式之一简单工厂

蜀道之难。难于上青天,侧身西望长咨嗟

                 ——蜀道难

设计模式第一篇,简单工厂。

定义Operation类

 1 package cn.no1.simplefactory;
 2
 3 public abstract class Operation {
 4
 5     private double numA;
 6     private double numB;
 7
 8     public double getNumA() {
 9         return numA;
10     }
11
12
13     public void setNumA(double numA) {
14         this.numA = numA;
15     }
16
17
18     public double getNumB() {
19         return numB;
20     }
21
22
23     public void setNumB(double numB) {
24         this.numB = numB;
25     }
26
27     public abstract double calculate ();
28 }

定义其四个子类

 1 package cn.no1.simplefactory;
 2
 3 public class OperationAdd extends Operation{
 4
 5     @Override
 6     public double calculate() {
 7         // TODO Auto-generated method stub
 8         return this.getNumA() + this.getNumB();
 9     }
10
11 }
12 public class OperationSub extends Operation {
13
14     @Override
15     public double calculate() {
16         // TODO Auto-generated method stub
17         return this.getNumA()-this.getNumB();
18     }
19
20 }
21 public class OperationMultiply extends Operation{
22
23     @Override
24     public double calculate() {
25         // TODO Auto-generated method stub
26         return this.getNumA()*this.getNumB();
27     }
28
29 }
30 public class OperationDivide extends Operation{
31
32     @Override
33     public double calculate() {
34         // TODO Auto-generated method stub
35         return this.getNumA()/this.getNumB();
36     }
37
38 }

定义工厂类

 1 package cn.no1.simplefactory;
 2
 3 public class OperationFactory {
 4
 5     public static Operation createOperation(String operator){
 6         Operation operation = null;
 7         switch (operator) {
 8         case "+":
 9             operation = new OperationAdd();
10             break;
11         case "-":
12             operation = new OperationSub();
13             break;
14         case "*":
15             operation = new OperationMultiply();
16             break;
17         case "/":
18             operation = new OperationDivide();
19             break;
20      }
21         return operation;
22     }
23 }

测试类:

 1 package cn.no1.simplefactory;
 2
 3 import java.util.Scanner;
 4
 5 public class _Test {
 6
 7     public static void main(String[] args) {
 8         Scanner sc = new Scanner(System.in);
 9         System.out.println("输入数字1:");
10         double numA = sc.nextDouble();
11         System.out.println("输入数字2:");
12         double numB = sc.nextDouble();
13         System.out.println("输入操作符:");
14         String operator = sc.next();
15         sc.close();
16         Operation operation = OperationFactory.createOperation(operator);
17         operation.setNumA(numA);
18         operation.setNumB(numB);
19         double result = operation.calculate();
20         System.out.println("计算结果是:"+result);
21     }
22 }
时间: 2024-09-30 20:42:35

Java学习笔记——设计模式之一简单工厂的相关文章

学习大话设计模式01_简单工厂模式(简易计算器)

1 /** 2 * 面向对象(运算类) 3 * 简易计算器 4 * @author Monica 5 * 6 */ 7 public class Operation { 8 private double numberA = 0; 9 private double numberB = 0; 10 11 //虚函数 12 public double GetResult() { 13 double result = 0; 14 return result; 15 } 16 17 public doub

《大话设计模式》学习笔记系列--1. 简单工厂模式

简单工厂模式实现了一种"工厂"概念的面向对象设计模式,它可以在不指定对象具体类型的情况下创建对象.其实质是定义一个创建对象的接口,但让实现这个接口的类来决定实例化具体类.工厂方法让类的实例化推迟到子类中进行. 以书本上的计算器程序为例,其UML描述如下: 图中,AddOperator, SubtactOpertor继承算式基类Operator,而CreateOperator则是负责创建一个操作类,而不指明具体的子类类型. 下面,我们来看代码: 首先操作积累: /// <summa

【设计模式学习笔记】 之 简单工厂模式

 简介:工厂模式(Factory Pattern)是 Java 中最常用的设计模式之一.这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式. 在工厂模式中,我们在创建对象时不会对客户端暴露创建逻辑,拒绝客服端程序员通过new创建需要的实例,并且是通过使用一个共同的接口来指向新创建的对象,即接口引用指向实现类对象,是多态的灵活运用. 举例1[未使用工厂模式]: 一个家庭中有多辆汽车,这个家庭想去出游,需要先传一个Car到Family中持有,才能出游. 首先考虑多辆汽车,都有同样的ru

Java学习笔记——设计模式之五.工厂方法

水边一只青蛙在笑 --石头和水 工厂方法模式(Factory Method),定义了一个用于创建对象的接口,让实现类决定实例化哪一个类.工厂方法使一个类的实例化延迟到其子类. 这里在简单和工厂的基础上写工厂: 先定义一个接口 1 package cn.no5.factorymethod; 2 3 import cn.no1.simplefactory.Operation; 4 5 public interface IFactory { 6 7 Operation CreateOperation(

JAVA学习笔记-----设计模式之工厂模式

1.设计模式---------->工厂模式: Sender.java package me.ele.mytest; public interface Sender {    public void send(); } 2.MailSend package me.ele.mytest; public class MailSend implements Sender {     @Override     public  void send()     {         System.out.pr

Java学习笔记——设计模式之十.观察者模式

 观察者模式(Observer),定义了一种一对多的依赖关系,让多个观察者对象同时监听某一个主题对象.这个主题对象在状态发生变化时,会通知所有观察者对象,使他们能够自动更新自己. Subject类: 1 package cn.happy.design_pattern._10publishsubscribe; 2 3 import java.util.ArrayList; 4 import java.util.List; 5 6 public class Subject { 7 8 private

Java学习笔记——设计模式之九.建造者模式

 建造者模式(Builder),将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示. Product类: 1 package cn.happy.design_pattern._09builder; 2 3 import java.util.ArrayList; 4 import java.util.List; 5 6 public class Product { 7 8 List<String> parts = new ArrayList<>(); 9 10

Java学习笔记——设计模式之六.原型模式(浅克隆和深克隆)

That there's some good in this world, Mr. Frodo. And it's worth fighting for. 原型模式(prototype),用原型实例指定创建对象的种类,并且通过拷贝这些原型创建新的对象. 至于Object.clone()这里就不赘述了.文档看起来可能有些难懂,直接上代码反而更容易理解: 浅克隆: 1 package cn.happy.design_pattern._06prototype.shallowclone; 2 3 pub

java学习笔记-设计模式16(观察者模式)

意图 定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时, 所有依赖于它的对象都得到通知并被自动更新. public interface Observer { public void update(); } public class Observer1 implements Observer { @Override public void update() { System.out.println("observer1 has received!"); } } public