面向对象编程-高级(四)-接口、内部类

一、接口

1.1 为什么有接口

1.2 接口快速入门

public interface UsbInterface { //接口 
	//规定接口的相关方法,老师规定的.即规范... 	
	public void start();
	public void stop();
}

public class Camera implements UsbInterface{//实现接口,就是把接口方法实现
	@Override
	public void start() {
		System.out.println("相机开始工作..."); 
	}
	@Override
	public void stop() {
		System.out.println("相机停止工作...."); 
	}
}

1.3 基本介绍

1.4 深入讨论

1.5 注意事项和细节

//1.接口不能被实例化
//2.接口中所有的方法是 public 方法, 接口中抽象方法，可以不用 abstract 修饰 
//3.一个普通类实现接口,就必须将该接口的所有方法都实现,可以使用 alt+enter 来解决 
//4.抽象类去实现接口时，可以不实现接口的抽象方法
interface IA {
	void say();//修饰符 public protected 默认 private
  	void hi(); 
  }

class Cat implements IA{ 
	@Override
	public void say() { }
	@Override 
	public void hi() {}
}

//抽象类
//抽象类去实现接口时，可以不实现接口的抽象方法
abstract class Tiger implements IA {}

public class InterfaceDetail02 {
	public static void main(String[] args) {
		//老韩证明 接口中的属性,是 public static final 
		System.out.println(IB.n1);
		//说明 n1 就是 static 
		//IB.n1 = 30; 说明 n1 是 final
		} 
	}
	interface IB {
		//接口中的属性,只能是 final 的，而且是 public static final 修饰符 
		int n1 = 10; //等价 public static final int n1 = 10;
	}
	
	interface IC {
		void say(); 
	}
}

//接口不能继承其它的类,但是可以继承多个别的接口
interface ID extends IB,IC {

}

//一个类同时可以实现多个接口 
class Pig implements IB,IC {
	@Override
	public void hi() { }
	@Override
	public void say() { }
}

1.6 实现接口 vs 继承类

小结:
1、当子类继承了父类，就自动的拥有父类的功能。
2、如果子类需要扩展功能，可以通过实现接口的方式扩展。
3、可以理解 实现接口 是 对 java 单继承机制的一种补充。

1.8 接口的多态特性

/**
* 演示多态传递现象 
*/
public class InterfacePolyPass {
	public static void main(String[] args) {
		//接口类型的变量可以指向，实现了该接口的类的对象实例 
		IG ig = new Teacher();
		//如果 IG 继承了 IH 接口，而 Teacher 类实现了 IG 接口 
		//那么，实际上就相当于 Teacher 类也实现了 IH 接口. 
		//这就是所谓的 接口多态传递现象.
		IH ih = new Teacher(); 
	}
}

interface IH { 
	void hi();
}

interface IG extends IH{ } 

class Teacher implements IG {
	@Override 
	public void hi() { }
}

二、内部类

如果定义类在局部位置(方法中/代码块) :

1. 局部内部类
2. 匿名内部类

定义在成员位置：

1. 成员内部类
2. 静态内部类

2.1 基本介绍

2.2 基本语法

2.3 快速入门案例

public class InnerClass01 { //外部其他类 
	public static void main(String[] args) {
	} 
}

class Outer { //外部类
	private int n1 = 100;//属性 
	public Outer(int n1) {//构造器
		this.n1 = n1; 
	}
	public void m1() {//方法 
		System.out.println("m1()");
	} 
	
	{//代码块
		System.out.println("代码块..."); 
	}
	
	//内部类, 在 Outer 类的内部
	class Inner { }
}

2.4 内部类的分类

1.5 局部内部类的使用

1.6 匿名内部类的使用(重要!!!)

1.7 匿名内部类的最佳实践

当做实参直接传递，简洁高效。

public class InnerClassExercise01 {
	public static void main(String[] args) {
		//当做实参直接传递，简洁高效 
		f1(new IL() {
				@Override
				public void show() {
					System.out.println("这是一副名画~~..."); 
				}
		});
		
		//传统方法 
		//f1(new Picture());
	}
	
	//静态方法,形参是接口类型 
	public static void f1(IL il) {
		il.show(); 
	}
}

//接口 
interface IL {
	void show(); 
}
//类->实现 IL => 编程领域 (硬编码) 
class Picture implements IL {
	@Override
	public void show() {
		System.out.println("这是一副名画 XX..."); 
	}
}

1.8 成员内部类的使用

1.10 静态内部类的使用

本博客引用韩顺平Java课程