使用面向对象技术替代switch-case和if-else

最新推荐文章于 2022-11-13 21:56:34 发布
最新推荐文章于 2022-11-13 21:56:34 发布
阅读量698 收藏
点赞数
分类专栏： java学习 文章标签： string delete class types interface 测试

本文出自 “子 孑 ” 博客，http://zhangjunhd.blog.51cto.com/113473/68070

  在日常开发中，常常会作一些状态判断，用到 swich-case 与 if-else 。在面向对象的环境里，有两种方式可以替代它们。一种是使用继承子类的多态，另一种是使用 state 模式。它们使用对象的间接性有效地摆脱了传统的状态判断。

举个例子。
Method.java
package com.zj.original;
 
import com.zj.utils.NoMethodTypeException;
 
public class Method {
    private int _type ;
    public static final int POST = 0;
    public static final int GET = 1;
    public static final int PUT = 2;
    public static final int DELETE = 3;
 
    public Method( int type) {
       _type = type;
    }
 
    public String getMethod() throws NoMethodTypeException {
       switch ( _type ) {
       case POST :
           return "This is POST method" ;
       case GET :
           return "This is GET method" ;
       case PUT :
           return "This is PUT method" ;
       case DELETE :
           return "This is DELETE method" ;
       default :
           throw new NoMethodTypeException();
       }
    }
 
    public boolean safeMethod() {
       if ( _type == GET )
           return true ;
       else
           return false ;
    }
 
    public boolean passwordRequired() {
       if ( _type == POST )
           return false ;
       else
           return true ;
    }
}
类 Method 中，存在四个状态 Post 、 Get 、 Put 和 Delete 。有一个 switch-case 判断，用于输出四种方法的描述信息；两个 if-else 判断，分别判断方法是否安全 ( 只有 Get 方法是安全的 ) ，方法是否需要密码 ( 只有 Post 方法不需要密码 ) 。
 
1. 使用继承子类多态
使用继承子类多态的方式，通常对于某个具体对象，它的状态是不可改变的 ( 在对象的生存周期中 ) 。

现在使用四个子类分别代表四种类型的方法。这样就可以使用多态将各个方法的具体逻辑分置到子类中去了。
在抽象基类 Method 中可以提供创建子类实例的静态方法，当然也可以使用 Simple Factory 模式。对于 getMethod() 方法，延迟到子类中实现；对于 safeMethod() 方法和 passwordRequired() 方法，提供一个默认的实现，这个实现应该符合绝大部分子类的要求，这样的话，对于少数不符合默认实现的子类只需 override 相应方法即可。
<<abstract>>Method.java
package com.zj.subclass;
 
public abstract class Method {
 
    public final static Method createPostMethod() {
       return new PostMethod();
    }
 
    public final static Method createGetMethod() {
       return new GetMethod();
    }
 
    public final static Method createPutMethod() {
       return new PutMethod();
    }
 
    public final static Method createDeleteMethod() {
       return new DelMethod();
    }
 
    abstract public String getMethod();
 
    public boolean safeMethod() {
       return false ;
    }
 
    public boolean passwordRequired() {
       return true ;
    }
}
四个子类分别继承和 override 相应的方法。
PostMethod.java
package com.zj.subclass;
 
public class PostMethod extends Method {
    @Override
    public String getMethod() {
       return "This is POST method" ;
    }
 
    @Override
    public boolean passwordRequired() {
       return false ;
    }
}
GetMethod.java
package com.zj.subclass;
 
public class GetMethod extends Method{
    @Override
    public String getMethod() {
       return "This is GET method" ;
    }
 
    @Override
    public boolean safeMethod() {
       return true ;
    }
}
PutMethod.java
package com.zj.subclass;
 
public class PutMethod extends Method {
    @Override
    public String getMethod() {
       return "This is PUT method" ;
    }
}
DelMethod.java
package com.zj.subclass;
 
public class DelMethod extends Method{
    @Override
    public String getMethod(){
       return "This is DELETE method" ;
    }
}
2. 使用 state 模式
如果希望对象在生存周期内，可以变化自己的状态，则可以选择 state 模式。

