newclass.java

人工智能

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
////////////////////////////////////////////////

//一级属性类
class classKind1
{
	public EnumKinds.kind1 kind1 = EnumKinds.kind1.空类;
	public boolean flag = false;
}

// 二级属性类
class classKind2
{
	public EnumKinds.kind2 kind2 = EnumKinds.kind2.空类;
	public boolean flag = false;
}

// 三级属性类
class classKind3
{
	public EnumKinds.kind3 kind3 = EnumKinds.kind3.空类;
	// public boolean flag = false;
	public boolean print = false;
}

// 名称类
class className
{
	public EnumKinds.name name = EnumKinds.name.空类;
	public boolean flag = false;
}

///************************************************************/////
// 利用前面的四个类创建综合数据库（反向推理）
  class AnimalDataBase1
{
	public final  int MAXSIZE = 255;
	private classKind1 kind1;
	private classKind2 kind2;
	public classKind3[] kind3;
	private int id_Kind3 = 1;
	private className name;

	// 构造函数
	public AnimalDataBase1()
    {
		kind1 = new classKind1();
		kind2 = new classKind2();
		kind3 = new classKind3[MAXSIZE];
		for (int i = 0; i < MAXSIZE; i++)
        {
            kind3[i] = new classKind3();
        }
		name = new className();
	 }


	// 设置一级属性
	public void setKind1(EnumKinds.kind1 x)
    {
		if (kind1.flag == false)
        {
			kind1.kind1 = x;
			kind1.flag = true;
		}
	}

	// 设置二级属性
	public void setKind2(EnumKinds.kind2 x)
    {
		if (kind2.flag == false)
        {
			kind2.kind2 = x;
			kind2.flag = true;
		}
	}

	// 设置三级属性
	public void setKind3(EnumKinds.kind3 x)
    {
		if (id_Kind3 > 0 && id_Kind3 < MAXSIZE)
        {
			kind3[id_Kind3].kind3 = x;
			kind3[id_Kind3].print = false;
			id_Kind3++;
		}
	}

	// 一号方案，为什么会失败？
	public String getKind3()
    {
		String s = "";
		for (int i = 1; i < id_Kind3; i++)
        {
            if (kind3[i].print = false)
            {
                kind3[i].print = true;
                s += kind3[i].kind3.toString();
            }
        }
		return s;
	}

	// 设置名称
	public void setName(EnumKinds.name x)
    {
		if (name.flag == false)
        {
			name.name = x;
			name.flag = true;
		}
	}

	public classKind1 getKind1()
    {
		return kind1;
	}

	public classKind2 getKind2()
    {
		return kind2;
	}

	public className getName()
    {
		return name;
	}

	// 在三级属性中寻找匹配项
	public boolean kindMatch(EnumKinds.kind3 x)
    {
		for (int i = 1; kind3[i].kind3 != x && i < id_Kind3; i++)
        {
            if (kind3[i].kind3 != EnumKinds.kind3.空类)
            {
                return false;
            }
        }
		return true;
	}
}
///************************************************************/////


// 利用前面的四个类创建综合数据库//（正向推理）
  class AnimalDataBase
{
	public final  int MAXSIZE = 255;
	private classKind1 kind1;
	private classKind2 kind2;
	public classKind3[] kind3;
	private int id_Kind3 = 1;
	private className name;

	// 构造函数
	public AnimalDataBase()
    {
		kind1 = new classKind1();       //一级属性
		kind2 = new classKind2();       //二级属性
		kind3 = new classKind3[MAXSIZE];//三级属性

		for (int i = 0; i < MAXSIZE; i++) //MAXSIZE=255
        {
            kind3[i] = new classKind3();
        }
		name = new className();    //生物名称。如:f
	}


	// 设置一级属性
	public void setKind1(EnumKinds.kind1 x)
    {
		if (kind1.flag == false)
        {
			kind1.kind1 = x;
			kind1.flag = true;
		}
	}

	// 设置二级属性
	public void setKind2(EnumKinds.kind2 x)
    {
		if (kind2.flag == false)
        {
			kind2.kind2 = x;
			kind2.flag = true;
		}
	}

	// 设置三级属性
	public void setKind3(EnumKinds.kind3 x)
    {
		if (id_Kind3 > 0 && id_Kind3 < MAXSIZE)
        {
			kind3[id_Kind3].kind3 = x;
			kind3[id_Kind3].print = false;
			id_Kind3++;
		}
	}

	// 一号方案，为什么会失败？
	public String getKind3()
    {
		String s = "";
		for (int i = 1; i < id_Kind3; i++)
        {
            if (kind3[i].print = false)
            {
                kind3[i].print = true;
                s += kind3[i].kind3.toString();
            }
        }
		return s;
	}

