0507 构造代码块和static案例，接口interface

0507构造代码块和static案例，接口interface

【重点】

1.局部变量，成员变量，静态变量的特点
2.接口
	接口语法：interface A {}
	
	接口内的成员变量【缺省属性】public static final
	接口内的成员方法【缺省属性】public abstract
	
	接口遵从的实现语法：
	class A implements B {}
	A类是B接口的实现类，A类遵从B接口
	接口的实现类需完成接口中所有缺省值为【public abstract】的方法
	
	一个类可以继承多个接口，接口可以继承接口
	
	abstract修饰的类遵从接口，相对于非abstract修饰的类有什么区别？==>abstract遵从接口不强制实现任何方法
	
	JDK1.8新特性：
		default关键字可以在接口中使用，用于修饰方法。使用default关键字修饰的方法在接口中允许有方法体。
		【默认方法】 【非强制重写方法】
		interface 接口内如果有default修饰的方法，那么这个接口的实现类可以不必强制重写default的方法
	
	
3.多态
	一个方法需要的参数的是父类，那么传入父类以及父类的子类都是可以的
	一个方法返回的参数的是父类，那么返回父类以及父类的子类都是可以的
	
	一个方法需要的参数时USB接口，但是传入的对象是USB接口的实现类或者间接类也是OK的		
	
	【多态】
		父类引用指向子类的对象
		接口的引用指向遵从接口的类对象

1. 构造代码块和static案例

1.1 分析过程

计数器
	记录用户的登陆次数，当前网站的访问人数...

自动生成用户ID号
	会员ID号不可以重复，而且是用户在申请账号时自动生成！！！

分析:
	1. 程序不退出，ID号始终处于一种记录状态，保存下一个用户的ID号
	2. 用户提供不管多少数据，都要给予一个对应的ID号

解决:
	ID号始终处于一种记录状态
	1. 这里需要一个变量来保存ID号
		int类型
		局部变量：
			局部变量在方法内，方法运行结束，局部变量销毁，无法作为持久化保存。
			【不能使用】
			
		成员变量：
			成员变量是保存在每一个对象中，而且每一个对象中保存的数据是不一样的，
			而且需要操作对象来进行获取，对象是存在可能性在一定条件下被销毁的。
			不具有持久性，操作较为繁琐。
			
		静态成员变量：
			整个代码运行周期内始终存在，并且和对象无关，不会受到对象的影响。
			可以直接通过类名操作，该变量保存在内存数据区，是一个共享资源。
	2. 用户提供不管多少数据，都要给予一个对应的ID号
		用户使用不同的构造方法，都要能够赋值对应ID号，ID号不是用户提供的！！！
		构造代码块不关你调用那一个new + 构造方法，都要执行对应的操作！！！

1.2 代码实现

package com.qfedu.a_count;

/**
 * 不管用户采用哪一种方式来创建对象，都会有一个唯一的ID号赋值操作
 * @author Anonymous
 *
 */
public class Vip {
	private int id;
	private String name;
	private int age;
	private String address;
	
	/**
	 * 使用静态成员变量count来计数ID
	 */
	private static int count = 1;
	
	/*
	 * 构造代码块完成ID赋值操作，使用静态成员变量count来进行赋值
	 * 并且每一次操作完成之后，count += 1
	 */
	{
		id = count;
		count += 1;
	}
	
	public Vip() {}

	public Vip(String name) {
		this.name = name;
	}

	public Vip(String name, int age) {
		this.name = name;
		this.age = age;
	}

	public Vip(String name, int age, String address) {
		this.name = name;
		this.age = age;
		this.address = address;
	}

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public String getAddress() {
		return address;
	}

	public void setAddress(String address) {
		this.address = address;
	}

	@Override
	public String toString() {
		return "Vip [id=" + id + ", name=" + name + ", age=" + age + ", address=" + address + "]";
	}
}

2. 接口【重点】

2.1 生活中的接口

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

接口有什么作用?
	USB
		U盘 移动硬盘 鼠标 键盘 耳机 网卡 声卡 摄像头...
	拓展功能，链接外部设备
	
USB接口限制了什么?
	制定规范，制定协议
	符合USB接口规范，USB接口协议才可以连接
	
RJ45 网线接口！！！

2.2 Java中定义接口的格式

关键字：
	interface 接口
	UI Design User Interface

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

package com.qfedu.b_interface;

/**
 * 自定义接口，接口名A
 * 
 * 两个问题:
 * 		1. USB接口，尺寸固定之后，有人改吗？
 * 			没有人修改
 *		2. USB接口做什么，是接口决定?还是设备决定?
 *			设备
 * 思考:
 * 		静态?
 * 		abstract?
 * 		final?
 * 		继承?
 * @author Anonymous
 *
 */
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();
}

public class Demo1 {

}

2.3 Java中类【遵从】接口的格式

