java如何写出高效优雅的代码(一)

于由wagnwu发布

浏览次数: 743
i

1. 构造器参数太多怎么办

解决办法 ：引入Builder模式
场景：当构造器有5个或者以上的构造参数时或者目前参数不多但是以后会不断增多的时候。
demo 如下：

public class Computer {
    protected String mBoard;
    protected String mDisplay;
    protected String mOs;


    private Computer(Builder builder) {
        this.mOs = builder.mOs;
        this.mBoard = builder.mBoard;
        this.mDisplay = builder.mDisplay;
    }

    @Override
    public String toString() {
        return "Computer{" +
                "mBoard='" + mBoard + '\'' +
                ", mDisplay='" + mDisplay + '\'' +
                ", mOs='" + mOs + '\'' +
                '}';
    }

    static class Builder {
        protected String mBoard;
        protected String mDisplay;
        protected String mOs;

        public Builder setmOs(String mOs) {
            this.mOs = mOs;
            return this;
        }

        public Builder setmBoard(String mBoard) {
            this.mBoard = mBoard;
            return this;
        }

        public Builder setmDisplay(String mDisplay) {
            this.mDisplay = mDisplay;
            return this;
        }

        public Computer build() {
            return new Computer(this);
        }
    }
}

调用的时候如下：

public static void main(String[] args) {
        Computer macbook = new Computer.Builder()
                .setmBoard("board")
                .setmDisplay("sowhat")
                .setmOs("Mac")
                .build();
        System.out.println(macbook);
    }

2. 不需要实例化的类构造器要私有化

经常用到的Utils类，比如Java自带的java.util.Arrays 这样的类，工具类都尽量不要实例化。

public class Arrays {
    private static final int MIN_ARRAY_SORT_GRAN = 8192;
    private static final int INSERTIONSORT_THRESHOLD = 7;
    private Arrays() {
    }
}

3. 不要创建不必要对象

  1. 能用基本类型到时候尽量要用基本类型。比如我们做数字运算，如果定义称了个Long 类型，会涉及到自动装箱。大大耗时。
  2. 对于一些程序中共用的参数尽量设置为static类型变量。
  3. 对于一些耗时性较大的对象比如数据库连接，尽量创建数据库连接池。
  4. 对于一些占据内存较大的对象也尽量少创建。因为在eden区来回倒腾，它累啊！。
public class Sum {
	public static void main(String[] args) {
		long start = System.currentTimeMillis();
		Long sum = 0L; //对象
		for(long i=0;i<Integer.MAX_VALUE;i++) {
			sum = sum+i;
			//new 20多亿的Long的实例
		}
		System.out.println("spend time:"+(System.currentTimeMillis()-start)+"ms");
	}
}

耗时：spend time:7042ms

public class Sum {
	public static void main(String[] args) {
		long start = System.currentTimeMillis();
		long sum = 0L; //基本类型
		for(long i=0;i<Integer.MAX_VALUE;i++) {
			sum = sum+i;
		}
		System.out.println("spend time:"+(System.currentTimeMillis()-start)+"ms");
	}
}

耗时：spend time:820ms

 

5. 类跟成员的可访问性最小化

这个说白了就是设计模式中的迪米特法则。
定义：要求一个对象应该对其他对象有最少的了解，所以迪米特法则又叫做最少知识原则（Least Knowledge Principle, LKP）。

意义：迪米特法则的意义在于降低类之间的耦合。由于每个对象尽量减少对其他对象的了解，因此，很容易使得系统的功能模块功能独立，相互之间不存在（或很少有）依赖关系，日常最常见的比如成员变量私有化。

6. 使可变性最小化

尽可能的使用final 来修饰一些变量，这样线程操作就不需要考虑同步问题，同时也对于一个变量不同setX方法也 OK。

7. 优先使用复合胜过继承

继承是实现代码重用的有力手段，但是使用不当会导致软件变得脆弱。在包的内部使用继承是非常安全的，子类和超类的实现都处在同一个程序员的控制之下。对于专门为了继承而设计、并且具有很好的文档说明的类来说，使用继承也是非常安全的。然而们对于进行跨越包边界的继承，则要非常小心。“继承”在这里特指一个类扩展另一个类。需要我们对父类十分对了解才可继承，只有当子类和超类之间确实存在父子关系时，才可以考虑使用继承。否则都应该用复合，包装类不仅比子类更加健壮，而且功能也更加强大。Effective Java

8.接口优于抽象类

简而言之，Java只允许单继承但是允许实现多个接口。通过接口扩充方法很简单，这样也复合设计模式中的开闭原则。接口可以简单的理解比抽象类还要抽象的一层，是我们对外提供的接口。
同时这里提一下骨架抽象类。