	// 设置名称
	public void setName(EnumKinds.name x)
    {
		if (name.flag == false)
        {
			name.name = x;
			name.flag = true;
		}
	}

	public classKind1 getKind1()
    {
		return kind1;
	}

	public classKind2 getKind2()
    {
		return kind2;
	}

	public className getName()
    {
		return name;
	}

	// 在三级属性中寻找匹配项
	public boolean kindMatch(EnumKinds.kind3 x)
    {
		for (int i = 1; kind3[i].kind3 != x && i < id_Kind3; i++)
        {
            if (kind3[i].kind3 != EnumKinds.kind3.空类)
            {
                return false;
            }
        }
		return true;
	}
}

///////////////////////////////////////////////
//定义枚举类型，用以存储动物的各级属性
class EnumKinds
{
	// 定义一级分类
	public static enum kind1
    {
		空类, 哺乳动物, 鸟类动物
	}

	// 定义二级分类
	public static enum kind2
    {
		空类, 食肉动物, 有蹄动物, 鸟类
	}

	// 定义底级属性
	public static enum kind3
    {
		空类, 有毛发, 有长爪, 有利齿, 有羽毛, 有蹄, 有长腿, 
        有长颈, 能产乳, 能生蛋, 能飞行, 能游泳, 吃肉, 反刍,
        眼睛前视, 黄褐色, 白色, 黑色与白色相杂, 黑色与白色,
        深色斑点, 黑色条纹, 善于飞行
	}

	// 定义动物名称
	public static enum name
    {
		空类, 猎豹, 老虎, 长颈鹿, 斑马, 鸵鸟, 企鹅, 海燕
	}
}


////******************************************/////
//定义可以（正向）推理的推理机
class Reasoning
{
	String name = "";      // 动物名称
	String YorN = "";      // 判断
	private int id_R = 0;  // 下一步推理序号
	private int id_Kind3 = 1;// 要输出的三级属性的序号

	public Reasoning()
    {
	}

	// 系统介绍
   private void introduce()
    {
		String str1;
		str1 = "\nA猎豹, B老虎,C长颈鹿 , D斑马, E鸵鸟, F企鹅, G海燕\n"
				+ "请输入您要验证的动物编号并按回车键结束\n：";
		System.out.println(str1);
	}

	// 用户输入方法
	private String inPut()
    {
		String s = "";
		try
        {
			BufferedReader stdin = new BufferedReader(new InputStreamReader(
					System.in));
			s = stdin.readLine();
		} catch (IOException e)
        {
			e.printStackTrace();
		}
		return s;
	}

	// 二号方案，三级属性输出方法。
	private boolean outPut(AnimalDataBase x)
    {
		String str = "动物满足如下特性吗？（确认请输入‘YES’,'NO'请回车！）\n";
		if (id_Kind3 < x.MAXSIZE)
        {
			while (x.kind3[id_Kind3].kind3 != EnumKinds.kind3.空类)
            {
				str += x.kind3[id_Kind3++].kind3 + "；";
			}
			System.out.println(str);
			return true;
		}
		return false;
	}

	// 对输出的三级属性的回复做出判断
	private boolean judge(AnimalDataBase x)
    {
		if (outPut(x) == true)
        {
			YorN = inPut();
			if (YorN.equals("YES")) {
                return true;
            }
			else {
                return false;
            }
		}
		return false;
	}

	// 请用户输入动物名称
	private void step1()
    {
		name = inPut();         //name是字符串变量。
		boolean flag = false;
		while (!flag)
        {
			flag = true;
			if (name.equals("A")) //A猎豹
            {
                id_R = 9;
            }
			else if (name.equals("B")) //B老虎
            {
                id_R = 10;
            }
			else if (name.equals("C")) //C长颈鹿
            {
                id_R = 11;
            }
			else if (name.equals("D")) //D斑马
            {
                id_R = 12;
            }
			else if (name.equals("E")) //E鸵鸟
            {
                id_R = 13;
            }
			else if (name.equals("F"))//F企鹅
            {
                id_R = 14;
            }
			else if (name.equals("G")) //G海燕
            {
                id_R = 15;
            }
			else
            {
				name = "";
				flag = false;
				System.out.println("请输入大写字母：");
				name = inPut();
			}
		}
	}

