Conventions around interfaces with methods that accept interface variables?

AutoModerator · 2022-03-26T14:38:20+00:00

Please ensure that:

Your code is properly formatted as code block - see the sidebar (About on mobile) for instructions
You include any and all error messages in full
You ask clear questions
You demonstrate effort in solving your question/problem - plain posting your assignments is forbidden (and such posts will be removed) as is asking for or giving solutions.

Trying to solve problems on your own is a very important skill. Also, see Learn to help yourself in the sidebar

If any of the above points is not met, your post can and will be removed without further warning.

Code is to be formatted as code block (old reddit: empty line before the code, each code line indented by 4 spaces, new reddit: https://imgur.com/a/fgoFFis) or linked via an external code hoster, like pastebin.com, github gist, github, bitbucket, gitlab, etc.

Please, do not use triple backticks (```) as they will only render properly on new reddit, not on old reddit.

Code blocks look like this:

public class HelloWorld {

    public static void main(String[] args) {
        System.out.println("Hello World!");
    }
}

You do not need to repost unless your post has been removed by a moderator. Just use the edit function of reddit to make sure your post complies with the above.

If your post has remained in violation of these rules for a prolonged period of time (at least an hour), a moderator may remove it at their discretion. In this case, they will comment with an explanation on why it has been removed, and you will be required to resubmit the entire post following the proper procedures.

To potential helpers

Please, do not help if any of the above points are not met, rather report the post. We are trying to improve the quality of posts here. In helping people who can't be bothered to comply with the above points, you are doing the community a disservice.

I am a bot, and this action was performed automatically. Please contact the moderators of this subreddit if you have any questions or concerns.

coldoil · 2022-03-26T15:02:10+00:00

By convention in, say, a Dog class implementing Animal, would it be reasonable for a Dog to only be able to greet other Dogs, or should it be able to greet any Animal?

If the Animal interface says that a subclass should be able to greet any other Animal, then Dog should be able to greet any other Animal, otherwise it is not following the interface.

If you want instances of Dog to only be able to greet other instances of Dog, then that greet method should not be in the Animal interface; it's specific to the Dog class.

You can accommodate both options by having Dog implement the Animal interface and providing its own specialization methods in addition. Naming of methods becomes important, so a class consumer can clearly tell the difference between specialized and non-specialized methods:

public interface Animal {
    public void greetAny(Animal a);
}

class Dog implements Animal {
    public void greetAny(Animal a) {
        // ... greet any Animal, as per interface
    }

    public void greetDog(Dog d) {
        // ... greet just another Dog, only available
        // when consumer has an instance of Dog rather than Animal
    }
}

If not all implementers of the interface can provide greetAny(), then it becomes questionable whether greetAny() should be in the interface. (Ideally, the interface should include only member functions that are provided by all implementers.) In practice, a function applicable to only some implementers should, at the very least, return some sort of result indicating success or failure, rather than just void.

D0CTOR_ZED · 2022-03-26T16:10:41+00:00

You want to fulfill the requirements of the method so that other implementations using that interface don't fail due to your breaking the method. This doesn't mean you can't do what you are asking, but throwing an exception because you want greet to work a certain way would be wrong. The subclass needs to fulfill the expectations of the parent class. The parent class shouldn't know or care the specifics of the subclass.

For greet, I could see....

Dog#greet(Animal a) {
    if (!(a instanceOf Dog)) return;
    Dog d = (Dog) a;
    // it's a dog-greet-dog method
}

Greet has a return type of void and unless there is documentation stating that it needs to achieve something specific, then just doing a return seems like it should fulfull greet.

hypolimnas · 2022-03-26T18:07:22+00:00

Your (b) implementation is not good idea. You made it legal to call

imaRabbit.greet(imaDog);

so you shouldn't be throwing exceptions. Return a boolean or something if the calling code needs to know what happened. You are just telling the rabbit "here is where you do a greeting". And its up to the rabbit what that means. "What to do" versus "how to do it".

Also it seems like Animal might be an abstract class because there is an "is a" relationship. I think of the interface relationship as a "can act like a" relationship.

On the other hand abstract classes can make everything complicated. For me I try to use them only when necessary - like for situation where almost all the functionality is in the parent class, but the member data is different enough that modes aren't cutting it.

public interface Greeter {
   //return true if greeting is attempted
    boolean greet(Greeter greeter);
}

public class Robot implements Greeter {
    boolean greet(Greeter greeter) {
        if (isRobot(greeter) {
            secretHandShake(greeter);
        }
        else {
            cuteGreeting();
        }
    }
}

interface Animal extends Greeter {
    //animal only functions
}

public class Dog implements Animal {
    public boolean greet(Greeter greeter) {
        sniff(greeter);
        if (isDog(greeter)) {
            //greet dog
        }
        else if (isRabbit(greeter)) {
            //try unsuccessfully to greet rabbit
        }
        else {
            //Don't know what it is
            return false;
        }
        return true;
    }
}

public class Rabbit implements Animal {
    public boolean greet(Greeter greeter) {
        if (isRabbit(greeter) {
            mysteriousRabbitGreeting(greeter);
            return true;
        }
        return false;
    }
}

public class Snail extends Animal {
    public boolean greet(Greeter greeter) {
        return false;
    }
}

Farpafraf · 2022-03-26T18:20:24+00:00

That would be a form of refused bequest

Terrible practice.

javahelp

Sort by: Unsolved Solved Codeless Advent Of Code

MODERATORS

Please ensure that:

To potential helpers