2021（Java13）

最新推荐文章于 2024-07-16 17:08:16 发布

白开水加冰(2020080603036)

最新推荐文章于 2024-07-16 17:08:16 发布

阅读量304

点赞数

文章标签： java

本文链接：https://blog.csdn.net/qq_55680191/article/details/118498424

版权

知识点

接口的多实现

之前学过，在继承体系中，一个类只能继承一个父类。而对于接口而言，一个类是可以实现多个接口的，这叫做接口的多实现。并且，一个类能继承一个父类，同时实现多个接口。

抽象方法

接口中，有多个抽象方法时，实现类必须重写所有抽象方法。如果抽象方法有重名的，只需要重写一次。

默认方法

接口中，有多个默认方法时，实现类都可继承使用。如果默认方法有重名的，必须重写一次。

静态方法

接口中，存在同名的静态方法并不会冲突，原因是只能通过各自接口名访问静态方法。

优先级的问题

当一个类，既继承一个父类，又实现若干个接口时，父类中的成员方法与接口中的默认方法重名，子类就近选择执行父类的成员方法。

接口的多继承

一个接口能继承另一个或者多个接口，这和类之间的继承比较相似。接口的继承使用 extends 关键字，子接口继承父接口的方法。如果父接口中的默认方法有重名的，那么子接口需要重写一次。

小贴士：子接口重写默认方法时，default关键字可以保留。

子类重写默认方法时，default关键字不可以保留。

接口中，无法定义成员变量，但是可以定义常量，其值不可以改变，默认使用public static final修饰。
接口中，没有构造方法，不能创建对象。
接口中，没有静态代码块。

课堂实践

package demo01;
/*

java7
常量
抽象方法
java8
默认方法
静态方法
java9
私有方法
接口中是可以定义成员变量但是必须用 public static final 关键字修饰
从效果上来看就相当于是一个常量
1.接口中的常量用public static final 来修饰，是可以省略这三个关键字
2.相当是常量，因此只能初始化的进行赋值后面不能更改
3.建议命名格式用大写字母加下划线

public class Demo01Interface {
	
	int num = 5;
	
	public void method() {
		
	}
}

package demo01;

public interface MylnterfaceConst {
	
	public static final int NUM_OF_CLASS=5;
}


package demo02;

public interface MyInterface {
	public default void method() {
		System.out.println("我是接口里面的默认方法");
	}
}


package demo02;

错误写法：接口中不能有静态代码块
static {
}
错误写法：接口中不能有构造方法
public MyInterfaceA() {
}

public interface MyInterfaceA {
	
	
	public abstract void methodA();
	
	
	public abstract void methodAbs();
	
	
	public default void methodDefault() {
		System.out.println("默认方法AAAA");
	}
	
}


package demo02;

public interface MyInterfaceB {
	public abstract void methodB();
	public abstract void methodAbs();
	public default void methodDefault() {
		System.out.println("默认方法BBBB");
	}
	
}

package demo02;

public abstract class MyInterfaceAbs implements MyInterfaceA,MyInterfaceB {
	@Override
	public void methodB() {
		
	}
	
	// 只实现了一次
	@Override
	public void methodAbs() {
		
	}
	
	@Override
	public void methodDefault() {
		// TODO 自动生成的方法存根
		MyInterfaceA.super.methodDefault();
	}

}

package demo02;

public class MyInterfaceImpl implements MyInterfaceA,MyInterfaceB {

	@Override
	public void methodB() {
		// TODO 自动生成的方法存根
		
	}

	@Override
	public void methodA() {
		// TODO 自动生成的方法存根
		
	}

	@Override
	public void methodAbs() {
		// TODO 自动生成的方法存根
		
	}

	@Override
	public void methodDefault() {
		// TODO 自动生成的方法存根
		
		MyInterfaceA.super.methodDefault();
		
	}


	
}

package demo02;

public class Fu {
	public void method() {
	System.out.println("我是父类方法");
}
}


package demo02;

public class Zi extends Fu implements MyInterface {
	
}


package demo03;
/*
 * 这个接口中一共有几个方法？
 * 
 * 4个方法：
 * methodA(接口A的方法)
 * methodB(接口B的方法)
 * methodCommon(同时来源于接口A和B)
 * method(自己的方法)
 *
 * 
 * 
 */
public interface MyInterface extends MyInterfaceA,MyInterfaceB {
	public abstract void method();
	
	
	@Override
    default void methodDefault() {
		// TODO 自动生成的方法存根
		MyInterfaceA.super.methodDefault();
	}
}


package demo03;

public interface MyInterfaceA {
	
	
	
	public abstract void methodA();
	public abstract void methodCommon();
	
	public default void methodDefault() {
		System.out.println("AAAAA");
	}
	
}

package demo03;

public interface MyInterfaceB {
	public abstract void methodB();
	public abstract void methodCommon();
	public default void methodfault() {
	System.out.println("bbbb");
}
}

package demo03;

public  class MyIterfaceImpl implements MyInterface {

	@Override
	public void methodA() {
		// TODO 自动生成的方法存根
		
	}

	@Override
	public void methodCommon() {
		// TODO 自动生成的方法存根
		
	}

	@Override
	public void methodB() {
		// TODO 自动生成的方法存根
		
	}

	@Override
	public void method() {
		// TODO 自动生成的方法存根
		
	}

}

package demo03;

1.类和类之间的是单继承直接父类只有一个
2.类和接口之间是多实现一个类可以实现多个接口
3.接口和接口之间是多继承的
注意事项：
1.多个父接口中的抽象方法如果重复(重名)，没有关系
2.多个父接口中的默认方法如果重复

public class Demo03Relations {
	
	// MyInterface myinterface = new MyInterface();	
}

package demo04;

public class MyAnother {
	public void anotherMthode() {
		
		MyClass myclass = new MyClass();
		// System.out.println(myclass.num)
	}
}


package demo04;

public class MyClass {
	private int num = 5;
	
	public void method() {
		 System.out.println(num);
	}
	int sum = num +1;
}


package demo04;

public class MySon1 extends MyClass {
	
	public void method() {
		
		// System.out.println(super.num);
		
	}
}

package demo04;

java 中有四种权限修饰符
public protected (default):默认，没有修饰符 private
同一个类中(我自己) 可以访问
public yes
protected yes
(default) yes
private yes
同一个包中(我的邻居)
public yes
protected yes
(default) yes
private NO
同一个包中的子类(儿子)
public yes
protected yes
(default) yes
private NO
不同包子类( MyClass demo05)
public yes
protected yes
(default) NO
private NO
不同包的非子类(Stranger)
public yes
protected NO
(default) NO
private NO

public class Demo01Main {

}

package demo05;

import demo04.MyClass;

public class MySon2 extends MyClass {
	public void method() {
		
	}

}


package demo05;

import demo04.MyClass;

public class Stranger {
	public void methodStranger() {
		MyClass myclass = new MyClass();
	}
}