反例：_name / __name / $name / name_ / name$ / name__

反例：_name / __name / $name / name_ / name$ / name__

说明：正确的英文拼写和语法可以让阅读者易于理解，避免歧义。注意，纯拼音命名方式更要避免采用。
正例：renminbi / alibaba / taobao / youku / hangzhou 等国际通用的名称，可视同英文。 
反例：DaZhePromotion [打折] / getPingfenByName() [评分] / int 某变量 = 3

说明：正确的英文拼写和语法可以让阅读者易于理解，避免歧义。注意，纯拼音命名方式更要避免采用。
正例：renminbi / alibaba / taobao / youku / hangzhou 等国际通用的名称，可视同英文。 
反例：DaZhePromotion [打折] / getPingfenByName() [评分] / int 某变量 = 3

正例：JavaServerlessPlatform / UserDO / XmlService / TcpUdpDeal / TaPromotion 
反例：javaserverlessplatform / UserDo / XMLService / TCPUDPDeal / TAPromotion

正例：JavaServerlessPlatform / UserDO / XmlService / TcpUdpDeal / TaPromotion 
反例：javaserverlessplatform / UserDo / XMLService / TCPUDPDeal / TAPromotion

说明：子类、父类成员变量名相同，即使是public类型的变量也是能够通过编译，而局部变量在同一方法内的不同代码块中同名也是合法的，但是要避免使用。对于非setter/getter的参数名称也要避免与成员变量名称相同。 
反例： public class ConfusingName { 
  			public int age; 
  			// 非setter/getter的参数名称，不允许与本类成员变量同名 
  			public void getData(String alibaba) { 
          if(condition) { 
            final int money = 531; 
            // ... 
          } 
          for (int i = 0; i < 10; i++) { 
            // 在同一方法体中，不允许与其它代码块中的money命名相同 
            final int money = 615; 
            // ... 
          } 
        } 
      } 
      class Son extends ConfusingName { 
        // 不允许与父类的成员变量名称相同 
        public int age; 
      }

说明：子类、父类成员变量名相同，即使是public类型的变量也是能够通过编译，而局部变量在同一方法内的不同代码块中同名也是合法的，但是要避免使用。对于非setter/getter的参数名称也要避免与成员变量名称相同。 
反例： public class ConfusingName { 
  			public int age; 
  			// 非setter/getter的参数名称，不允许与本类成员变量同名 
  			public void getData(String alibaba) { 
          if(condition) { 
            final int money = 531; 
            // ... 
          } 
          for (int i = 0; i < 10; i++) { 
            // 在同一方法体中，不允许与其它代码块中的money命名相同 
            final int money = 615; 
            // ... 
          } 
        } 
      } 
      class Son extends ConfusingName { 
        // 不允许与父类的成员变量名称相同 
        public int age; 
      }

正例：startTime / workQueue / nameList / TERMINATED_THREAD_COUNT 
反例：startedAt / QueueOfWork / listName / COUNT_TERMINATED_THREAD

正例：startTime / workQueue / nameList / TERMINATED_THREAD_COUNT 
反例：startedAt / QueueOfWork / listName / COUNT_TERMINATED_THREAD

1）第二行相对第一行缩进4个空格，从第三行开始，不再继续缩进，参考示例。 
2）运算符与下文一起换行。 
3）方法调用的点符号与下文一起换行。 
4）方法调用中的多个参数需要换行时，在逗号后进行。 
5）在括号前不要换行，见反例。 正例：
StringBuilder sb = new StringBuilder();
// 超过120个字符的情况下，换行缩进4个空格，点号和方法名称一起换行
sb.append("Jack").append("Ma")...
.append("alibaba")...
.append("alibaba")...
.append("alibaba");

反例：
StringBuilder sb = new StringBuilder();
// 超过120个字符的情况下，不要在括号前换行
sb.append("Jack").append("Ma")...append
("alibaba");
// 参数很多的方法调用可能超过120个字符，不要在逗号前换行
method(args1, args2, args3, ...
, argsX);

1）第二行相对第一行缩进4个空格，从第三行开始，不再继续缩进，参考示例。 
2）运算符与下文一起换行。 
3）方法调用的点符号与下文一起换行。 
4）方法调用中的多个参数需要换行时，在逗号后进行。 
5）在括号前不要换行，见反例。 正例：
StringBuilder sb = new StringBuilder();
// 超过120个字符的情况下，换行缩进4个空格，点号和方法名称一起换行
sb.append("Jack").append("Ma")...
.append("alibaba")...
.append("alibaba")...
.append("alibaba");

