Java基础篇------接口详解

🎉🎉Java入门级教程🎉🎉

🌹🌹适合刚学习Java的小白选手🌹🌹

😃😃快来学习一下吧~~~ 😃😃

😊😊如果对于抽象类没有概念，可以先看下面👇这篇文章😊😊

👉👉👉👉关于抽象类的详细知识

目录

一、接口的概述

二、接口的基本实现

三、接口与接口的多继承

四、JDK1.8开始之后接口新增的三个方法

五、实现多个接口的使用注意事项

---

一、接口的概述

接口定义：
接口体现的是规范的思想，实现接口的子类必须重写完接口的全部抽象方法。
接口是更加彻底的抽象，接口中全部是抽象方法。

接口的定义格式：

修饰符 interface 接口名称{
    //抽象方法
}
interface是定义接口的核心关键字。

接口中的成分：
1、抽象方法
接口中的抽象方法可以省略public abstract，默认会加上。
2、常量
变量值只有一个，而且在程序运行过程中不可更改。
常量的一般修饰符是：public static final
常量变量名称建议字母全部大写。

interface SportMan{
//	类似于public abstract void run();
	void run();
//	类似于public abstract void competition();
	void competition();
	
	public static final String SPORT_NUMBER="101";
}

小结：
1、接口体现的是规范思想。
2、接口中的抽象方法public abstract可以不写，默认会加上。
3、接口中的常量 public static final可以不写，默认会加上。
4、除此之外没有其他成分。！！！！！

二、接口的基本实现

1、类与类是继承关系。
2、类与接口是实现关系，接口是被类实现的。
3、实现接口的类称为实现类。

类实现接口的格式：
修饰符 class 实现类名称 implements 接口1，接口2{

}

继承只能单继承，实现可以多实现。！！！！
implements：类实现接口的关键字。

interface SportMan{

	void run();
	void competition();
}

class PingPongMan implements SportMan{
	private String name;
	 public PingPongMan(String name) {
		 this.name=name;
	 }

	@Override
	public void run() {
		System.out.println(name+"要跑步~~");
	}

	@Override
	public void competition() {
		System.out.println(name+"要比赛~~");
	}
	
}
测试类：
public class InterfaceDemo {
	public static void main(String[] args) {
		PingPongMan man = new PingPongMan("张继科");
		man.run();
		man.competition();
		System.out.println(SportMan.SPORT_NUMBER);
		
		
	}

}

小结：
1、实现接口的类称为实现类。
2、接口是被类实现的。
3、一个类实现接口必须重写玩接口中全部的抽象方法，否则这个类要定义成抽象类。
    

三、接口与接口的多继承

敲重点：
1、类与类是单继承关系：一个类只能继承一个父类。
2、类与接口是多实现关系：一个类可以同时实现多个接口。
3、接口与接口是多继承关系：一个接口可以同时继承多个接口。

也可以用一个接口继承多个接口，子类只需要实现该接口就可以了。

interface Law{
	void law();
}

interface Go{
	void abroad();
}
interface SportMan extends Law,Go{
	void run();
	void competition();
}


class PingPongMan implements SportMan{

	@Override
	public void abroad() {
		System.out.println(" go abroad..");
	}

	@Override
	public void law() {
		System.out.println("keep rules..");
		
	}

	@Override
	public void run() {
		System.out.println("is running..");
		
	}

	@Override
	public void competition() {
		System.out.println(" is competition");
		
	}
	
}
测试类：
public class InterfaceDemo {
	public static void main(String[] args) {
		PingPongMan man = new PingPongMan();
		man.abroad();
		man.competition();
		man.law();
		man.run();
		
	}

}

四、JDK1.8开始之后接口新增的三个方法。

1、默认方法
--必须加default修饰
--默认会加public修饰
--只能用接口的实现类的对象来调用。

2、静态方法
--可以直接加static修饰。
--默认会加public修饰。
--接口的静态方法只能用接口的类名称本身调用。

3、私有方法
--就是私有的实例方法，必须加private修饰。
--私有的实例方法只能再本接口中被访问。

私有方法通常是给私有方法或者给默认方法调用的。

class Man implements SportMan{
	
	
}
interface SportMan{
	//默认方法
	default void run(){
		System.out.println("run---");
	//默认方法来调用私有方法go()
		go();
	}
	
	//静态方法
	static void jump() {
		System.out.println("jump---");
	}
	
	//私有方法
	private void go() {
		System.out.println("go---");
	}
}


测试类：
public class InterfaceDemo {
	public static void main(String[] args) {
		Man man = new Man();
		man.run();
		SportMan.jump();
		
	}
}

五、实现多个接口的使用注意事项

1、如果实现了多个接口，多个接口中存在同名的静态方法并不会冲突。
原因是只能通过各自接口名访问各自静态方法。

class c implements A,B{
	
}
interface A{
	static void test() {
		System.out.println("A");
	}
}

interface B{
	static void test() {
		System.out.println("B");
	}
}


测试类：

public class InterfaceDemo {

	public static void main(String[] args) {
			A.test();
			B.test();
	}

}

2、就近原则：当一个类继承了一个父类，又实现接口时，

父类中的成员方法与接口中的默认方法同名，子类就近选择执行父类的成员方法。

class Cat extends Animal implements Interface{
	
}
class Animal{
	public void test() {
		System.out.println("run in Animal");
	}
}

interface Interface{
	 default void test() {
		 System.out.println("run in interface");
	 }
}

测试类：
public class InterfaceDemo2 {
	public static void main(String[] args) {
		Cat cat = new Cat();
		cat.test();
		
	}
}

3、当一个类实现多个接口时，多个接口中如果存在同名的默认方法，实现类必须重写这个方法。

interface C{
	default void test() {
		System.out.println("test");
	}
}
interface D{
	default void test() {
		System.out.println("test");
	}
}

class E implements C,D{

	@Override
	public void test() {
		C.super.test();
	}	
}