Interfaces-ComparablePets

src/main/java/io/zipcoder/Application.java

@@ -1,5 +1,47 @@
 package io.zipcoder;
 
 
+import java.util.Scanner;
+
 public class Application {
+
+    public static Scanner scan = new Scanner(System.in);
+    public String input="";
+    private Integer numberOfPets;
+    private String petName;
+    private String petType;
+    PetInventory inventory = new PetInventory();
+
+    public static void main(String[] args) {
+        Application app = new Application();
+        System.out.println("Hey Mr. Green Maker how many pets do you have?");
+        app.numberOfPets = scan.nextInt();
+        scan.nextLine();
+        //app.setTotalNumberOfPets(nu);
+        app.PetApplication();
+    }
+    public void setTotalNumberOfPets(int numberOfPets){
+        this.numberOfPets = numberOfPets;
+    }
+    public int getTotalNumberOfPets(){
+        return numberOfPets;
+    }
+    public void PetApplication(){
+
+        PetInventory inventory = new PetInventory();
+        for(int i =0;i<getTotalNumberOfPets();i++){
+            String petType="";
+            String name ="";
+            System.out.println("What is the type of your first Pet ");
+            petType+=scan.nextLine();
+            System.out.println("What is its name");
+            name+=scan.nextLine();
+
+            inventory.addPet(petType,name);
+        }
+
+        System.out.println(inventory.listnamesOrdered());
+    }
+
+
 }

src/main/java/io/zipcoder/PetInventory.java

@@ -0,0 +1,146 @@
+package io.zipcoder;
+
+import io.zipcoder.pets.Cat;
+import io.zipcoder.pets.Dog;
+import io.zipcoder.pets.Otter;
+import io.zipcoder.pets.Pet;
+
+import java.util.*;
+
+public class PetInventory {
+
+    protected HashMap<String,ArrayList<Pet>> pets;
+
+    public PetInventory() {
+        this.pets = new HashMap<String, ArrayList<Pet>>();
+
+    }
+
+    public void addPet(String type, String name){
+        if(hasEntry(type)){
+            if(type.equalsIgnoreCase("cat")){
+                Cat aCat =new Cat(name);
+                getArrayListForPets("Cat").add(aCat);
+                pets.put("Cat",getArrayListForPets("Cat"));
+            }else if(type.equalsIgnoreCase("dog")){
+                Dog aDog = new Dog(name);
+                getArrayListForPets(type).add(aDog);
+                pets.put("Dog",getArrayListForPets("Dog"));
+            }else if(type.equalsIgnoreCase("otter")){
+                Otter anOtter = new Otter(name);
+                getArrayListForPets("Otter").add(anOtter);
+                pets.put("Otter",getArrayListForPets("Otter"));
+            }
+
+        }else {
+            if(type.equalsIgnoreCase("cat")){
+                ArrayList<Pet>cats = new ArrayList<Pet>();
+                Cat aCat =new Cat(name);
+                cats.add(aCat);
+                pets.put("Cat",cats);
+            }else if(type.equalsIgnoreCase("dog")){
+                ArrayList<Pet>dogs = new ArrayList<Pet>();
+                Dog aDog = new Dog(name);
+                dogs.add(aDog);
+                pets.put("Dog",dogs);
+            }else if(type.equalsIgnoreCase("otter")){
+                ArrayList<Pet>otters = new ArrayList<Pet>();
+                Otter anOtter = new Otter(name);
+                otters.add(anOtter);
+                pets.put("Otter",otters);
+
+            }
+
+        }
+
+
+    }
+
+    public void removePet(String petName){
+        for (Map.Entry<String, ArrayList<Pet>> entry : pets.entrySet()) {
+            for (int i = 0; i < pets.entrySet().size(); i++)
+                if (entry.getValue().get(i).getName().equalsIgnoreCase(petName)) {
+                    entry.getValue().remove(i);
+                }
+        }
+
+
+    }
+
+    public String listPets(){
+        StringBuilder builder = new StringBuilder();
+        for (Map.Entry<String, ArrayList<Pet>> entry : pets.entrySet()) {
+            for (int i = 0; i < pets.entrySet().size()-1; i++){
+                builder.append(entry.getValue().get(i).getName()+ " says " + entry.getValue().get(i).speak() + "\n");
+
+                }
+        }
+
+        return builder.toString();
+    }
+
+    public String getPetType(String name){
+        for (String keys : pets.keySet()) {
+            for (int i = 0; i < getArrayListForPets(keys).size(); i++) {
+                if (getArrayListForPets(keys).get(i).getName().equalsIgnoreCase(name))
+                    return keys;
+            }
+        }
+        return null;
+
+    }
+
+    public ArrayList<String> listOfPetsByName() {
+        ArrayList<String> petNames = new ArrayList<String>();
+        for (Map.Entry<String, ArrayList<Pet>> entry : pets.entrySet()) {
+            for (int i = 0; i < pets.entrySet().size()+1; i++) {
+                petNames.add(entry.getValue().get(i).getName());
+            }
+        }
+        Collections.sort(petNames);
+        return petNames;
+
+    }
+    public String listnamesOrdered(){
+        String str ="";
+        ArrayList<Pet>totalPets = getAllPets();
+        for(int i=0;i<totalPets.size();i++){
+            str+=totalPets.get(i).getName() + " says "+ totalPets.get(i).speak()+"\n";
+        }
+        return str;
+    }
+
+    public ArrayList<String> listOfPetsByTypeSorted(){
+        ArrayList<String> petNames = new ArrayList<String>();
+        for (Map.Entry<String, ArrayList<Pet>> entry : pets.entrySet()) {
+            for (int i = 0; i < pets.entrySet().size(); i++) {
+                petNames.add(entry.getValue().get(i).getName());
+            }
+
+        }
+
+        return petNames;
+    }
+
+    public boolean hasEntry(String petType){
+        if(pets.containsKey(petType)){
+            return true;
+        }
+        return false;
+    }
+    public ArrayList<Pet> getArrayListForPets(String petType){
+        return pets.get(petType);
+    }
+    public ArrayList<Pet> getAllPets(){
+        ArrayList<Pet>allPets = new ArrayList<Pet>();
+        for(String keys:pets.keySet()) {
+            for (int i = 0; i < getArrayListForPets(keys).size(); i++) {
+                allPets.add(getArrayListForPets(keys).get(i));
+            }
+        }
+        return allPets;
+    }
+
+
+
+}