反例：
StringBuilder sb = new StringBuilder();
// 超过120个字符的情况下，不要在括号前换行
sb.append("Jack").append("Ma")...append
("alibaba");
// 参数很多的方法调用可能超过120个字符，不要在逗号前换行
method(args1, args2, args3, ...
, argsX);

正例：
int one = 1;
long two = 2L;
float three = 3F;
StringBuilder sb = new StringBuilder();

说明：增加sb这个变量，如果需要对齐，则给one、two、three都要增加几个空格，在变量比较多的情况下，是非常累赘的事情。

正例：
int one = 1;
long two = 2L;
float three = 3F;
StringBuilder sb = new StringBuilder();

说明：增加sb这个变量，如果需要对齐，则给one、two、three都要增加几个空格，在变量比较多的情况下，是非常累赘的事情。

正例："test".equals(object); 
反例：object.equals("test"); 
说明：推荐使用java.util.Objects#equals（JDK7引入的工具类）。

正例："test".equals(object); 
反例：object.equals("test"); 
说明：推荐使用java.util.Objects#equals（JDK7引入的工具类）。

说明：浮点数采用“尾数+阶码”的编码方式，类似于科学计数法的“有效数字+指数”的表示方式。二进制无法精确表示大部分的十进制小数，具体原理参考《码出高效》。 
反例： float a = 1.0f - 0.9f; 
			float b = 0.9f - 0.8f; 
			if (a == b) { 
        // 预期进入此代码快，执行其它业务逻辑 
        // 但事实上a==b的结果为false 
      } 
			Float x = Float.valueOf(a); 
			Float y = Float.valueOf(b); 
			if (x.equals(y)) { 
        // 预期进入此代码快，执行其它业务逻辑 
        // 但事实上equals的结果为false 
      } 
正例： (1) 指定一个误差范围，两个浮点数的差值在此范围之内，则认为是相等的。 
      float a = 1.0f - 0.9f; 
      float b = 0.9f - 0.8f; 
      float diff = 1e-6f; 
      if (Math.abs(a - b) < diff) { 
        System.out.println("true"); 
      } 
		(2) 使用BigDecimal来定义值，再进行浮点数的运算操作。 
      BigDecimal a = new BigDecimal("1.0"); 
			BigDecimal b = new BigDecimal("0.9"); 
			BigDecimal c = new BigDecimal("0.8"); 
			BigDecimal x = a.subtract(b); 
			BigDecimal y = b.subtract(c); 
			if (x.equals(y)) { 
        System.out.println("true");
      }

说明：浮点数采用“尾数+阶码”的编码方式，类似于科学计数法的“有效数字+指数”的表示方式。二进制无法精确表示大部分的十进制小数，具体原理参考《码出高效》。 
反例： float a = 1.0f - 0.9f; 
			float b = 0.9f - 0.8f; 
			if (a == b) { 
        // 预期进入此代码快，执行其它业务逻辑 
        // 但事实上a==b的结果为false 
      } 
			Float x = Float.valueOf(a); 
			Float y = Float.valueOf(b); 
			if (x.equals(y)) { 
        // 预期进入此代码快，执行其它业务逻辑 
        // 但事实上equals的结果为false 
      } 
正例： (1) 指定一个误差范围，两个浮点数的差值在此范围之内，则认为是相等的。 
      float a = 1.0f - 0.9f; 
      float b = 0.9f - 0.8f; 
      float diff = 1e-6f; 
      if (Math.abs(a - b) < diff) { 
        System.out.println("true"); 
      } 
		(2) 使用BigDecimal来定义值，再进行浮点数的运算操作。 
      BigDecimal a = new BigDecimal("1.0"); 
			BigDecimal b = new BigDecimal("0.9"); 
			BigDecimal c = new BigDecimal("0.8"); 
			BigDecimal x = a.subtract(b); 
			BigDecimal y = b.subtract(c); 
			if (x.equals(y)) { 
        System.out.println("true");
      }

说明：BigDecimal(double)存在精度损失风险，在精确计算或值比较的场景中可能会导致业务逻辑异常。
如：BigDecimal g = new BigDecimal(0.1f); 
实际的存储值为：0.10000000149 
正例：优先推荐入参为String的构造方法，或使用BigDecimal的valueOf方法，此方法内部其实执行了Double的toString，而Double的toString按double的实际能表达的精度对尾数进行了截断。
BigDecimal recommend1 = new BigDecimal("0.1"); 
BigDecimal recommend2 = BigDecimal.valueOf(0.1);

