Java Day24

接口

生活常见接口：
USB Type-C UBS-C 雷电 RJ45 HDMI VPA PCI-E Lighting 3.5MM M.2 SATA

接口有什么作用?
USB
U盘 移动硬盘 鼠标 键盘 耳机 网卡 声卡 摄像头…
拓展功能，链接外部设备

USB接口限制了什么?
制定规范，制定协议
符合USB接口规范，USB接口协议才可以连接

RJ45 网线接口！！！

关键字：
interface 接口
UI Design User Interface

格式:
interface 接口名 {
成员变量
成员方法
}
要求：
1. 接口名要求符合命名规范，大驼峰命名法！！！见名知意
2. 成员变量【缺省属性】 public static final 定义时必须初始化
3. 成员方法【缺省属性】 public abstract 方法没有方法体

interface A {
/* 成员变量
* The blank final field num may not have been initialized
*
* 通过Outline工具，发现当前成员变量存在public static final修饰，但是代码并没有
* 显式当前修饰内容
* 【缺省属性】 public static final
*/
int num = 10;

/*
 * 成员方法
 * Abstract methods do not specify a body
 * 
 * 错误提示，当前代码中test方法是一个abstract修饰方法，并且在Outline发现方法
 * 存在一个A标记，证明为abstract，但是代码中并没有显式展示abstract修饰
 * 【缺省属性】public abstract
 */
void test();

}

类遵从接口

关键字:
implements

格式:
class A implements B {

}
A类是B接口的实现类
A类遵从B接口

/**

• B类通过关键字 implements 遵从接口A，要求是实现接口A中的所有
• 缺省属性为public abstract修饰的方法。
• @author Anonymous

*/
class B implements A {

@Override
public void test() {
	System.out.println("B类遵从接口A，实现test方法");
}

}

一个类可以同时遵从多个接口

package com.qfedu.b_interface;

interface C {
	void testC();
}

interface D {
	void testD();
}

interface E {
	void testE();
}

/**
 * 一个类可以同时遵从多个接口
 * 在implements关键字之后，接口使用 , 分割
 * @author Anonymous
 *
 */
class F implements C, D, E {

	@Override
	public void testE() {
		System.out.println("遵从接口E，实现testE方法");
	}

	@Override
	public void testD() {
		System.out.println("遵从接口D，实现testD方法");		
	}

	@Override
	public void testC() {
		System.out.println("遵从接口C，实现testC方法");		
	}
	
}

public class Demo2 {

}

接口可以继承接口

/*

• USB1.0协议
  */
  interface Usb1_0 {
  void usb1_0();
  }

/*

• USB2.0协议
  */
  interface Usb2_0 {
  void usb2_0();
  }

/*

• USB3.0协议
  */

interface Usb3_0 {
	void usb3_0();
}

/**
 * 小米电脑上的USB接口需要兼容USB1.0 USB2.0 USB3.0 协议
 * 
 * 接口可以使用extends完成继承，并且允许多继承存在
 * @author Anonymous
 *
 */
interface UsbMi extends Usb1_0, Usb2_0, Usb3_0 {
	void usbMi();
}

class MiGameComputer implements UsbMi {

	@Override
	public void usb1_0() {
		System.out.println("兼容USB1.0");
	}

	@Override
	public void usb2_0() {
		System.out.println("兼容USB2.0");		
	}

	@Override
	public void usb3_0() {
		System.out.println("兼容USB3.0");		
	}

	@Override
	public void usbMi() {
		System.out.println("小米USB接口");		
	}
	
}

public class Demo3 {
	public static void main(String[] args) {
		new MiGameComputer().usb1_0();
		new MiGameComputer().usb2_0();
		new MiGameComputer().usb3_0();
		new MiGameComputer().usbMi();
	}
}

abstract类遵从接口
abstract修饰的方法
1. 没有方法体
2. 必须定义在abstract修饰的类内，或者interface接口内

一个abstract修饰的类遵从接口，想对于非abstract修饰的类有什么区别???
abstract遵从接口不强制实现任何方法！！！

interface Servlet {
	/**
	 * init初始化方法
	 */
	void init();
	
	/**
	 * 提供服务的核心方法
	 */
	void service();
}

/**
 * abstract修饰的类遵从接口，不强制完成接口中缺省属性为abstract修饰的方法
 * 一般会选择性完成一些统一功能方法，简化后期代码的压力
 * @author Anonymous
 *
 */
