猫狗队列

给你一个这样的类：

public class DogCatqQueue {
	public class Pet{
		private String type;
		public Pet(String type) {
			this.type=type;
		}
		public String getPetType() {
			return this.type;
		}
	}
	public class Dog extends Pet{

		public Dog() {
			super("dog");	
		}
	}
	public class Cat extends Pet{
		public Cat() {
			super("cat");
		}
	}

要求：实现一种新的猫狗队列结构

1.用户可以调用add方法将cat类或者dog类的实例放入队列中；
2.用户可以调用pollAll方法，将队列中所有的实例按照队列的先后顺序依次弹出；
3.用户可以调用pollDog方法，将队列中dog类的实例按照队列的先后顺序依次弹出；
4.用户可以调用pollCat方法，将队列中cat类的实例按照队列的先后顺序依次弹出；
5.用户可以调用isEmpty方法，检查队列中是否还有dog和cat的实例；
6.用户可以调用isDogEmpty方法，检查队列中是否还有dog的实例；
7.用户可以调用isCatEmpty方法，检查队列中是否还有cat的实例。

---

思路：实现一个新的队列，里面包含猫队列与狗队列（可跳过直接看方法2的实现）

当添加宠物为猫时，调用猫队列的添加方法，添加宠物为狗时，同理，检查队列中有无猫//狗时，直接调用相应队列是否为空的方法。这样，1，3，4，6，7都可以实现。

然后对此新的队列进行改进，加一个计数变量，每进入一个宠物记一次数，变量为0即队列已空即可得到5方法。（或者分别查询猫狗队列是否为空也可实现5方法）

方法2的实现：

增加一个count变量，绑定在宠物本身，给宠物一个编号，记录入栈顺序。在add时，增加宠物以及他的编号。在弹出时，可分别弹出猫和狗，对比编号入栈顺序，进行相应的弹出。（类似于c++中的结构体，进队列的是int与pet组成的结构体而非pet本身）

package Queue;

import java.util.LinkedList;
import java.util.Queue;

import Queue.DogCatqQueue.CountPet;

public class DogCatqQueue {
	public static class Pet {
		private String type;

		public Pet(String type) {
			this.type = type;
		}

		public String getPetType() {
			return this.type;
		}
	}
	public static class Dog extends Pet {
		public Dog() {
			super("dog");
		}
	}
	public static class Cat extends Pet {
		public Cat() {
			super("cat");
		}
	}



//自定义一个带有编号的宠物类
	public static class CountPet {
		private Pet pet;
		private int count;

		CountPet(Pet a, int b) {
			this.pet = a;
			this.count = b;// 记录是第几个进入猫狗队列的
		}
		public Pet getPet() {
			return this.pet;
		}
		public int getCount() {
			return this.count;
		}

	}




//猫狗队列
	public static class CatDogQueue {
		Queue<CountPet> catq;
		Queue<CountPet> dogq;// 此队列之进入pet类型为dog，具体对象类型为 CountPet
		private int count;// 记录猫狗队列中宠物数量中

		CatDogQueue() {
			catq = new LinkedList<CountPet>();
			dogq = new LinkedList<CountPet>();
			count = 0;// count初始化
		}

		// 进队列的方法
		public void add(Pet pet) {
			if (pet.getPetType().equals("dog")) {
				dogq.add(new CountPet(pet, this.count++));
			} else if (pet.getPetType().equals("cat")) {
				catq.add(new CountPet(pet, this.count++));
			} else
				throw new RuntimeException("没有这样的宠物！！！");

		}


		public Pet pollall() {
			if(!dogq.isEmpty()&&!catq.isEmpty()) {
			int a=dogq.peek().getCount();
			int b=catq.peek().getCount();
			return a<b?dogq.poll().getPet():catq.poll().getPet();
		}
			else if(!dogq.isEmpty()) {
				return dogq.poll().getPet();
			}
			else if(!catq.isEmpty()) {
				return catq.poll().getPet();
			}
			else throw new RuntimeException("队列已空");
	}


		public Dog pollDog() {
			if(!dogq.isEmpty())
			{return (Dog) dogq.poll().getPet();}
			else throw new RuntimeException("狗队列已空");

		}


		public Cat pollCat() {
			if(!catq.isEmpty())
			return (Cat) catq.poll().getPet();
			else throw new RuntimeException("猫队列已空");
		}

		public boolean isEmpty() {

			return (dogq.isEmpty() && catq.isEmpty());

		}

		public boolean isDogEmpty() {
			return dogq.isEmpty();

		}

		public boolean isCatEmpty() {
			return catq.isEmpty();

		}

	}
	


//主函数

	public static void main(String []args) {
	CatDogQueue test=new CatDogQueue();
	Pet dog1=new Dog();
	Pet dog2=new Dog();
	Pet dog3=new Dog();
	Pet cat1=new Cat();
	Pet cat2=new Cat();
	Pet cat3=new Cat();

	test.add(dog1);
	test.add(dog2);
	test.add(cat1);
	test.add(cat2);
	test.add(dog3);
	test.add(cat3);
	/*while (!test.isDogEmpty()) {
		System.out.println(test.pollDog().getPetType());
	}*/
	while (!test.isEmpty()) {
		System.out.println(test.pollall().getPetType());
	}
	}
}