//	--When compiling, the syntax verification of compilation is determined according to the type of compilation
	//	--When a method is called at runtime, it is essentially a method of runtime type

		//Compile time type runtime type
		Person p    =    new Doctor();
		// When the method is called with a reference variable, the behavior characteristics of the subclass are displayed
		p.eat();

		//Because the compile time type of p is Person, the work method cannot be found in the Person class during compilation, and compilation error occurs
		p.work();//The method work() is undefined for the type Person
		

public class ElectronicShop {
	// There is a method to repair the electronic device, repair(), which calls the openAndCheck method in the device
	public void repair(ElectronicEquipment equipment) {
		equipment.openAndCheck();// Inspection and maintenance
	}
	
	//Write test code
	public static void main(String[] args) {
		//Electronic equipment repair shop repairs Mobile Phones
		ElectronicShop shop = new ElectronicShop();
		
		shop.repair(new MobilePhone("Huawei", "Chongqing", "unicorn"));
		shop.repair(new Flat("Apple", "Shenzhen", "M1"));
	}
}

public class ElectronicEquipment {
	// Name [name]\productionaddress[production point]\cpu[processor]
	public String name;
	public String produtionAddress;
	public String cpu;

	// : openAndCheck(); Method [output name is starting, output device information]
	public void openAndCheck() {
		System.out.println(name + "Starting, address information of device:" + produtionAddress + "    cpu:" + cpu);
	}
//Constructor, with and without participation
	public ElectronicEquipment(String name, String produtionAddress, String cpu) {
		super();
		this.name = name;
		this.produtionAddress = produtionAddress;
		this.cpu = cpu;
	}

	public ElectronicEquipment() {
		super();
	}

}

class MobilePhone extends ElectronicEquipment {
	public void openAndCheck() {
		System.out.println("Starting the phone, ready for detection" + name + "Address information of the device:" + produtionAddress + "    cpu:" + cpu);
	}

	public MobilePhone(String name, String produtionAddress, String cpu) {
		super();
		this.name = name;
		this.produtionAddress = produtionAddress;
		this.cpu = cpu;
	}

	public MobilePhone() {
		super();
	}
}

class Flat extends ElectronicEquipment {
	public void openAndCheck() {
		System.out.println("Starting the tablet, ready for detection" + name + "Address information of the device:" + produtionAddress + "    cpu:" + cpu);
	}

	public Flat(String name, String produtionAddress, String cpu) {
		super();
		this.name = name;
		this.produtionAddress = produtionAddress;
		this.cpu = cpu;
	}

	public Flat() {
		super();
	}
}

class Computer extends ElectronicEquipment {
	public void openAndCheck() {
		System.out.println("Starting the computer, ready for detection" + name + "Address information of the device:" + produtionAddress + "    cpu:" + cpu);
	}

	public Computer(String name, String produtionAddress, String cpu) {
		super();
		this.name = name;
		this.produtionAddress = produtionAddress;
		this.cpu = cpu;
	}

	public Computer() {
		super();
	}
}

		Person p1 = new Doctor();//person is the parent class of doctor and student.
		//instanceof keyword [judge the object type stored in the variable]   
		//The type after instanceof should inherit from the compile time type of the previous variable [subclass, parent class, this class]
		if (p1 instanceof Student) {//Judged as false
			System.out.println("yes Student");
			Student d = (Student) p1;
			d.eat();
		}
		if (p1 instanceof Doctor) {//Judged as true
			System.out.println("yes Doctor");
			Doctor d = (Doctor) p1;
			d.eat();
		}//Result output: Doctor Doctor eats

//Static type: determine which method is called in the same class
public class StaticTest {
	//In the same class, how to call which method depends on the method signature [based on the compile time type of the variable in the parameter]
	public void test(A a) {
		System.out.println("test(A a)-----------------");
	}
	public void test(B b) {
		System.out.println("test(B b)-----------------");
	}
	public void test(C c) {
		System.out.println("test(C c)-----------------");
	}
	//main
	public static void main(String[] args) {
		//
		StaticTest test = new StaticTest();
		//
		A a = new C();
		B b = new C();
		//In the same class, which method to call has determined [method signature] and [parameter data compile time type] at compile time
		test.test(a);// A a \ the input parameter is of type A, that is, it matches test(A a)
		test.test(b);// B b \ the input parameter is of type B, that is, it matches test(B b)
	}
}
class A {
}
class B extends A {
}
class C extends B {
}

public class DynamicTest {
	//1. Determine which class to call [determine the runtime type of the variable calling the method]   
    //2. Determine which method to call [determine the compile time type of the input variable]
	public static void main(String[] args) {
		A a = new A();
		B b = new B();
		C c = new C();
		a.test(b);// a--b \a is type A, where B is method B
		A a_c = new C();
		a_c.test(b);// c--b \a_c is type C, B is method B
		B b_c = new C();
		b_c.test(a);// c--a \b_c is type C and a is method a
		//
		a_c = a;
		b = b_c;
		b.test(a_c);// C--a \ B is b_c, i.e. type C, a_c is method a
		b_c.test(b_c);//c--b  \b_c is type C, b_c is method B
	}
}
class A {
	public void test(A a) {
		System.out.println("A ---------- a");}
	public void test(B b) {
		System.out.println("A ---------- b ");}
	public void test(C c) {
		System.out.println("A ---------- c");}}

class B extends A {
	public void test(A a) {
		System.out.println("B ---------- a");}
	public void test(B b) {
		System.out.println("B ---------- b ");}
	public void test(C c) {
		System.out.println("B ---------- c");}}

class C extends B {
	public void test(A a) {
		System.out.println("C ---------- a");}
	public void test(B b) {
		System.out.println("C ---------- b ");}
	public void test(C c) {
		System.out.println("C---------- c");}}

//Singleton: lazy [created when used]
public class SingleLaz {
	// 3. Define a variable to store the object of the singleton
	static SingleLaz laz = null;
	// 1. Privatize the constructor
	private SingleLaz() {
	}
	// 2. Provide a static method to get the singleton object
	public static SingleLaz getInstance() {
		//If the object is null, create a unique object
		if(laz == null) {
			laz = new SingleLaz();
		}
		return laz;
	}
}

//Singleton: hungry Han style [created at the beginning]
public class SingleHug {
	// 3. Define a variable to store the object of the singleton
	final static SingleHug laz = new SingleHug();

	// 1. Privatize the constructor
	private SingleHug() {
	}

	// 2. Provide a static method to get the singleton object
	public static SingleHug getInstance() {
		//Return unique object
		return laz;
	}
}

Person -->eat(){System.out.println("People eat");}[General]
Person -->eat();[Abstract class]//With; ending

		People p = new People();//No, abstract classes cannot be instantiated!
		People p = new Doctor();//doctor is a subclass object of people
		p.eat();

//You cannot define a normal implementation method \ but you can define a default method
	public void demo() {//This is a common method and cannot be defined in this way
		System.out.println("sdfdsf");
	}
	//Default method
	default void test() {//In the interface, default means default, which is different from the function of default in the modifier
		System.out.println("sdfdsf");
	}

// Abstract methods \ default public abstract can also be defined in the interface
	public abstract void devilyData();//That is, this statement and void devilyData(); Same function

		Clothes c = new Clothes();//When creating a non static internal class, the constructor of the internal class should be called through the object of the external class
		Button b = c.new Button();//Buttons are non static inner classes of clothes
		b.test();

	//Create objects by referencing the constructor of static internal classes through external types
		Collar collar = new Clothes.Collar();//Collar is a static inner class of clothes
		collar.demo_test();