《Effective Java》第4章 类和接口

最新推荐文章于 2021-06-14 13:51:50 发布
原创 最新推荐文章于 2021-06-14 13:51:50 发布 · 640 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java

本文深入探讨了《Effective Java》第四章关于类和接口的设计原则，包括最小化可访问性、使用访问方法而非公有域、使可变性最小化、优先选择复合而非继承以及接口优于抽象类等。强调了封装性、不可变性、复合和接口在提高代码质量、减少耦合和增强灵活性方面的重要性，并提供了设计接口和类的实用建议。

类和接口是Java程序设计语言的核心，那么类和接口的设计上必然会有一些大师的指导性原则，能够指导我们设计出有用，健壮和灵活的类和接口。

  1. 使类和成员的可访问性最小化【Item 13】
    1） 设计良好的模块会隐藏所有的实现细节，把它的API和实现清晰的隔离开，模块之间只通过API进行通信，一个模块不需要知道其它模块的内部工作情况，这叫做信息隐藏，在类的角度来说就是保持好的封装性
    2）封装的优点：
    a.有效的解除组成系统的各模块之间的耦合关系，使得这些模块可以独立进行开发，测试，优化，使用，理解和优化。
    b.信息隐藏对于开发速度，可维护性，系统性能分模块剖析便利性的提升有很大的优势，可以保证在调整某个模块不影响其它模块
    c.提高了软件的可重用性，因为模块比较独立，如其它系统有需要可以直接挪过去复用
    d.信息隐藏降低了构建大型系统的风险，即使整个系统不可用，但是这些独立的模块却可能是有用的
    3）Java语言中关于支持封装性实现的机制
    a.访问控制机制决定了类、接口和成员的可访问性
    b.实例的可访问性由该实例所声明的位置，以及该实例声明中所出现的访问修饰符共同决定
    4）封装实现的一些注意点
    a.尽可能地使每个类或者成员不被外界访问
    复习下访问级别，详细的还得参考java语言定义：
    private：只在声明该成员的顶层类内部才可以访问这个成员
    package：缺省(default)访问级别，声明该成员的包内部任何类都可以访问这个成员
    protected：声明该成员的类的子类可以访问这个成员，并且该成员的包内部的任何类都可以访问这个成员
    public：在任何地方都可以访问该成员
    public和protected的成员将被作为API导出,一旦发布必须永久支持，慎重
    b.protected成员少用
    c.子类override超类的方法时，只能扩大访问范围，不能缩小，这样确保任何使用超类的实例的地方都可以使用子类的实例，保证继承is-a的特性
    d.实例域局不能是公有的，包含公有可变域的类并不是线程安全的，一旦把实例域设计为公有的，就失去了对该实例成员的控制权限，虽然你可能将该成员定义为final,但是只是引用不可变，里面的值可能被修改
    e.静态域也不建议作为公有的，常量除外，引用类型的实例域不建议作为公有，因为即使final显示引用不能修改，但是引用指向的对象是可能被修改的
    f.长度非零的数组总是可变的，因为数组也是引用类型，类具有公有的静态final数组域或者返回这种域的访问方法，这几乎总是错误的
    g.尽可能的降低可访问性，访问级别尽量从最低开始设计，如果非得升级访问权限需要有充分的原因
    h.防止把任何散乱的类、接口和成员变成API的一部分
  2. 在公有类中使用访问方法而非公有域【Item 14】
    1）公有类不应该直接暴露数据域，如果类可以在它所在的包的外部进行访问，就提供访问方法，以保留将来改变该类的内部表示法的灵活性
    2）如果类是包级私有的，或者是私有的嵌套类，直接暴露它的数据域并没有本质的错误，因为访问范围本身比较小，也不需要遵循API的延续不可更改性
  3. 使可变性最小化【Item 15】
    1）遵循如下规则使类成为不可变，不可变类只是其实例不能被修改的类，每个实例包含的信息必须在创建时提供，并在实例整个生命周期内固定不变
    a.不要提供任何会修改对象状态的方法
    b.保证类不会被扩展：可以用final修改类，也可以通过静态工厂方法来做，private/protected修改构造器，通过静态工厂方法获取实例，因为不可能把来自另一个包的类，缺少公有或者受保护的构造器的类进行扩展
    c.使所有的域都成为私有的，不提供任何修改途径
    e.确保对于任何可变组件的互斥访问，如果类有指向可变对象的域，确保客户端无法获得指向这些对象的引用，并且永远不要用客户端提供的对象引用来初始化这样的域，也不要从任何访问方法中返回该对象的引用，一旦是公有引用，哪怕是final修改的引用域，因为final只能保证引用指向的对象不变，但是对象的值控制不了，引用指向的对象的值就不可控了。
    2）不可变对象的优势
    a.不可变对象本质上是线程安全的，它们不要求同步，不可变对象可以被自由的共享
    b.不仅可以共享不可变对象，甚至也可以共享它们的内部信息
    e.不可变对象为其它对象（可变或者不可变）提供了大量的构件
    3）不可变类的唯一缺点是，存在潜在的性能问题，对于每个不同的值都需要一个单独的对象，创建这种对象的代价可能很高，特别是对于大型对象的情形。
    针对此缺点，
    a.可以通过预测客户端将要在不可变类上执行哪些复杂的多阶段操作，如果可以预测出来，那么使用包级私有的可变配套类就可以避免多次对象的创建，而如果无法预测，那么可以通过提供公有可变配套类来进行可变部分的处理，例如String的可变配套类StringBuilder
    b.可以考虑将一些下的值对象的类设计为不可变
    c.也可以考虑将一些较大的值对象做成不可变的
    d.总之当你确认有必要实现令人满意的性能时，才应该为不可变的类提供公有的可变配套类
    4）其它注意事项
    a.不可变类，可以通过每次操作返回一个新创建的对象的方式（函数方式）实现，这样做的缺点是创建的实例会越来越多，而通过静态工厂方法则可以规避该缺陷，创建，从而降低内存占用和垃圾回收的成本
    b.不需要也不应该为不可变的类提供clone方法或者拷贝构造器
    c.坚决不要为每个get方法编写一个相应的set方法，除非有很好的理由让类成为可变类，否则就应该是不可变的
    d.如果类不能被做成是不可变的，仍然应该尽可能的限制它的可变性，降低对象可以存在的状态数，可以更加容易的分析该对象的行为，并且降低出错的可能性。
    e.除非有令人信服的理由要使域变成非final的，否则要使每个域都是final的
    f.构造器应该创建完全初始化的对象，并建立起约束条件，不能在构造器以及静态工厂方法之外提供初始化方法，或者重新初始化方法
  4. 复合优先于继承（针对类非接口）【Item 16】
    1）继承提高了代码的复用性，同时也破坏了封装性，子类和父类耦合在一起，父类的改动直接影响子类，因此在如下两种场景下使用继承是安全的：
    a.在包的内部使用继承
    b.对于专门为继承而设计，并且具有很好的文档说明的类来说
    2）子类在复写父类的方法时，需要遵守父类设计该方法的约定，因为在父类中可能会根据该方法设计的约定进行自用，如果子类破坏了该约定，相关功能方法就会运行不正确，出现出乎意料的结果
    3）那么如果不是非得使用继承，可以通过复合（组合）来达到代码的复用，复合是指不扩展现有的类，而是在新的类中增加一个私有域，它引用现有类的一个实例
    4）包装类(Wrapper)是复合的一种典型的用法，包装类不需要像类继承那样，子类必须对于父类中的每一个构造器都要求有一个单独的构造器与之对应，包装类可以用来包装被包装的类的任何实现，并结合任何先前存在的构造器一起工作，这也是Decorator模式的实现方式
    5）包装类不适合用在回调框架中，因为在回调框架中，对象把自身的引用传递给其它对象，用于后续的调用(回调)，因为被包装起来的对象并不知道它外面的包装对象，因此就它传递一个自身的引用(this)，那么回调时就避开了外面的包装对象。
    6）只有当子类和父类真正存在一种is-a的关系，才适合使用继承
    7）如果类之间是has-a的关系，一定要使用复合
    8）在适合使用复合的地方使用的继承，则会不必要的暴露实现细节，这样得到的API会把你限制在原始的实现上，永远限定了类的性能，更严重的是暴露了内部细节，客户端就有可能直接访问这些内部细节，这样至少会导致语义上的混淆
    9）继承机制会把超类API中的所有缺陷传播到子类中，而复合则允许设计新的API来隐藏这些缺陷
    10）如果超类和子类不同包，而超类并非为继承而设计，那么继承就会导致脆弱性，超类的修改并不会顾忌子类，子类的行为就不确定了
  5. 要么为继承而设计，并提供文档说明，要么就禁止继承【Item 17】
    1）如果类为继承而设计，那么必须对可覆盖的方法进行详细的说明，尤其是可被覆盖的自用方法，类必须有文档说明它可覆盖的方法的自用性，也就说该类的内部怎么用的该方法，以便子类不未被超类的设计初衷，或者取消自用方法的可覆盖性
    2）好的API文档应该描述一个给定的方法做了什么，而不是描述它是如何做到的，但是对于自用可被覆盖的方法就应该说明如何做到的，确保其被安全的子类化
    3）为继承而设计的类除了添加合适的文档说明外，也可以为程序员编写更加有效的子类，避免子类化的危险。这种有效的子类必须通过某种形式提供适当的钩子（hook），以便能够进入到它的内部工作流程中，这种形式可以是精心选择的受保护的（protected）的方法，也可以是受保护的域。
    4）对于为继承设计的类，唯一的测试方式就是编写子类
    a.如果遗漏了关键的受保护成员，尝试编写子类就会使遗漏所带来的痛苦更加明显
    b.如果编写了多个子类，并且无一使用受保护的成员，或许就应该将其访问级别降为私有的
    5）为了版本延续性，一旦API公开，类就必须保持public与protected的域，成员等做了永久的承诺，所以必须在发布前做好充分的验证，因为一旦发布，你的API就遍布各个地方，后续不能随意修改了
    6）为继承而设计的类还应该遵守构造器决不能调用可被覆盖的方法，无论是直接调用还是间接调用。因为超类的构造器在子类构造器之前调用，这个时候是调用不到被子类覆盖的方法的，这个时候子类还未初始化，可能出现final域出来两个值的情况
    7）为继承而设计的类不建议实现Cloneable和Serializable接口，因为这样会把实质性的负担转给了扩展这个类的程序员身上，clone和readObjetc两个方法在行为上非常类似于构造器，所以无论clone还是readObject方法都不可以调用可被覆盖的方法，不管直接还是间接的
    8）消除可覆盖方法的自用性，可以通过将该方法的代码移到一个私有的“辅助方法”中，并且每个可覆盖方法调用它的私有辅助方法，然后，用“直接调用可覆盖方法的私有辅助方法”来代替“可覆盖方法的每个自用调用”，从而避免了可覆盖方法在超类中的自用，提升子类化的安全性
    9）那么如果不是为继承儿设计的类，就应该禁止子类化
    a.把类声明为final
    b.把所有的构造器变成私有的，或者包级私有的，并增加一些公有的静态工厂方法来替代构造器
  6. 接口优于抽象类【Item 18】
    1）接口的优势
    a.现有的类可以很容易被更新，以实现新的接口，通过implements接口就可以啦
    b.接口就是定义mixin(混合类型)的理想选择，可以模拟实现多继承
    c.接口允许我们构造非层次结构的类型框架，就一个类的多面性，如 一个人可以是软件工程师，也可以是硬件工程师
    2）接口使得安全的增加类的功能成为可能，避免了继承抽象类代码了限制
    3）接口不允许有具体的实现，为了降低使用接口程序员的工作量，可以为接口提供一个抽象的骨架实现类，把接口和抽象类的优点结合起来，接口的作用是定义类型，而骨架实现类接管了所有与接口实现相关的工作
    。如Collections Framework为每个重要集合接口都提供了一个骨架实现，包括AbstractCollection,AbstractSet,AbstractList和AbstractMap
    4）骨架实现的美妙之处在于它们为抽象类提供了实现上的帮助，但有不强加“抽象类被用作类型定义时”所持有的严格限制。
    5）抽象类可增加具体方法和域，而接口只能增加域，不能增加方法，因为接口中增加的方法都没有具体实现，一旦公开接口增加接口随意增加方法，所有implements的类都必须实现该方法，不然无法编译通过，所以在抽象类的演变比接口的演变要容易得多
    6）如上原因所述，接口一旦被公开发行，并且已被广泛实现，再想修改这个接口几乎是不可能的
    7）抽象类和接口的选择
    a.当演变容易性比灵活性和功能更为重要的时候，在这种情况下，应该使用抽象类来定义类型，但前提是必须理解并且可以接受这些局限性
    b.如果你导出了一个重要的接口，就应该坚决考虑同时提供骨架实现类
    c.应该尽可能谨慎地设计所有的公开接口，并通过编写多个实现来对它们进行全面的测试
  7. 接口只用于定义类型【Item 19】
    1）为了增加类型而设计接口
    2）常量接口模式是针对接口的不良使用，即接口仅有常量并无接口方法
    3）导出常量的几种合适的方式：
    a.如果这些常量与某个现有的类或者接口紧密相关，就应该把这些常量加到这些类和接口中，如JDK中的Integer和Double中的MAX_VALUE和MIN_VALUE
    b.如果常量最好被看作枚举类型的成员，那么就应该使用枚举类型
    c.如上都不合适，可以使用不可实例化的工具类来导出这些常量
  8. 类层次优于标签类【Item 20】
    1）标签类即是一个类中包含多个类型，增加所有类型的域以及方法，多个类混合在一起
    2）标签类过于冗长，容易出错，并且效率低下
    3）类层次的好处在于其反应了类型之间本质上的层次关系，有助于增强灵活性，并进行更好的编译时类型检查
  9. 用函数对象表示策略【Item 21】
    1）允许函数调用者通过传入第二个函数来指定自己的行为，java中通过传入策略对象决定行为，即某一个对象的方法执行其他对象上的操作，这种机制叫做策略模式
    2）在设计具体的策略类时，还需要定义一个策略接口，策略接口被用作所有具体策略实例的类型
    3）java中实现策略模式方式
    a.要声明一个接口来表示该策略，并且为每个具体策略生命一个实现了该接口的类
    b.当一个具体策略只被使用一次时，通常使用匿名类来声明和实例化这个具体策略类
    c.当一个具体策略是设计用来重复使用的时候，它的类通常就要被实现为私有静态成员类，并通过公有的静态final域被导出，且类型为该策略接口
  10. 优先考虑静态成员类【Item 22】
    1）嵌套类(nested class)是指被定义在一个类的内部的类，它的目的是为其外围类(enclosing class)提供服务
    2）嵌套类有静态成员类、非静态成员类、匿名类、局部类四种，其中静态成员类为非内部类，其无异于外围类，仅仅是位置位于外围类内部，即使没有外围类的实例，静态成员类仍可以被正常使用，其它三种被成为内部类
    3）静态成员类一种常见用法是作为公有的辅助类，仅当与它的外部类一起使用才有意义
    4）非静态成员类的每个实例都隐含着与外围类的一个外围实例相关联，没有外围类的实例的情况下，要想创建非静态成员类的实例是不可能的
    5）非静态成员类的一种常见用法是定义一个Adapter，它允许外部类的实例被看作是另一个不相关的类的实例
    6）如果声明成员类不要求访问外围类实例，就要始终把static修饰符放在它的声明中，使它成为静态成员类，而不是非静态成员类，如果缺省了static修饰，那么其嵌套类的每个实例都包含一个外围类的实例，保存这份引用需要时间和空间，并且导致外围实例在垃圾回收时得以保留
    7）私有静态成员类的一种常见用法是用来代表外围类所代表的组件
    8）当且仅当匿名类出现在非静态环境中时，它才有外围实例，但是即使它们出现在静态环境中，也不可能拥有任何静态成员
    9）匿名类常见用法
    a.动态的创建函数对象，也就是策略对象
    b.创建过程对象，比如runnable,Thread或者TimerTask等
    c.静态工厂方法的内部进行匿名自定义类对象的创建
    10）匿名类的限制
    a.除了在匿名类声明的时候，是无法将它们实例化的，你不能执行instanceof测试，或者做任何需要命名类的其它事情
    b.无法声明一个匿名类来实现多个接口，或者扩展一个类，并同时扩展类和实现接口
    c.匿名类的客户端无法调用任何成员，除了从它的超类中继承得到之外
    d.由于匿名类出现在表达式中，其必须保持简短
    11）在任何声明局部变量的地方都可以声明局部类，并且局部类也遵守同样的作用域规则
    12）局部类同其它三种嵌套类都有一些共同属性
    a.与成员类一样，局部类有名字，可以被重复地使用
    b.与匿名类一样，只有当局部类在非静态环境中定义的时候，才有外围实例，它们不能包含静态成员
    c.与匿名类一样，它必须非常简短，以便不会影响到可读性
    13）四种嵌套类的用法：
    a.如果一个嵌套类需要在单个方法之外仍然是可见的，或者它太长了，不适合于放在方法内部，就应该使用成员类
    b.如果嵌套类的每个实例都需要一个指向其外围类实例的引用，就要把成员类做成非静态的，否则做成静态的
    c.假设这个嵌套类属于一个方法内部，如果你只需要在一个地方创建该类的实例，并且已经有了一个预置类型可以说明这个类的特征，那么将其做成匿名类
    d.以上特征都没有，那么就可以将嵌套类设计成局部类
