Effective java读书笔记（3）

第三章节

13）使类和成员的可访问性最小化

首先，“信息隐藏(information hiding)”或“封装(encapsulation)”是软件设计的基本原则之一。
我们提出几天规则：
1. 尽可能地使每个类或者成员不被外界访问。
2. 实例域决不能是公有的

类具有公有的静态final数组与，或者返回这种域的访问方式，这几乎总是错误的
public static final Thing[] VALUES = { ... };
这是常见的安全漏洞根源。

我们推荐将这行代码改成

private static final Thing[] VALUES = { ... };
public static list<Thing> =
    Collections.unmodifiableList(Arrays.asList(VALUES));

或者是

private static final Thing[] VALUES = { ... };
public static Thing[] values() {
    return VALUES.clone();
}

总结：你应该始终尽可能地降低可访问性。

14）在公有类中使用访问方法而非公有域

//effective java例子
class Point {
    private double x;
    private double y;
    public Point(double x, double y) {
        this.x = x;
        this.y = y;
    }
    public double getX() {
        return x;
    }

    public double getY() {
        return y;
    }

    public void setX(double x) {
        this.x = x;
    }

    public void setY(double y) {
        this.y = y;
    }
}

总而言之，不要直接访问类的数据域。

15）使可变性最小化

我们更应该去设计不可变的类，因为它更加易于设计，实现和使用。并且还不容易出错，更加安全。
为了使类成为不可变，要遵循下面五条规则：
1. 不要提供任何会修改对象状态的方法
2. 保证类不会被扩展
3. 使所有的域都是final的
4. 使所有的域都成为私有的
5. 确保对于任何可变组件的互斥访问
我们根据上面这5条规则，设计了一个类：

//com.insanus.Goods.java
package com.insanus;
public final class Goods {
    private final int id;
    private final String name;
    private final double price;
    private final int num;
    private final String firstSuppliers;
    private final String secondSuppliers;

    private Goods(GoodsBuilder i) {
        id = i.id;
        name = i.name;
        price = i.price;
        num = i.num;
        firstSuppliers = i.firstSuppliers;
        secondSuppliers = i.secondSuppliers;
    }
    private Goods(Goods i, Goods o) {
        id = i.id;
        name = i.name;
        price = i.price;
        num = i.num + o.num;
        firstSuppliers = i.firstSuppliers;
        secondSuppliers = i.secondSuppliers;
    }

    public Goods updata(Goods i) {
        if (i.id == this.id && i.name.equals(this.name))
            return new Goods(i, this);
        else
            return null;
    }

    @Override
    public boolean equals(Object obj) {
        if (!(obj instanceof Goods))
            return false;
        if (((Goods) obj).id == this.id && ((Goods) obj).name.equals(this.name)) {
            return true;
        } else {
            return false;
        }
    }

    @Override
    public int hashCode() {
        int result = 17;
        result = name.length() * 31 + result;
        result = id * 31 + result;
        return result;
    }

    @Override
    public String toString() {
        return String.format("这个商品id为:%d, 名称为:%s, 价格为:%.2f, 数量为:%d, 第一供应商是:%s, 第二供应商是%s", id, name, price, num, firstSuppliers, secondSuppliers);
    }

    public static class GoodsBuilder {
        private int id = 0;
        private String name;
        private double price;
        private int num = 0;
        private String firstSuppliers = null;
        private String secondSuppliers = null;
        public GoodsBuilder(String name, double price) {
            this.name = name;
            this.price = price;
        }
        public GoodsBuilder setId(int id) {
            this.id = id;
            return this;
        }
        public GoodsBuilder setNum(int num) {
            this.num = num;
            return this;
        }
        public GoodsBuilder setFirstSuppliers(String firstSuppliers) {
            this.firstSuppliers = firstSuppliers;
            return this;
        }
        public GoodsBuilder setSecondSuppliers(String secondSuppliers) {
            this.secondSuppliers = secondSuppliers;
            return this;
        }
        public Goods valueOf() {
            return new Goods(this);
        }
    }

