大家一般在什么情况下会用switch结构呢

Question

我的认为switch机构 都没if 好用哦
 switch 只能判断 选择
比如说 switch(name):
       cese 1:       case 2:
      
   可是要怎么来判断字符串的呢！！
 
       请大家说说switch有什么好处

Answer 1

感觉比有时比if更加直观，不那么绕！但是有时候还是用if比较好，这就要是情况而定了！你觉得用什么好久用什么！

Answer 2

switch适合相同的条件下根据不同的值产生不同的结果的情况。

Answer 3

面向对象程序设计中应该少用或者不用 switch...case 结构

Answer 4

在面向对象程序中应该使用多态来替代 switch...case

Answer 5

学习了
如果传入的是一个参数，并且参数可以在某些范围之内用switchcase的话，可以省去很多if。。else

Answer 6

if/else多用于循环吧，要是程序的主旨是通过某个输入的值来确定要执行的语句，我觉得用switch就比较好~一点小见解哈~

Answer 7

感觉这个就如同说用java做开发 数据层一定要用orm一样..  
     有的正好用到了判断数字的地方用switch case 显然要比if else要强. 比如rcp中通过下标判断列名的时候....

Answer 8

楼主别着急，我那次看介绍jdk7的文章，jdk7可以用switch判断字符串，但是现在的还不能判断字符串，呵呵 ，等着吧。

Answer 9

"在面向对象程序中应该使用多态来替代 switch...case"
对于这个说法 我不是很赞同 虽然很多书里是这么说的但只是针对某些情况 并不是所有的情况都要考虑多态如果所有switch都用多态来代替 那么switch这个关键字就没有存在的意义了另一方面 switch可以完全用if else来代替如果switch必须用多态来代替 那么if else也用多态来代替吧 这个说法显然不成立

Answer 10

顶，我by accident没用过噢 ^..^

Answer 11

我觉得switch的使用范围有很大的局限性。

Answer 12

在if中出现过多的&&时候，用switch更直观

Answer 13