Effective Java第三版1
08-08
### 第四章 类和接口 这一章可能涉及类的设计原则，如接口的使用、继承的注意事项、类的封装、访问控制以及如何有效地使用抽象类和接口。 ### 第五章 方法设计 可能包括方法的签名设计、异常处理、方法的返回值、...
精选资源
Effective-Java:Effective Java中文版第二版示例代码
07-09
合理选择接口和抽象类，可以更好地设计API并支持多继承。 7. **可变与不可变对象**：不可变对象在多线程环境中更安全，且可以被共享。构建不可变对象需确保类是final的，所有字段都是final的，并且没有修改状态的...
Effective java笔记-第四章
hjvgf的博客
04-07 803
类和接口第十三条使类和成员的可访问性最小化应该使用与你正在编写的软件的对应功能相一致的、最小的访问级别 对于顶层的类（顶层是指非嵌套的类）和接口只有两种可能的访问级别：包级私有和公有的。 如果类或接口可以被做成包级私有的就应该做成包级私有的，这样这个类实际成了这个包的实现的一部分，可以在以后对他修改，替换而不用担心影响到客户端程序，如果做成公有的，你就有责任永远支持它的兼容性。 如果一个包级
EffectiveJava第四章 类和接口 (思维导图)
飛白的学习笔记
06-22 667
读书笔记思维导图 第四章 所有对象的通用方法 (思维导图) 第四章 所有对象的通用方法 (思维导图).xmind下载
EffectiveJava第四章：类和接口
FromNowOnUntilTheEnd
04-23 306
第15条：使类和成员的可访问性最小化 对于成员（域、方法、嵌套类、嵌套接口）有四种级别，按递增顺序如下： 私有的（private）：只有在声明该成员的顶层类内部才可以访问这个成员 包级私有的（package-private）：声明该成员的包内部的任何类都可以访问这个成员。从技术上讲，它被称为“缺省”（default）访问级别，如果没有为成员指定访问修饰符，就采用这个访问级别（接口成员除外，它...
Effective Java读书笔记 -- 第四章：类和接口
weixin_41704428的博客
05-28 399
    类和接口是Java程序设计语言的核心，也是Java语言的基本抽象单元。Java语言提供了许多强大的基本元素，供程序员用来设计类和接口。第十三条：使类和成员的可访问性最小化    设计良好的模块会隐藏所有的实现细节，把它的API与它的实现清晰地隔离开来。然后，模块之前只通过它们的API进行通信，一个模块不需要知道其他模块的内部工作情况。这个概念被称为信息隐藏或封装，是软件设计的基本原则之一。...
