学习effective java-18类和接口之接口优于抽象类

最新推荐文章于 2022-01-10 10:50:17 发布

原创最新推荐文章于 2022-01-10 10:50:17 发布 · 405 阅读

0 ·

CC 4.0 BY-SA版权

Effective Java 专栏收录该内容

24 篇文章

订阅专栏

该知识点是自己从书籍中学习的笔记。

如果一个方法是抽象方法的话，那么该类一定是抽象类，并且该类的类名前必须加abstract。抽象类中的抽象方法也必须加abstract。

接口可以多继承，而抽象类不能够。将抽象类和接口混合使用，可以构建出骨架类。

接口和抽象各有各自的好处与缺点：当接口增加一个方法的时候，那么它的实现类也必须增加对该方法的实现，这会打破原有的类设计，但是使用抽象类就没有此缺点。

总而言之，接口通常是用来定义具有多个实现的类型的最佳途径。当演化性和功能较重要的时候，则考虑使用抽象类。

确定要放弃本次机会？

福利倒计时

: :

立减 ¥

普通VIP年卡可用

立即使用

初中生

关注关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
分享

复制链接

分享到 QQ

分享到新浪微博

扫一扫
举报

举报

专栏目录

effective java：接口优于抽象类

qq_36667796的博客

06-11

188

1，已有的类更容易实现新接口，而实现新的抽象类十分困难假如，你需要让已有的类 class N拥有一个全新的类型，以便其作为组件用在某程序中，你有两个选择。 1，实现一个接口interface A，implements+具体方法即可。 2，继承一个抽象类 abstract class A，如果这个已有的类没有直接父类，直接extends即可，但是，很多情况，已有类是有直接父类的，此路不通。怎么办...

Effective Java 类和接口第18条：接口优于抽象类

热门推荐

yancyang的博客

08-20

1万+

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

参与评论您还未登录，请先登录后发表或查看评论

Effective Java 第二版中文版笔记（十八）接口优于抽象类

qq_37538698的博客

09-17

202

这里主要就是接口和抽象类的区别：使用一个例子直接进行说明；理解：抽象类：抽象类是对一种事物的抽象，即对类抽象接口：是对行为进行抽象；从网上看了个例子感觉不错： interface Alram { void alarm(); } abstract class Door { void open(); void close(); } ...

Effective Java - 类和接口 - 接口优于抽象类

wujunyucg的博客

11-17

393

读书笔记仅供参考接口和抽象类 抽象类允许某些方法的实现，但是接口不允许(JDK 1.8 已经运行了) 现有类必须成为抽象类的子类，但是只能单继承，接口可以多继承接口优点现有类可以很容易被更新，以实现新的接口只需要在接口中添加方法就可以了接口是定义 mixin （混合类型）的理想选择mixin：类除了实现它的“基本类型”之外，还可以实现 mixin 类型，表明它提供了可供选择的行为，例如 Comp

effective java（18）之接口优于抽象类

Eric的博客

10-18

751

effective java 之接口优于抽象类 1、Java程序设计语言提供了两种机制，可以用来定义允许多个实现的类型：接口和抽象类。 2、两种机制之间最明显的区别在： ① 抽象类允许包含某个方法的实现，而接口则不允许。 ②为了实现由抽象类定义的类型，类必须成为抽象类的一个子类。Java只允许单继承，所以，抽象类作为类型定义受到了极大限制。 3、现在的类可以很容易的被更新

Java：Effective java学习笔记之接口优于抽象类

JMW1407的博客

12-16

561

Java接口优于抽象类接口优于抽象类1、接口和抽象类2、接口优点3、骨架类3.1、demo参考接口优于抽象类 1、接口和抽象类 Java中抽象类和接口的区别 2、接口优点 1、现有的类可以很容易的被更新，以实现新的接口。如果你前期编写了一个类A，后期有在系统中加入了一个新的接口B，当你想让前期编写的类来实现这个接口，你只用加上一句implement B，然后在类A中实现里面的方法即可，不会影响到以前的类对类A的使用。 2、接口是定义mixin（混合类型）的理想选择。这一条主要说的是，一个类可以实

