码迷,mamicode.com
首页 > 其他好文 > 详细

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

时间:2020-05-07 19:36:05      阅读:55      评论:0      收藏:0      [点我收藏+]

标签:协议   tde   keyboard   退出   public   思考   继承   重点   print   

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. 或者接口的引用指向遵从接口的类对象
这就是多态

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

标签:协议   tde   keyboard   退出   public   思考   继承   重点   print   

原文地址:https://www.cnblogs.com/raising/p/12844932.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!