关键字:
	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方法");
	}

}

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

USB接口可以同时兼容多个协议
	USB3.1 USB3.0 USB2.0 USB1.0

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 {

}

2.5 接口可以继承接口

关键字:
	extends

package com.qfedu.b_interface;

/*
 * 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();
	}
}

2.6 abstract类遵从接口

abstract修饰的方法
	1. 没有方法体
	2. 必须定义在abstract修饰的类内，或者interface接口内
	
一个abstract修饰的类遵从接口，想对于非abstract修饰的类有什么区别???\
	abstract遵从接口不强制实现任何方法！！！

package com.qfedu.b_interface;

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();
	}
}

2.7 JDK1.8新特征 default关键字

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

package com.qfedu.b_interface;

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();	
	}
}

3. 多态【重点】

3.1 动物之间的关系【三遍】

动物能不能看作是一个类？
	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();
	}
}

3.2 小总结

1. 一个方法需要的参数是父类，传入实际参数是父类对象本身，或者其子类对象都是OK的！
2. 一个方法返回值类型是父类，实际返回的数据时父类对象本身，或者其子类对象也是OK的！
3. 引用数据类型之间的强制类型转换时允许使用，但是要求明确真实数据类型是一致的，不然会导致异常出现ClassCastException

3.3 USB接口和USB设备【三遍】

USB接口
	规定一个方法
		connect方法
		
键盘一个类
鼠标一个类

package com.qfedu.c;

/**
 * USB接口
 * 
 * @author Anonymous
 *
 */
interface USB {
	/**
	 * 要求所有的USB设备，都要完成connect方法
	 * 告知PC当前设备是什么功能
	 */
	void connect();
}

/**
 * Mouse类遵从USB接口，可以认为是一个USB设备
 * 
 * @author Anonymous
 *
 */
class Mouse implements USB {

	@Override
	public void connect() {
		System.out.println("鼠标控制光标");
	}
}

/**
 * Logi是Mouse类的子类，是鼠标类的子类，
 * 是否间接遵从USB接口? 是的
 * 
 * 算不算USB设备? 算
 * @author Anonymous
 *
 */
class Logi extends Mouse {
	@Override
	public void connect() {
		System.out.println("Logi Master 2S");
	}
}

/**
 * Keyboard类遵从USB接口，也可以认为是一个USB设备
 * 
 * @author Anonymous
 *
 */
class Keyboard implements USB {

	@Override
	public void connect() {
		System.out.println("键盘敲代码");
	}	
}

/**
 * IKBC类，继承Keyboard类，是键盘类的子类
 * 算不算USB设备??? 算
 * @author Anonymous
 *
 */
class IKBC extends Keyboard {
	@Override
	public void connect() {
		System.out.println("IKBC C87 270 -/+ RMB");
	}
}

/**
 * 电脑类
 * 
 * @author Anonymous
 *
 */
class Computer {
	/**
	 * 电脑使用通过USB接口，连接USB设备
	 * @param usb USB接口，要求连接是一个USB设备
	 */
	public void useUSBInterface(USB usb) {
		// 通过USB设备执行connect方法，执行功能
		usb.connect();
	}
}

public class Demo2 {
	public static void main(String[] args) {
		// 电脑类对象
		Computer computer = new Computer();
		
		// Mouse是USB设备
		Mouse mouse = new Mouse();
		// Keyboard也是USB设备
		Keyboard keyboard = new Keyboard();
		
		// 电脑需要通过USB接口连接USB设备
		computer.useUSBInterface(mouse);
		computer.useUSBInterface(keyboard);
		
		// computer通过USB设备连接Mouse或者Keyboard类的子类是完全OK的
		// 因为这些子类也是USB设备
		computer.useUSBInterface(new Logi());
		computer.useUSBInterface(new IKBC());
	}
}

3.4 小总结

1. 一个方法需要的参数是USB接口，但是传入的对象是USB接口的直接实现类或者间接实现类都是完全OK
2. 代码整个过程中是完全符合生活逻辑的！！！

3.5 这其实是多态【背下来】

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

posted @ 2020-05-07 19:01 路漫漫兮其修远阅读(216) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

路漫漫兮其修远

0507 构造代码块和static案例，接口interface

0507构造代码块和static案例，接口interface

1. 构造代码块和static案例

1.1 分析过程

1.2 代码实现

2. 接口 【重点】

2.1 生活中的接口

2.2 Java中定义接口的格式

2.3 Java中类【遵从】接口的格式

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

2.5 接口可以继承接口

2.6 abstract类遵从接口

2.7 JDK1.8新特征 default关键字

3. 多态【重点】

3.1 动物之间的关系【三遍】

3.2 小总结

3.3 USB接口和USB设备【三遍】

3.4 小总结

3.5 这其实是多态【背下来】

公告

2. 接口【重点】