说明：BigDecimal(double)存在精度损失风险，在精确计算或值比较的场景中可能会导致业务逻辑异常。
如：BigDecimal g = new BigDecimal(0.1f); 
实际的存储值为：0.10000000149 
正例：优先推荐入参为String的构造方法，或使用BigDecimal的valueOf方法，此方法内部其实执行了Double的toString，而Double的toString按double的实际能表达的精度对尾数进行了截断。
BigDecimal recommend1 = new BigDecimal("0.1"); 
BigDecimal recommend2 = BigDecimal.valueOf(0.1);

1） 【强制】所有的POJO类属性必须使用包装数据类型。 
2） 【强制】RPC方法的返回值和参数必须使用包装数据类型。 
3） 【推荐】所有的局部变量使用基本数据类型。 
说明：POJO类属性没有初值是提醒使用者在需要使用时，必须自己显式地进行赋值，任何NPE问题，或者入库检查，都由使用者来保证。 
正例：数据库的查询结果可能是null，因为自动拆箱，用基本数据类型接收有NPE风险。 

反例：比如显示成交总额涨跌情况，即正负x%，x为基本数据类型，调用的RPC服务，调用不成功时，返回的是默认值，页面显示为0%，这是不合理的，应该显示成中划线。所以包装数据类型的null值，能够表示额外的信息，如：远程调用失败，异常退出。

1） 【强制】所有的POJO类属性必须使用包装数据类型。 
2） 【强制】RPC方法的返回值和参数必须使用包装数据类型。 
3） 【推荐】所有的局部变量使用基本数据类型。 
说明：POJO类属性没有初值是提醒使用者在需要使用时，必须自己显式地进行赋值，任何NPE问题，或者入库检查，都由使用者来保证。 
正例：数据库的查询结果可能是null，因为自动拆箱，用基本数据类型接收有NPE风险。 

反例：比如显示成交总额涨跌情况，即正负x%，x为基本数据类型，调用的RPC服务，调用不成功时，返回的是默认值，页面显示为0%，这是不合理的，应该显示成中划线。所以包装数据类型的null值，能够表示额外的信息，如：远程调用失败，异常退出。

说明：
String str = "a,b,c,,";
String[] ary = str.split(",");
// 预期大于3，结果是3
System.out.println(ary.length);

说明：
String str = "a,b,c,,";
String[] ary = str.split(",");
// 预期大于3，结果是3
System.out.println(ary.length);

反例：
public Integer getData() {
  if (condition) {
  	return this.data + 100;
  } else {
  	return this.data - 100;
  }
}

反例：
public Integer getData() {
  if (condition) {
  	return this.data + 100;
  } else {
  	return this.data - 100;
  }
}

说明：下例中，反编译出的字节码文件显示每次循环都会new出一个StringBuilder对象，然后进行append操作，最后通过toString方法返回String对象，造成内存资源浪费。
反例：
String str = "start";
for (int i = 0; i < 100; i++) {
	str = str + "hello";
}

说明：下例中，反编译出的字节码文件显示每次循环都会new出一个StringBuilder对象，然后进行append操作，最后通过toString方法返回String对象，造成内存资源浪费。
反例：
String str = "start";
for (int i = 0; i < 100; i++) {
	str = str + "hello";
}

1） 如果不允许外部直接通过new来创建对象，那么构造方法必须是private。 
2） 工具类不允许有public或default构造方法。 
3） 类非static成员变量并且与子类共享，必须是protected。 
4） 类非static成员变量并且仅在本类使用，必须是private。 
5） 类static成员变量如果仅在本类使用，必须是private。 
6） 若是static成员变量，考虑是否为final。 
7） 类成员方法只供类内部调用，必须是private。 
8） 类成员方法只对继承类公开，那么限制为protected。
说明：任何类、方法、参数、变量，严控访问范围。过于宽泛的访问范围，不利于模块解耦。思考：如果是一个private的方法，想删除就删除，可是一个public的service成员方法或成员变量，删除一下，不得手心冒点汗吗？变量像自己的小孩，尽量在自己的视线内，变量作用域太大，无限制的到处跑，那么你会担心的。