骨架类存在的意义是实现一个接口中设计者认为比较公用的方法，然后在具体类实现的时候，具体类继承自骨架类同时实现接口类的若干方法。

HashSet源码

public class HashSet<E>
    extends AbstractSet<E>
    implements Set<E>, Cloneable, java.io.Serializable

看Set源码

public interface Set<E> extends Collection<E> {
}

 

AbstractSet源码

public abstract class AbstractSet<E> extends 
AbstractCollection<E> implements Set<E> //

 

AbstractSet抽象类有若干函数已经实现了。
在这里插入图片描述

HashSet实现了Set<E>的接口，同时它还继承自AbstractSet<E>这个骨架类(类中有一些公用方法)

10. 尽量不要返回NULL,尽量返回零数组或集合

函数中如果返回NULL，那么代码还要去重新的判断返回值。JDK都主动给我们提供好了Collections.EMPTY_LIST。当然如果是对象就只能是NULL了。
阿里巴巴开发手册也是这样建议的哦。

1.返回值为null并不会有什么问题，但是在“解引用”（dereference）时，调用者没有对null进行判断就会出现NullPointerException。
2. 在返回值为数组或者集合时，尽量返回长度为零的数组或者集合，而不是null，这样在调用时就能简化代码，减少不必要的麻烦，并且不必担心NullPointer异常（除非这对性能会造成很大的影响)。

11.优先使用标准异常

总结来说好处就是：追求代码的重用考虑，在装载类的性能上面考虑。具体细节如下：

  1. 它使你对官方API更加易于学习和使用，因为他与程序员已经熟悉的习惯用法是一致的。
  2. 对于用到这些API的程序而言，他们的可读性会更好，因为他们不会出现很多程序员不熟悉的异常。
  3. 异常类越少，意味着内存印迹就越小，装载这些类的时间开销也越少。

12.尽量使用枚举替换int

枚举的本质就是一个类的具体实例。枚举比普通业务类型int类型的区别跟好处，以及策略枚举的使用

public class ActiveEnum {

   public enum NormalActive{
      PLUS,MINUS,MULTI,DIVIDS;

      double oper(double x,double y) {
         switch(this) {
            case PLUS:return x+y;
            case MINUS:return x-y;
            case MULTI:return x*y;
            case DIVIDS:return x/y;
         }
         throw new UnsupportedOperationException(); // 这个存在的含义仅仅是替换 default
      }
   }

   public static void main(String[] args) {
      System.out.println(NormalActive.PLUS.oper(0.1, 0.2));
   }
}

 

public enum DepotEnum {
   UNPAY(0, "未支付"), PAID(1, "已支付"), TIMOUT(-1, "超时");

   private int status; //状态
   private String desc; // 含义描述
   private String dbInfo;//其他属性

   private DepotEnum(int status, String desc) {
      this.status = status;
      this.desc = desc;
   }

   public int getStatus() {
      return status;
   }

   public String getDesc() {
      return desc;
   }

   public String getDbInfo() {
      return dbInfo;
   }

   public int calcStatus(int params) {
      return status + params;
   }

   public static void main(String[] args) {
      for (DepotEnum e : DepotEnum.values()) {
         System.out.println(e + ":" + e.calcStatus(14));
      }
   }

}

public enum BetterPayDay {

   MONDAY(PayType.WORK), TUESDAY(PayType.WORK), WEDNESDAY(
         PayType.WORK), THURSDAY(PayType.WORK), FRIDAY(PayType.WORK),
   SATURDAY(PayType.REST), SUNDAY(PayType.REST),WUYI(PayType.REST);

   private final PayType payType; // 成员变量 然后定义一个外部枚举来包装 策略枚举。

   BetterPayDay(PayType payType) {
      this.payType = payType;
   }

   double pay(double hoursOvertime) {
      return payType.pay(hoursOvertime);
   }

   //策略枚举 我们只定义 工作日还是节假日的薪资计算方法。
   private enum PayType {
      WORK {
         double pay(double hoursOvertime) {
            return hoursOvertime*HOURS_WORK;
         }
      },
      REST {
         double pay(double hoursOvertime) {
            return hoursOvertime*HOURS_REST;
         }
      };
      private static final int HOURS_WORK = 2;
      private static final int HOURS_REST = 3;

      abstract double pay(double hoursOvertime);//抽象计算加班费的方法
   }

   public static void main(String[] args) {

      System.out.println(BetterPayDay.MONDAY.pay(7.5));
   }
}

13. 局部变量作用域最小化

  1. 从系统GC的角度考虑(一个变量的周期越短整个gc过程越快)。
    2.从栈桢中的局部变量表的可重用性来看，作用域越小系统的栈桢空间利用了越大。
  2. 可以增强代码的可读性和可维护性，并降低出错的可能性。