abstract class BaseServlet implements Servlet {
	
	/*
	 * 利用abstract统一实现init方法，简化提供真实服务功能类内代码
	 * 结构
	 */
	@Override
	public void init() {
		System.out.println("BaseServlet实现init方法");
	}
}

class MyServlet extends BaseServlet {

	/*
	 * 提供服务的类只需要完成service核心方法即可
	 * init初始化方式有abstract class BaseServlet提供
	 */
	@Override
	public void service() {
		System.out.println("MyServlet实现service方法");
	}
	
}

class MyServlet2 extends BaseServlet {
	@Override
	public void service() {
		System.out.println("MyServlet2实现service方法");		
	}
}

public class Demo4 {
	public static void main(String[] args) {
		new MyServlet().init();
		new MyServlet().service();
		
		System.out.println("--------------------");
		
		new MyServlet2().init();
		new MyServlet2().service();
	

default关键字可以在接口中使用，用于修饰方法，使用default关键字修饰的方法在接口中是允许有方法体
【默认方法】【非强制重写方法】

interface DefaultInterface {
	// 【缺省属性】public abstract
	void test(); 
	
	default public void testDefault() {
		System.out.println("testDefault() 默认方法，非强制重写方法");
	}
	
	default public void defaultMethod() {
		System.out.println("defaultMethod() 默认方法，非强制重写方法");
	}
}

class Demo implements DefaultInterface {

	/*
	 * 只强制完成【缺省属性】public abstract修饰的方法test
	 */
	@Override
	public void test() {
		System.out.println("强制实现的test方法");
	}
	
	@Override
	public void testDefault() {
		System.out.println("实现类重写default方法");
	}
	
}

public class Demo5 {
	public static void main(String[] args) {
		new Demo().test();
		new Demo().testDefault();
		new Demo().defaultMethod();	
	}
}

多态

动物能不能看作是一个类？
Animal

动物园:
老虎 是不是动物??? 是
熊猫 是不是动物??? 是
猴子 是不是动物??? 是

class Animal {

}

老虎，熊猫，猴子，能不能继承Animal类

package com.qfedu.c;

/**
 * 动物类
 * @author Anonymous
 *
 */
class Animal {
	
}

/**
 * 老虎类，继承Animal类
 * @author Anonymous
 *
 */
class Tiger extends Animal {
	
}

/**
 * 熊猫类，继承Animal类
 * @author Anonymous
 *
 */
class Panda extends Animal {
	
}

/**
 * 猴子类，继承Animal类
 * @author Anonymous
 *
 */
class Monkey extends Animal {
	
}

public class Demo1 {
	public static void main(String[] args) {
		Animal animal = new Animal();
		Tiger tiger = new Tiger();
		Panda panda = new Panda();
		Monkey monkey = new Monkey();
		
		showAnimal(animal);
		
		// tiger也是动物
		showAnimal(tiger);
		// panda也是动物
		showAnimal(panda);
		// monkey还是动物
		showAnimal(monkey);
		
		System.out.println("--------------------------------");
		// 引用数据类型强制类型转换，讲Animal类型强制转换为Panda
		Panda p = (Panda) getAnimal();
		System.out.println(p);
		
		
	}
	
	/**
	 * 展示动物的方法
	 * 
	 * @param animal 这里需要的是一个Animal类对象
	 */
	public static void showAnimal(Animal animal) {
		System.out.println(animal);
	}
	
	/**
	 * 返回一个动物类对象
	 * 
	 * @return Animal类对象
	 */
	public static Animal getAnimal() {
		return new Panda(); //Panda类对象是动物
//		return new Tiger(); //Tiger类对象是动物
//		return new Monkey(); //Monkey类对象是动物
//		return new Animal();
	}
}

1. 一个方法需要的参数是父类，传入实际参数是父类对象本身，或者其子类对象都是OK的！

2. 一个方法返回值类型是父类，实际返回的数据时父类对象本身，或者其子类对象也是OK的！

3. 引用数据类型之间的强制类型转换时允许使用，但是要求明确真实数据类型是一致的，不然会导致异常出现ClassCastException

4. 父类的引用指向子类的对象

5. 或者接口的引用指向遵从接口的类对象
   这就是多态