1） 如果不允许外部直接通过new来创建对象，那么构造方法必须是private。 
2） 工具类不允许有public或default构造方法。 
3） 类非static成员变量并且与子类共享，必须是protected。 
4） 类非static成员变量并且仅在本类使用，必须是private。 
5） 类static成员变量如果仅在本类使用，必须是private。 
6） 若是static成员变量，考虑是否为final。 
7） 类成员方法只供类内部调用，必须是private。 
8） 类成员方法只对继承类公开，那么限制为protected。
说明：任何类、方法、参数、变量，严控访问范围。过于宽泛的访问范围，不利于模块解耦。思考：如果是一个private的方法，想删除就删除，可是一个public的service成员方法或成员变量，删除一下，不得手心冒点汗吗？变量像自己的小孩，尽量在自己的视线内，变量作用域太大，无限制的到处跑，那么你会担心的。

反例：直接使用toArray无参方法存在问题，此方法返回值只能是Object[]类，若强转其它类型数组将出现ClassCastException错误。 
正例：
List<String> list = new ArrayList<>(2);
list.add("guan");
list.add("bao");
String[] array = list.toArray(new String[0]); 
说明：使用toArray带参方法，数组空间大小的length： 
1） 等于0，动态创建与size相同的数组，性能最好。 
2） 大于0但小于size，重新创建大小等于size的数组，增加GC负担。
3） 等于size，在高并发情况下，数组创建完成之后，size正在变大的情况下，负面影响与上相同。
4） 大于size，空间浪费，且在size处插入null值，存在NPE隐患。

反例：直接使用toArray无参方法存在问题，此方法返回值只能是Object[]类，若强转其它类型数组将出现ClassCastException错误。 
正例：
List<String> list = new ArrayList<>(2);
list.add("guan");
list.add("bao");
String[] array = list.toArray(new String[0]); 
说明：使用toArray带参方法，数组空间大小的length： 
1） 等于0，动态创建与size相同的数组，性能最好。 
2） 大于0但小于size，重新创建大小等于size的数组，增加GC负担。
3） 等于size，在高并发情况下，数组创建完成之后，size正在变大的情况下，负面影响与上相同。
4） 大于size，空间浪费，且在size处插入null值，存在NPE隐患。

说明：毕竟泛型是在JDK5后才出现，考虑到向前兼容，编译器是允许非泛型集合与泛型集合互相赋值。 
反例： List<String> generics = null; 
			List notGenerics = new ArrayList(10); 
			notGenerics.add(new Object()); 
			notGenerics.add(new Integer(1));
      generics = notGenerics; 
      // 此处抛出ClassCastException异常 
      String string = generics.get(0);

说明：毕竟泛型是在JDK5后才出现，考虑到向前兼容，编译器是允许非泛型集合与泛型集合互相赋值。 
反例： List<String> generics = null; 
			List notGenerics = new ArrayList(10); 
			notGenerics.add(new Object()); 
			notGenerics.add(new Integer(1));
      generics = notGenerics; 
      // 此处抛出ClassCastException异常 
      String string = generics.get(0);

正例：
List<String> list = new ArrayList<>();
list.add("1");
list.add("2");
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
  String item = iterator.next();
  if (删除元素的条件) {
    iterator.remove();
  }
}
反例：
for (String item : list) {
  if ("1".equals(item)) {
  	list.remove(item);
  }
}
说明：以上代码的执行结果肯定会出乎大家的意料，那么试一下把“1”换成“2”，会是同样的结果吗？

正例：
List<String> list = new ArrayList<>();
list.add("1");
list.add("2");
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
  String item = iterator.next();
  if (删除元素的条件) {
    iterator.remove();
  }
}
反例：
for (String item : list) {
  if ("1".equals(item)) {
  	list.remove(item);
  }
}
说明：以上代码的执行结果肯定会出乎大家的意料，那么试一下把“1”换成“2”，会是同样的结果吗？

说明：三个条件如下 
1） x，y的比较结果和y，x的比较结果相反。 
2） x>y，y>z，则x>z。 
3） x=y，则x，z比较结果和y，z比较结果相同。 
反例：下例中没有处理相等的情况，交换两个对象判断结果并不互反，不符合第一个条件，在实际使用中 可能会出现异常。
new Comparator<Student>() {
  @Override
  public int compare(Student o1, Student o2) {
  	return o1.getId() > o2.getId() ? 1 : -1;
  }
};

说明：三个条件如下 
1） x，y的比较结果和y，x的比较结果相反。 
2） x>y，y>z，则x>z。 
3） x=y，则x，z比较结果和y，z比较结果相同。 
反例：下例中没有处理相等的情况，交换两个对象判断结果并不互反，不符合第一个条件，在实际使用中 可能会出现异常。
new Comparator<Student>() {
  @Override
  public int compare(Student o1, Student o2) {
  	return o1.getId() > o2.getId() ? 1 : -1;
  }
};

