Effective Java读书笔记 -- 第四章：类和接口

分手后的思念是犯贱 2022-05-24 13:41 218阅读 0赞

类和接口是Java程序设计语言的核心，也是Java语言的基本抽象单元。Java语言提供了许多强大的基本元素，供程序员用来设计类和接口。

## 第十三条：使类和成员的可访问性最小化 ##

设计良好的模块会隐藏所有的实现细节，把它的API与它的实现清晰地隔离开来。然后，模块之前只通过它们的API进行通信，一个模块不需要知道其他模块的内部工作情况。这个概念被称为信息隐藏或封装，是软件设计的基本原则之一。

Java程序设计语言提供了许多机制来协助信息隐藏。访问控制机制决定了类、接口和成员的可访问性。

第一条规则很简单：尽可能地使每个类或者成员不能被外界访问。

对于成员（域、方法、嵌套类和嵌套接口）有四种可能的访问级别：

1）私有的（private）——只有在声明该成员的顶层类内部才可以访问这个成员。

2）包级私有的（package-private）——声明该成员的包内部的任何类都可以访问这个成员。从技术上讲，它被称为“缺省（default）访问级别”，如果没有为成员钉钉访问修饰符，那就是这个访问级别。

3）受保护的（protected）——声明该成员的类和它的子类可以访问这个成员，并且，声明该成员的包内部的任何类也可以访问这个成员。

4）公有的（public）——在任何地方都可以访问该成员。

## 第十四条：在公有类中使用访问方法而非公有域 ##

坚持面向对象程序设计思想的看法的是正确的：如果类可以在它所在的包的外部进行访问，就提供访问方法，以保留将来改变类的内部表示法的灵活性。

然而，如果是包级私有的，或者是私有的嵌套类，这几暴露它的数据域并没有本质的错误。

总之，公有类永远都不该暴露可变的域。

## 第十五条：使可变性最小化 ##

不可变类只是实例不能被修改的类。每个实例中所包含的所有信息都必须在创建该实例的时候就提供，并在对象的整个生命周期内固定不变。

为了使类成为不可变，要遵循下面五条规则：

1）不要提供任何会修改对象状态的方法。

2）保证类不会被扩展。使这个类成为final的。

3）使所有的域都为final的。

4）使所有的域都成为私有的。

5）确保对于任何可变组件的互斥访问。

不可变对象本质上是线程安全的，它们不要求同步。当多个线程并发访问这样的对象时，它们不会遭到破坏。

“不可变对象可以被自由地共享”导致的结果是：永远也不需要进行保护性拷贝。

不仅可以共享不可变对象，甚至也可以共享它们的内部信息。

不可变对象为其他对象提供了大量的构件，无论是可变的还是不可变的对象。

不可变对象真正唯一的缺点是：对于每一个不同的值都需要一个单独的对象。

让不可变的类变成final的另一种方法就是，让类的所有构造器都变成私有的或者包级私有的，并添加共有的静态工厂来代替公有的构造器。

## 第十六条：复合优先于继承 ##

继承是实现代码重用的有力手段，但它并非永远是完成这项工作的最佳工具。使用不当会导致软件变得很脆弱。

与方法调用不同的是，继承打破了封装性。换句话说，子类依赖于其超类中特定功能的实现细节。

如果在适合于使用复合的地方使用了继承，则会不必要地暴露实现细节。这样得到的API会把你限制在原始的实现上，永远限定了类的性能。

简而言之，继承的功能非常强大，但是也存在诸多问题，因为它违背了封装原则。只有当子类和超类之间确实存在子类型关系时，使用继承才是恰当的。

## 第十七条：要么为继承而设计，并提供文档说明，要么就禁止继承 ##

对于不是为了继承而设计、并且没有文档说明的“外来”类进行子类化是很危险的。而对于专门为了继承而设计并且具有良好文档说明的类而言，该类的文档必须精确地描述覆盖每个方法所带来的影响。

好的API文档应该描述一个给定的方法做了什么工作，而不是描述它是如何做到的。

为了允许继承，类必须遵守其他一些约束：构造器不能调用可被覆盖的方法，无论是直接调用还是间接调用。

package JavaDay5_28;
    
    import java.util.Date;
    
    /**
     * @author myvina@qq.com
     * @date 18-5-28  下午7:04
     */
    
    public class Demo1 {
        public static void main(String[] args) {
            Sub sub = new Sub();
            sub.overrideMe();
        }
    }
    
    class Super {
        public Super() {
            overrideMe();
        }
    
        public void overrideMe() {}
    }
    
    class Sub extends Super {
        private final Date date;
    
        public Sub() {
            date = new Date();
        }
    
        @Override
        public void overrideMe() {
            super.overrideMe();
            System.out.println(date);
        }
    }

对于以上栗子，可能期望输出当前日期两次，然后第一次输出为null，输出结果如下：

![70][]

因为overrideMe方法被Super构造器调用时，构造器Sub还没有机会初始化data域。

## 第十八条：接口优于抽象类 ##