Effective Java---20 接口优于抽象类

weixin_44212383的博客

07-23

188

前言 Java有两种机制允许多个类型的实现来进行扩展：接口和抽象类。抽象类即用abstract关键字修饰的类，它的特点是可以存在抽象方法，也可以存在普通方法；接口是用interface关键字修饰的，在Java 8之前只能有抽象方法，在Java 8中允许使用default关键字修饰的普通方法存在，在结构上和抽象类类似，但是抽象类有构造方法的，虽然不能直接实例化，接口就没有。 Java的单继承多实现接口优于抽象类的最主要原因就是Java是单继承的，在一定程度上限制了扩展性，限制了它们作为类型定义的使用，我们不

EffectiveJava-3-类和接口

o118abcdef的博客

01-07

214

使类和成员的可访问性最小化 - 封装（信息隐藏）：隐藏实现细节，将它的API与内部实现隔离，降低模块间的耦合性，易于独立开发，测试，优化等，提高软件的可重用性， - 访问控制的方式：使用访问修饰符（private，public，protected） - 尽可能的使每个类或者成员不能被外界访问 - 不能为了方便测试，而将类，接口或者成员变成包的导出API的一部分（即不要将权限大于package-private（default）） - 包含公有可变域的类不是线程安全的，即 public &&a

带你快速看完9.8分神作《Effective Java》—— 类和接口篇

如切如磋，如琢如磨

01-10

1662

???? Java学习：Java从入门到精通总结 ???? Spring系列推荐：Spring源码解析 ???? 最近更新：2022年1月7日 ???? 个人简介：通信工程本硕????、阿里新晋猿同学????。我的故事充满机遇、挑战与翻盘，欢迎关注作者来共饮一杯鸡汤 ???? 点赞 ???? 收藏 ⭐留言 ???? 都是我最大的动力！ 15 使类和成员的可访问性最小化面向对象语言设计时的两大“法宝”就是封装和解耦。其中，封装可以隐藏组件所有的实现细节，把API与实现清晰隔离开，因此也就解除组成系

Java-Effective:Java Effective 2nd Edition书中的源代码

05-11

- **接口优于抽象类**：在Java中，由于单继承限制，接口通常是实现多态的首选。 2. **重用已存在的类**： - **优先使用现有类库**：Java拥有丰富的标准库，合理利用可以减少重复工作。 - **组合优于继承**：通过...

effective-java:Intellij IDEA 的有效 Java 模式重构

07-03

5. **接口的优先级高于抽象类（Prefer Interfaces to Abstract Classes）**：Java的多继承特性限制了抽象类的使用，接口则允许类实现多个行为。IntelliJ IDEA的"Extract Interface"功能可以帮助我们快速创建接口。 ...

Effective Java第三版1

08-08

4. **抽象类和具体类**：何时使用抽象类，何时使用具体类，以及它们在继承体系中的角色。以上只是根据标题和描述的部分内容推测的知识点，实际书中会有更详尽的解释和示例。《Effective Java》的每一项条目都是...

学习effective java-16类和接口之复合优于继承

啦啦的专栏

01-06

1593

该知识点是自己从书籍中学习的笔记。与方法调用不同，继承打破了类的封装特性。使用继承估计会出现以下问题： 1．如果父类发生了变化，那么子类也需要检查是否需要更新。 2．开始时，子类有一个方法，而后父类增加了与子类一摸一样的方法，那么这个时候就相当于是子类重写了父类的方法，有可能并不是客户想要的结果。如果仅仅是返回类型不一致的话，还会造成编译错误。如果要编写一个类的话，最好是将其要

学习effective java-22类和接口之优先考虑静态成员类

啦啦的专栏

01-11

805

该知识点是自己从书籍中学习的笔记。嵌套类就是在类中定义的类，嵌套类仅仅是为它的外部类服务的。如果还需要给其他外部的类服务的话，那么就需要将该嵌套类提升一个层次。目前有四种嵌套套：静态成员类，非静态成员类，匿名类，局部类。除第一种类外，其他都可以成为内部类。静态成员类可以看作仅仅是外部类的一个静态成员，如果静态成员类被声明为private的，那么该类就只能够在外部类的内部中使用。静态成员类只

