一、构造代码块和static案例，接口interface
1.分析过程
计数器：记录用户的登陆次数，当前网站的访问人数...
自动生成用户ID号：会员ID号不可以重复，而且是用户在申请账号时自动生成！！！
分析:
1. 程序不退出，ID号始终处于一种记录状态，保存下一个用户的ID号
2. 用户提供不管多少数据，都要给予一个对应的ID号
解决:
ID号始终处于一种记录状态
1. 这里需要一个变量来保存ID号
int类型
局部变量：
局部变量在方法内，方法运行结束，局部变量销毁，无法作为持久化保存【不能使用】
成员变量：
成员变量是保存在每一个对象中，而且每一个对象中保存的数据是不一样的，而且需要操作对象来进行获取，对象是存在可能性在一定条件下被销毁的。
不具有持久性，操作较为繁琐。
静态成员变量：
整个代码运行周期内始终存在，并且和对象无关，不会受到对象的影响。可以直接通过类名操作，该变量保存在内存数据区，是一个共享资源。
2. 用户提供不管多少数据，都要给予一个对应的ID号
用户使用不同的构造方法，都要能够赋值对应ID号，ID号不是用户提供的！！！
构造代码块不关你调用那一个new + 构造方法，都要执行对应的操作！
2.代码实现
/**
* 不管用户采用哪一种方式来创建对象，都会有一个唯一的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 + "]";
}
}
3.接口
java中定义接口的格式：
3.1java中类【遵从】接口的格式
关键字：implements
格式：class A implements B {
}
A类是B接口的实现类，A类遵从B接口
3.2一个类可以同时遵从多个接口
3.3接口可以继承接口
关键字：extends
/*
* 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();
}
}
3.4abstract类遵从接口
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();
}
}
3.5JDK1.8新特征default关键字
JDK1.8更新特征default关键字可以在接口中使用，用于修饰方法，使用default关键字修饰的方法在接口中是允许有方法体的【默认方法】【非强制重写方法】
4.多态
/**
* 动物类
* @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();
}
}
4.1小总结
1.一个方法需要的参数是父类，传入的实际参数是父类对象本身，或者其子类对象都OK
2.一个方法返回值类型是父类，实际返回的数据是父类对象本身，或者其子类对象都OK
3.引用数据类型之间的强制类型转换时允许使用，但是要求明确真实数据类型是一致的，不然会导致异常出现ClassCastException
4.2USB接口和USB设备
USB接口 规定一个方法 connect方法，键盘一个类、鼠标一个类
/**
* 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());
}
}
4.3小总结
1.一个方法需要的参数是USB接口，但是传入的对象是USB接口的直接实现类或者间接实现类都是完全可以的
2.代码整个过程中是完全符合生活逻辑的！
4.4这其实是多态【直接背下来】
父类的引用指向子类的对象或者接口的引用指向遵从接口的类对象，这就是多态
