effective java第4章 类和接口

最新推荐文章于 2022-02-27 21:25:36 发布
原创 最新推荐文章于 2022-02-27 21:25:36 发布 · 252 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文探讨了面向对象设计的几个核心原则，包括使类和成员的可访问性最小化，使用访问方法而非公有域，使可变性最小化，以及在公有类中优先采用复合而非继承。这些原则有助于创建更稳定、更易于维护的软件系统。

第13条 使类和成员的可访问性最小化
第一规则：尽可能地使每个类或成员不被外界访问
只有当同一个包内的另一个类真正需要访问一个成员的时候，你才应该删除private修饰符。
如果方法覆盖了超类中的一个方法，子类中的访问级别就不允许低于超类中的访问级别。这样可确保任何可使用超类实例的地方也可以使用子类的实例。
长度非零的数组总是可变的，所以，类具有公有的静态final数组域，或者返回这种域的访问方法，这几乎总是错误的。修正方法如下：

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

第14条 在公有类中使用访问方法而非公有域(过)
第15条 使可变性最小化
要使类成为不可变，要遵循下面几条圆原则:
1,不要提供任何会修改对象状态的方法
2，保证类不会被扩展
3，使所有的域都是final的
4，使所有的域都是私有的
5，确保对于任何可变组件的互斥访问
第16条 复合优先于继承
对于两个类，A和B，只有当两者之间确实存在“is_a”的关系时，类B才应该扩展类A

带你快速看完9.8分神作《Effective Java》—— 类和接口篇
如切如磋，如琢如磨
01-10 1777
???? Java学习：Java从入门到精通总结 ???? Spring系列推荐：Spring源码解析 ???? 最近更新：2022年1月7日 ???? 个人简介：通信工程本硕????、阿里新晋猿同学????。我的故事充满机遇、挑战与翻盘，欢迎关注作者来共饮一杯鸡汤 ???? 点赞 ???? 收藏 ⭐留言 ???? 都是我最大的动力！ 15 使类和成员的可访问性最小化 面向对象语言设计时的两大“法宝”就是封装和解耦。其中，封装可以隐藏组件所有的实现细节，把API与实现清晰隔离开，因此也就解除组成系
effective-java.pdf
04-30
标题《effective-java.pdf》表明本文档是关于Java编程语言的实践指南，而描述说明了这是一份根据...文档《effective-java.pdf》详细地探讨了静态工厂方法在设计和实现上的优势，强调了其在现代Java编程实践中的重要性。
effective java之第四章：类和接口
Richard_666的博客
10-04 320
第十三条：使用类和成员的可访问性最小化 第一规则：尽可能使每个类或者成员不被外界访问。 第十四条：在公有类中使用访问方法而非公有域 公有类不应该直接暴露数据域，公有类永远都不应该暴露可变的域，让公有类暴露不可变的域其危害比较小，有时候会需要用包级私有或者私有的嵌套类来暴露域。 第十五条：使可变性最小化 使用类成为不可变，要遵循下面5条规则 1、不要提供任何会修改对象状态的方法 2、保...
java第四章
04-27
1.顺序结构2.分支结构3.循环结构4.控制循环结构5.数组类型
java基础学习第四章
04-09
循环结构 循环语句顾名思义就是当满足循环条件的情况下，反复执行某一段代码，这段被 重复执行的代码被称为循环体语句，当反复把循环判断执行这个循环体时，需要 在合适的时条件修改为 false，从而结束循环，否则循环将一直执行下去，形成 死循环。
Effective java笔记-第四章
hjvgf的博客
04-07 798
类和接口第十三条使类和成员的可访问性最小化应该使用与你正在编写的软件的对应功能相一致的、最小的访问级别 对于顶层的类（顶层是指非嵌套的类）和接口只有两种可能的访问级别：包级私有和公有的。 如果类或接口可以被做成包级私有的就应该做成包级私有的，这样这个类实际成了这个包的实现的一部分，可以在以后对他修改，替换而不用担心影响到客户端程序，如果做成公有的，你就有责任永远支持它的兼容性。 如果一个包级
EffectiveJava第四章 类和接口 (思维导图)
飛白的学习笔记
06-22 666
读书笔记思维导图 第四章 所有对象的通用方法 (思维导图) 第四章 所有对象的通用方法 (思维导图).xmind下载
Effective Java第三版1
08-08
### 第四章 类和接口 这一章可能涉及类的设计原则，如接口的使用、继承的注意事项、类的封装、访问控制以及如何有效地使用抽象类和接口。 ### 第五章 方法设计 可能包括方法的签名设计、异常处理、方法的返回值、...
精选资源
Effective-Java:Effective Java中文版第二版示例代码
07-09
合理选择接口和抽象类，可以更好地设计API并支持多继承。 7. **可变与不可变对象**：不可变对象在多线程环境中更安全，且可以被共享。构建不可变对象需确保类是final的，所有字段都是final的，并且没有修改状态的...
EffectiveJava第四章：类和接口
FromNowOnUntilTheEnd
04-23 300
第15条：使类和成员的可访问性最小化 对于成员（域、方法、嵌套类、嵌套接口）有四种级别，按递增顺序如下： 私有的（private）：只有在声明该成员的顶层类内部才可以访问这个成员 包级私有的（package-private）：声明该成员的包内部的任何类都可以访问这个成员。从技术上讲，它被称为“缺省”（default）访问级别，如果没有为成员指定访问修饰符，就采用这个访问级别（接口成员除外，它...
Effective Java读书笔记 -- 第四章：类和接口
weixin_41704428的博客
05-28 397
    类和接口是Java程序设计语言的核心，也是Java语言的基本抽象单元。Java语言提供了许多强大的基本元素，供程序员用来设计类和接口。第十三条：使类和成员的可访问性最小化    设计良好的模块会隐藏所有的实现细节，把它的API与它的实现清晰地隔离开来。然后，模块之前只通过它们的API进行通信，一个模块不需要知道其他模块的内部工作情况。这个概念被称为信息隐藏或封装，是软件设计的基本原则之一。...
