CODEWITHSUNDEEP
c#javaoop
user1088875
user1088875

Reputation: 33

Is there a way to hide/show certain methods when instantiating an object?

This question came to mind while I was writing a class that iterates over a list, with methods next() and previous() that will continuously loop (e.g. if at the last object, return it, and then reset index to 0)

In the constructor I was pondering adding a boolean variable, which if true would just act like a regular iterator with only next() methods and no looping. In this case, having the method previous() would make no sense. So I'm curious, is it possible to hide the previous() method in this case. Is it possible to achieve this somehow in Java or C#?.

What about other languages?

Upvotes: 3

Views: 260

Answers (5)

Stephen C
Stephen C

Reputation: 719004

It is not possible to hide a method like that in a statically typed language. The best you can do is implement the method to throw an exception (or equivalent) if the method is called.

There are tricks that you can do to make it appear like the methods are not there. For instance, having the class implement two interfaces, and using different factory methods to create them. However, they don't work if the constructor is used directly, or if you want the choice to be determined by the value of a constructor or factory method parameter.

Upvotes: 2

Jon
Jon

Reputation: 437454

C#

It is possible by making the two methods part of two different interfaces, and casting the object to one of the two interfaces. For example:

interface ILoopingIterator
{
    void Next();
    void Previous();
}

interface INonLoopingIterator
{
    void Next();
}

class PlaysItBothWays : ILoopingIterator, INonLoopingIterator
{
    void ILoopingIterator.Next()
    {
         this.NextCore();
    }

    void ILoopingIterator.Previous()
    {
         // since this code will never be shared anyway, put it here
    }

    void INonLoopingIterator.Next()
    {
         this.NextCore();
    }

    private void NextCore()
    {
        // do stuff here; this method only exists so that code can be shared
    }
}

Note that I have made the class implement both interfaces explicitly; this way, users of instances are forced to select which "mode" they want to use the class in. You could implement only one interface explicitly instead (providing a "default" mode that can be changed).

and now:

var looping = (ILoopingIterator) new PlaysItBothWays(); // selects mode A
var nonLooping = (INonLoopingIterator) new PlaysItBothWays(); // selects mode B

Of course this does not stop anyone from casting the instance to the "other" interface if they want to, but if the programmer wants to subvert their own code they can also use reflection which allows much more than that.

Java

In Java, the above is not possible. You can come close by having the class expose methods that return instances of one of the two interfaces, and using the returned value. Of course then the object is really a factory and not a service provider, so that's feels like cheating on the problem.

class PlaysItBothWays
{
    public ILoopingIterator asLooping() { return /* something */ }
    public INonLoopingIterator asNonLooping() { return /* something else */ }
}

Upvotes: 6

Ilia G
Ilia G

Reputation: 10211

You can't hide class members at run time (well, not in C# anyway - not sure about Java). If you so worried about Previous() method being used in the context where it is not doing anything useful, then simply have it throw InvalidOperationException in that case.

It is also worth noting that .NET already has standard "iterator" interface. It is called IEnumerable (and generic version IEnumerable<T>) and is forward-only.

Upvotes: 0

wsanville
wsanville

Reputation: 37516

Rather than passing a boolean to a constructor, you should simply use inheritance.

Suppose you have a base iterator that supports only next(). If that's the only functionality you need, instantiate it.

To provide more functionality, inherit from this base iterator, make a class called TwoWayIterator or something like that, and provide a previous() method.

Both of these classes will share a common super class, so you can treat them as one, and you can hide the previous() method by treating an instance as its base class.

Upvotes: 4

Alejandro Diaz
Alejandro Diaz

Reputation: 431

Not in Java. You can't "Hide" methods at runtime. I'd suggest you to create Two interfaces , one with the next method and the other one extending the first one and adding the "previous" method. Then, you can have 2 factories methods to create an instance of one of these classes.

Please take a look to the Java "Iterator" class

interface Iterator<T> {
    T next();
}

interface LoopingIterator<T> extends Iterator<T>{
    T previous();
}

Then you can cast them. Similar to the previous C# answer

Upvotes: 0

Related Questions