学习effective java-14类和接口之在公有类中使用可访问的方法，而不是使用公有域

啦啦的专栏

01-05

784

该知识点是自己从书籍中学习的笔记。对于下面的代码： public class Test14 { public int x; public int y; } 这是很不好的表现，因为该类的x、y可以被任意访问和修改，直接就暴露了信息给客户，没有做到封装的效果。你应该使用setter和getter的方式来设置和访问其中的值，修改代码如下： public class Test1

学习effective java-17类和接口之要么为继承而设计，并提供文档说明，要么就禁止继承

啦啦的专栏

01-06

742

该知识点是自己从书籍中学习的笔记。第16条告诉了我们对一个不是继承而设计并且没有文档的类是很危险的。那么一个为了设计而使用继承并且有很好的文档则应该做以下事情：该类的文档必须精确地说明每个改写的方法作用以及影响。好的API文档：应该是描述该方法做了什么工作，而不是如何做的。一个为了继承而设计的类（超类）应该是： a.为了允许被继承，无论是直接还是间接，构造方法都不能够调用非final

学习effective java-3创建和销毁对象之利用私有构造方法或枚举类型来强化单例的属性

啦啦的专栏

12-27

699

该知识点是自己从书籍中学习的笔记。单例：是指类只能够被实例化一次。单例通常是表示一个惟一的系统组件，如widows管理者或者文件系统。将一个类制作成单例对于测试用户会变的困难，因为替换掉一个单例的模拟实现类是不太可能的，除非该单例实现了一个作为它自己类型的接口。实现方法：在jdk1.5之前，有两种方式来实现单例，这两种方法都是基于构造方法是私有的和

学习effective java-7创建和销毁对象之避免使用终结器（finalizers）

啦啦的专栏

12-28

687

该知识点是自己从书籍中学习的笔记背景终结器的理念是允许 Java 方法释放任何需要返回到操作系统的本机资源。使用Finalizers会带来一些不可预期的危险、古怪的结果、性能降低、移植性问题，所以通常情况下，作为一种规则，都不要使用Finalizers。当然Finalizers是有一点作用的。在c++，通常是使用析构函数来回收已经分配给对象的资源或者其他资源。在java中，是自动回收不

学习effective java-1创建和销毁对象之静态工厂方法

啦啦的专栏

12-26

665

