abstract class A{
	public static final String FLAG = "CHINA";
	private String name = "张三";
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	
	public abstract void print();		//定义一个抽象方法
}

class B extends A{					//继承抽象类，覆写全部的抽象方法
	public void print(){
		System.out.println("FLAG="+FLAG);
		System.out.println("姓名="+super.getName());
	}
}

public class abstract_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		B b = new B();
		b.print();
	}

}

abstract class People{
	private String name;
	private int age;
	
	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 People(String name, int age) {	//构造函数
		this.name = name;
		this.age = age;
	}
	
	public void say(){									
		System.out.println(this.getContent());
	}
	
	public abstract String getContent();	//get方法，说话的内容由子类决定
	
}

class Student extends People{
	
	private float score;
	
	public Student(String name, int age,float score) {
		super(name, age);					//调用父类的构造方法
		// TODO 自动生成的构造函数存根
		this.score = score;
	}

	@Override
	public String getContent() {		//覆写父类中的get抽象方法
		// TODO 自动生成的方法存根
		return "学生信息-->姓名："+super.getName()+"年龄："+super.getAge()+"成绩："+this.score;
	}
	
}

class Worker extends People{
	
	private float salary;
	
	public Worker(String name, int age,float salary) {
		super(name, age);					//调用父类的构造方法
		// TODO 自动生成的构造函数存根
		this.salary = salary;
	}

	@Override
	public String getContent() {		//覆写父类中的get抽象方法
		// TODO 自动生成的方法存根
		return "工人信息-->姓名："+super.getName()+"年龄："+super.getAge()+"薪水："+this.salary;
	}
	
}

public class abstract_demo2 {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		Student stu = new Student("张三",18,99.0f);
		Worker wor = new Worker("张三",18,1000.0f);
		stu.say();
		wor.say();
	}

}

interface A_1{										//定义接口A_1
	public String AUTHOR = "张三";		//定义全局常量,等价于：public static final String AUTHOR = "张三";	
	public void print();							//定义抽象方法,等价于：public abstract void print();
	public String getInfo();					//定义抽象方法,等价于：public abstract String getInfo();
}

interface B_1{										//定义接口B_1
	public void say();							//定义抽象方法
}

class X implements A_1,B_1{				//子类同时实现两个接口

	@Override
	public void say() {							//覆写B接口中的抽象方法
		// TODO 自动生成的方法存根
		System.out.println("Hello World!");
	}

	@Override
	public void print() {						//覆写A接口中的抽象方法
		// TODO 自动生成的方法存根
		System.out.println("作者:"+AUTHOR);
	}

	@Override
	public String getInfo() {					//覆写A接口中的抽象方法
		// TODO 自动生成的方法存根
		return "HELLO";
	}
	
}

public class interface_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		X x = new X();				//实例化子类对象
		x.say();						//调用被覆写过的方法
		x.print();						//调用被覆写过的方法
	}

}

interface A_2{	//定义接口A_1
	public String AUTHOR = "张三";	/定义全局常量
	public void print();	//定义抽象方法
	public String getInfo();	//定义抽象方法
}

abstract class B_2{	//定义一个抽象类
	public abstract void say();	//定义一个抽象方法
}

abstract class B_3 implements A_2{	//定义一个抽象类，并实现接口
	public abstract void say();	//定义一个抽象方法
}

class X_2 extends B_2 implements A_2{	//同时实现继承和接口

	@Override
	public String getInfo() {	//覆写A_2接口中的抽象方法
		// TODO 自动生成的方法存根
		return "HELLO";
	}

	@Override
	public void say() {	//覆写B_2抽象类中的抽象方法
		// TODO 自动生成的方法存根
		System.out.println("Hello World!");
	}				

	@Override
	public void print() {	//覆写A_2接口中的抽象方法
		// TODO 自动生成的方法存根
		System.out.println("作者:"+AUTHOR);
	}
}

class X_3 extends B_3{	//继承抽象类，覆写全部的抽象方法

	@Override
	public void print() {	//覆写B_3抽象类中的抽象方法
		// TODO 自动生成的方法存根
		System.out.println("作者:"+AUTHOR);
	}

	@Override
	public String getInfo() {	//覆写B_3抽象类中的抽象方法
		// TODO 自动生成的方法存根
		return "HELLO";
	}

	@Override
	public void say() {	//覆写B_3抽象类中的抽象方法
		// TODO 自动生成的方法存根
		System.out.println("Hello World!");
	}
	
}

public class extends_implements_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		X_2 x = new X_2();	//实例化子类对象
		x.say();	//调用被覆写过的方法
		x.print();	//调用被覆写过的方法
		X_3 x_1 = new X_3();
		x_1.say();
		x_1.print();
	}

}

interface C{	// 定义接口C
	public String AUTHOR = "张三";	//定义全局常量
	public void printC();	//定义抽象方法
}

interface D{	//定义接口D
	public void printD();	//定义抽象方法
}

interface E extends C,D{	// 定义接口E，同时继承接口C和D
	public void printE();	//定义抽象方法
}

class F implements E{

	@Override
	public void printC() {
		// TODO 自动生成的方法存根
		System.out.println("C--Hello World");
	}

	@Override
	public void printD() {
		// TODO 自动生成的方法存根
		System.out.println("D--Hello World");
	}

	@Override
	public void printE() {
		// TODO 自动生成的方法存根
		System.out.println("E--Hello World");
	}							
	
}

public class extends_implements_demo2 {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		F f = new F();
		f.printC();
		f.printD();
		f.printE();
	}

}

interface USB{
	public void start();
	public void stop();
}

class computer {
	public static void plugin(USB usb){
		usb.start();
		System.out.println("=====USB 设备工作=====");
		usb.stop();
	}
}

class FLASH implements USB{

	@Override
	public void start() {
		// TODO 自动生成的方法存根
		System.out.println("U盘开始工作");
	}

	@Override
	public void stop() {
		// TODO 自动生成的方法存根
		System.out.println("U盘停止工作");
	}
	
}

class Print implements USB{

	@Override
	public void start() {
		// TODO 自动生成的方法存根
		System.out.println("打印机开始工作");
	}

	@Override
	public void stop() {
		// TODO 自动生成的方法存根
		System.out.println("打印机停止工作");
	}
	
}

public class implements_usb_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		computer.plugin(new FLASH());
		computer.plugin(new Print());
	}

}