构造代码块案例，接口interface

构造代码块案例，接口interface

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格式

关键字：
	interface

格式：
	interface 接口名 {
        成员变量     // 默认为 public static final
        成员方法     // 默认为 public abstract
	}
要求：
	1.接口名要求符合命名规范，大驼峰命名法。
	2.成员变量【缺省属性】 public static final 定义时必须赋值
	3.成员方法【缺省属性】 public abstract 方法没有方法体

2.2 Java中类【遵从】接口格式

关键字：
	implements
格式：
	class A implements B {  //  可以同时遵从多个接口 用 “,”分开
		// A 类通过关键字implements遵从接口A，要求实现接口A中的所有抽象方法
	}
	A类是B接口的实现类
	A类遵从B接口

2.3 接口可以继承接口

关键字：
	extends
example：
	interface A enxtends B, C, D{
	
	}
	// 接口A继承接口B,C,D   -->接口允许多继承存在

2.4 abstract类遵从接口

abstract修饰的方法
	1. 没有方法体
	2. 必须定义在abstract修饰的类内，或者interface接口内
	
abstract类遵从接口，不强制实现任何方法

2.5 default关键字

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

3. 多态

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. 引用数据类型之间的强制类型转换时允许使用，但是要求明确真实数据类型是一致的，不然会导致异常出现

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

总结

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

其实多态

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