    public static void main(String[] args) {
        Goods i = new GoodsBuilder("哇哈哈", 998).setId(110).setNum(9).setFirstSuppliers("人民大会堂").setSecondSuppliers("中南海").valueOf();
        Goods t = new GoodsBuilder("哇哈哈", 998).setId(110).setNum(10).setFirstSuppliers("人民大会堂").setSecondSuppliers("中南海").valueOf();
        System.out.format("哈希测试, i = %d, t = %d\neqlues测试:%s\ntoString测试:\n%s\n", i.hashCode(), t.hashCode(), i.equals(t), i);
        Goods n = i.updata(t);
        System.out.println(n);
    }
}/* Output:
哈希测试, i = 3520, t = 3520
eqlues测试:true
toString测试:
这个商品id为:110, 名称为:哇哈哈, 价格为:998.00, 数量为:9, 第一供应商是:人民大会堂, 第二供应商是中南海
这个商品id为:110, 名称为:哇哈哈, 价格为:998.00, 数量为:19, 第一供应商是:人民大会堂, 第二供应商是中南海
*///:~

16）复合优先于继承

继承打破了封装性

复合在java编程思想称为组合
导致子类脆弱的一个相关的原因是：它们的超类在后续的发行版本中可以获得新的方法。
我们可以通过转发方法来转发它的结果。提高类的稳固性。

//com.insanus.SupperClass.java
package com.insanus;
public class SupperClass {
    private final FatherClass fatherClass;
    public SupperClass(FatherClass i) {
        fatherClass = i;
    }
    //转发方法
    public String getData() {
    //转发
        return fatherClass.getData();
    }
}

17）要么为继承而设计，并提供文档说明，要么就禁止继承

18）接口优于抽象类

1. 现有的类可以很容易被更新，以实现新的接口。
2. 接口是定义mixin（混合类型）的理想选择。
3. 接口允许我们构造非层次结构的类型框架。

mixin演示

//com.insanus.MixinClass.java
package com.insanus;
public interface MixinClass {
    public void view();
}
class Mixin1 implements MixinClass {
    public void view() {
        System.out.println("From Mixin1");
    }
}

class Mixin2 implements MixinClass {
    private MixinClass i;
    Mixin2() {
        i = new Mixin1();
    }
    public void view() {
        System.out.println("From Mixin2");
        i.view();
    }
}

非层次结构演示

//com.insanus.Structure.java
package com.insanus;
public interface Structure extends Singer, Performer {
    //现实中有些人是演员同时也是歌手
}

interface Singer {

}

interface Performer {

}

我们可以利用abstract来编写骨架实现类，但是因为骨架实现类是为了继承的目的而设计的，所以我们应该遵守17条的知道原则。

同时，设计公有的接口要非常的谨慎。接口一旦被公开发行，并且已被广泛实现，再想改变这个接口几乎是不可能的。
尽可能谨慎地设计所有的公有接口，并通过编写多个实现对它们进行全面的测试。

19）接口只用于定义类型

有一种接口被称为常量接口。常量接口模式是对接口的不良使用。

//do not use!
public interface Test {
    static final double A = 6.666;
}

我们可以通过设置一个这样的方式

public class TestClass {
    private TestClass() { }
    public static final double A = 6.6666;
}

总结：接口应该只是被用来定义类型，它们不应该被用来导出常量。

20）类层次优于标签类

标签类

//com.insanus.Figure.java
package com.insanus;
public class Figure {
    enum Shape {
        RECTANGLE, CIRCLE
    };
    final Shape shape;
    double area() {
        swith(shape) {
            case RECTANGLE:
                //...
            case CIRCLE:
                //...
        }
    }
}

标签类过于冗长，容易出错，并且效率低下。
我们可以通过把他改成类层次。

//com.insanus.Figure.java
package com.insanus;
public abstract class Figure {
    double area();
}
class Circle extends Figure {
    double area() {
        //....
    }
}
class Rectangle extends Figure {
    double area() {
        //...
    }
}

21）用函数对象表示策略

策略接口

public interface Comparator<T> {
    public int compare(T t1, T t2);
}

具体的策略类往往使用匿名类声明

Arrays.sort(stringArrays, new Comparator<String> {
    public int compare(String s1, String s2) {
        return s1.length() - s2.lenght();
    }
});

我们还可以把函数对象储存到一个私有的静态final域中，并重用它。

22）优先使用静态成员类

嵌套类

嵌套类有四种：
1. 静态成员类
2. 非静态成员类
3. 匿名类
4. 局部类

如果声明成员类不要要求访问外围实例，就要始终把static修饰符放在它的声明中，使他变成静态成员类，而不是非静态成员类。

//com.insanus.OutClas.java
package com.insanus;
public class OutClass {
    public static class InClass {
    }
}