Effective java第三版

2. 当构造方法参数过多时使用builder模式

用泛型让接口，抽象类返回自己子类的实现

限定Parent的self方法返回继承Parent的实现子类

//父类(抽象类)
//限制泛型为继承自己的类型 
abstract static class Parent>{
     abstract T self();
}
public static class Son extends Parent {
     Son self(){
     //实现方法只能返回自己,上面的泛型限定了子类实现的方法返回自己类型  
    };
}

用Builder来创建多参类,抛弃javabean

实例:

public class People{
    //必选
    private final int age;
    private String name;
    //可选
    private String carName;
    public static class Builder{
                //必选
        private final int age;
        private String name;
        //可选
        private String carName;
        Builder(int age,String name){
            this.name = name;
            this.age = age;
        }
        public Builder carName(String carName){
            this.carName = carName;
            return this;
        }
        public People build(){
            return new People(this);
        }
    }
    private People(Builder builder){
        this.age = builder.age;
        this.name = builder.name;
        this.carName = builder.carName;
    }
}


//示例:
System.out.println(new People.Builder(22,"vijay").carName("宝马").build());
//People{age=22, name='vijay', carName='宝马'}

利用抽象拓展,使子类可延伸

abstract class Ret {
    public enum RetCode {SUCCESS, ERROR, WARNING}

    private final Set code;

    abstract static class Builder> {
        //创建一个空枚举Set
        private EnumSet enumSet = EnumSet.noneOf(RetCode.class);

        public T addHttpCode(RetCode code) {
            enumSet.add(code);
            return self();
        }
        //使用嵌套泛型使子类继承该方法后只能返回该类对象
        abstract T self();

        protected abstract Ret build();
    }

    public Ret(Builder builder) {
        this.code = builder.enumSet.clone();
    }

}

class RetDefault extends Ret {
    private String msg;

    public static class Builder extends Ret.Builder {
        private String msg;

        Builder self() {
            return this;
        }
    //子类拓展
        public Builder msg(String msg) {
            this.msg = msg;
            return self();
        }

        protected Ret build() {
            return new RetDefault(this);
        }
    }

    public RetDefault(Builder builder) {
        super(builder);
        msg = builder.msg;
    }

}

3.使用枚举类来实现单例类

Enum类和普通类十分相似,只不过它的构造方法是私有的,只能在类内部创建对象,正好完美的符合了单例模式

enum Singleton{
    SINGLETON;
    final String name = "singleton";
    public void sayName(){
        System.out.println(name);
    }
}

//使用
Singleton.SINGLETON.sayName();

4.使用私有构造函数防止子类实例化

有些工具类场景例如:Arrays,Math。

这些类只是用来存放一些静态的工具方法,但是其默认会被生成一个构造函数,会被实例化造成没有意义的设计。即使使用抽象类来代替工具类也会被出现子类实现该抽象类之后子类被实例化

解决方法:显示私有化其构造器,使其在类外无法调用注意,反射获取到私有的构造器也是无法创建实例的。并抛异常进行提示防止在类中无意调用了该构造器

// Noninstantiable utility class
public class UtilityClass {
    // Suppress default constructor for noninstantiability
    private UtilityClass() {
        throw new AssertionError();
    }
    ... // Remainder omitted
}

5.使用依赖注入取代硬连接资源

当一个类依赖底层资源(其他类)时,可以使用构造器依赖注入,在创建类时将该资源注入进去。而非在类内部定义资源(错误的做法)

6.避免创建不必要的对象

/*例如字符串匹配*/
String str = "abc";
//内部其实是创建了一个Pattern对象,如果该匹配是经常用的,比如时间格式匹配等,那么会造成很大的开销  应为Pattern对象创建需要很大的开销
boolean boo = str.matches(".{1}bc");
System.out.println(boo);

/*正确做法*/
public static final Pattern isABC = Pattern.compile(".{1}bc");
public void matchABC(str) {
    boolean boo = isABC.matcher(str).matches();
    System.out.println(boo);

}

/*还有基础类型的自动装包拆包*/
//优先使用基础类型,不然在时间复杂度高的情况下创建很多的包装对象也是很消耗性能的

7.消除过期的对象引用

8.避免使用Finalizer和Cleaner机制

9. 使用try-with-resources语句替代try-finally语句

使用try-with-resources可以自动关闭流对象,避免try-finally出现漏关闭等其他影响性能的问题

public static void copy(String in, String out) {
    try {
        FileInputStream inputStream = new FileInputStream(new File(in));
        FileOutputStream outputStream = new FileOutputStream(new File(out));
        try(BufferedInputStream bufferedInputStream = new BufferedInputStream(inputStream);
            BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(outputStream)){
            byte[] caches = new byte[1024];
            int pointer = 0;
            while ((pointer = bufferedInputStream.read(caches))!=-1){
                bufferedOutputStream.write(Arrays.copyOf(caches,pointer));
            }
        }
    } catch (FileNotFoundException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

10.重写equals需要尊重的通用约定

自反性:自己和自己equals必须返回true
对称性:自己equals一个对象为true的话,该对象也必须eqauls自己为true。
传递性：对于任何非空引用x、y、z，如果x.equals(y)返回true，y.equals(z)返回true，则x.equals(z)必须返回true。
一致性：对于任何非空引用x和y，如果在equals比较中使用的信息没有修改，则x.equals(y)的多次调用必须始终返回true或始终返回false。
对于任何非空引用x，x.equals(null)必须返回false。

自反性和对称性限定了一个对象重写equals方法必须判断传入的比较对象是否继承自己(instanceof)。

11.重写equals方法时同时也要重写hashcode方法

12.始终重写 toString 方法

13.谨慎地重写 clone 方法

14.重写compareTo接口(实现Comparable接口)

在数组排序(Arrays.sort)中是调用每个对象的compareTo方法来进行排序的,重写compareTo方法需要注意的是返回负数和正数代表排序方向

例子:

public class Person implements Comparable {
    //....
      @Override
    public int compareTo(Object o) {
        return (o instanceof Person && ((Person) o).age < this.age)? -1 : 1;
    }
}

//test
 Object[] objects = {
     new Person.Builder(10).name("v1").build(),
     new Person.Builder(12).name("v2").build(),
     new Person.Builder(19).name("v3").build(),
     new Person.Builder(6).name("v4").build()
        };
        Arrays.sort(objects);
        System.out.println(Arrays.toString(objects));
//[Person{age=19, name='v3'}, Person{age=12, name='v2'}, Person{age=10, name='v1'}, Person{age=6, name='v4'}]

ArrayList list = new ArrayList();
list.add(new Person.Builder(10).name("v1").build());
list.add(new Person.Builder(12).name("v2").build());
list.add(new Person.Builder(19).name("v3").build());
list.add(new Person.Builder(6).name("v4").build());
Collections.sort(list);
System.out.println(list.toString());
//[Person{age=19, name='v3'}, Person{age=12, name='v2'}, Person{age=10, name='v1'}, Person{age=6, name='v4'}]

15.使用静态导入类导入常量

注意区分枚举类和常量。

多个变量有关联建议使用枚举类
单个变量无关联或者用于配置使用常量

注:常量不要定义在接口中,接口是用来继承的,以免出现不必要的BUG

import static com.Code.*;
System.out.println(SUCCESS);