这里抽象状态为一个接口 MethodType ，四种不同的状态实现该接口。
<<interface>>MethodType.java
package com.zj.state;
 
public interface MethodType {
    String getTypeDescription();
 
    String getMethodDescription();
 
    boolean isSafe();
 
    boolean isRequired();
}
Post.java
package com.zj.state;
 
public class Post implements MethodType{
    public String getMethodDescription() {
       return "This is POST method" ;
    }
 
    public String getTypeDescription() {
       return "===POST===" ;
    }
 
    public boolean isRequired() {
       return false ;
    }
 
    public boolean isSafe() {
       return false ;
    }
}
Get.java
package com.zj.state;
 
public class Get implements MethodType{
    public String getMethodDescription() {
       return "This is GET method" ;
    }
 
    public String getTypeDescription() {
       return "===GET===" ;
    }
 
    public boolean isRequired() {
       return true ;
    }
 
    public boolean isSafe() {
       return true ;
    }
}
Put.java
package com.zj.state;
 
public class Put implements MethodType{
    public String getMethodDescription() {
       return "This is PUT method" ;
    }
 
    public String getTypeDescription() {
       return "===PUT===" ;
    }
 
    public boolean isRequired() {
       return true ;
    }
 
    public boolean isSafe() {
       return false ;
    }
}
Delete.java
package com.zj.state;
 
public class Delete implements MethodType{
    public String getMethodDescription() {
       return "This is DELETE method" ;
    }
 
    public String getTypeDescription() {
       return "===DELETE===" ;
    }
 
    public boolean isRequired() {
       return true ;
    }
 
    public boolean isSafe() {
       return false ;
    }
}
此时，在类 Method 中保存一个 field 表示 MethodType ，在某对象中，可以随时变化四种已知的状态 ( 具体见 runAllMethods() 方法 ) 。
Method.java
package com.zj.state;
 
public class Method {
    private MethodType _type ;
 
    public Method() {
       _type = null ;
    }
 
    public Method(MethodType type) {
       _type = type;
    }
 
    public String getMethod() {
       return _type .getMethodDescription();
    }
 
    public boolean safeMethod() {
       return _type .isSafe();
    }
 
    public boolean passwordRequired() {
       return _type .isRequired();
    }
 
    public void changeType(MethodType type) {
       _type = type;
    }
 
    public void runAllMethods() {
       MethodType[] types = new MethodType[] { new Post(), new Get(),
              new Put(), new Delete() };
       for (MethodType type : types) {
           System. out .println(type.getTypeDescription());
           changeType(type);
           System. out .println(getMethod());
           System. out .println(safeMethod());
           System. out .println(passwordRequired());
       }
    }
}
3. 测试
在测试类中，分别使用上面 3 中机制展示结果。它们的结果应该是一致的。
Client.java
package com.zj.utils;
 
public class Client {
    static void print(String s) {
       System. out .println(s);
    }
 
    static void print(Boolean b) {
       System. out .println(b);
    }
 
