PBO-13 Implementasi Abstract Class Makhluk Hidup

Laporan mata kuliah Pemrograman Berorientasi Objek (A) - Pertemuan 13

Nama: Nabil Irawan

NRP: 5025241231

Kelas: Pemrograman Berorientasi Objek (A)

fajarbaskoro: PBO 2019 - Abstraksi Kelasfajarbaskoro

Laporan

Implementasi Abstract Class Makhluk Hidup

Soal 1

MakhlukHidup.java

Class ini memiliki method abstrak yang mewajibkan kelas turunannya Manusia, Hewan, Tumbuhan untuk mendefinisikan cara kerjanya sendiri.

Code:

abstract class MakhlukHidup {
    protected String nama;

    public MakhlukHidup(String nama) {
        this.nama = nama;
    }

    public void makan() {
        System.out.println(nama + " sedang memproses nutrisi untuk bertahan hidup.");
    }

    public abstract void bernafas();
}

class Manusia extends MakhlukHidup {
    public Manusia(String nama) {
        super(nama);
    }

    @Override
    public void bernafas() {
        System.out.println(nama + " bernafas menggunakan paru-paru.");
    }
}

class Hewan extends MakhlukHidup {
    public Hewan(String nama) {
        super(nama);
    }

    @Override
    public void bernafas() {
        System.out.println(nama + " bernafas.");
    }
}

class Tumbuhan extends MakhlukHidup {
    public Tumbuhan(String nama) {
        super(nama);
    }

    @Override
    public void bernafas() {
        System.out.println(nama + " bernafas melalui stomata dan lentisel.");
    }
}

public class MainMakhlukHidup {
    public static void main(String[] args) {
        Manusia andi = new Manusia("Andi");
        Hewan kucing = new Hewan("Kucing");
        Tumbuhan bunga = new Tumbuhan("Bunga Matahari");

        andi.makan();
        andi.bernafas();
        
        kucing.makan();
        kucing.bernafas();
        
        bunga.makan();
        bunga.bernafas();
    }
}

Soal 2

Simulasi Foxes and Rabbits memiliki duplikasi kode yang banyak antara kelas Fox dan Rabbit. Keduanya memiliki umur, lokasi, status hidup/mati, dan referensi ke Field. Untuk mengubahnya menjadi struktur Abstract Class, perlu membuat superclass bernama Animal untuk menampung kode yang sama.

Animal.java

Code:

import java.util.List;

public abstract class Animal {
    protected boolean alive;
    protected Location location;
    protected Field field;

    public Animal(Field field, Location location) {
        this.alive = true;
        this.field = field;
        setLocation(location);
    }

    public boolean isAlive() {
        return alive;
    }

    protected void setDead() {
        alive = false;
        if(location != null) {
            field.clear(location);
            location = null;
            field = null;
        }
    }

    protected void setLocation(Location newLocation) {
        if(location != null) {
            field.clear(location);
        }
        location = newLocation;
        field.place(this, newLocation);
    }
    
    protected Location getLocation() {
        return location;
    }

    abstract public void act(List<Animal> newAnimals);
}

Rabbit.java

Code:

import java.util.List;
import java.util.Random;

public class Rabbit extends Animal {
    private static final int BREEDING_AGE = 5;
    private static final int MAX_AGE = 40;
    private int age;
    private static final Random rand = new Random();

    public Rabbit(boolean randomAge, Field field, Location location) {
        super(field, location);
        age = 0;
        if(randomAge) {
            age = rand.nextInt(MAX_AGE);
        }
    }

    @Override
    public void act(List<Animal> newAnimals) {
        incrementAge();
        if(isAlive()) {
            giveBirth(newAnimals);            
            Location newLocation = field.freeAdjacentLocation(location);
            if(newLocation != null) {
                setLocation(newLocation);
            } else {
                setDead();
            }
        }
    }

    private void incrementAge() {
        age++;
        if(age > MAX_AGE) {
            setDead();
        }
    }
    
    private void giveBirth(List<Animal> newAnimals) {
    }
}

Fox.java

Code:

import java.util.List;
import java.util.Random;

public class Fox extends Animal {
    private static final int BREEDING_AGE = 15;
    private static final int MAX_AGE = 150;
    private int age;
    private int foodLevel;
    private static final Random rand = new Random();

    public Fox(boolean randomAge, Field field, Location location) {
        super(field, location);
        age = 0;
        if(randomAge) {
            age = rand.nextInt(MAX_AGE);
        }
    }

    @Override
    public void act(List<Animal> newAnimals) {
        incrementAge();
        incrementHunger();
        if(isAlive()) {
            giveBirth(newAnimals);            
            Location newLocation = findFood();
            if(newLocation == null) { 
                newLocation = field.freeAdjacentLocation(location);
            }
            
            if(newLocation != null) {
                setLocation(newLocation);
            } else {
                setDead();
            }
        }
    }
    
    private void incrementHunger() {
        foodLevel--;
        if(foodLevel <= 0) setDead();
    }

    private void incrementAge() {
        age++;
        if(age > MAX_AGE) setDead();
    }
    