该知识点是自己从书籍中学习的笔记。静态工厂方法定义：类提供一个静态方法，来返回该类的实例。代替使用公有构造方法的方式来获取类的实例。例子： public static Boolean valueOf(boolean b) { return b ? Boolean.TRUE : Boolean.FALSE；｝优点: 1. 类的构造方法的名字必须要和类名字一样，但是静态工厂

Java类的学习

最新发布

07-16

<think>我们正在讨论Java类的深入学习。根据用户之前的请求，用户已经学习了Java基础，现在想深入理解Java类相关的知识。根据引用[1]中的学习路线，面向对象编程部分（第2部分）详细介绍了类和对象、继承和多态、接口和抽象类、封装等内容，这些都是Java类的核心知识。同时，引用[2]提到本站有从0做项目的教程，引用[3]则提供了JavaCV相关的实战教程，但用户当前问题聚焦在Java类本身，因此我们主要参考引用[1]的路线，并适当结合实践。因此，我们将围绕以下方面展开： 1. 类的定义和对象的创建 2. 类的成员：字段、方法、构造器 3. 访问控制（封装） 4. 继承（包括方法重写） 5. 多态 6. 抽象类和接口 7. 内部类（包括匿名内部类） 8. 枚举类 9. 常用类（如Object、String等）的深入理解 10. 设计模式中类的使用（如单例、工厂等）同时，为了帮助用户巩固知识，我们将提供一些示例代码，并推荐一些实践项目。注意：由于用户要求深入，我们会适当深入一些高级特性和最佳实践。最后，按照要求生成相关问题。</think>### Java类的深入学习指南 Java类是面向对象编程的核心概念，深入理解类及其相关特性是掌握Java的关键。以下是系统化的学习路径： #### 1. **类与对象基础** - **类定义**：模板声明，包含字段（属性）和方法（行为） ```java public class Person { // 字段 private String name; private int age; // 构造器 public Person(String name, int age) { this.name = name; this.age = age; } // 方法 public void introduce() { System.out.println("我叫" + name + "，今年" + age + "岁"); } } ``` - **对象实例化**：通过`new`关键字创建对象 ```java Person person1 = new Person("张三", 25); person1.introduce(); // 输出：我叫张三，今年25岁 ``` #### 2. **面向对象三大特性** - **封装**：通过访问修饰符控制可见性 - `private`（仅本类访问） - `protected`（本包及子类访问） - `public`（全局访问） - 使用getter/setter管理字段访问 ```java public String getName() { return name; } public void setName(String name) { this.name = name; } ``` - **继承**：`extends`实现代码复用 ```java public class Student extends Person { private String school; public Student(String name, int age, String school) { super(name, age); // 调用父类构造器 this.school = school; } } ``` - **多态**：父类引用指向子类对象 ```java Person p = new Student("李四", 20, "清华大学"); p.introduce(); // 运行时绑定子类方法 ``` #### 3. **高级类特性** - **抽象类**：包含抽象方法的类，需用`abstract`声明 ```java public abstract class Animal { public abstract void makeSound(); // 抽象方法无实现 } ``` - **接口**：`interface`定义纯抽象规范（Java 8+支持默认方法） ```java public interface Swimmable { void swim(); // 默认public abstract default void dive() { // Java 8默认方法 System.out.println("潜水"); } } ``` - **内部类**： - 成员内部类（可访问外部类私有成员） - 静态嵌套类（`static`修饰） - 局部内部类（方法内定义） - 匿名内部类（即时实现接口） ```java Runnable r = new Runnable() { @Override public void run() { System.out.println("匿名内部类"); } }; ``` #### 4. **关键类深度解析** - **Object类**：所有类的超类，重点方法： - `equals()`/`hashCode()`：对象相等性判断 - `toString()`：对象字符串表示 - `clone()`：对象克隆 - **String类**：不可变性原理与内存机制 ```java String s1 = "abc"; // 字符串常量池 String s2 = new String("abc"); // 堆中新对象 System.out.println(s1 == s2); // false（引用不同） ``` #### 5. **设计模式中的类应用** - **单例模式**：确保全局唯一实例 ```java public class Singleton { private static Singleton instance; private Singleton() {} // 私有构造器 public static Singleton getInstance() { if (instance == null) { instance = new Singleton(); } return instance; } } ``` - **工厂模式**：解耦对象创建 ```java public interface Shape { void draw(); } public class Circle implements Shape { @Override public void draw() { System.out.println("绘制圆形"); } } public class ShapeFactory { public Shape createShape(String type) { if ("circle".equals(type)) return new Circle(); // 扩展其他形状... return null; } } ``` #### 6. **最佳实践** - **组合优于继承**：优先使用组合提高灵活性 - **不可变类设计**：所有字段`private final`，不提供setter - **有效重写`equals()`**： ```java @Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; Person person = (Person) o; return age == person.age && Objects.equals(name, person.name); } ``` **推荐学习资源**： 1. 官方教程：[Java Classes and Objects](https://docs.oracle.com/javase/tutorial/java/javaOO/classes.html) 2. 书籍：《Effective Java》第3版（条目10-25详解类设计） 3. 实战项目：实现一个完整的银行账户管理系统（包含账户类、交易类、异常处理等） --- ### 相关问题 1. Java中抽象类和接口的主要区别是什么？分别在什么场景下使用？[^1] 2. 如何正确重写`equals()`和`hashCode()`方法？为什么要同时重写这两个方法？[^1] 3. 在Java内部类中，为什么局部内部类只能访问`final`局部变量？[^1] 4. 单例模式有哪些实现方式？如何防止反射攻击破坏单例？[^1] 5. 设计一个不可变类需要遵循哪些原则？举例说明其优势。[^1] [^1]: 参考自Java面向对象编程核心概念及官方文档 [^2]: Java学习路线中的面向对象模块 [^3]: JavaCV教程中类设计的实战应用案例