猫狗队列的实现——Java从0开始学习系列之路(5)

前言---

现在人有点精神，写篇博客，晚点再去吃饭。人在，博客在！

（注：笔者水平有限，若有错误，请读者慷慨指出）

 

猫狗队列

题目：

package code_180;

//用户自己定义的类，不允许修改
public class Pet {   
	
	private String type;
	
	public Pet(String type) {
		
		this.type = type;
	}
	
	public String getType() {
		
		return this.type;
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub

	}

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

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类的实例

 

分析：

其实这题主要考察的还是自定义数据机构的设计能力，唯一要注意的地方就是不能修改原用户的数据结构，不然这题就没什么意义了，就是个垃圾题目了，假如运行修改Pet类，那么我多加个计数变量不就可以了。。。。。。

注意了上面这点之后，我们就只能新定义一个类PetOrder，这个类含有Pet,并且加了一个计数器，没办法，只能这样了。

这边可以在把dog或者cat 添加进队列之前就生成PetOrder（见下面的代码），然后add，也可以通过子类可以赋值给父类这个特点，用Pet作为函数的参数，然后具体判断是狗还是猫，进而再new成一个PetOrder，然后再add,这只是具体的实现细节而已，可以自由选择。

附完整Java代码（这边是把Pet类单独放在一个Java文件，把其余部分放在另外一个Java文件，但都是在同一个包下面）

package code_180;

import java.util.*;
import java.util.Queue;

public class PetOrder {      //由于不能改变原用户的结构，因此为了加上计数标签，又新定义了一个类。

	public Pet pet;
	public int order;
	
	public PetOrder(Pet pet ,int order) {
		
		this.pet = pet;
		this.order =  order;
		
	}
	
	public int getOrder() {
		
		return order;
	}
	
	public static void main(String[] args) {                   //Main 函数的测试
		// TODO Auto-generated method stub
		
		Pet nowPet;
		QueuePet  queue = new QueuePet();
		
		for(int i = 1 ;i <=5 ;i++) {
			
			if( i%2 == 1) {
				nowPet = new Dog();
				queue.add(nowPet, i);
				
				
			}
			else {
			  
				nowPet = new Cat();
				queue.add(nowPet, i);
				
			}
		}
		
		System.out.println();
		
		queue.pollAll();
		queue.pollCat();
		queue.pollDog();
		queue.pollDog();
		if(queue.isDogEmpty() )
			System.out.println("empty");
	
		else
			System.out.println("no empty");
		
		
		
		
		
		
	}

}

class QueuePet{         //这就是所谓的猫狗队列，其实本质就是含有一个狗队列，一个猫队列的自定义队列，还是考查自定义结构的设计
	
	private Queue<PetOrder>dogs;
	private Queue<PetOrder>cats;
	
	public QueuePet() {                     //构造函数
		
		dogs = new LinkedList <PetOrder>();    
		cats = new LinkedList <PetOrder>();
		
	}
	
	public void add( Pet pet ,int order) {       //添加入队的动物
		
		if(pet.getType().equals("Dog") ) {
			
			System.out.println("now add is a dog,its id is " + order);
			dogs.add(new PetOrder(pet,order));
			
		}
		else if(pet.getType().equals("Cat")){
			
			System.out.println("now add is a cat, its id is " + order);
			cats.add(new PetOrder(pet, order));
		}
		else
			throw new RuntimeException("not dog or cat");

		
	}
	
	public void pollCat() {      //弹出当前队列中最早入队的猫
		
		if( cats.isEmpty())
			throw new RuntimeException("cats  empty");
		else {
		   
			System.out.println("It is a  cat,its id is " + cats.peek().order);
		    cats.poll();
		}
	}
	public void pollDog() {           //弹出当前队列中最早入队的狗
		if(dogs.isEmpty())
			throw new RuntimeException("dogs empty");
		else {
			
			System.out.println("It is a dog,its id is " + dogs.peek().order);
			dogs.poll();
		}
	}
	
	public void pollAll() {                  //弹出当前队列中最早入队的动物
		
		if(cats.isEmpty() && dogs.isEmpty())
			throw new RuntimeException("all empty");
		
		else if(cats.isEmpty()&&!dogs.isEmpty())
			pollDog();
		
		else if(!cats.isEmpty()&& dogs.isEmpty())
			pollCat();
		else {
			
			if(cats.peek().order < dogs.peek().order) {
				
				pollCat();
			}
			
			else
				pollDog();
		}
   }
		
	  public boolean isEmpty() {  // 判断猫狗是否都为空
		  
		  if(cats.isEmpty() && dogs.isEmpty())
			  return true;
		  else
			  return false;
	  }
	  
	  public boolean isDogEmpty() {  //判断狗队列是否为空
		  
		  if(dogs.isEmpty())
			  return true;
		  else
			  return false;
	  }
	  
	  public boolean isCatEmpty() {   //判断猫是否为空
		  
		  if(cats.isEmpty())
			  return true;
		  else
			  return false;
	  }
	
	
	
}
//1狗，2猫，3狗，4猫，5狗

从这道题学习到的Java知识(也顺带复习了C++知识）

1.

子类中父类部分的构造，必须要通过调用父类的构造函数来完成。如果父类中含有无参构造函数，那么子类的构造函数会隐式调用，相当于子类的构造函数中有一个隐式的super（）语句。

如果父类中没有无参构造函数，那么我们必须在子类的构造函数中显示地调用super(参数), 也就是必须自己手写语句。

（如果父类中有含参的构造函数，那么无参的构造函数就不会存在了！！，这点要注意）

附测试代码：（以下代码会报错，请自行修改）

package code_180;

public class AboutSuper {

	int num;
	
	AboutSuper(int a){
       
		System.out.println("OK");
	}
	
	/*
	AboutSuper(){
	       
		System.out.println("OK");
	}
	*/
	

	
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub
         AboutSuper1  test = new AboutSuper1();
	}

}

class AboutSuper1 extends AboutSuper{
	
	AboutSuper1(){
		
		super();
		//super(3);
	}
}

 

2.

LinkedList 提供了方法支持了Queue的接口，因而可以用LinkedList用作队列的一种实现

如以下语句 ： Queue <Integer> = new LinkedList<Integer>();