    public static void main(String[] args) throws NoMethodTypeException {
       print ( "===original===" );
       print ( "===POST===" );
       com.zj.original.Method post1 = new com.zj.original.Method(
              com.zj.original.Method. POST );
       print (post1.getMethod());
       print (post1.safeMethod());
       print (post1.passwordRequired());
       print ( "===GET===" );
       com.zj.original.Method get1 = new com.zj.original.Method(
              com.zj.original.Method. GET );
       print (get1.getMethod());
       print (get1.safeMethod());
       print (get1.passwordRequired());
       print ( "===PUT===" );
       com.zj.original.Method put1 = new com.zj.original.Method(
              com.zj.original.Method. PUT );
       print (put1.getMethod());
       print (put1.safeMethod());
       print (put1.passwordRequired());
       print ( "===DELETE===" );
       com.zj.original.Method del1 = new com.zj.original.Method(
              com.zj.original.Method. DELETE );
       print (del1.getMethod());
       print (del1.safeMethod());
       print (del1.passwordRequired());
 
       print ( "===subclass===" );
       print ( "===POST===" );
       com.zj.subclass.Method post2 = com.zj.subclass.Method
              .createPostMethod ();
       print (post2.getMethod());
       print (post2.safeMethod());
       print (post2.passwordRequired());
       print ( "===GET===" );
       com.zj.subclass.Method get2 = com.zj.subclass.Method.createGetMethod ();
       print (get2.getMethod());
       print (get2.safeMethod());
       print (get2.passwordRequired());
       print ( "===PUT===" );
       com.zj.subclass.Method put2 = com.zj.subclass.Method.createPutMethod ();
       print (put2.getMethod());
       print (put2.safeMethod());
       print (put2.passwordRequired());
       print ( "===DELETE===" );
       com.zj.subclass.Method del2 = com.zj.subclass.Method
              .createDeleteMethod ();
       print (del2.getMethod());
       print (del2.safeMethod());
       print (del2.passwordRequired());
 
        print ( "===state===" );
       new com.zj.state.Method().runAllMethods();
    }
}

 

eagullx
关注
专栏目录
Unity3d 面向对象设计思想（二）（动态UI的分配与调度）
Unity3d 攻城师一枚
04-09 6086
昨天写了一个UI弹窗，功能是可以实现，但是使用起来不是很方便，如果需要代码动态指定 静态弹窗无法满足项目的需求，比如服务器断开连接，诸如此类的UI，需要代码来动态实现，这样才可以使用起来 项目化，可以封装到弹窗的类型，弹窗显示的内容，包括弹窗显示一些游戏奖品道具这类物品
java多态替换switch_使用面向对象技术替代switch-case和if-else
weixin_36342477的博客
03-08 1125
在日常开发中，常常会作一些状态判断，用到swich-case与if-else。在面向对象的环境里，有两种方式可以替代它们。一种是使用继承子类的多态，另一种是使用state模式。它们使用对象的间接性有效地摆脱了传统的状态判断。举个例子。Method.javapackagecom.zj.original;importcom.zj.utils.NoMethodTypeException;publiccl...
面向对象与IF-ElSE
★ 喜欢看海 ★
02-27 2976
                            面向对象与IF-ElSE我们这里要讨论的问题是，对于代码中出现了很多的IF-Else，我们如何处理我之前写了个代码，要求对输入的不同字符作不同处理，所以写了很多IF-Else，后来，需求增加，也就是增加了一些判断，我把所有的半段都提出来放到了一个方法里，利用flag进行表示处理，虽然解决了需求的扩展问题，但是大量的IF-Else没有得
