diff --git a/src/main/java/io/zipcoder/Application.java b/src/main/java/io/zipcoder/Application.java index 3a257cb..0b2079b 100644 --- a/src/main/java/io/zipcoder/Application.java +++ b/src/main/java/io/zipcoder/Application.java @@ -1,5 +1,67 @@ package io.zipcoder; +import java.util.*; public class Application { + public static void main(String[] args) { + /** + + Create a program that asks the user how many pets they have. + Once you know how many pets they have, ask them what kind of pet each one is, + along with each pet's name. + For now your program should just hold onto the user input and + print out the list at the end; we'll modify this in part 3.*/ + int totalPets; + String petType; + String petName; + ArrayList petInfo = new ArrayList(); + + Scanner scan = new Scanner(System.in); + System.out.println("Hello! How many pets do you have?"); + totalPets = scan.nextInt(); + scan.nextLine(); + + //ask them what kind of pet each one is, along with each pet's name. + for (int i = 0; i < totalPets; i++) { + System.out.println("What kind of pet is this?(Dog,Cat or Reptile)"); + //waits for input to be entered before continuing on to the nextline + petType = scan.nextLine(); + System.out.println("What is the name of this pet?"); + petName = scan.nextLine(); + //compares incoming string to case and stores appropriate object for info entered by user + switch (petType.toLowerCase()) { + case "dog": + petInfo.add(new Dog(petName)); + break; + case "cat": + petInfo.add(new Cat(petName)); + break; + case "reptile": + petInfo.add(new Reptile(petName)); + break; + default: + System.out.printf("%s is an invalid pet type.", petType); + } + + } + + //iterate over an arrayList using an enhanced for loop. use getter to return name and call method + for (PetClass obj : petInfo) { + System.out.printf("My pet %s says %s%n", obj.getName(), obj.speak()); + } + //will call comparable + Collections.sort(petInfo); + int count = 0; + for (PetClass obj : petInfo) { + count++; + System.out.printf("Pet %d is %s%n", count, obj.getName()); + } + //will call comparator + Collections.sort(petInfo, new PetCompare()); + for (PetClass obj : petInfo) { + System.out.printf("I am a %s%n.", obj.getClass()); + } + } + } + diff --git a/src/main/java/io/zipcoder/Cat.java b/src/main/java/io/zipcoder/Cat.java new file mode 100644 index 0000000..f5cbf8c --- /dev/null +++ b/src/main/java/io/zipcoder/Cat.java @@ -0,0 +1,21 @@ +package io.zipcoder; + +public class Cat extends PetClass { + + //Constructor uses super keyword to invoke constructor of parent class + public Cat(String name) { + super(name); + } + + @Override + public String speak() { + return "Meow"; + } + + /* 1.super keyword, It is used inside a subclass method definition to call a method defined in the super class. + * Private methods of the super-class can't be called. Only public and protected methods of the super-class can + * be called by the super keyword. + * 2.super keyword is also used by class constructors to invoke constructors of its parent class**/ +} + + diff --git a/src/main/java/io/zipcoder/Dog.java b/src/main/java/io/zipcoder/Dog.java new file mode 100644 index 0000000..78d6043 --- /dev/null +++ b/src/main/java/io/zipcoder/Dog.java @@ -0,0 +1,13 @@ +package io.zipcoder; + +public class Dog extends PetClass { + + public Dog(String name) { + super(name); + } + + @Override + public String speak() { + return "Woof"; + } +} diff --git a/src/main/java/io/zipcoder/PetClass.java b/src/main/java/io/zipcoder/PetClass.java new file mode 100644 index 0000000..656a55a --- /dev/null +++ b/src/main/java/io/zipcoder/PetClass.java @@ -0,0 +1,64 @@ +package io.zipcoder; + +import java.lang.Comparable; + +public abstract class PetClass implements Comparable { + //Since the Petclass has an abstract method, need to declare this class abstract. + + //The Pet class must have a name field with setters and getters. + String name; + + public PetClass(String name) { + + this.name = name; + } + + public String getName() { + + return name; + } + + public void setName(String name) { + + this.name = name; + } + //The Pet class must have a speak method that each subclass overrides. + //abstract method + + /** + * All the child classes should override this method. There is no point to implement this + * method in parent class. Making this method abstract would be a good choice because making + * it abstract will force subclasses to implement this method (or will get compile error) + */ + public abstract String speak(); + + @Override + public int compareTo(PetClass other) { + int equality = this.name.compareTo(other.name); + if (equality != 0) { + return equality; + } + return this.getClass().getSimpleName().compareTo(other.name.getClass().getSimpleName()); + } + +} + + +/** + * Notes on Comparable and CompareTo(). + * To sort an Object by its property, you have to make the Object implement the Comparable interface + * and override the compareTo() method.A comparable object is capable of comparing itself with another object. + * The class itself must implements the java.lang.Comparable interface to compare its instances. When comparing strings + * we have 3 possible outcomes. Int of 0 which means the strings are equal. Int of -1 means string + * on the left is greater lexigraphically than whats on the right(comparing value). Int of 1 means + * whats on the left is smaller lexigraphically than whats on the right(comparing value). + * In this case I compared the current instance of the objects name to the previous(or next instance of the object.. + * code for compareTo does that). if it's 0 it falls through to the second return statement. if returns 1 or -1 then + * it returns that value. + * The second return statement compares class Name. If pets name is equal will compare classname. + */ + + + + + diff --git a/src/main/java/io/zipcoder/PetCompare.java b/src/main/java/io/zipcoder/PetCompare.java new file mode 100644 index 0000000..397bd09 --- /dev/null +++ b/src/main/java/io/zipcoder/PetCompare.java @@ -0,0 +1,17 @@ +package io.zipcoder; + +import java.util.Comparator; + +public class PetCompare implements Comparator { + + @Override + public int compare(PetClass pet1, PetClass pet2) { + int equality = pet1.getClass().getSimpleName().compareTo(pet2.name.getClass().getSimpleName()); + if (equality != 0) { + return equality; + } + return pet1.getName().compareTo(pet2.getName()); + } +} +/** Implementation of comparator very similar to comparable. Did enough research to make app function. + * Need to research the difference between the 2. Still lacking some understanding here.*/ \ No newline at end of file diff --git a/src/main/java/io/zipcoder/Reptile.java b/src/main/java/io/zipcoder/Reptile.java new file mode 100644 index 0000000..7d571a7 --- /dev/null +++ b/src/main/java/io/zipcoder/Reptile.java @@ -0,0 +1,15 @@ +package io.zipcoder; + +public class Reptile extends PetClass { + + public Reptile(String name) { + + super(name); + } + + @Override + public String speak() { + + return "Hiss!"; + } +} diff --git a/src/test/java/io/zipcoder/CatTest.java b/src/test/java/io/zipcoder/CatTest.java new file mode 100644 index 0000000..c952245 --- /dev/null +++ b/src/test/java/io/zipcoder/CatTest.java @@ -0,0 +1,41 @@ +package io.zipcoder; + +import org.junit.Assert; +import org.junit.Test; + +import static org.junit.Assert.*; + +public class CatTest { + + @Test + public void testSpeak() { + //ARRANGE: create an instance of the object to act on + Cat myCat = new Cat("Snowball"); + String expected = "Meow"; + //ACT: call method on our object + String actual = myCat.speak(); + //Assert: check outcome is what we expect + Assert.assertEquals(expected, actual); + } + + //This is where we are testing the constructor of the parent class + @Test + public void testGetName() { + String expected = "Snowball"; + Cat myCat = new Cat(expected); + String actual = myCat.getName(); + Assert.assertEquals(expected, actual); + + } + + @Test + public void testSetName() { + String expected = "Whiskers"; + Cat myCat = new Cat(expected); + myCat.setName(expected); + String actual = myCat.getName(); + Assert.assertEquals(expected, actual); + } + +} + diff --git a/src/test/java/io/zipcoder/DogTest.java b/src/test/java/io/zipcoder/DogTest.java new file mode 100644 index 0000000..0f0fc31 --- /dev/null +++ b/src/test/java/io/zipcoder/DogTest.java @@ -0,0 +1,36 @@ +package io.zipcoder; + +import org.junit.Assert; +import org.junit.Test; + +import static org.junit.Assert.*; + +public class DogTest { + + @Test + public void testSpeak() { + Dog myDog = new Dog("Fido"); + String expected = "Woof"; + String actual = myDog.speak(); + Assert.assertEquals(expected, actual); + } + + @Test + public void testGetName() { + String expected = "Fido"; + Dog myDog = new Dog("Fido"); + String actual = myDog.getName(); + Assert.assertEquals(expected, actual); + + } + + @Test + public void testSetName() { + Dog myDog = new Dog("Fido"); + String expected = "Fido"; + myDog.setName(expected); + String actual = myDog.getName(); + Assert.assertEquals(expected, actual); + } +} + diff --git a/src/test/java/io/zipcoder/PetClassTest.java b/src/test/java/io/zipcoder/PetClassTest.java new file mode 100644 index 0000000..8a8fea3 --- /dev/null +++ b/src/test/java/io/zipcoder/PetClassTest.java @@ -0,0 +1,28 @@ +package io.zipcoder; + +import org.junit.Test; + +import static org.junit.Assert.*; + +public class PetClassTest { +//Note PetClass is abstract and can not be instantiated +// How to test and abstract class? +//Create a concrete class that inherits the abstract +// class and then test the functions the concrete class +// inherits from the abstract class. So test the following +// in cat and dog tests + + @Test + public void testGetName() { + + + } + + @Test + public void testSetName() { + } + + @Test + public void testSpeak() { + } +} \ No newline at end of file diff --git a/src/test/java/io/zipcoder/ReptileTest.java b/src/test/java/io/zipcoder/ReptileTest.java new file mode 100644 index 0000000..f8458bc --- /dev/null +++ b/src/test/java/io/zipcoder/ReptileTest.java @@ -0,0 +1,38 @@ +package io.zipcoder; + +import org.junit.Assert; +import org.junit.Test; + +import static org.junit.Assert.*; + +public class ReptileTest { + + @Test + public void testSpeak() { + Reptile myReptile = new Reptile("Alfred"); + String expected = "Hiss!"; + String actual = myReptile.speak(); + Assert.assertEquals(expected, actual); + } + + @Test + public void testGetName() { + Reptile myReptile = new Reptile("Alfred"); + String expected = "Alfred"; + String actual = myReptile.getName(); + Assert.assertEquals(expected, actual); + + } + + @Test + public void testSetName() { + String expected = "Sneaky Snake"; + Cat myReptile = new Cat(expected); + myReptile.setName(expected); + String actual = myReptile.getName(); + Assert.assertEquals(expected, actual); + } +} + + +