src/main/java/io/zipcoder/perComparator.java

@@ -0,0 +1,19 @@
+package io.zipcoder;
+
+import io.zipcoder.pets.Pet;
+
+import java.util.Comparator;
+
+public class perComparator implements Comparator<Pet>{
+    public int compare(Pet aPet, Pet anotherPet) {
+        String aPetClass = aPet.getClass().getSimpleName();
+        String antherPetClass = anotherPet.getClass().getSimpleName();
+        int compare = aPetClass.compareToIgnoreCase(antherPetClass);
+        if(compare==0){
+            compare =(aPet.getName().compareToIgnoreCase(anotherPet.getName()));
+        }
+
+
+        return compare;
+    }
+}

src/main/java/io/zipcoder/pets/Cat.java

@@ -0,0 +1,22 @@
+package io.zipcoder.pets;
+
+public class Cat extends Pet {
+
+    private String name;
+
+    public Cat (String catName) {
+        this.name = catName;
+    }
+
+    public String speak(){
+        return "Meow";
+    }
+
+    public String getName() {
+        return this.name;
+    }
+
+    public void setName(String catName) {
+        this.name = catName;
+    }
+}

src/main/java/io/zipcoder/pets/Dog.java

@@ -0,0 +1,22 @@
+package io.zipcoder.pets;
+
+public class Dog extends Pet {
+    private String name;
+
+    public Dog(String dogName) {
+        this.name = dogName;
+    }
+
+    public String speak(){
+        return "Woof!";
+    }
+
+    public String getName() {
+        return this.name;
+    }
+
+    public void setName(String aDogName) {
+        this.name = aDogName;
+    }
+
+}

src/main/java/io/zipcoder/pets/Otter.java

@@ -0,0 +1,23 @@
+package io.zipcoder.pets;
+
+public class Otter extends Pet {
+    private String name;
+
+    public Otter(String otterName) {
+        this.name = otterName;
+    }
+
+    public String speak(){
+        return "Muahaha";
+    }
+
+    public String getName() {
+        return this.name;
+    }
+
+    public void setName(String anOtterName) {
+        this.name = anOtterName;
+
+    }
+
+}

src/main/java/io/zipcoder/pets/Pet.java

@@ -0,0 +1,30 @@
+package io.zipcoder.pets;
+
+abstract public class Pet implements PetBehavior, Comparable<Pet>{
+
+    private String name;
+
+    public String speak(){
+        return null;
+    }
+
+    public String getName() {
+        return null;
+    }
+
+    public void setName(String aPetName) {
+
+    }
+
+    public int compareTo(Pet anyPet) {
+
+        if (getName().compareTo(anyPet.getName()) > 0) {
+            return 1;
+        } else if (getName().compareTo(anyPet.getName()) < 0) {
+            return -1;
+        } else {
+            return getClass().getSimpleName().compareTo(getClass().getSimpleName());
+        }
+    }
+
+}

src/main/java/io/zipcoder/pets/PetBehavior.java

@@ -0,0 +1,7 @@
+package io.zipcoder.pets;
+
+public interface PetBehavior {
+
+    public String speak();
+
+}

src/test/java/io/zipcoder/ApplicationTest.java

@@ -1,5 +1,36 @@
 package io.zipcoder;
 
 
+import org.junit.Before;
+import org.junit.Test;
+
 public class ApplicationTest {
+
+    Application testApp;
+
+
+    @Before
+    public void setup() {
+        testApp = new Application();
+    }
+
+    @Test
+    public void getPetNameTest() {
+
+
+    }
+
+    @Test
+    public void getPetTypeTest() {
+
+    }
+
+    @Test
+    public void getNumberOfPetsTest() {
+
+    }
+
+
+
+
 }