说明：菱形泛型，即diamond，直接使用<>来指代前边已经指定的类型。
正例：
// diamond方式，即<>
HashMap<String, String> userCache = new HashMap<>(16);
// 全省略方式
ArrayList<User> users = new ArrayList(10);

说明：菱形泛型，即diamond，直接使用<>来指代前边已经指定的类型。
正例：
// diamond方式，即<>
HashMap<String, String> userCache = new HashMap<>(16);
// 全省略方式
ArrayList<User> users = new ArrayList(10);

说明：HashMap使用HashMap(int initialCapacity) 初始化。
正例：initialCapacity = (需要存储的元素个数 / 负载因子) + 1。注意负载因子（即loader factor）默认为0.75，如果暂时无法确定初始值大小，请设置为16（即默认值）。
反例：HashMap需要放置1024个元素，由于没有设置容量初始大小，随着元素不断增加，容量7次被迫扩大，resize需要重建hash表，严重影响性能。

说明：HashMap使用HashMap(int initialCapacity) 初始化。
正例：initialCapacity = (需要存储的元素个数 / 负载因子) + 1。注意负载因子（即loader factor）默认为0.75，如果暂时无法确定初始值大小，请设置为16（即默认值）。
反例：HashMap需要放置1024个元素，由于没有设置容量初始大小，随着元素不断增加，容量7次被迫扩大，resize需要重建hash表，严重影响性能。

说明：keySet其实是遍历了2次，一次是转为Iterator对象，另一次是从hashMap中取出key所对应的value。而entrySet只是遍历了一次就把key和value都放到了entry中，效率更高。如果是JDK8，使用Map.forEach方法。
正例：values()返回的是V值集合，是一个list集合对象；keySet()返回的是K值集合，是一个Set集合对象；entrySet()返回的是K-V值组合集合。

说明：keySet其实是遍历了2次，一次是转为Iterator对象，另一次是从hashMap中取出key所对应的value。而entrySet只是遍历了一次就把key和value都放到了entry中，效率更高。如果是JDK8，使用Map.forEach方法。
正例：values()返回的是V值集合，是一个list集合对象；keySet()返回的是K值集合，是一个Set集合对象；entrySet()返回的是K-V值组合集合。

private final static int CORE_POOL_SIZE = 30;
    private final static int MAX_POOL_SIZE = 35;
    private final static int keeAliveTime = 0;

    ExecutorService executor = new ThreadPoolExecutor(CORE_POOL_SIZE, MAX_POOL_SIZE, keeAliveTime,
            TimeUnit.SECONDS, new ArrayBlockingQueue<>(10000000), new ThreadFactory() {
        private final AtomicInteger mThreadNum = new AtomicInteger(1);
        // 定义线程组名称，在jstack问题排查时，非常有帮助
        @Override
        public Thread newThread(Runnable r) {
            Thread t = new Thread(r, "SDX X-" + mThreadNum.getAndIncrement());
            return t;
        }
    }, new ThreadPoolExecutor.CallerRunsPolicy());

private final static int CORE_POOL_SIZE = 30;
    private final static int MAX_POOL_SIZE = 35;
    private final static int keeAliveTime = 0;

    ExecutorService executor = new ThreadPoolExecutor(CORE_POOL_SIZE, MAX_POOL_SIZE, keeAliveTime,
            TimeUnit.SECONDS, new ArrayBlockingQueue<>(10000000), new ThreadFactory() {
        private final AtomicInteger mThreadNum = new AtomicInteger(1);
        // 定义线程组名称，在jstack问题排查时，非常有帮助
        @Override
        public Thread newThread(Runnable r) {
            Thread t = new Thread(r, "SDX X-" + mThreadNum.getAndIncrement());
            return t;
        }
    }, new ThreadPoolExecutor.CallerRunsPolicy());

说明：Executors返回的线程池对象的弊端如下：
1） FixedThreadPool和SingleThreadPool： 
	允许的请求队列长度为Integer.MAX_VALUE，可能会堆积大量的请求，从而导致OOM。 
2） CachedThreadPool： 
	允许的创建线程数量为Integer.MAX_VALUE，可能会创建大量的线程，从而导致OOM。

说明：Executors返回的线程池对象的弊端如下：
1） FixedThreadPool和SingleThreadPool： 
	允许的请求队列长度为Integer.MAX_VALUE，可能会堆积大量的请求，从而导致OOM。 