    private Location findFood() {
        return null;
    }
    
    private void giveBirth(List<Animal> newAnimals) {
    }
}

Location.java

Code:

public class Location {
    private int row;
    private int col;

    public Location(int row, int col) {
        this.row = row;
        this.col = col;
    }

    public int getRow() {
        return row;
    }

    public int getCol() {
        return col;
    }

    @Override
    public boolean equals(Object obj) {
        if(this == obj) {
            return true;
        }
        if(!(obj instanceof Location)) {
            return false;
        }
        Location other = (Location) obj;
        return row == other.getRow() && col == other.getCol();
    }

    @Override
    public int hashCode() {
        return (row << 16) + col;
    }
}

Field.java

Code:

import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
import java.util.Random;

public class Field {
    private static final Random rand = new Random();
    private int depth, width;
    private Object[][] field;

    public Field(int depth, int width) {
        this.depth = depth;
        this.width = width;
        field = new Object[depth][width];
    }

    public void clear() {
        for(int row = 0; row < depth; row++) {
            for(int col = 0; col < width; col++) {
                field[row][col] = null;
            }
        }
    }

    public void clear(Location location) {
        field[location.getRow()][location.getCol()] = null;
    }

    public void place(Object animal, int row, int col) {
        place(animal, new Location(row, col));
    }

    public void place(Object animal, Location location) {
        field[location.getRow()][location.getCol()] = animal;
    }

    public Object getObjectAt(Location location) {
        return getObjectAt(location.getRow(), location.getCol());
    }

    public Object getObjectAt(int row, int col) {
        return field[row][col];
    }

    public Location freeAdjacentLocation(Location location) {
        List<Location> adjacent = adjacentLocations(location);
        for(Location next : adjacent) {
            if(getObjectAt(next) == null) {
                return next;
            }
        }
        return null;
    }

    public List<Location> adjacentLocations(Location location) {
        assert location != null : "Null location passed to adjacentLocations";
        List<Location> locations = new LinkedList<>();
        if(location != null) {
            int row = location.getRow();
            int col = location.getCol();
            for(int roffset = -1; roffset <= 1; roffset++) {
                int nextRow = row + roffset;
                if(nextRow >= 0 && nextRow < depth) {
                    for(int coffset = -1; coffset <= 1; coffset++) {
                        int nextCol = col + coffset;
                        if(nextCol >= 0 && nextCol < width && (roffset != 0 || coffset != 0)) {
                            locations.add(new Location(nextRow, nextCol));
                        }
                    }
                }
            }
            Collections.shuffle(locations, rand);
        }
        return locations;
    }

    public int getDepth() {
        return depth;
    }

    public int getWidth() {
        return width;
    }
}

Simulator.java

Code:

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Random;

public class Simulator {
    private static final int DEFAULT_WIDTH = 50;
    private static final int DEFAULT_DEPTH = 50;
    private static final double FOX_CREATION_PROBABILITY = 0.02;
    private static final double RABBIT_CREATION_PROBABILITY = 0.08;

    private List<Animal> animals;
    private Field field;
    private int step;

    public static void main(String[] args) {
        Simulator simulator = new Simulator();
        simulator.runLongSimulation();
    }

    public Simulator() {
        this(DEFAULT_DEPTH, DEFAULT_WIDTH);
    }

    public Simulator(int depth, int width) {
        if(width <= 0 || depth <= 0) {
            System.out.println("The dimensions must be greater than zero.");
            System.out.println("Using default values.");
            depth = DEFAULT_DEPTH;
            width = DEFAULT_WIDTH;
        }
        
        animals = new ArrayList<>();
        field = new Field(depth, width);
        reset();
    }

    public void runLongSimulation() {
        simulate(500);
    }

    public void simulate(int steps) {
        for(int i = 1; i <= steps && !animals.isEmpty(); i++) {
            simulateOneStep();
        }
    }

    public void simulateOneStep() {
        step++;
        System.out.println("Step: " + step + " Population: " + animals.size());
        
        List<Animal> newAnimals = new ArrayList<>();
        
        for(Iterator<Animal> it = animals.iterator(); it.hasNext(); ) {
            Animal animal = it.next();
            if(animal.isAlive()) {
                animal.act(newAnimals);
            } else {
                it.remove();
            }
        }
               
        animals.addAll(newAnimals);
    }

    public void reset() {
        step = 0;
        animals.clear();
        field.clear();
        populate();
    }

    private void populate() {
        Random rand = new Random();
        field.clear();
        for(int row = 0; row < field.getDepth(); row++) {
            for(int col = 0; col < field.getWidth(); col++) {
                if(rand.nextDouble() <= FOX_CREATION_PROBABILITY) {
                    Location location = new Location(row, col);
                    Fox fox = new Fox(true, field, location);
                    animals.add(fox);
                }
                else if(rand.nextDouble() <= RABBIT_CREATION_PROBABILITY) {
                    Location location = new Location(row, col);
                    Rabbit rabbit = new Rabbit(true, field, location);
                    animals.add(rabbit);
                }
            }
        }
    }
}

Proof:

Done.