彦舜原创，CSDN首发：定义三种商品，他们各自具备的对应功能，并使用(3)——重点

package cm.abstracts.application;

public class InstanceFfourtyEight2 {

	public static void main(String[] args) {
//		//主类主方法，所有程序入口，执行起点
		分布4：各个子类的具体操作由主类主方法发出命令
//		//通过创建对应子类对象的向上转型，实例父类(抽象类)对象
//		//通过创建Robot类对象的向上转型，创建父类对象
//		Abstract a = new Robot2();
//		a.program();
//		
//		//通过创建对应Human类对象的向上转型，创建抽象类对象
//		Abstract b = new Human2();
//		b.program();
//		
//		//通过创建对应Pig类对象的向上转型，创建抽象类对象
//		Abstract c = new Pig2();
//		c.program();
		
		funny(new Robot3());
		System.out.println();  //换行
		System.out.println();  //换行
		
		InstanceFfourtyEight2.funny(new Human3());
		System.out.println();  //换行
		System.out.println();  //换行
		
		InstanceFfourtyEight2.funny(new Pig3());
	}
	
	public static void funny(Abstract2 a) {
		//调用工具包(cm.abstracts.application)中的工具类(Abstract2)的某功能/属性
		a.command(Abstract2.EAT);
		a.command(Abstract2.SLEEP);
		a.command(Abstract2.WORK);
		
		System.out.println();  //换行
		
		a.command(Abstract2.EAT + Abstract2.SLEEP);
		a.command(Abstract2.EAT + Abstract2.WORK);
		a.command(Abstract2.SLEEP + Abstract2.WORK);
	}
	
}

/** 按照以上的设计思路，实际上可以对程序做进一步的扩展，现在假设有3类事物：机器人(Robot)、人类(Human)
 、猪(pig)
 
 	现在要求实现对以上事物的控制，即可以控制机器人、人类、猪的操作行为，具体化每个实际事物类，即(覆写抽象类中的抽象方法)。
  再由父类(抽象类)中的普通方法直接调用本类中的抽象方法，最后由行为类(创建实例化对象)发出具体的操作命令，即主类主方法。
  
    分步1：首先应该对行为进行抽象，
    分布2：对应每种行为创建出具体的对应子类
    分步3：具体化对应子类，即覆写抽象类中的所有抽象方法
    分布4：子类的具体操作由主类主方法发出命令
*/

//分步1：首先应该对行为进行抽象，声明一个抽象类，必有子类，类中普通方法直接调用该抽象类的抽象方法
abstract class Abstract2{
	//定义各个事物共有的共同的属性/特征，常量，由此保存在底层的公共数据区
	public static final int EAT = 3;
	public static final int SLEEP = 4;
	public static final int WORK = 5;
	
	
//	//创建抽象类中的一个普通方法
//	public void program() {
//		//普通方法直接调用本抽象类中的抽象方法
//		this.eat();
//		this.sleep();
//		this.work();
//	}
	
	public void command(int order) {
		//switch只支持数值判断，而if支持条件判断
		//switch判断语句很危险，切记每次判断结束使用break，终结循环
		switch(order) {
		//当前为吃的操作
		case EAT:
			//调用子类中具体化的“吃”功能
			this.eat();
			break;
			
		//当前为睡的操作
		case SLEEP:
			//调用子类中具体化的“睡”方法
			this.sleep();
			break;
			
		//当前为工作的操作
		case WORK:
			//调用子类中具体化的“工作”行为
			this.work();
			break;
		
		/** 方法/行为/功能/操作组合，同时调用子类中具体化的多种行为	*/
		case EAT + WORK:
			this.eat();
			this.work();
			this.sleep();
			break;
		case EAT + SLEEP:
			this.eat();
			this.sleep();
			break;
		case WORK + SLEEP:
			this.work();
			this.sleep();
			break;
		}
	}
	//分步1：首先应该对每种行为/功能进行抽象化
	protected abstract void eat();
	protected abstract void sleep();
	protected abstract void work();
}

//三个实际研发对象，即三个实际事物三个子类，每个研发事物(子类)覆写父类中的抽象方法，由三个子类分别决定其具体内容
//创建子类1：机器人(Robot)
//分步2：对应每种行为创建出具体的对应子类
class Robot3 extends Abstract2{
	//分步3：具体化对应子类，即覆写抽象类中的所有抽象方法
	@Override
	public void work() {
		System.out.println("机器人正在努力工作！" + WORK);
	}
	
	@Override
	public void sleep() {
		System.out.println("我们都知道，机器人无法睡觉无法休息的");
	}
	
	@Override
	public void eat() {
		System.out.println("机器人正在补充能量！" + EAT);
	}
}

//分布2：对应每种行为创建出具体的对应子类
//创建子类2：人类(Human)
class Human3 extends Abstract2{
	//分步4：具体化对应子类，即覆写抽象类中的所有抽象方法
	@Override 
	public void work() {
		System.out.println("人为了梦想在努力工作！" + WORK);
	}
	
	@Override
	public void sleep() {
		System.out.println("人类正在睡觉休息！" + SLEEP);
	}
	
	@Override
	public void eat() {
		System.out.println("人类正在吃饭！" + EAT);
	}
}

//分布2：对应每种行为创建出具体的对应子类
//创建子类3：猪(Pig)
class Pig3 extends Abstract2{
	//分步4：具体化对应子类，即覆写抽象类中的所有抽象方法
	@Override
	public void work() {
		System.out.println("猪猪每天除了吃就是睡，无法工作噢");
	}
	
	@Override
	public void sleep() {
		System.out.print("猪在睡觉养膘！" + SLEEP);
	}
	
	@Override
	public void eat() {
		System.out.println("猪猪正在吃饭！" + EAT);
	}
}

彦舜原创，CSDN首发