2） CachedThreadPool： 
	允许的创建线程数量为Integer.MAX_VALUE，可能会创建大量的线程，从而导致OOM。

正例：注意线程安全，使用DateUtils。亦推荐如下处理：
private static final ThreadLocal<DateFormat> df = new ThreadLocal<DateFormat>() {
  @Override
  protected DateFormat initialValue() {
  	return new SimpleDateFormat("yyyy-MM-dd");
  }
};
说明：如果是JDK8的应用，可以使用Instant代替Date，LocalDateTime代替Calendar，DateTimeFormatter代替SimpleDateFormat，官方给出的解释：simple beautiful strong immutable thread-safe。

正例：注意线程安全，使用DateUtils。亦推荐如下处理：
private static final ThreadLocal<DateFormat> df = new ThreadLocal<DateFormat>() {
  @Override
  protected DateFormat initialValue() {
  	return new SimpleDateFormat("yyyy-MM-dd");
  }
};
说明：如果是JDK8的应用，可以使用Instant代替Date，LocalDateTime代替Calendar，DateTimeFormatter代替SimpleDateFormat，官方给出的解释：simple beautiful strong immutable thread-safe。

反例：猜猜下面的代码输出是什么？
public class SwitchString {
public static void main(String[] args) {
	method(null);
}
public static void method(String param) {
  switch (param) {
    // 肯定不是进入这里
    case "sth":
    System.out.println("it's sth");
    break;
    // 也不是进入这里
    case "null":
    System.out.println("it's null");
    break;
    // 也不是进入这里
    default:
    System.out.println("default");
    }
  }
}

反例：猜猜下面的代码输出是什么？
public class SwitchString {
public static void main(String[] args) {
	method(null);
}
public static void method(String param) {
  switch (param) {
    // 肯定不是进入这里
    case "sth":
    System.out.println("it's sth");
    break;
    // 也不是进入这里
    case "null":
    System.out.println("it's null");
    break;
    // 也不是进入这里
    default:
    System.out.println("default");
    }
  }
}

if (condition) {
...
return obj;
}
// 接着写else的业务逻辑代码;

说明：如果非使用if()...else if()...else...方式表达逻辑，避免后续代码维护困难，【强制】请勿超过3层。
正例：超过3层的 if-else 的逻辑判断代码可以使用卫语句、策略模式、状态模式等来实现，其中卫语句即代码逻辑先考虑失败、异常、中断、退出等直接返回的情况，以方法多个出口的方式，解决代码中判断分支嵌套的问题，这是逆向思维的体现。
示例如下：
public void findLove(Man man) {
  if (man.isLazy()) {
  	System.out.println("加油");
  	return;
  }
  if (man.isPoor()) {
  	System.out.println("加油");
  	return;
  }
  System.out.println("Bingo.");
}

if (condition) {
...
return obj;
}
// 接着写else的业务逻辑代码;

说明：如果非使用if()...else if()...else...方式表达逻辑，避免后续代码维护困难，【强制】请勿超过3层。
正例：超过3层的 if-else 的逻辑判断代码可以使用卫语句、策略模式、状态模式等来实现，其中卫语句即代码逻辑先考虑失败、异常、中断、退出等直接返回的情况，以方法多个出口的方式，解决代码中判断分支嵌套的问题，这是逆向思维的体现。
示例如下：
public void findLove(Man man) {
  if (man.isLazy()) {
  	System.out.println("加油");
  	return;
  }
  if (man.isPoor()) {
  	System.out.println("加油");
  	return;
  }
  System.out.println("Bingo.");
}

说明：赋值点类似于人体的穴位，对于代码的理解至关重要，所以赋值语句需要清晰地单独成为一行。 
反例：
  public Lock getLock(boolean fair) {
    // 算术表达式中出现赋值操作，容易忽略count值已经被改变
    threshold = (count = Integer.MAX_VALUE) - 1;
    // 条件表达式中出现赋值操作，容易误认为是sync==fair
    return (sync = fair) ? new FairSync() : new NonfairSync();
  }

说明：赋值点类似于人体的穴位，对于代码的理解至关重要，所以赋值语句需要清晰地单独成为一行。 
反例：
  public Lock getLock(boolean fair) {
    // 算术表达式中出现赋值操作，容易忽略count值已经被改变
    threshold = (count = Integer.MAX_VALUE) - 1;
    // 条件表达式中出现赋值操作，容易误认为是sync==fair
    return (sync = fair) ? new FairSync() : new NonfairSync();
  }