Dev

pom.xml

@@ -7,6 +7,20 @@
     <groupId>com.zipcodewilmington</groupId>
     <artifactId>froilans-farm</artifactId>
     <version>1.0-SNAPSHOT</version>
+    <dependencies>
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <version>4.13.1</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter</artifactId>
+            <version>RELEASE</version>
+            <scope>compile</scope>
+        </dependency>
+    </dependencies>
 
 
 </project>

src/main/java/com/zipcodewilmington/froilansfarm/abstractClasses/Aircraft.java

@@ -0,0 +1,13 @@
+package com.zipcodewilmington.froilansfarm.abstractClasses;
+
+import com.zipcodewilmington.froilansfarm.interfaces.Pilot;
+import com.zipcodewilmington.froilansfarm.interfaces.Vehicle;
+
+public abstract class Aircraft implements Vehicle<Pilot> {
+
+    public boolean fly(){
+        System.out.println("Flying~~~");
+        return true;
+    }
+
+}

src/main/java/com/zipcodewilmington/froilansfarm/abstractClasses/Crop.java

@@ -0,0 +1,37 @@
+package com.zipcodewilmington.froilansfarm.abstractClasses;
+
+
+import com.zipcodewilmington.froilansfarm.interfaces.EdibleCrops;
+import com.zipcodewilmington.froilansfarm.interfaces.Produce;
+
+public abstract class Crop<EdibleCropsType extends EdibleCrops> implements Produce<EdibleCropsType> {
+    public boolean hasBeenFertilized = false;
+    public boolean hasBeenHarvested = false;
+    public void setHasBeenFertilized(boolean hasBeenFertilized){
+        this.hasBeenFertilized = hasBeenFertilized;
+    }
+
+    public void setHasBeenHarvested(boolean hasBeenHarvested){
+        this.hasBeenHarvested = hasBeenHarvested;
+    }
+
+
+    /*
+     * So here in Crop, Crop is also a generic, because we'll want each class
+     * inheriting it to specify what kind of Edible it will Produce, etc, etc.
+     * We went through a similar process with Eater.
+     *
+     * Anyway! The cool thing about Crop is that its
+     * type parameter upper bound is NOT Edible.
+     * It's EdibleCrops!
+     * By doing this, we'll be able to eliminate EdibleEgg as a possible thing
+     * our Crops can yield -- because EdibleEgg will not be inheriting EdibleCrops.
+     * AND we can still pass the EdibleCropsType into Produce because
+     * EdibleCropsType is an Edible!
+     * We are just using EdibleCrops to limit ourselves to a certain subset
+     * of Edibles we can use for Crops.
+     *
+     * >>> CornStalk
+     */
+
+}

src/main/java/com/zipcodewilmington/froilansfarm/abstractClasses/EdibleStorage.java

@@ -0,0 +1,9 @@
+package com.zipcodewilmington.froilansfarm.abstractClasses;
+
+import com.zipcodewilmington.froilansfarm.interfaces.Edible;
+
+import java.util.ArrayList;
+
+public abstract class EdibleStorage<EdibleType extends Edible> extends ArrayList<EdibleType> {
+
+}

src/main/java/com/zipcodewilmington/froilansfarm/abstractClasses/Housing.java

@@ -0,0 +1,38 @@
+package com.zipcodewilmington.froilansfarm.abstractClasses;
+
+import com.zipcodewilmington.froilansfarm.interfaces.Animal;
+
+import java.util.ArrayList;
+
+public abstract class Housing <AnimalType extends Animal> extends ArrayList<AnimalType> {
+
+    /*
+     * Housing is fun because you don't have to write anything in it
+     * and in the things that inherit it!!! :DDDDDDDD
+     *
+     * Housing is inheriting from ArrayList (extends ArrayList),
+     * so it inherits all of ArrayLists methods (add, remove, size, etc. etc.)
+     *
+     * The generics here are saying that Housing (and anything inheriting Housing)
+     * will hold (or be a list of, since it's inheriting from ArrayList)
+     * many certain somethings that is inheriting from Animal.
+     * That's this line here: Housing<AnimalType extends Animal>
+     * Since we want to be consistent, and since ArrayList itself is also a generic class,
+     * we put AnimalType as a type parameter for ArrayList (ArrayList<AnimalType>)
+     *
+     * We put this generic here because we want Housing to only ever handle things that
+     * are Animals!!!!
+     * By doing this, we make it so that it can't handle
+     * other things like Corn or Tractors or etc, etc, etc.
+     *
+     * Note: AnimalType here works like a method parameter name...
+     * ... except instead of name, it's data type
+     * So if you have any methods in here that uses/returns the animal,
+     * you would use AnimalType as the data type
+     *
+     * The method signature for the add method inherited from ArrayList would look like this:
+     * public boolean add(AnimalType animalToAdd);
+     *
+     */
+
+}