effective java第4章 类和接口
lc138544的博客
09-27 253
第13条 使类和成员的可访问性最小化 第一规则：尽可能地使每个类或成员不被外界访问 只有当同一个包内的另一个类真正需要访问一个成员的时候，你才应该删除private修饰符。 如果方法覆盖了超类中的一个方法，子类中的访问级别就不允许低于超类中的访问级别。这样可确保任何可使用超类实例的地方也可以使用子类的实例。 长度非零的数组总是可变的，所以，类具有公有的静态final数组域，或者返回这种域的访问方法...
effective-java.pdf
04-30
标题《effective-java.pdf》表明本文档是关于Java编程语言的实践指南，而描述说明了这是一份根据...文档《effective-java.pdf》详细地探讨了静态工厂方法在设计和实现上的优势，强调了其在现代Java编程实践中的重要性。
【Effective Java】第4章 读书笔记
qq_45050687的博客
06-14 1295
第4章 类和接口 15，使类和成员可访问性最小化 尽可能地使每个类或者成员不能被外界访问。 公有类的实例域绝不能是公有的。 包含公有可变域的类通常并不是线程安全的。 让类具有公有的静态 final 数组域，或者这种域的访问方法是错误的。 16，要在公有类中使用访问方法而非公有域 公有类永远都不要暴露可变的的域 17，使可变性最小化 不可变类是指实例不可以被修改的类 17.1 不可变类要遵循的五条原则： 不要提供任何可以修改对象状态的方法。 保证类不会被扩展。 声明所有的域都是 final 的。 声明所有的
effective java之第四章：类和接口
Richard_666的博客
10-04 322
第十三条：使用类和成员的可访问性最小化 第一规则：尽可能使每个类或者成员不被外界访问。 第十四条：在公有类中使用访问方法而非公有域 公有类不应该直接暴露数据域，公有类永远都不应该暴露可变的域，让公有类暴露不可变的域其危害比较小，有时候会需要用包级私有或者私有的嵌套类来暴露域。 第十五条：使可变性最小化 使用类成为不可变，要遵循下面5条规则 1、不要提供任何会修改对象状态的方法 2、保...
《Effective Java》第5章 泛型
AnnaLoad的专栏
01-07 1362
Java 1.5发行版本中增加了泛型，在没有泛型之前，从集合中读取到的每一个对象都必须进行类型转换，如果有人不小心插入了类型错误的对象，在运行时的转换处理就会出错。 而有了泛型之后呢，可以告诉编译器每个集合中都接受那些对象类型，编译器自动地为你的插入进行转化，并在编译时告知是否插入了类型错误的对象，这样尽早的暴露错误，保证后续的运行安全。
《Effective Java》第7章 方法
AnnaLoad的专栏
04-08 846
本章主要讨论方法设计的几个面：如何处理参数和返回值，如何设计方法签名，如何为方法编写文档。
《Effective Java》第9章 异常
AnnaLoad的专栏
04-08 703
充分发挥异常的优点，可以提高程序的可读性，可靠性和可维护性，如果使用不当，它们也会带来负面影响。
《Effective Java》第10章 并发
AnnaLoad的专栏
04-08 600
本章给出一些建议帮忙程序员编写出清晰，正确，文档组织良好的并发程序。
《Effective Java》第3章 对于所有对象都通用的方法
AnnaLoad的专栏
12-24 586
Object类默认为所有类的基类，其虽然为一个具体的类，但是它的设计主要是为了扩展，而它的所有非final的方法(equals, hashCode, toString, clone和finalize)都有明确的通用约定, 如果在自定义类时要重写这些方法，需要注意主动遵守这些约定，不然一些依赖于这些约定的类（如HashMap和HashSet）将无法正确工作。 通用概念 1.值类：表示值的
《Effective Java》第6章 枚举与注解
AnnaLoad的专栏
01-08 576
Jdk 1.5发行版本新增了两个引用类型家族：一种新的类称作枚举类型（enum）；另一种新的接口称作注解类型（annotation type）
《Effective Java》第2章 创建和销毁对象
AnnaLoad的专栏
12-17 560
学习一门语言有三个重要的部分必须要掌握：语法（该门语言的结构如何），词汇（如何用该语言命名你想要讨论的事物），用法（如何用惯用和高效的方式表达日常事物）。 那么《Effective Java》就是描述Java语言的用法很不错的一本书，阅读学习本书能够为程序员提供很多很好的编写Java代码的建议，从写代码的时候就避免掉进一些不必要的陷阱，减轻后续的debug的工作量。 也就是借鉴牛人们的经典建议，避
介绍《Effective Java》第4、第5章知识点
最新发布
11-20
### 《Effective Java》第 4 章：类和接口 - **使类和成员的可访问性最小化**：设计类和成员时，应尽可能降低其可访问性，遵循信息隐藏原则。对于顶层的类和接口，只有两种访问级别：包级私有和公有。对于成员（字段、方法、嵌套类和嵌套接口），有四种访问级别：私有的、包级私有的、受保护的和公有的。 ```java // 私有字段 private int privateField; // 包级私有方法 void packagePrivateMethod() { // 方法实现 } ``` - **在公有类中使用访问方法而非公有字段**：公有类不应直接暴露其字段，而应提供访问方法（getter 和 setter），这样可以更好地控制对字段的访问，便于后续修改和维护。 ```java public class Point { private double x; private double y; public double getX() { return x; } public void setX(double x) { this.x = x; } public double getY() { return y; } public void setY(double y) { this.y = y; } } ``` - **使可变性最小化**：不可变类更易于设计、实现和使用，不容易出错且更安全。要创建不可变类，需要遵循以下规则：不提供修改对象状态的方法；保证类不会被扩展（通常使用 final 修饰类）；所有字段都是 final 的；所有字段都是私有的；确保对任何可变组件的互斥访问。 ```java public final class Complex { private final double re; private final double im; public Complex(double re, double im) { this.re = re; this.im = im; } public double realPart() { return re; } public double imaginaryPart() { return im; } public Complex add(Complex c) { return new Complex(re + c.re, im + c.im); } } ``` - **复合优先于继承**：继承是实现代码复用的有力手段，但它也有一些局限性，如打破了封装性，父类的修改可能会影响子类。复合是指在新类中包含一个现有类的实例，并通过该实例调用其方法。 ```java // 复合示例 public class ForwardingSet<E> implements Set<E> { private final Set<E> s; public ForwardingSet(Set<E> s) { this.s = s; } @Override public int size() { return s.size(); } // 其他方法... } ``` - **要么为继承而设计并提供文档说明，要么就禁止继承**：如果一个类不是为继承而设计的，应该禁止它被继承，可以使用 final 修饰类。如果要设计一个可继承的类，需要提供详细的文档说明，包括哪些方法可以重写，哪些方法不能重写等。 ```java // 禁止继承的类 public final class NonInheritableClass { // 类的实现 } ``` - **接口优于抽象类**：接口定义了一组方法的签名，而不包含实现，它可以被任何类实现。抽象类则既可以包含抽象方法，也可以包含具体方法。接口更灵活，一个类可以实现多个接口，但只能继承一个抽象类。 ```java // 接口示例 public interface MyInterface { void doSomething(); } // 实现接口的类 public class MyClass implements MyInterface { @Override public void doSomething() { // 方法实现 } } ``` - **为后代设计接口**：在设计接口时，要考虑到接口的扩展性，避免频繁修改接口。如果需要添加新的方法，可以提供默认方法。 ```java public interface MyInterface { void doSomething(); // 默认方法 default void doAnotherThing() { // 默认实现 } } ``` - **接口只用于定义类型**：接口应该只用于定义类型，而不应该包含常量。如果需要定义常量，可以使用枚举类型或不可实例化的类。 ```java // 错误示例：接口包含常量 public interface Constants { int MAX_VALUE = 100; } // 正确示例：使用不可实例化的类定义常量 public class Constants { private Constants() { throw new AssertionError(); } public static final int MAX_VALUE = 100; } ``` - **类层次优于标签类**：标签类是指包含多种不同类型对象信息的类，通过一个标签字段来区分不同的类型。类层次则是通过继承和多态来实现不同类型的对象。类层次更加清晰、灵活和可维护。 ```java // 标签类示例 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(); } } } // 类层次示例 abstract class Figure { abstract double area(); } class Circle extends Figure { final double radius; Circle(double radius) { this.radius = radius; } @Override double area() { return Math.PI * radius * radius; } } class Rectangle extends Figure { final double length; final double width; Rectangle(double length, double width) { this.length = length; this.width = width; } @Override double area() { return length * width; } } ### 《Effective Java》第 5 章：泛型 - **请不要在新代码中使用原生态类型**：原生态类型是指没有指定泛型参数的泛型类型，使用原生态类型会失去泛型的类型安全检查和自动装箱拆箱等优点。 ```java // 错误示例：使用原生态类型 List list = new ArrayList(); list.add("hello"); String s = (String) list.get(0); // 需要手动类型转换 // 正确示例：使用泛型类型 List<String> list = new ArrayList<>(); list.add("hello"); String s = list.get(0); // 无需手动类型转换 ``` - **消除非受检警告**：在使用泛型时，可能会出现一些非受检警告，应该尽量消除这些警告。如果不能消除警告，但可以证明引发警告的代码是类型安全的，那么可以使用 `@SuppressWarnings("unchecked")` 注解来抑制警告。 ```java @SuppressWarnings("unchecked") public static <T> T[] toArray(List<T> list) { T[] arr = (T[]) new Object[list.size()]; for (int i = 0; i < list.size(); i++) { arr[i] = list.get(i); } return arr; } ``` - **列表优先于数组**：数组是协变的，即如果 `Sub` 是 `Super` 的子类型，那么 `Sub[]` 就是 `Super[]` 的子类型；而泛型是不可变的，`List<Sub>` 不是 `List<Super>` 的子类型。数组在运行时才进行类型检查，而泛型在编译时就进行类型检查。因此，在使用集合时，列表通常比数组更安全和灵活。 ```java // 数组的协变问题 Object[] array = new String[10]; array[0] = 1; // 运行时抛出 ArrayStoreException // 泛型的不可变 List<String> list = new ArrayList<>(); // 编译错误：不能将 List<String> 赋值给 List<Object> // List<Object> objList = list; ``` - **优先考虑泛型类型**：在设计类和方法时，优先使用泛型类型，这样可以提高代码的类型安全性和可重用性。 ```java // 泛型类示例 public class Box<T> { private T t; public void set(T t) { this.t = t; } public T get() { return t; } } ``` - **优先考虑泛型方法**：泛型方法可以在调用时自动推断泛型类型，使代码更加简洁。 ```java // 泛型方法示例 public static <T> T getLast(List<T> list) { return list.get(list.size() - 1); } ``` - **利用有限制的通配符来提升 API 的灵活性**：有限制的通配符包括 `<? extends T>` 和 `<? super T>`。`<? extends T>` 表示该类型是 `T` 的子类型，用于生产者；`<? super T>` 表示该类型是 `T` 的父类型，用于消费者。 ```java // 生产者使用 <? extends T> public static double sumOfList(List<? extends Number> list) { double sum = 0; for (Number n : list) { sum += n.doubleValue(); } return sum; } // 消费者使用 <? super T> public static void addNumbers(List<? super Integer> list) { for (int i = 1; i <= 10; i++) { list.add(i); } } ``` - **优先考虑类型安全的异构容器**：类型安全的异构容器是指可以存储不同类型对象的容器，通过使用 `Class` 作为键来保证类型安全。 ```java // 类型安全的异构容器示例 public class Favorites { private Map<Class<?>, Object> favorites = new HashMap<>(); public <T> void putFavorite(Class<T> type, T instance) { favorites.put(type, type.cast(instance)); } public <T> T getFavorite(Class<T> type) { return type.cast(favorites.get(type)); } }
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值