Java 默认方法
Java提供了一种在接口内部创建默认方法的功能。在接口内部定义并带有默认标记的方法称为默认方法。这些方法都是非抽象方法。
默认方法使您可以向库的接口添加新功能，并确保与为接口的旧版本编写的代码二进制兼容。
示例1: Java默认方法
下面的示例说明了一种情况，如果接口中没有默认方法该怎么办。
interface Sayable{
// abstract method
void say(String msg);
void sayMore(String msg);
}
publicclass DefaultMethods implements Sayable{
// implementing abstract methods
publicvoid say(String msg){
System.out.println(msg);
}
publicvoid sayMore(String msg){
System.out.println(msg);
}
publicstaticvoid main(String[] args) {
DefaultMethods dm = new DefaultMethods();
dm.say("Hello there"); // calling abstract method
dm.sayMore("Work is worship"); // calling abstract method
}
}
输出:
Hello there
Work is worship
Java默认方法示例
在下面的示例中，Sayable是一个功能接口，其中包含默认方法和抽象方法。默认方法的概念用于定义具有默认实现的方法。您还可以覆盖默认方法，以为该方法提供更具体的实现。
让我们看一个简单的
interface Sayable{
// default method
default void say(){
System.out.println("Hello, this is default method");
}
// abstract method
void sayMore(String msg);
}
public class DefaultMethods implements Sayable{
public void sayMore(String msg){ // implementing abstract method
System.out.println(msg);
}
public static void main(String[] args) {
DefaultMethods dm = new DefaultMethods();
dm.say(); // calling default method
dm.sayMore("Work is worship"); // calling abstract method
}
}
输出:
Hello, this is default method
Work is worship
Java 8接口内的静态方法
您还可以在接口内定义静态方法。静态方法用于定义实用程序方法。以下示例说明了如何在接口中实现静态方法？
interface Sayable{
// default method
default void say(){
System.out.println("Hello, this is default method");
}
// abstract method
void sayMore(String msg);
// static method
static void sayLouder(String msg){
System.out.println(msg);
}
}
public class DefaultMethods implements Sayable{
public void sayMore(String msg){ // implementing abstract method
System.out.println(msg);
}
public static void main(String[] args) {
DefaultMethods dm = new DefaultMethods();
dm.say(); // calling default method
dm.sayMore("Work is worship"); // calling abstract method
Sayable.sayLouder("Helloooo..."); // calling static method
}
}
输出:
Hello there
Work is worship
Helloooo...
抽象类与Java 8接口
在接口中包含默认方法和静态方法之后，我们考虑了Java中抽象类的需求。接口和抽象类几乎相似，除了可以在抽象类中创建构造函数，而不能在接口中创建。
abstract class AbstractClass{
public AbstractClass() { // constructor
System.out.println("You can create constructor in abstract class");
}
abstract int add(int a, int b); // abstract method
int sub(int a, int b){ // non-abstract method
return a-b;
}
static int multiply(int a, int b){ // static method
return a*b;
}
}
public class AbstractTest extends AbstractClass{
public int add(int a, int b){ // implementing abstract method
return a+b;
}
public static void main(String[] args) {
AbstractTest a = new AbstractTest();
int result1 = a.add(20, 10); // calling abstract method
int result2 = a.sub(20, 10); // calling non-abstract method
int result3 = AbstractClass.multiply(20, 10); // calling static method
System.out.println("Addition: "+result1);
System.out.println("Substraction: "+result2);
System.out.println("Multiplication: "+result3);
}
}
输出:
You can create constructor in abstract class
Addition: 30
Substraction: 10
Multiplication: 200
