如何避免大量的重复代码？

Question

经常会碰到像如下的情况，有大量的类似的重复代码，请问如何避免？
1.大量的try...catch，很多方法，其实catch了做的都是一样的操作，像LOG记录一下什么的，有没有办法可以去掉代码中大量的雷同的try...catch呢？
2.给String类型赋值时，经常要判断是否等于NULL，如果为NULL，则设置为空字符串这样的情况，有没好一些的方法或技术可以实现我想知道的是具体的实现技术而不是某某框架可以实现，链接的，复制的均可，当然可以的话，希望能给出简单的示例代码，谢谢

Answer 1

1、等JAVA7(还是8)，会对这问题改进
2、这个我觉得最好有默认值，或者用3元表达式

Answer 2

1.你可以弄一个大的try catch把所有的代码都放进去，但是这样没啥太多好处2.没太明白你的意思

Answer 3

1.虽然程序中可能会用到很多try...catch，但是相信每次用的地方都是为了捕捉不同的东西，我觉得这个不能算作是代码的重复，而且建议try...catch不要太大，这样不利于错误地点的定位。
2.可以不用去判断是否为null，不管什么时候都给后面加上""，但是估计效率会有影响！

Answer 4

1 AOP http://janistoolbox.typepad.com/blog/2009/12/errorhandlingaop.html2 Null Object Pattern http://sinokaka.javaeye.com/blog/32764

Answer 5

关于2，就像这样public void setName(String name){
   if(name==null)//当然，可以用?:，但是出现大量的类似代码还是觉得有点不舒服
      this.name = "";
   else
      this.name = name;
}
谢谢各位的答复

Answer 6

1。没有非常简便的方法，可以考虑使用模式，但别嫌理解起来麻烦，以及性能等问题。
package houlei.java.lang;/**
 * 该类屏蔽的try-catch的相关代码，用户使用时，主要使用本类的对象进行编程。<br/>
 * 当然，主要还要用到<code>TryCatchCallBack</code>类对象进行编程。
 * @see houlei.java.lang.TryCatchCallback
 * @author 侯磊
 */
public class EasyTryCatch {
/**
 * 默认的异常处理器，用户可以根据自己的情况，自定义一个异常处理器，比如，记个日志什么的。
 */
private static final ErrorHandler DefaultHandler = ConsoleErrorHandler.getInstance();
/**
 * 当前的异常处理器，如果不进行设置则采用默认的异常处理器。
 */
private ErrorHandler errorHandler = DefaultHandler;

public EasyTryCatch() {
} public EasyTryCatch(ErrorHandler errorHandler) {
super();
this.errorHandler = errorHandler;
} /**
 * 用户通过调用该方法来完成对try-catch块内的代码调用。
 * @param callback try-catch块内要执行的代码，都封装在这里。
 */
public void doTryCatch(TryCatchCallback callback){
try{
callback.doContext();
}catch (Throwable t) {
errorHandler.handleError(t);
}
} public ErrorHandler getErrorHandler() {
return errorHandler;
} public void setErrorHandler(ErrorHandler errorHandler) {
this.errorHandler = errorHandler;
}

}package houlei.java.lang;/**
 * 该接口的实现类主要用于封装try-catch块内，要执行的代码。<br/>
 * 通过<code>EasyTryCatch.doTryCatch</code>方法来回调使用。
 * @see houlei.java.lang.EasyTryCatch
 * @author 侯磊
 */
public interface TryCatchCallback {
/**
 * 回调函数
 * @throws Throwable 该对象实例就是try-catch中的代码抛出的异常，用户不用关心这个，这个会在ErrorHandler里面集中处理。
 */
void doContext()throws Throwable;
}package houlei.java.lang;/**
 * 异常处理器的接口，用于封装针对try-catch块抛出异常的处理过程。<br/>
 * 我这里主要实现了一个将异常打印在控制台的异常处理器，
 * 用户可以考虑根据具体情况来编写实现类，比如写个日志什么的。
 * @see houlei.java.lang.ConsoleErrorHandler
 * @author 侯磊
 */
public interface ErrorHandler {
/**
 * 当try-catch块中的代码抛出异常时，该方法被调用。
 * @param t 在try-catch块中的代码抛出的异常
 */
void handleError(Throwable t);}
package houlei.java.lang;/**
 * 控制台异常处理器，用于将捕获到的异常打印到控制台上。<br/>
 * 由于一般情况下，程序都只有一个控制台，所以，我使用了单例模式，只能产生一个对象。
 * @author 侯磊
 *
 */
public class ConsoleErrorHandler implements ErrorHandler{
    private static ConsoleErrorHandler instance = new ConsoleErrorHandler();
    private ConsoleErrorHandler(){};
    /**
     * 得到控制台异常处理器的对象
     */
    public static ErrorHandler getInstance(){
        return instance;
    }
    /**
     * 将异常的信息打印到控制台上。
     * @see houlei.java.lang.ErrorHandler#handleError(java.lang.Throwable)
     */
    public void handleError(Throwable t) {
        t.printStackTrace();
    }
}
package houlei.java.lang;/**
 * 最土的测试用例。用来指导用户怎样使用这几个类。
 * @author 侯磊
 */