C语言学习—使用函数指针替代switch...case...
m0_52867233的博客
11-13 912
使用函数指针替代switch...case...
面向对象开发技术06_01 多态-动态-静态-替换
qq_52370024的博客
06-16 1086
与替换原则结合使用。实现运行时多态技术的条件：采用多态技术的优点： 引进多态技术之后，尽管子类的对象千差万别，但都可以采用 父类引用.方法名([参数])　统一方式来调用，在程序运行时能根据子对象的不同得到不同的结果。这种“以不变应万变”的形式可以规范、简化程序设计，符合软件工程的“一个接口，多种方法”思想。两种不同的关于改写/覆盖/重写的解释方式： pet.bark() ; →error, Animal中没有bark方法，编译错误 转换表示程序员所进行的显式类型转换。在许多语言里这种转换操作称为“造型”
不要再用if/else和switch/case了，快使用“表驱动法”代替，面向对象思维，对修改关闭。
CodeBowl的博客
06-13 718
表驱动是一种编程模式，是一种将输入变量作为索引在表里查找直接的结果或者处理函数，而不是用很多的逻辑语句来进行判断(比如if-sle||switch_case).索引表可以是个数组、map或者其他高效率查找的数据结构。...
如何在JAVA编程中干掉if/else、switch/case（三）
java的平凡之路
05-24 853
前言 前面的文章咱们通过表驱动法、策略模式两种方法替换掉JAVA代码里的if...else和switch...case，今天继续介绍第三种方法：责任链设计模式。在WEB应用中，大名鼎鼎的filter链就是责任链模式的具体实现。在笔者一个实际项目中就用到责任链模式，来看看吧。 场景 所有移动端app开发，都会面临一个问题：升级！后台在开发升级接口时，会判断很多逻辑，比如版本是否在升级的范...
python中Switch/Case实现的示例代码
09-21
在Python编程语言中，与许多其他面向对象的语言如C、C++或Java不同，Python并没有内置的`switch/case`语句。然而，由于Python的灵活性和动态特性，可以通过多种方式来模拟`switch/case`的功能。以下是几种常见的实现...
switch 语句与 case 语句一起使用，每个 case 对应一个可能的值.rar
最新发布
06-13
它们通常用于替代多个`if...else if...else`结构，使得代码更加简洁易读。下面我们将深入探讨`switch`语句和`case`语句的工作原理、语法特点以及在实际编程中的应用。 `switch`语句是基于表达式值进行判断的多路...
使用对象代替 if 及 switch
半夏_2021的博客
07-12 1015
使用对象代替 if 及 switch
面向对象思想 - 面向对象与if else语句
qazw9600的专栏
05-22 540
说明 面向过程设计和面向对象设计的区别之一：是否在业务逻辑层使用冗余的if else判断，如果你还在大量使用if else，当然，界面表现层除外，即使你使用Java/C#这样完全面向对象的语言，也只能说明你的思维停留在传统的面向过程语言上。 个人理解 上面的话是在解道技术博客上摘录的，相信在很多博客上有说明，但是大部分没有描述清晰，至少我一时没理解。 首先面向对象设计不是完全干掉if else语句，只是尽可能的减少冗余的if else语句，不可能完全不使用，判断是编程的基础元素，如果完全不需要使用，面
架构 之 使用子类多态 and 使用state模式（使用面向对象技术替代switch-case和if-else）
05-15 958
在日常开发中，常常会作一些状态判断，用到swich-case与if-else。在面向对象的环境里，有两种方式可以替代它们。一种是使用继承子类的多态，另一种是使用state模式。它们使用对象的间接性有效地摆脱了传统的状态判断。 举个例子。 Method.java package com.zj.original;   import com.zj.utils.NoMethodT
C#用什么方法可以减少或不使用switch
weixin_34329187的博客
03-04 166
有在论坛看见一帖，《C#用什么方法可以减少或不使用switch》   Insus.NET的解决方法，是使用工厂方法来处理，可以创建一个工厂接口，然后每个方法设计为一个工厂类，并实现工厂接口。 工厂接口： IGetFactory using System; using System.Collections.Generic; using System.Linq; using Sys...
替换switch case方法的方式1--多态
小刚的专栏
03-04 6713
double getSpeed() { switch (_type) { case EUROPEAN: return getBaseSpeed(); case AFRICAN: return getBaseSpeed() - getLoadFactor() * _numberOfCoconuts; case NORWEGI
switch_case对象
xiaodan007的专栏
08-27 1114
/******************************************************************** *　 文件名： CLK_LIB.h *　 文件描述： Switch_Case对象 *　 创建人： 陈泽丹 ,2012年8月27日 *　 版本号： 1.0 *　 修改记录: ***************************
js中使用对象映射代替 if-else,可以这很优雅！
奔跑的面条博客
04-22 1819
没人喜欢一大串的单调的ifelse，有没有更加优雅的方式呢？那就是 jojo 对象映射哒！ 例子： //常见if-else组成的逻辑判断 FnAll(code, p){ if(code === 'a'){ Fna(p); } if(code === 'b'){ Fnb(p); }if(code === 'b'){ Fnc(p); }if(code === 'd'){ F...
Spring通过注解和策略模式简化if-else/switch-case
传统的if-else/switch-case结构虽然直观，但随着业务需求的变化和代码复杂性的增加，可能会导致代码冗长、难以维护和违背面向对象的设计原则。 Spring 提供了一种结合注解（Annotations）、策略模式（Strategy ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值