Java程序设计语言提供了两种机制，可以用来定义允许多个实现的类型：接口和抽象类。这两种机制最明显的区别在于，抽象类允许包含某些方法的实现，但是接口则不允许。一个更为重要的区别在于，为了实现抽象类定义的类型，类必须成为抽象类的一个子类。任何一个类，只要它定义了所有必要的方法，并且遵守通用约定，它就被允许实现一个接口，而不管这个类是处于类层次的哪个位置。因为Java只允许单继承，所以抽象类作为类型定义受到了极大的限制。

现有的类可以很容易被更新，以实现新的接口。

接口是定义mixin（混合类型）的理想选择。

接口允许我们构造非层次结构的类型框架。

通过包装类模式，接口使得安全地增强类的功能成为可能。

虽然接口不允许包含方法的实现。但是，通过对导出的每个重要接口都提供一个抽象的骨架实现类，把接口和抽象类的有点结合起来。接口的作用仍然是定义类型，但是骨架实现类接管了所有与接口实现相关的工作。

设计共有的接口要非常谨慎。接口一旦被公开发行，并且已经被广泛实现，再想改变这个接口几乎是不可能的。

简而言之，接口通常是定义允许多个实现的类型的最佳途径。

##    第十九条：接口只用于定义类型 ##

当类实现接口时，接口就充当可以引用这个类的实例的类型。

接口应该只被用来定义类型，不应该被用来导出常量（即常量接口）。

## 第二十条：类层次优于标签类 ##

子类型化是面向对象语言提供的能表示多重风格的单个数据类型。以下为一个标签类的栗子：

package JavaDay5_28;
    
    /**
     * @author myvina@qq.com
     * @date 18-5-28  下午7:57
     */
    
    public class Figure {
        enum Shape { RECTANGLE, CIRCLE};
    
        final Shape shape;
    
        double length;
        double width;
    
        double radius;
    
        Figure(double radius) {
            shape = Shape.CIRCLE;
            this.radius = radius;
        }
    
        Figure(double length, double width) {
            shape = Shape.RECTANGLE;
            this.length = length;
            this.width = width;
        }
    
        double area() {
            switch (shape) {
                case RECTANGLE:
                    return length * width;
                case CIRCLE:
                    return Math.PI * (radius * radius);
                default:
                    throw new AssertionError();
            }
        }
    }

为了将标签类转变成类层次，要为标签类中的每个方法都定义一个包括抽象方法的抽象类，每个方法的行为都依赖于标签值。以下为转换为类层次的代码：

package JavaDay5_28;
    
    /**
     * @author myvina@qq.com
     * @date 18-5-28  下午8:02
     */
    
    abstract class FigureDemo {
        abstract double area();
    }
    
    class Circle extends FigureDemo {
        final double radius;
    
        Circle(double radius) {
            this.radius = radius;
        }
    
        @Override
        double area() {
            return Math.PI * (radius * radius);
        }
    }
    
    class Rectangle extends FigureDemo {
        final double length;
        final double width;
    
        Rectangle(double length, double width) {
            this.length = length;
            this.width = width;
        }
    
        @Override
        double area() {
            return length * width;
        }
    }

简而言之，标签类很少有使用的时候，大多数标签类都可以被类层次所代替。

## 第二十一条：用函数对象表示策略 ##

有些语言支持函数指针、代理、lambda表达式，或者支持蕾丝的机制，允许程序把“调用特殊函数的能力”存储起来并传递这种能力。这种机制通常用于允许函数的调用者通过传入第二个函数，来指定自己的行为。

Java没有提供函数指针，但是可以用对象引用实现同样的功能。调用对象的方法通常就是执行该对象上的某项操作。然而，我们也可能定义这样一种对象，它的方法执行其他对象上的操作。如果一个类仅仅导出这样的一个方法，它的实例实际上就等同于一个指向该方法的指针。这样的实例被称为函数对象。

函数指针的主要用途就是实现策略模式。

## 第二十二条：优先考虑静态成员类 ##

嵌套类是指被定义在另一类的内部的类。嵌套类存在的目的应该只是为它的外围类提供服务。如果嵌套类将来可能回用于其他的某个环境中，他就应该是顶层类。

嵌套类有四种：静态成员类、非静态成员类、匿名类和局部类。除了静态成员类，其他三中都被成为内部类。

静态成员类是最简单的一种嵌套类。它可以访问外围类的所有成员，包括那些声明为私有的成员。当它被声明为私有的，它就只能在外围类的内部才可以被访问。静态成员类的一种常用用法就是作为公有的辅助类，仅当与它的外部类一起使用时才有意义。

从语法上将，静态成员类和非静态成员类的唯一的区别就是P：静态成员类的声明中包含修饰符static。

如果嵌套类的实例可以在它外围类的实例之外独立存在，这个嵌套类就必须是静态成员类：在没有外围实例的情况下，要想创建非静态成员类的实例是不可能的。

匿名类不同于Java程序设计语言中的其他任何语法单元。匿名类灭有名字。他不是外围类的一个成员。它并不与其他的成员一起被声明，而是在使用的同时被声明和实例化。匿名类除了在它们被声明的时候之外，是无法被实例化的。匿名类的一种常见用法就是动态地创建函数对象。