public class EasyTryCatchTest {
/**
 * 由于要产生异常，所以，专门编写了一个能产生异常的代码。大家不要介意。
 */
public static void main(String args[]) {
test0();
System.out.println("----------------------淫-荡-的-分-割-线------------------");
test();
}
/**
 * 这个是原始的执行代码，用来与新的编程方式做对比的。
 */
public static void test0(){
int [] array = new int[]{1,2};
try{
for(int i=0;i<10;i++){
System.out.println(array[i]);
}
}catch(Throwable t){
t.printStackTrace();
}
}
/**
 * 这个是新的编程方式，样例。
 */
public static void test(){
//这是try-catch块前面的代码，注意有些用到的变量要转换成final的。
final int [] array = new int[]{1,2};
//创建EasyTryCatch对象，它封装的try-catch的过程。
EasyTryCatch etc = new EasyTryCatch();
etc.doTryCatch(new TryCatchCallback(){//采用匿名内部类来实现try-catch块的代码。
public void doContext() throws Throwable {
for(int i=0;i<10;i++){
System.out.println(array[i]);
}
}
});
}}

Answer 7

第二个问题，楼主完成可以写一个工具类，把你这个功能做成工具类的一个STATIC方法，这样看起来比较爽一点。而第一个问题，要看看这些日志记录是否有相似性，如果有，则可以封装一下

Answer 8

1.面对不同的异常肯定是需要这么去捕捉和处理的，没什么好说的。你要做的只能总编码的设计去搞定这个事情，比如用一些设计模式之类的。2.这样的判断显然是很有必要的，你不判断可能出现BUG的。这个估计无解，你要是看着烦就用3目表达式或者断言assert之类的东东。

Answer 9

2。可以编写一个工具类，进行处理就可以了。别的没想到。
package houlei.java.lang;/**
 * 字符串的工具类，主要完成针对字符串的一些辅助操作。
 * @author 侯磊
 */
public class StringUtil {

public static final String NULL = "";

/**
 * 如果参数<code>str</code>为<code>null</code>，则返回一个空字符串。<br/>
 * 如果参数<code>str</code>不为<code>null</code>，则返回参数<code>str</code>本身。
 */
public static String maskNull(String str){
return maskNull(str,NULL);
}
/**
 * 如果参数<code>str</code>为<code>null</code>，则返回参数<code>def</code>的值。<br/>
 * 如果参数<code>str</code>不为<code>null</code>，则返回参数<code>str</code>本身。
 */
public static String maskNull(String str,String def){
if(null == str){
str = def;
}
return str;
}}package houlei.java.lang;/**
 * 最土的测试用例。
 * @author 侯磊
 */
public class StringUtilTest {
public static void main(String args []){
String nullStr = null;//空字符串
String str = "hello world ...";//有内容的字符串
String defStr = "default string .";//默认的字符串
System.out.println("----------------------测--试--开--始----------------------");
System.out.println(StringUtil.maskNull(nullStr));//本身为空，返回空字符串。显示为空行。
System.out.println(StringUtil.maskNull(str));//不为空，显示本身
System.out.println(StringUtil.maskNull(nullStr,defStr));//为空，显示默认
System.out.println(StringUtil.maskNull(str,defStr));//不为空，显示本身
}
}

Answer 10

这个度不算是代码的重复，一个try和多个catch结合，字符串的判定通常是要判断字符串是否为空的

Answer 11

1.感觉没太好方法，那里可能会抛出异常就要在哪里捕获，或者你每个底层的方法都throws，在最上层try..cache()
2.如上所说写个工具类就行了，这种简单的判断感觉没有必要做的太花哨了。

Answer 12

2.给String类型赋值时，经常要判断是否等于NULL，如果为NULL，则设置为空字符串这样的情况你这种做法是不对的，等于 null，并不能将其置为空！

Answer 13

我觉得没有try catch，也就是不定义受检异常的情况下，也是需要类似的代码来进行判断的，会有更多判断，try catch设计初衷之一就是尝试简化这些

Answer 14

谢谢各位的回复，让我学到不少
提出这个问题的原因，是因为在代码中能看到不少的，很雷同的重复代码，想要精简却又无从下手，谢谢各位的指导这个情况我是在和实际想联系的时候才这么写的，比如展示给用户时，如果是null只要显示空就成了，谢谢严谨的提示在看struts2的异常处理模式时，发现和preferme的方式有点像，不过就像他说的，有点担心性能方面的问题明天起来结贴，再看看大家有没别的什么意见

Answer 15

  1.这个问题确实纠结，过多的抽象又会影响程序的效率，而直接写又感觉代码非常多的重复。不过其实像try,catch这类语法在维护方面几乎可以忽略，所以还是这样用着吧。
  2.判断师是否为空，你可以写一个工具类，有的人会说就算写一个tools也会有很多地方需要调用，那么你写一个vo也同样有很多地方调用啊。    所以这根本就是个蛋痛的问题。呵呵