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

    类和接口是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 [email protected]
 * @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,输出结果如下:

    Effective Java读书笔记 -- 第四章:类和接口_第1张图片

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


第十八条:接口优于抽象类

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

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

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

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

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

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

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

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


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

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

    接口应该只被用来定义类型,不应该被用来导出常量(即常量接口)。


第二十条:类层次优于标签类

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

package JavaDay5_28;

/**
 * @author [email protected]
 * @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 [email protected]
 * @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程序设计语言中的其他任何语法单元。匿名类灭有名字。他不是外围类的一个成员。它并不与其他的成员一起被声明,而是在使用的同时被声明和实例化。匿名类除了在它们被声明的时候之外,是无法被实例化的。匿名类的一种常见用法就是动态地创建函数对象。

局部类是四中嵌套类中用得最少的类。在任何“可以声明局部变量”的地方,都可以声明局部类,并且局部类也遵守同样的作用域规则。


总结:本章主要讨论了类和接口的相关知识,看完之后,领悟到Java是一门真正意义上的面向对象的语言,应该多使用接口或者抽象类来编程,并注意编程中关于接口编程的问题。共勉。

你可能感兴趣的:(Java,Effective,Java读书笔记)