zoukankan      html  css  js  c++  java
  • 设计模式之简易工厂模式

    需求:从键盘接收,写一个计算器。

    理解:面向对象设计的好处,明白三大特性 “封装,继承,多态”;

    注意:1.命名规范,2.代码重用,3.运算类和界面类分离,实现灵活性,方便维护,易于扩展。

    写一个运算父类:

    package com.opertionFactory;
    
    /**
     * 简易工厂模式:封装,继承,多态
     * 封装:把运算类和控制台分离,方便维护
     * 继承:写一个父类,包含两个属性和一个运算方法,运算方法要重写
     * 多态:指允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。
     *           父类的对象,指向子类的引用,增加灵活性
     * 实现一个计算器,随机输入两个数字进行运行。
     * 计算的父类,有两个double属性, 和一个返回结果的方法
     */
    public class Operation {   //
        private    int  numA  ;
        private   int numB ;
    
        public int getNumA() {
            return numA;
        }
    
        public void setNumA(int numA) {
    
            try {
                this.numA = numA;
            } catch (Exception e) {
                System.out.println("数字输入有误,请重新输入");
            }
        }
    
        public int getNumB() {
            return numB;
        }
    
        public void setNumB(int numB) {
            try {
                this.numB = numB;
            } catch (Exception e) {
                System.out.println("数字输入有误,请重新输入");
            }
        }
    
        public int getResult(){
            int result = 0 ;
            return  result;
        }
    }

    写多个子类,继承父类,并且重写方法;

    package com.opertionFactory;
    
    
    /**
     * 加减乘除 ,继承运算类,三大特性,继承,封装,多态
     * Created by Administrator on 2017/10/13 0013.
     */
     class OperationAdd extends  Operation {
    
        @Override
        public int getResult() {
            int result = 0 ;
    
            result = getNumA() + getNumB();
    
            return  result;
    
        }
    }
    
    class OperationSub extends  Operation {
    
        @Override
        public int getResult() {
            int result = 0 ;
    
            result = getNumA() - getNumB();
    
            return  result;
    
        }
    }
    
    class OperationMul extends  Operation {
    
        @Override
        public int getResult() {
            int result = 0 ;
    
            result = getNumA() * getNumB();
    
            return  result;
    
        }
    }
    
    class OperationDiv extends  Operation {
    
        @Override
        public int getResult() {
            int result = 0 ;
    
            if(getNumB() == 0) {
    
                // System.out.println("被除数不能为0");
                throw new RuntimeException();
            }else {
    
                result = getNumA() / getNumB();
                return  result;
            }
    
    
    
        }
    }

    客户端类;

    package com.opertionFactory;
    
    
    import java.util.Scanner;
    
    /**
     * 简单工厂类
     * Created by Administrator on 2017/10/13 0013.
     */
    
    public class OperationFactory {
    
    
        public static void main(String[] args) {
    
            Scanner scan = new Scanner(System.in);
    
    
            Operation oper= null;
            try {
                System.out.println("请输入运算符 + - * /");
                String str  = scan.nextLine();
    
                oper = OperationFactory.CreatOperation(str);
    
                System.out.println("请输入一个整除数");
                int numA = scan.nextInt();
                oper.setNumA(numA);
    
                System.out.println("请输入一个被除数");
                int numB = scan.nextInt();
                oper.setNumB(numB);
    
                int result = oper.getResult();
                System.out.println("计算结果为:" + result);
            } catch (Exception e) {
                System.out.println("输入有误,请重新输入");
            }
    
        }
    
        public static  Operation CreatOperation(String operate ){
            Operation oper = null;
    
            try {
                switch (operate){
                    case "+":
                        oper = new OperationAdd();
                        break;
                    case "-":
                        oper = new OperationSub();
                        break;
                    case "*":
                        oper = new OperationMul();
                        break;
                    case "/":
                        oper = new OperationDiv();
                        break;
                }
            } catch (Exception e) {
                System.out.println("运算符输入有误,请重新输入");
            }
            return  oper;
        }
        }

    什么是多态

    1. 面向对象的三大特性:封装、继承、多态。从一定角度来看,封装和继承几乎都是为多态而准备的。这是我们最后一个概念,也是最重要的知识点。
    2. 多态的定义:指允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。(发送消息就是函数调用)
    3. 实现多态的技术称为:动态绑定(dynamic binding),是指在执行期间判断所引用对象的实际类型,根据其实际的类型调用其相应的方法。
    4. 多态的作用:消除类型之间的耦合关系。

    多态存在的三个必要条件
    一、要有继承;
    二、要有重写;
    三、父类引用指向子类对象。

     多态的好处

    1.可替换性(substitutability)。多态对已存在代码具有可替换性。例如,多态对圆Circle类工作,对其他任何圆形几何体,如圆环,也同样工作。
    2.可扩充性(extensibility)。多态对代码具有可扩充性。增加新的子类不影响已存在类的多态性、继承性,以及其他特性的运行和操作。实际上新加子类更容易获得多态功能。例如,在实现了圆锥、半圆锥以及半球体的多态基础上,很容易增添球体类的多态性。
    3.接口性(interface-ability)。多态是超类通过方法签名,向子类提供了一个共同接口,由子类来完善或者覆盖它而实现的。如图8.3 所示。图中超类Shape规定了两个实现多态的接口方法,computeArea()以及computeVolume()。子类,如Circle和Sphere为了实现多态,完善或者覆盖这两个接口方法。
    4.灵活性(flexibility)。它在应用中体现了灵活多样的操作,提高了使用效率。
    5.简化性(simplicity)。多态简化对应用软件的代码编写和修改过程,尤其在处理大量对象的运算和操作时,这个特点尤为突出和重要。

    Java中多态的实现方式:接口实现,继承父类进行方法重写,同一个类中进行方法重载。

  • 相关阅读:
    Codeforces 834D The Bakery
    hdu 1394 Minimum Inversion Number
    Codeforces 837E Vasya's Function
    Codeforces 837D Round Subset
    Codeforces 825E Minimal Labels
    Codeforces 437D The Child and Zoo
    Codeforces 822D My pretty girl Noora
    Codeforces 799D Field expansion
    Codeforces 438D The Child and Sequence
    Codeforces Round #427 (Div. 2) Problem D Palindromic characteristics (Codeforces 835D)
  • 原文地址:https://www.cnblogs.com/JavaBlackHole/p/7661464.html
Copyright © 2011-2022 走看看