	// 对用户输入动物进行推理
	private void step2(AnimalDataBase x)
    {
//		int m1 = 1;
//		int m2 = 11;
//		int m3 = 21;
		boolean end = false;//验证正确标志。正确时end=true
		while (id_R != 0)
        {
			switch (id_R)
            {
			case 1:
              {
				x.setKind3(EnumKinds.kind3.有毛发);
				if (judge(x))
                {
					id_R = 0;
					end = true;
				 } else {
                    id_R = 2;
                }
				// y.R1(x);
				break;
			  }
			case 2:
            {
				x.setKind3(EnumKinds.kind3.能产乳);
				if (judge(x)) {
                    end = true;
                }
				id_R = 0;
				// y.R2(x);
				break;
			}
			case 3:
            {
				x.setKind3(EnumKinds.kind3.有羽毛);
				if (judge(x))
                {
					id_R = 0;
					end = true;
				} else {
                    id_R = 4;
                }
				// y.R3(x);
				break;
			}
			case 4:
            {
				x.setKind3(EnumKinds.kind3.能飞行);
				x.setKind3(EnumKinds.kind3.能生蛋);
				if (judge(x)) {
                    end = true;
                }
				id_R = 0;
				// y.R14(x);
				break;
			}
			case 5:
            {
				x.setKind3(EnumKinds.kind3.吃肉);
				// System.out.println(x.kind3[3].kind3);
				if (judge(x)) {
                    id_R = 1;
                }
				else {
                    id_R = 6;
                }
				// y.R5(x);
				break;
			}
			case 6:
            {
				x.setKind3(EnumKinds.kind3.有长爪);
				x.setKind3(EnumKinds.kind3.有利齿);
				x.setKind3(EnumKinds.kind3.眼睛前视);
				if (judge(x)) {
                    id_R = 1;
                }
				else {
                    id_R = 0;
                }
				// y.R6(x);
				break;
			}
			case 7:
            {
				x.setKind3(EnumKinds.kind3.有蹄);
				if (judge(x)) {
                    id_R = 1;
                }
				else {
                    id_R = 8;
                }
				// y.R7(x);
				break;
			}
			case 8:
            {
				x.setKind3(EnumKinds.kind3.反刍);
				if (judge(x)) {
                    id_R = 1;
                }
				else {
                    id_R = 0;
                }
				// y.R8(x);
				break;
			}
			case 9:
            {
				x.setName(EnumKinds.name.猎豹);
				x.setKind3(EnumKinds.kind3.黄褐色);
				x.setKind3(EnumKinds.kind3.深色斑点);
				// System.out.println(x.kind3[1].kind3+x.kind3[2].kind3.toString());
				if (judge(x)) {
                    id_R = 5;
                }
				else {
                    id_R = 0;
                }
				// y.R9(x);
				break;
			}
			case 10:
            {
				x.setName(EnumKinds.name.老虎);
				x.setKind3(EnumKinds.kind3.黄褐色);
				x.setKind3(EnumKinds.kind3.黑色条纹);
				if (judge(x)) {
                    id_R = 5;
                }
				else {
                    id_R = 0;
                }
				// y.R10(x);
				break;
			}
			case 11:
            {
				x.setName(EnumKinds.name.长颈鹿);
				x.setKind3(EnumKinds.kind3.有长腿);
				x.setKind3(EnumKinds.kind3.有长颈);
				x.setKind3(EnumKinds.kind3.黄褐色);
				x.setKind3(EnumKinds.kind3.深色斑点);
				if (judge(x)) {
                    id_R = 7;
                }
				else {
                    id_R = 0;
                }
				// y.R11(x);
				break;
			}
			case 12:
            {
				x.setName(EnumKinds.name.斑马);
				x.setKind3(EnumKinds.kind3.白色);
				x.setKind3(EnumKinds.kind3.黑色条纹);
				if (judge(x)) {
                    id_R = 7;
                }
				else {
                    id_R = 0;
                }
				// y.R12(x);
				break;
			}
			case 13:
            {
				x.setName(EnumKinds.name.鸵鸟);
				x.setKind3(EnumKinds.kind3.有长腿);
				x.setKind3(EnumKinds.kind3.有长颈);
				x.setKind3(EnumKinds.kind3.黑色与白色相杂);
				if (judge(x)) {
                    id_R = 3;
                }
				else {
                    id_R = 0;
                }
				// y.R13(x);
				break;
			}
			case 14:
            {
				x.setName(EnumKinds.name.企鹅);
				x.setKind3(EnumKinds.kind3.能游泳);
				x.setKind3(EnumKinds.kind3.有长颈);
				x.setKind3(EnumKinds.kind3.黑色与白色);
				if (judge(x)) {
                    id_R = 3;
                }
				else {
                    id_R = 0;
                }
				// y.R14(x);
				break;
			}
			case 15:
            {
				x.setName(EnumKinds.name.海燕);
				x.setKind3(EnumKinds.kind3.善于飞行);

				// y.R15(x);
				if (judge(x)) {
                    id_R = 3;
                }
				else {
                    id_R = 0;
                }
				break;
			}
			}// switch
		}// while

		// 结果判定
		String str;
		if (id_R == 0 && end == true) {
            str = "验证成功! 您要验证的动物是" +"\""+x.getName().name+"\"" + "!";
        }
		else {