JavaSE -接口及高版本语法(十)

一、接口的概念

接口：是一种标准、规范，接口的使用者和接口的实现者都必须遵循的约定。

语法：（基于 jdk7.0 版本）

(1) 关键字： interface

interface 接口名{}

(2) 接口在编译之后会生独立 .class 文件

(3) 接口不能创建对象，但是可以声明引用。

接口名变量名;

(4) 接口中没有构造方法

(5) 接口中属性都是公开、静态、常量(默认被 public static final 修饰)

(6) 接口中方法都是公开、抽象方法(默认被 public abstract 修饰)

注意：接口从语法角度是一个特殊的抽象类，是对抽象类进一步的抽象；但是接口从 Java分类：不是类。

public class TestMyInter{
      
      
	public static void main(String[] args){
      
      	
		MyInter mi ;
		//MyInter.n = 20;
		System.out.println(MyInter.n);
		
		System.out.println(MyInter.m);
		//MyInter.m = 50;
	}
}
// 抽象类
/*
	抽象类不能单独new 对象，但是可以声明引用
	抽象类：编译之后生成独立的  .class
*/
abstract class MyClass{
      
      
	int a = 3;  // 实例变量
	static int b = 7; // 静态变量
	public MyClass(){
      
      }
	public void m1(){
      
      }
	public abstract void m2();
}

// 接口:共语法角度，相当于 特殊的抽象类

interface MyInter{
      
      
	int m =0;  // 默认 被  static ,同是 被 final 修饰
	static int n = 7; // 静态变量,默认 被 final 修饰
	
	//public MyInter(){} // 接口中没有构造方法
	public void t1();// 默认的被 public  abstract 修饰
	public abstract void t2();
	void t3();// 被  public abstract 修饰
}

实现类【开发应用重点】

(1) 语法：class 类名 implements 接口名{}

(2) 注意：

a. 如果实现类不想定义为抽象类，则必须覆盖接口中所有的抽象方

法，同时给与实现；否则实现类必须定义为抽象类。

b. 接口中方法默认的访问权限为 public ，所以实现类覆盖接口中的方法时访问
修饰符必须也是 public 。因为类中方法如果不谢访问修饰符。默认的访问权限为 default。

(4) 使用：接口类型的引用中可以存储实现类的对象，多态的应用

语法：接口名引用 = new 实现类类名(实参);

注意：如果以接口类型的引用调用方法，只能调用接口中有的方法。

(5) 案例：

public class TestInter{
      
      
	public static void main(String[] args){
      
      
		// 接口类型的引用 --》 实现类的对象
		MyInter mi = new MyClass();  // 多态
		
		mi.m1();
		mi.m2();
		//mi.m3();
	}
}
// 接口
interface MyInter{
      
      
	public void m1();// 默认 被 abstract
	void m2(); //默认 public abstract 修饰
}
// 接口的实现类 （从语法角度：类 继承一个 特殊的 抽象类）
class MyClass implements MyInter{
      
      
	public void m1(){
      
      
		System.out.println("m1方法的实现....");
	}
	public void m2(){
      
      
		System.out.println("m2方法的实现....");
	}
	public void m3(){
      
      }
}

Java中接口的继承性【开发应用重点】

(1) 接口与接口之间是多继承

语法：interface 接口名 extends 父类接口1,父接口2{}

(2) 类和接口是实现的关系：即一个类可以同时实现多个接口

① 语法： class 类名 implements 接口名1,接口名2{}

② 注意：如果实现类不想成为抽象类,必须覆盖所有接口中的所有方法

(3) 一个类继承一个父类的同时可以实现多个接口：

① 语法：class 类名 extends 父类 implements 接口1,接口名2{}

② 注意：必须先定义继承，再定义实现

接口多继承的影响【理解】

(1) 让多态的应用更加的复杂和多样性。

(2) 如果强制类型转换的双方有一方为接口类型，编译一定通过，运行有

以下两种情况：

① 如果实际存储对象类型和要转换的类型相兼容，则运行通过；

② 如果实际存储对象类型和要转换的类型不兼容，则运行报错，错误

信息为：java.lang.ClassCastException(类型转换异常)

注意：评判是否兼容：实际存储的对象类型是否为要转换类型一种

public class Test6{
      
      
	public static void main(String[] args){
      
      
	   
		MyClass mc = new MyClass();
		
		/*System.out.println(mc instanceof ClassA);
		System.out.println(mc instanceof IA);
		System.out.println(mc instanceof IB);
		System.out.println(mc instanceof IC);
		System.out.println(mc instanceof ID);*/
		
		/*IA ia = mc;
		ia.m1();
		ia.m2();
		//ia.m3();*/
		/*IB ib = mc;
		ib.m3();*/
		
		/*IC ic = mc;
		ic.m1();
		ic.m2();
		ic.m3();
		ic.m4();*/
		
		/*ID id = mc;
		id.m5();*/
		
		ClassA ca = mc;
		ca.m6();
	}
}

