blocks|key|1351602|text|当抽象类中的非抽象方法被重写时，当它的具体子类调用super()时，将调用它。所以有多种可能性。如果未重写方法，则将执行超类方法。如果在具体子类方法中使用super()，那么将执行带有超类方法的重写方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1351603|作为Java+8接口，默认方法是完全不同的。它为开发人员提供了在实现类中实现方法的选择。如果函数没有实现，那么只有在之后，默认方法才会被执行。|offset|length|style|BOLD|1351604|可能用例：|1351605|JDK库中这个新特性最重要的用例是在不破坏现有实现者的情况下扩展现有接口:向接口添加新的抽象方法将需要所有实现类来实现该新方法(Source)。|1351606|entityMap|0|LINK|mutability|MUTABLE|url|http://blog.hartveld.com/2013/03/jdk-8-13-interface-default-method.html^0|0|1G|6|0|0|1S|6|0|0^^$0|@$1|2|3|4|5|6|7|T|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|U|8|@$D|V|E|W|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|X|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|Y|8|@]|9|@$D|Z|E|10|1|11]]|A|$]]|$1|L|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|M|$N|$5|O|P|Q|A|$R|S]]]]

non-abstract methods in abstract classes will be called when it's concrete subclass calls super() if it is overridden. So there are multiple possibilities. If method is not overridden then the super class method will be executed. if we use super() in the concrete subclass method then the overridden method with the super class method will be executed.

Where as Java 8 interface default methods are completely different. It provided a choice to the developers to implement the method in the implementing class or not. If the function is not implemented then and only then the default method will be executed.

Possible Use Case : 

The most important use case for this new feature in the JDK libraries is the possibility to extend existing interfaces without breaking existing implementers: adding a new abstract method to an interface would require all implementing classes to implement that new method.(<a href="http://blog.hartveld.com/2013/03/jdk-8-13-interface-default-method.html">Source</a>)

blocks|key|691899|text|首先，默认方法允许您在不破坏现有实现的情况下向接口添加新方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|691900|还有一个Collections类的例子，它是一个用于Collection接口的实用类。|offset|length|style|CODE|691901|因此，使用默认方法，我们现在可以将所有实用程序方法移动为Collection本身中的默认实现，这将比为此类实用程序创建单独的类更有意义。|691902|此外，您还可以从多个接口继承方法，这些方法不可能使用普通的abstract类完成。|691903|entityMap^0|0|4|B|Q|A|0|S|A|0|T|8|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@$D|P|E|Q|F|G]|$D|R|E|S|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|T|8|@$D|U|E|V|F|G]]|9|@]|A|$]]|$1|J|3|K|5|6|7|W|8|@$D|X|E|Y|F|G]]|9|@]|A|$]]|$1|L|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|M|$]]

Firstly Default methods allow you to add new methods to interface without breaking existing implementations.

Also take an example of <code>Collections</code> class which is a utility class for <code>Collection</code> interface right. 

So using default methods we can now move all the utility methods as default implementation in the <code>Collection</code> itself, which will make more sense than making a separate class for such utilities.

Also you will be able to inherit methods from multiple interfaces, which could not have been done using plain <code>abstract</code> classes.

blocks|key|692574|text|重要的是要记住的是，默认方法不能访问状态，只能访问行为。它实际上是一个定义合理、默认、行为的好地方。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|692575|假设您有一个接口：|692576|public+interface+Plant+{
++++enum+Pace+{+FAST,+SLOW;+}

++++void+grow(Pace+pace);
++++void+growFast();
++++void+growSlow();
}|code-block|syntax|javascript|692577|提供默认行为似乎是合理的：|692578|default+void+growFast()+{+grow(Pace.FAST);+}
default+void+growSlow()+{+grow(Pace.SLOW);+}|692579|这是一个简单的例子，但显示了默认方法是如何有帮助的。在这种情况下，growSlow或growFast的行为方式是接口契约的一部分，因此在接口级别定义它们的行为是有意义的。|offset|length|style|CODE|692580|然而，接口并没有假设“种植植物”的动作是如何实现的。可以在抽象类中定义。|692581|entityMap^0|0|0|0|0|0|X|8|16|8|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|X|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Y|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|Z|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|10|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|11|8|@$O|12|P|13|Q|R]|$O|14|P|15|Q|R]]|9|@]|A|$]]|$1|S|3|T|5|6|7|16|8|@]|9|@]|A|$]]|$1|U|3|-4|5|6|7|17|8|@]|9|@]|A|$]]]|V|$]]

The important thing to keep in mind is that default methods don't have access to state, only to behaviour. It is actually a great place to define reasonable, default, behaviour.

Imagine you have an interface:

<pre><code>public interface Plant {
 enum Pace { FAST, SLOW; }

 void grow(Pace pace);
 void growFast();
 void growSlow();
}
</code></pre>

It seems reasonable to provide a default behaviour:

<pre><code>default void growFast() { grow(Pace.FAST); }
default void growSlow() { grow(Pace.SLOW); }
</code></pre>

This is a simplistic example but shows how default methods can be helpful. In this case, the way <code>growSlow</code> or <code>growFast</code> behaves is part of the interface contract so it makes sense to define their behaviour at the interface level.

However the interface makes no assumption about how the action "grow a plant" is implemented. That could be defined in an abstract class.

blocks|key|692595|text|最大的区别是构造函数可能在匿名类中运行，可能有检查过的异常。这可以防止匿名类成为函数接口，从而使它们无法用作lambda表达式的基础。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|692596|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

the big difference is that the constructor can possibly be run in an anonymous class, possibly with checked exceptions. this prevents anonymous classes being functional interfaces, and in turn makes them unavailable to use as the basis for a lambda expression.

blocks|key|691951|text|主要区别是:+Java+8默认接口方法是公共的，而抽象类的非抽象(具体)方法可以定义为公共、保护或私有方法。Lambda表达式是在Java+8中引入的，为了使用lambda特性，我们需要默认的方法(为了保持向后兼容性)，抽象类的非抽象方法不能达到这个目的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|691952|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

The main differences are:
Java 8 default methods of interfaces are public, while non-abstract (concrete) methods of abstract classes can be defined as public, protected or private.
Lambda expressions got introduced in Java 8, to use lambda features we need default methods(to preserve backward compatibility), non-abstract methods of abstract classes can not serve the purpose.

Java 8 interface default methods vs. non-abstract methods in abstract classes
- are there any differences between the two (besides the differences of iface - class, visibility etc.)

Isn't a default method a step back in Java, meaning it's against the essence that Java has advertised for years?!

Java 8 default methods vs. non-abstract methods in abstract classes

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

Java 8接口默认方法与抽象类中的非抽象方法之间有什么区别(除了iface类、可见性等方面的差异外)在Java中，一个默认的方法不是倒退了一步，这意味着它违背了Java多年来所宣传的本质吗？！

问Java 8默认方法与抽象类中的非抽象方法
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Java 8默认方法与抽象类中的非抽象方法EN