没说所有的，而是大多数的。举个例子吧，针对一个日志系统，我们有如下的接口定义：01. public interface Log {
02.     
03.     public void trace(String message, Object... args);
04.     public void trace(String message, Throwable throwable, Object... args);
05.     
06.     public void debug(String message, Object... args);
07.     public void debug(String message, Throwable throwable, Object... args);
08.    
09.     public void info(String message, Object... args);
10.     public void info(String message, Throwable throwable, Object... args);
11.    
12.     public void warn(String message, Object... args);
13.     public void warn(String message, Throwable throwable, Object... args);
14.    
15.     public void error(String message, Object... args);
16.     public void error(String message, Throwable throwable, Object... args);
17.    
18.     public void fatal(String message, Object... args);
19.     public void fatal(String message, Throwable throwable, Object... args);
20.    
21.     public void log(Level level, Object obj, Object... args);
22.     public void log(Level level, Object obj, Throwable throwable, Object... args);
23.
24.     public boolean isTraceEnabled();
25.     public boolean isDebugEnabled();
26.     public boolean isInfoEnabled();
27.     public boolean isWarnEnabled();
28.     public boolean isErrorEnabled();
29.     public boolean isFatalEnabled();
30.     public boolean isEnabled(Level level);
31. }Level 是一个 enum 类，其中有 TRACE，DEBUG，INFO，WARN，ERROR，FATAL 等数据，先不看接口中其他代码的实现，我们仅仅研究 21, 22, 30 行的代码实现。如果第 21 行传入的 Level 是一个 Level.DEBUG 的话，那我们理所当然的应该调用 06 行的方法来做这件事情。有很多人可能会在 21，22，30 行的代码实现中使用 if...else 或者是 switch...case 来判断 Level 具体的值，再根据不同的值调用不同的方法。如果今后需要再增加一种日志级别的话，那我们必须更改 21，22，30 行的实现方法，如果这样的话就将打破面向对象程序设计中一个很重要的原则，即“开-闭原则”，“开-闭原则”的思想是：不要去改动已经能正经运行的代码，只能通过新增加实现类来达到目的，所谓的“开”指的是代码对增加实现是开放的，所谓的“闭”指的是对既有代码的修改是关闭的。为了能使用多态来取代 if...else 或者 switch...case 来实现 21，22，30 行的方法，为了对于日后的扩展，我们可以这样做：class LogImpl implements Log {        ......    public void log(Level level, String message, Object... args) {
        level.log(this, message, args);
    }    public void log(Level level, String message, Throwable throwable, Object... args) {
        level.log(this, message, throwable, args);
    }
    
    public boolean isEnabled(Level level) {
        return level.isEnabled(this);
    }
}上面这段是 LogImpl 的部分代码，可以注意一下，这个实现类并不是 public 的，主要是为了对外隐藏实现，大家或许注意到了 Log 接口是 public 的。LogImpl 其他的代码省略了，这里只给出了接口中 20，21，30 行方法的实现，注意看一下是如何调用的。之后来看一下 Level 这个 enum 进行代码重构后是怎么样的：public enum Level {    TRACE {
        public boolean isEnabled(Log log) {
            return log.isTraceEnabled();
        }
        
        public void log(Log log, String message, Object... args) {
            log.trace(message, args);
        }
        
        public void log(Log log, String message, Throwable throwable, Object... args) {
            log.trace(message, throwable, args);
        }
    },    DEBUG {
        public boolean isEnabled(Log log) {
            return log.isDebugEnabled();
        }
        
        public void log(Log log, String message, Object... args) {
            log.debug(message, args);
        }
        
        public void log(Log log, String message, Throwable throwable, Object... args) {
            log.debug(message, throwable, args);
        }
    },    INFO {
        public boolean isEnabled(Log log) {
            return log.isInfoEnabled();
        }
        
        public void log(Log log, String message, Object... args) {
            log.info(message, args);
        }
        
        public void log(Log log, String message, Throwable throwable, Object... args) {
            log.info(message, throwable, args);
        }
    },    WARN {
        public boolean isEnabled(Log log) {
            return log.isWarnEnabled();
        }
        
        public void log(Log log, String message, Object... args) {
            log.warn(message, args);
        }
        
        public void log(Log log, String message, Throwable throwable, Object... args) {
            log.warn(message, throwable, args);
        }
    },    ERROR {
        public boolean isEnabled(Log log) {
            return log.isErrorEnabled();
        }
        
        public void log(Log log, String message, Object... args) {
            log.error(message, args);
        }
        
        public void log(Log log, String message, Throwable throwable, Object... args) {
            log.error(message, throwable, args);
        }
    },    FATAL {
        public boolean isEnabled(Log log) {
            return log.isFatalEnabled();
        }
        
        public void log(Log log, String message, Object... args) {
            log.fatal(message, args);
        }
        
        public void log(Log log, String message, Throwable throwable, Object... args) {
            log.fatal(message, throwable, args);
        }
    };
    // 定义三个抽象方法，用于多态的实现
    
    /**
     * 是否启用当前级别的日志
     */
    abstract boolean isEnabled(Log log);
    
    /**
     * 记录当前级别的日志
     * @param log
     * @param message
     * @param args
     */
    abstract void log(Log log, String message, Object... args);
    abstract void log(Log log, String message, Throwable throwable, Object... args);
}上面这个是 Level 枚举的代码，其中定义了三个包内可见的 abstract 方法，主要是为了把这三个方法仅提供给包内的类使用，其他地方不可使用。再回到 LogImpl 的那三个方法中，如今是采用这种步骤运作的，通过调用 Level 中具体的日志级别中具体的方法来实现 Level 指定日志级别的日志记录。通过对以上代码的重构，我们可以看出代码结构很清楚，调用明确，看不到 if...else 和 switch...case 语句，由于根据 Level 指定日志级别进行调用，完全掌控在 Level 这一个 enum 中，与其他类没有什么关系，与其他类之间的通信都是依赖于接口和抽象进行的。

Answer 14

java 7就支持在switch使用字符串了。

Answer 15

我这里所说的在代码是尽量少用 switch...case，是从代码结构和面向对象设计角度上来看的。并不是从算法和数据结构来看的，在算法和数据结构中 if...else/switch...case 有无可替代的作用，特别是在字符串算法中 switch...case 亦然。希望大家能明白。

Answer 16

switch...case语句是面向过程的
面向对象语言中尽量少用

Answer 17

可以善于利用switch的穿透能力

Answer 18

   呵呵！
  那么请问下switch 存在的意义呢！！
        

Answer 19

回33楼我说的是具体问题具体分析 如果没有必要把判断的内容抽象出来 用switch搞定就行了

Answer 20

已经很久没用SWITH了。。
终于有一天，一个同学让我写个switch。。我说好吧然后我说额。。突然想起来switch是要int型哎
宝宝火了宝宝我理解你的
不过对于内部类，我很多疑惑
另，你是不是把源代码都快看完了