使用哪种设计模式（主动和被动方法）？

Question

I have a player which can feed a dog or chop a tree .

Below are the classes I have written:

public class Dog {

    private int health;

    public void feed(Food food){
        health = health + food.getNutritionalValue();
    }
}

public class Player{

    public void feed(Dog dog, Food food) {
        dog.feed(food);
    }

Player and Dog both have methods that are "active" .

Player feeds the dog and dog starts eating the food (I am not really sure if it is good to couple methods in this way).

On the other hand, I have tree . And player is able to chop the tree.

public class Player{

public void chop(Tree tree) {
        //At this point I am not sure
    }

I am not sure if I would use getters and setters of Tree class to interact with the Tree.

Or if I should write an own method for this because the tree gets chopped so it is nothing really active I would call.

So, in the end, there would be two or more kinds of implementations but the two I am thinking of are:

tree.setAmountofWood = x

or

tree.gettingChopped(Damage int)

I think I should make an own method for this chopping-process .

Or is there any design principle I should follow?

Answer 1

I would start from something like this.

Tree can grow and receive damage.

public class Tree {
    private int lumber;

    public Tree(int size) {
        this.lumber = size;
    }

    public void grow() {
        this.lumber++;
    }

    public void grow(int size) {
        this.lumber += size;
    }

    public int receiveDamage(int damage) {
        int lumber = 0;
        if (damage > this.lumber) {
            lumber = this.lumber;
            this.lumber = 0;
        } else {
            lumber = damage;
            this.lumber -= damage;
        }
        return lumber;
    }
}

Food just stores nutritional value.

public class Food {
    private int nutrition;

    public Food(int nutrition) {
        this.nutrition = nutrition;
    }

    public int getNutritionalValue() {
        return this.nutrition;
    }
} 

I'm not sure if all types of player can chop trees, so I created a class to separate responsibilities. You can move methods to the Player class if you like.

public class Woodcutter extends Player {
    public int chop(Tree tree) {
        // lumber amount may depend on a tool,
        // i.e. axe, chainsaw, etc.
        return tree.receiveDamage(10);
    }

    // fell down the tree
    public int fell(Tree tree) {
        int result = 0;
        int lumber = 0;
        do {
            lumber = chop(tree);
            result += lumber;
        } while (lumber > 0);
        return result;
    }
}

Somewhere in your code

// create a tree and let it grow for a while
Tree tree = new Tree(10);
tree.grow(90);

// Start chopping
Woodcutter woodcutter = new Woodcutter();
System.out.println("Lumber received: " + woodcutter.chop(tree));
System.out.println("Lumber received: " + woodcutter.fell(tree));

Dog dog = new Dog();
Food food = new Food(5);
woodcutter.feed(dog, food);

Answer 2

I wouldn't dive into passive/active methods here. An 'active tree' may indeed be a misnomer.

I would rather consider calling an object's method as passing a message to the object. And you apparently need to send the message to the tree that it is currently being cut by someone, and let the tree decide when to eg fall() or to bend() , or to shake() .

The tree has some internal state ( strength ? thickness of its trunk? health ?). 'Sending a message ' to the tree means to call its method, eg beingCut() , which in turn deteriorates the state of the tree. After the state of the tree reaches a certain limit, other actions (=consequences of tree's bad state) may be started by the tree .

Of course, as in every iteration of your main loop you tree has also the chance to get the message to grow() , so its state may improve a little each time, so eventually it may even recover from being only partially cut and reach its initial, perfect state back.

So, yes, while trees seem rather passive, they still react to messages/stimulus. :-)

Answer 3

I see 3 principles here,

1. SRP - It is the responsibility of the Tree to get chopped and fall down, but to cut is the responsibility of the Person!
2. Demeter's law - looks good from my POV.
3. OCP - The tree must be able to do further actions when get cut.

So you must use

tree.gettingChopped(Damage damage)

To your code:

1. The method Dog.feed is wrong, rename it to Dog.eat because the Dog is not feeding, the dog is eating. By the way, the food must reduce its NutritionalValue .
2. The health is an integer value, this is bad because in reality there is nothing like a numeral health. We may have a handicapped numeral value in percent, but this is more a byte who not can be in negative value. You should create a custom class for the Health! This way your code is open(OCP) for extensions like to be toxified or depresive.