src/main/java/com/zipcodewilmington/froilansfarm/abstractClasses/Person.java

@@ -0,0 +1,22 @@
+package com.zipcodewilmington.froilansfarm.abstractClasses;
+
+import com.zipcodewilmington.froilansfarm.interfaces.Animal;
+import com.zipcodewilmington.froilansfarm.interfaces.Edible;
+import com.zipcodewilmington.froilansfarm.interfaces.Rideable;
+import com.zipcodewilmington.froilansfarm.interfaces.Rider;
+
+public abstract class Person implements Animal<Edible> {
+    @Override
+    public String makeNoise() {
+        return "What a great Day";
+    }
+
+    @Override
+    public boolean eat(Edible edible, EdibleStorage edibleStorage) {
+        if (edibleStorage.contains(edible)) {
+            return edibleStorage.remove(edible);
+        }
+        System.out.println("We don't got this!");
+        return false;
+    }
+}

src/main/java/com/zipcodewilmington/froilansfarm/classes/CropRow.java

@@ -0,0 +1,10 @@
+package com.zipcodewilmington.froilansfarm.classes;
+
+import com.zipcodewilmington.froilansfarm.abstractClasses.Crop;
+
+import java.util.ArrayList;
+
+public class CropRow<CropType extends Crop> extends ArrayList<CropType > {
+
+
+}

src/main/java/com/zipcodewilmington/froilansfarm/classes/Farm.java

@@ -0,0 +1,72 @@
+package com.zipcodewilmington.froilansfarm.classes;
+
+import com.zipcodewilmington.froilansfarm.classes.storage.*;
+
+import java.util.ArrayList;
+
+public class Farm {
+    ArrayList<Stable> stables;
+    ArrayList<ChickenCoop> coops;
+    FarmHouse farmHouse;
+    Field field;
+    TomatoStorage tomatoStorage;
+    PotatoStorage potatoStorage;
+    CornStorage cornStorage;
+    EggStorage eggStorage;
+
+    public Farm(FarmHouse farmHouse){
+        this.farmHouse = farmHouse;
+        this.stables = new ArrayList<>();
+        this.coops = new ArrayList<>();
+    }
+
+    public void addStables(Stable stable){
+        stables.add(stable);
+    }
+
+    public void addCoops(ChickenCoop coop){
+        coops.add(coop);
+    }
+
+    public ArrayList<Stable> getStables(){ return this.stables; }
+    public ArrayList<ChickenCoop> getCoops(){ return this.coops; }
+
+    public void setTomatoStorage(TomatoStorage tomatoStorage){
+        this.tomatoStorage = tomatoStorage;
+    }
+
+    public TomatoStorage getTomatoStorage(){
+        return this.tomatoStorage;
+    }
+
+    public void setPotatoStorage(PotatoStorage potatoStorage) {
+        this.potatoStorage = potatoStorage;
+    }
+
+    public PotatoStorage getPotatoStorage() {
+        return potatoStorage;
+    }
+
+    public void setCornStorage(CornStorage cornStorage) {
+        this.cornStorage = cornStorage;
+    }
+
+    public CornStorage getCornStorage() {
+        return cornStorage;
+    }
+
+    public void setEggStorage(EggStorage eggStorage) {
+        this.eggStorage = eggStorage;
+    }
+
+    public EggStorage getEggStorage() {
+        return eggStorage;
+    }
+
+    public Field getField(){
+        return this.field;
+    }
+    public void setField(Field field){
+        this.field = field;
+    }
+}

src/main/java/com/zipcodewilmington/froilansfarm/classes/Farmer.java

