刷题day1-3

猫狗队列

实现一种狗猫队列的结构，要求如下： 用户可以调用add方法将cat类或dog类的 实例放入队列中； 用户可以调用pollAll方法，将队列中所有的实例按照进队列 的先后顺序依次弹出； 用户可以调用pollDog方法，将队列中dog类的实例按照 进队列的先后顺序依次弹出； 用户可以调用pollCat方法，将队列中cat类的实 例按照进队列的先后顺序依次弹出； 用户可以调用isEmpty方法，检查队列中是 否还有dog或cat的实例； 用户可以调用isDogEmpty方法，检查队列中是否有dog 类的实例； 用户可以调用isCatEmpty方法，检查队列中是否有cat类的实例。

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

public class Test {

    public static void main(String[] args) {
        CatDogQueue queue = new CatDogQueue();
        queue.add(new Dog());
        queue.add(new Dog());
        System.out.println(queue.pollCat());
        System.out.println(queue.pollAll());
    }
}

class Pet{
    private String type;//宠物类别

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

    @Override
    public String toString() {
        return type;
    }
}
class Cat extends Pet{
    public Cat() {
        super("Cat");
    }
}
class Dog extends Pet{
    public Dog() {
        super("Dog");
    }
}

class PetIn{
    private Pet pet;
    private int cnt;

    public PetIn(Pet pet,int cnt) {
        this.pet = pet;
        this.cnt = cnt;
    }

    public Pet getPet() {
        return pet;
    }

    public String getPetType() {
        return pet.getPetType();
    }

    public int getCnt() {
        return cnt;
    }
}
class CatDogQueue{
    private Queue<PetIn> catQueue = new LinkedList<>();
    private Queue<PetIn> dogQueue = new LinkedList<>();
    private int cnt = 0;

    public void add(Pet pet){
        if (pet.getPetType() == "Cat"){
            catQueue.add(new PetIn(pet,this.cnt++));
        }else {
            dogQueue.add(new PetIn(pet,this.cnt++));
        }
    }

    public boolean isEmpty(){
        if (catQueue.isEmpty()&&dogQueue.isEmpty()){
            return true;
        }
        return false;
    }
    public boolean isCatEmpty(){
        if (catQueue.isEmpty()){
            return true;
        }
        return false;
    }

    public boolean isDogEmpty(){
        if (dogQueue.isEmpty()){
            return true;
        }
        return false;
    }

    public Pet pollAll(){
        if (isEmpty()){
            System.out.println("All queue is empty");
            return null;
        }
        if (catQueue.isEmpty()){
            return dogQueue.poll().getPet();
        }
        if (dogQueue.isEmpty()){
            return catQueue.poll().getPet();
        }
        PetIn pet = catQueue.peek().getCnt()<dogQueue.peek().getCnt()
                ?catQueue.poll():dogQueue.poll();
        return pet.getPet();
    }

    public Cat pollCat(){
        if (isCatEmpty()){
            System.out.println("There are no cats in the queue");
            return null;
        }
        return (Cat) catQueue.poll().getPet();
    }

    public Dog pollDog(){
        if (isDogEmpty()){
            System.out.println("There are no dogs in the queue");
            return null;
        }
        return (Dog)dogQueue.poll().getPet();
    }
}