Query on Design

Question

Hi,
I have a class namely MyClass. This has three overloaded public methods namely addNode(), addNode(String) and addNode(int).
Requirement:
I need a specialized class namely PrintMyClass derived from MyClass which will support the following:
1. It should provide an extra overloaded method namely addNode(Object). Now, this method will inturn invoke the addNode() in the super and do something extra as well - say printing 'Hi' on console (It does something with the argument Object as well, so this overloaded method needs to be provided). This printing on the console is not provided by methods in the base class.
Query:
Is there any means by which we can hide the addNode(), addNode(String) and addNode(int) methods in the base class?
Here is what I mean:
PrintMyClass class = new PrintMyClass();
class.addNode("new String instance");
Now, this will invoke the addNode from base class and then print 'Hi' on the console. This is expected behavior.
Now when I do the following:
class.addNode();
This will invoke the method from the base class and nothing will be printed in the console. This is not correct.
One way is that we override all the addNode() methods in the base class and ensure that something is printed in the console. This is tiresome as there can be many such overloaded methods of addNode()?
Other way is to hide the addNode() methods inthe base class somehow... I am not sure how to go about in this case... This is against OOPS principles. Is there any design pattern or technique by which this can be achieved? We can get a somewhat similar effect by using Composition; however this is not acceptable.
Please guide.
Regards,
Jay

Answer 1

So for instance
class Node {
     public Node() { ... }
     public Node(String s) { ... }
     public Node(int i ) { ... }
public Nodez0r extends Node {
     public Nodez0r(Object o) {
          super.node();
          // or
          super.node((String) o);
          //or
          super.node((Integer) o);
}Is this something like what you need