@@ -0,0 +1,72 @@
+package com.zipcodewilmington.froilansfarm.classes;
+
+import com.zipcodewilmington.froilansfarm.classes.food.CornStalk;
+import com.zipcodewilmington.froilansfarm.classes.food.PotatoPlant;
+import com.zipcodewilmington.froilansfarm.classes.food.TomatoPlant;
+import com.zipcodewilmington.froilansfarm.classes.rideables.Horse;
+import com.zipcodewilmington.froilansfarm.classes.rideables.Tractor;
+import com.zipcodewilmington.froilansfarm.interfaces.Botanist;
+import com.zipcodewilmington.froilansfarm.abstractClasses.Person;
+import com.zipcodewilmington.froilansfarm.interfaces.Rider;
+
+public class Farmer extends Person implements Botanist, Rider<Tractor,Horse> {
+
+    @Override
+    public boolean mount(Tractor tractor) {
+        if(tractor.isIfMounted() == false){ // is false cause nobody is on the tractor
+            tractor.setIfMounted(true);  //  the tractor is  mounted
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public boolean dismount(Tractor tractor) {
+        if(tractor.isIfMounted() == true){ // is true cause somebody is on the  tractor
+            tractor.setIfMounted(false);//  the tractor is not mounted
+            return true;
+        }
+        return false;
+    }
+
+
+    // boolean ifMounted = false; started the horse with nobody on the horse
+    @Override
+    public boolean mount(Horse horse) {
+        if(horse.getIfMounted() == false){ // is false cause nobody is on the horse
+            horse.setIfMounted(true);  //  the horse is  mounted
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public boolean dismount(Horse horse) {
+        if(horse.getIfMounted() == true){ // is true cause somebody is on the  horse
+            horse.setIfMounted(false);//  the horse is not mounted
+            return true;
+        }
+        return false;
+    }
+
+    // I forgot to ask dolio about theseeeee
+    // ideally you would not want to write plant n times like this
+    // supposed to use generics to make a general plant method
+    // for all types of valid crops
+    // i.e. plant(Crop crop, CropRow<Crop> cropRow)... or something like this
+    // but it was giving us grief so we forced it like so below :D
+    @Override
+    public boolean plant(TomatoPlant crop, CropRow<TomatoPlant> cropRow) {
+        return cropRow.add(crop);
+    }
+
+    @Override
+    public boolean plant(PotatoPlant crop, CropRow<PotatoPlant> cropRow) {
+        return cropRow.add(crop);
+    }
+
+    @Override
+    public boolean plant(CornStalk crop, CropRow<CornStalk> cropRow) {
+        return cropRow.add(crop);
+    }
+}

src/main/java/com/zipcodewilmington/froilansfarm/classes/Field.java

@@ -0,0 +1,12 @@
+package com.zipcodewilmington.froilansfarm.classes;
+
+import com.zipcodewilmington.froilansfarm.classes.food.CornStalk;
+import com.zipcodewilmington.froilansfarm.classes.food.PotatoPlant;
+import com.zipcodewilmington.froilansfarm.classes.food.TomatoPlant;
+
+import java.util.ArrayList;
+
+public class Field extends ArrayList<CropRow> {
+
+
+}

src/main/java/com/zipcodewilmington/froilansfarm/classes/Froilan.java

@@ -0,0 +1,5 @@
+package com.zipcodewilmington.froilansfarm.classes;
+
+
+public class Froilan extends Farmer {
+}

src/main/java/com/zipcodewilmington/froilansfarm/classes/Froilanda.java

@@ -0,0 +1,51 @@
+package com.zipcodewilmington.froilansfarm.classes;
+import com.zipcodewilmington.froilansfarm.abstractClasses.Person;
+import com.zipcodewilmington.froilansfarm.classes.rideables.CropDuster;
+import com.zipcodewilmington.froilansfarm.classes.rideables.Horse;
+import com.zipcodewilmington.froilansfarm.interfaces.Pilot;
+
+public class Froilanda extends Person implements Pilot {
+
+    boolean ifMounted = false; // no one mounted it
+
+    @Override
+    public boolean mount(CropDuster cropDuster) {
+        if(cropDuster.getIfMouted() == false){
+            cropDuster.setIfMouted(true);
+                    return true;
+        }
+
+
+        return false;
+    }
+
+    @Override
+    public boolean dismount(CropDuster cropDuster) {
+        if(cropDuster.getIfMouted() == true) {
+            cropDuster.setIfMouted(false);
+            return true;
+
+        }
+        return false;
+    }
+
+    @Override
+    public boolean mount(Horse horse) {
+        if(horse.getIfMounted() == false){
+            horse.setIfMounted(true);
+            return  true;
+        }
+        return false;
+    }
+
+    @Override
+    public boolean dismount(Horse horse) {
+        if(horse.getIfMounted() == true){
+            horse.setIfMounted(true);
+            return true;
+        }
+        return false;
+    }
+
+
+}