Effective Java读书笔记——第四章 类和接口
vanpersie_9987的博客
03-08 660
第13条：使类和成员的可访问性最小化 略。。。 第14条：在共有类中使用访问方法而非公有域 class Point { public double x; public double y; } 上面的类没有对数据域进行封装，导致这些数据是可以被直接访问的，也就无法进行任何的约束条件。反正，应该对其进行封装： class Point { private
《Effective java》笔记(第二版) --第四章(20-22)
syk1996的博客
01-16 427
个人笔记第四章 ——类和接口第二十条: 类层次优于标签类类层次代表会有更多的类被创建，之间有一种继承关系，构成层次关系，标签类(tagged class)则像一个大杂烩，标签类中有各式各样的成员，通过公共暴露的接口往外界提供作用，伴随着switch等分之判断和多余的使用成本(使用其中一个功能必须吧里面的玩意全实例化),违反了面向对象的专一原则，在java中，则使用类层次来替换，使得每次调用不会使用过
【Effective Java】第4章 读书笔记
qq_45050687的博客
06-14 1294
第4章 类和接口 15，使类和成员可访问性最小化 尽可能地使每个类或者成员不能被外界访问。 公有类的实例域绝不能是公有的。 包含公有可变域的类通常并不是线程安全的。 让类具有公有的静态 final 数组域，或者这种域的访问方法是错误的。 16，要在公有类中使用访问方法而非公有域 公有类永远都不要暴露可变的的域 17，使可变性最小化 不可变类是指实例不可以被修改的类 17.1 不可变类要遵循的五条原则： 不要提供任何可以修改对象状态的方法。 保证类不会被扩展。 声明所有的域都是 final 的。 声明所有的
《Effective java》笔记(第二版) --第四章(13-16)
syk1996的博客
01-02 403
个人笔记第三章 ——类和接口第十三条: 使类和成员的可访问性最小化尽可能使每个类或者成员不被外界访问私有的东西将不被智能提示和导出到API文档中，这是内部的实现，而不是给外部暴露用，为了不使用户(使用这个类的人)疑惑和增加类的可变性，类暴露的接口，不是private修饰的都是可以被使用的，那么如果别人使用了你不该使用的部分，而你这个类下个版本更新，却删除了这个方法，将不止导致用户对于你的类的厌恶，而
Java第4章
A_Huan_的博客
02-27 197
Java算数运算符的使用 1.%的本质：看成一个公式：a % b = a - a / b * b 2.自增：++ 作为独立的语句使用时，前++和后++都完全等价于i=i+1； 作为表达式使用 前++：++i先自增后赋值 后++:i++先赋值后自增 3.--,+,-,*是一个道理，完全可以类推 面试题 1. int i = 1; i=i++;//先赋值后自增。(1)temp=i;(2)i=i+1;(3)i=temp; system.out.println(i);//1 2. int i =
java第4章
YHYNB的博客
01-07 302
这个是接这写的， 7.抽象到类，假如有公交车，轿车，车有属性和行为，车有属性车的功率，速度了。把公交车和轿车抽象成车(car)，行为为功率(power)速度(speed). 我们建立了一个car类，上面的car是一个类，我们在类里面写方法，写内容。 public class Car { double speed;//这个是成员变量,成员变量的范围是整个类 public void s() {//我们...
介绍《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、付费专栏及课程。

余额充值