应该：

  1. 在第一次使用某个局部变量的地方进行声明。
  2. 如果你还没有足够的前置信息来对一个变量进行有意义的初始化，就应该推迟这个声明，直到可以初始化为止。
  3. 尽量将方法小而集中。方法的功能尽量单一。

14. 对于精度技术不用float或double

Java在允许float或者double类之间计算的时候会有误差。

double a = 0.2;
double b = 0.1;
double c = a+ b;
System.out.println(c);
-----
0.30000000000000004

要用：BigDecimal 或者FloatDecimal。具体类用法自行百度

 

15.字符串操作少用String

这点操作是大家都知道的，String定义为private final byte[] value;是不可变的。StringBuilder 和 StringBuffer都继承于：AbstractStringBuilder
他们的底层使用的是没有用final修饰的字符数组：char[]

在这里插入图片描述

1.如果要操作少量的数据用 String；
2. 多线程操作字符串缓冲区下操作大量数据 StringBuffer；
3. 单线程操作字符串缓冲区下操作大量数据 StringBuilder。

16.对资源的close建议分开操作

比如说我们有这样的一个close方法，

try{
	a.close()
	b.close()
}catch(Exception e){
 ...
}

上面这样写一旦a关闭的时候出错了，b的关闭也会出错。尽量分开来关闭。

try{
	a.close()
}catch(Exception e){
 ...
}

try{
	b.close()
}catch(Exception e){
 ...
}

 

17. 数据类型转换

基本数据类型转换为String的时候注意性能优化，比如Integer类型数据转换为String一般有三种方法

  1. Integer.toString方法，首先推荐。速度最好
  2. String.valueOf() ，该方法底层调用的是Integer.toString方法，速度中等。
  3. i + “” 这种方法，底层是用StringBuilder实现，先用append方法拼接，再用toString方法获取字符串。速度最慢。

 

18. 不用的对象记得置NULL

我们不用一个空间对象后而没有将其置NULL，JDK底层代码对用不到的对象都会立马置空，如果不这样容易造成内存泄露，比如我自己实现了一个栈

public class Stack {
	
	public  Object[] elements;
	private int size = 0; //指示器，用来指示当前栈顶的位置

    private static final int Cap = 16;

    public Stack() {
    	elements = new Object[Cap];
    }
    //入栈
    public void push(Object e){
    	elements[size] = e;
    	size++;
    }
    //出栈
    public Object pop(){
    	size = size-1;
    	Object object = elements[size];
    	elements[size] = null; //  这里很重要 JDK底层都是这样实现的，不用了，即使置NULL
        return object;
    }
}

 

19. if判断常量在前

if(i==1)跟if(1==i)看起来没有差别，但是从容错性上面来考虑，如果手误写成了if(i=1)就是赋值语句了，而if(1=i)则不会出现这样的错误。因此if判断建议常量在前，变量在后。

20. 字符串变量比较的时候

str.equal("sowhat")跟“sowhat”.equal(str)功能上看是一样的，但是从代码的健壮性来看推荐后者，因为你无法确实str 一定是非空，可以避免空指针异常。

21. 同步方法跟同步方法块

尽量使用同步方法块而不是同步方法，这点在多线程模块中的synchronized锁 方法块文章中已经讲得很清楚了，除非我们能确定一整个方法都是需要进行同步的，否则尽量使用同步代码块，避免对那些不需要进行同步的代码也进行了同步，影响了代码执行效率。

22.方法要尽可能小

一个方法要尽量实现单一指责，方法编译后字节码越小越可能会引发JIT的方法内联，

public void SetAge(int age){
   this.age = age
}
-------JIT 优化后直接就是 如下，避免类方法调用。
this.age = age

23.一定记得写注释

代码写的再好也要记得写类跟方法的大概注释，不然接收你工作的人绝对分分钟化身祖安玩家！

参考

阿里Java编码规范
Builder模式
finalize跟gc
深入理解String

[elementor-template id=”6632″]

0
分类： 代码整洁

0 条评论

发表回复

Avatar placeholder

您的电子邮箱地址不会被公开。 必填项已用 * 标注

此站点使用Akismet来减少垃圾评论。了解我们如何处理您的评论数据。

相关文章

代码整洁

常见 Java 代码缺陷及规避方式

  导读 在日常开发过程中，我们会碰到各种各样的代码缺陷或者 阅读更多…

代码整洁

整洁架构在前端的设计思想与应用实践

随着业务的发展，前端项目承载了越来越多的职责，也越来越复杂，简单通过 阅读更多…

代码整洁

你见过哪些目瞪口呆的 Java 代码技巧？

导语 自从毕业后，今年已经是我工作的第 8 个年头了，我甚至都快忘记了 阅读更多…

蜀ICP备16001794号
© 2014 - 2024 linpxing.cn All right reserved.