当我在学习接口时，我注意到现在可以在接口中定义静态和默认方法。
public interface interfacesample2 {
public static void method() {
System.out.println("hello world");
}
public default void menthod3() {
System.out.println("default print");
}
}
请简要说明这两者之间的区别，如果有使用示例更好。接口让我有点困惑。
Java 8 中静态方法和默认方法的区别：
1）默认方法可以在实现类中被重写，而静态方法不能。
2）静态方法仅属于接口类，因此只能在接口类上调用静态方法，而不能在实现该接口的类上调用，例如：
public interface MyInterface {
default void defaultMethod(){
System.out.println("Default");
}
static void staticMethod(){
System.out.println("Static");
}
}
public class MyClass implements MyInterface {
public static void main(String[] args) {
MyClass.staticMethod(); //not valid - static method may be invoked on containing interface class only
MyInterface.staticMethod(); //valid
}
}
3) 类和接口都可以拥有同名的静态方法，它们之间不会相互覆盖！
public class MyClass implements MyInterface {
public static void main(String[] args) {
//both are valid and have different behaviour
MyClass.staticMethod();
MyInterface.staticMethod();
}
static void staticMethod(){
System.out.println("another static..");
}
}
目的(使用公共实现)并通过在子类中再次实现逻辑 (覆盖，隐藏) 来解决歧义。唯一合理的原因可能是由于接口静态方法不被继承，因此我们无法使用子类实例调用它们。 - amarnath harish静态方法是适用于类“名称空间”的方法，可以这么说。因此，接口Interface的static方法foo通过Interface.foo()进行访问。请注意，函数调用不适用于任何特定的接口实例。
另一方面，默认实现bar则是通过调用：
Interface x = new ConcreteClass();
x.bar();
静态接口方法无法访问 this 变量，但默认实现可以。
public class Test {
public static void main(String[] args) {
// Accessing the static member
I1.hello();
// Anonymous class Not overriding the default method
I1 t = new I1() {
@Override
public void test() {
System.out.println("Anonymous test");
}
};
t.test();
t.hello("uvw");
// Referring to class instance with overridden default method
I1 t1 = new Test2();
t1.test();
t1.hello("xyz");
}
}
interface I1 {
void test();
//static method
static void hello() {
System.out.println("hello from Interface I1");
}
// default need not to be implemented by implementing class
default void hello(String name) {
System.out.println("Hello " + name);
}
}
class Test2 implements I1 {
@Override
public void test() {
System.out.println("testing 1234...");
}
@Override
public void hello(String name) {
System.out.println("bonjour" + name);
}
}
2. 我们什么时候会使用这个功能呢？
这取决于您的问题陈述。我认为，如果您需要在该契约中的所有类中将某个方法的实现相同，则默认方法非常有用，或者它可以像适配器类一样使用。
此外，下面的 Oracle 文档解释了默认和静态方法如何用于演化现有接口：
实现增强了新默认或静态方法的接口的类的用户不必修改或重新编译它们以适应其他方法。
http://docs.oracle.com/javase/tutorial/java/IandI/nogrow.html
以下是我的看法：
接口中的静态方法:
可以直接调用(InterfacetA.staticMethod())。
子类将无法重写。
子类可能会有与staticMethod同名的方法。
接口中的默认方法:
不能直接调用。
子类将能够重写它。
优点:
静态方法:您不需要创建单独的类来实现公用方法。
默认方法:在默认方法中提供公共功能。
public interface MyInterface {
private void privateMethod() {
System.out.println("Hi, this is privateMethod");
}
private static void staticPrivateMethod() {
System.out.println("Hi, this is staticPrivateMethod");
}
static void staticMethod() {
//privateMethod(); // Non-static method cannot be referenced from a static contex
System.out.println("Hi, this is staticMethod");
staticPrivateMethod();
}
default void defaultMethod() {
System.out.println("Hi, this is defaultMethod");
}
}
public class MyInterfaceImpl implements MyInterface{
public static void main(String[] args) {
MyInterface.staticMethod();
// myInterface.staticMethod(); // Not allowed
MyInterface myInterface = new MyInterfaceImpl();
myInterface.defaultMethod();
// MyInterface.defaultMethod(); // Not allowed
}
}
interface IDemo {
//this method can be called directly from anywhere this interface is visible
static int convertStrToInt(String numStr) {
return Integer.parseInt(numStr);
}
//getNum will be implemented in a class
int getNum();
default String numAsStr() {
//this.getNum will call the class's implementation
return Integer.toString(this.getNum());
}
}
接口默认方法：
它有助于避免使用实用程序类，例如所有Collections类方法可以在接口本身中提供。
它有助于扩展接口，而不必担心破坏实现类。
接口静态方法：
它们是接口的一部分，我们不能将其用于实现类对象。
它有助于通过不允许实现类覆盖它们来提供安全性。
现在介绍静态方法如何提供安全性。让我们看一个例子。
interface MyInterface {
/*
* This is a default method so we need not to implement this method in the implementation classes
*/
default void newMethod() {
System.out.println("Newly added default method in Interface");
}
/*
* This is a static method. Static method in interface is similar to default method except that we cannot override them in the implementation classes. Similar to default methods, we need to implement these methods in implementation classes so we can safely add them to the existing interfaces.
*/
static void anotherNewMethod() {
System.out.println("Newly added static method in Interface");
}
/*
* Already existing public and abstract method We must need to implement this method in implementation classes.
*/
void existingMethod(String str);
}
public class Example implements MyInterface {
// implementing abstract method
public void existingMethod(String str) {
System.out.println("String is: " + str);
}
public void newMethod() {
System.out.println("Newly added default method in Class");
}
static void anotherNewMethod() {
System.out.println("Newly added static method in Class");
}
public static void main(String[] args) {
Example obj = new Example();
// calling the default method of class
obj.newMethod();
// calling the static method of class
obj.anotherNewMethod();
// calling the static method of interface
MyInterface.anotherNewMethod();
// calling the abstract method of interface
obj.existingMethod("Java 8 is easy to learn");
}
}
在这里，obj.newMethod(); 打印类实现的逻辑，意味着我们可以在实现类内部更改该方法的逻辑。
但是，obj.anotherNewMethod(); 打印类的实现逻辑，但没有更改接口实现。因此，如果在该方法中编写了任何加密解密逻辑，则无法更改。
我们无法执行Interfacesample2.menthod3();，因为它不是静态方法。为了执行method3()，我们需要一个Interfacesample2接口的实例。
请参考以下实际示例：
public class Java8Tester {
public static void main(String args[]){
// Interfacesample2.menthod3(); Cannot make a static reference to the non-static method menthod3 from the type Interfacesample2
new Interfacesample2(){ }.menthod3();// so in order to call default method we need an instance of interface
Interfacesample2.method(); // it
}
}
interface Interfacesample2 {
public static void method() {
System.out.println("hello world");
}
public default void menthod3() {
System.out.println("default print");
}
}
静态接口方法：
默认方法：
这里有一个详细解释的链接。详细示例：Java 中接口中的默认方法与静态方法有什么区别？