interface IA{
      
      
	void m1();
	void m2();
}

interface IB{
      
      
	void m3();
}

interface IC extends IA,IB{
      
      
	void m4();
}
interface ID{
      
      
	void m5();
}
// 类和接口的多实现
class MyClass extends ClassA implements IC,ID {
      
      
	public void m1(){
      
      
		System.out.println("m1()...");
	}
	public void m2(){
      
      
		System.out.println("m2()...");
	}
	public void m3(){
      
      
		System.out.println("m3()...");
	}
	public void m4(){
      
      
		System.out.println("m4()...");
	}
	public void m5(){
      
      
		System.out.println("m5()...");
	}
}
class ClassA{
      
      
	public void m6(){
      
      
		System.out.println("m6()...");
	}
}

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xicYskxA-1585710724113)(C:\Users\zmj\AppData\Roaming\Typora\typora-user-images\1585286799654.png)]$

接口的应用场景

(1) 利用接口扩充子类的能力【开发中应用】

a. 类之间是单继承，当子类通过继承关系，从父类继承的功能不满足子类的功能需求时，可以利用接口扩充子类的功能需求。

b. 通常将主要功能定义在父类中，相对次要功能定义接口中。

(2) 依赖倒转原则：当一个类和其他类建立联系时，尽可能和父类或是接

口建立联系，避开直接与其子类或是实现类建立联系。【理解】

a. 降低代码之间的耦合度，从而实现弱耦合

b. 提高程序的可维护性。

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hx3LmvXG-1585710724113)(C:\Users\zmj\AppData\Roaming\Typora\typora-user-images\1585299803890.png)]$

public class TestComputer{
      
      
	public static void main(String[] args){
      
      
		// 创建电脑对象
		Computer c = new Computer();
		
		// 创建鼠标对象
		//Mouse m = new Mouse();
		
		//Keyboard k = new Keyboard(); // 实现类对象对象
		
		//Mouse m = new Mouse();
		
		Fan f = new Fan();
		
		c.useDevice(f);
	}
}
// A类   --》使用者
class Computer{
      
      
	// 鼠标
	public void useDevice(USB usb){
      
      //USB usb = f;  --->体现的多态
		usb.service();
	}
}

// 对电子设备 和 电脑做一个标准和规范(接口)
interface USB{
      
      
	void service();
}

// 实现类
// B类
class Mouse implements USB{
      
      
	public void service(){
      
      
		System.out.println("咔嚓...");
	}
}
// C类
class Keyboard implements USB{
      
      
	public void service(){
      
      
		System.out.println("噼里啪啦...");
	}
}
// D类
class Fan implements USB{
      
      
	public void service(){
      
      
		System.out.println("呼呼的...");
	}
}

JDK高版本对接口语法升级【了解】

(1) JDK8.0版本接口的升级内容

-> 可以定义默认方法：

a. 语法：default 返回值类型方法名(形参列表){}

b. 注意：

-> 接口中默认方法中的 default不再是访问修饰符，代表此方法可

以写方法的实现部分

-> 接口中默认方法访问权限为 public

-> 可以定义静态方法：

a. 语法：public static 返回值类型方法名(形参列表){}

b. 注意：接口中静态方法默认访问权限也是 public，可以省略

c. 使用：接口名.静态方法名(实参);

(2) JDK9.0版本接口中升级：可以定义私有方法

语法：private 返回值类型方法名 (形参列表){}
接口的分类：【了解】

(1) 常量接口：接口中只有公开静态常量,没有定义任何方法->应用不广泛

(2) 标记接口：空接口，接口中没有定义任何的常量，也没有定义任何的

方法，例如IO中对象序列化

(3) 普通接口：具有至少定义一个抽象方法。–》开发广泛应用

(4) 函数式接口：是一种特殊的普通接口，接口中只有一个抽象方法，对

静态方法和默认方法没有要求。
接口回调：【了解】

(1) 理解：将接口对应的实现类对象作为实际参数赋值给接口类型的引用，当接口类型的引用调用方法时，实际运行的是对应实现类中的方法(覆盖)，实现类作为实际参数传递给引用类型，目的是让接口的使用者完成对应的功能，这种现象称为接口回调。

(2) 使用场景：通常接口制定好之后，接口的使用者先被定义，根据需求的不同，再定义接口的实现者(先有接口的使用者，再有接口的实现者)，开发时一旦出现接口回调的现象，作为开发人员，通常关注的根据需求定义接口的实现类，无需关注接口的使用者。

JavaSE -接口及高版本语法(十)

一、接口的概念

面试重点：接口和抽象类的区别？

猜你喜欢