Hiding methods

Hello again world.
Let me first say that I have searched the forum for previous discussions of this topic. Since they just added to my confusion, please allow me to start from square zero.
According to the Java Language Specification:
If a class declares a static method, then the declaration of that method is said to hide any and all methods with the same signature in the superclasses and superinterfaces of the class that would otherwise be accessible to code in the class.
But, the following code:
public class Hide
public static void main(String[] params)
    Alpha alpha = new Alpha();
    Beta beta = new Beta();
    alpha.hiddenMethod();
    alpha.overriddenMethod();
    beta.hiddenMethod();
    beta.overriddenMethod();
    Alpha chi = beta;
    chi.hiddenMethod();
    chi.overriddenMethod();
class Alpha
public static void hiddenMethod()
     System.out.println("Alpha Hide"); // I don't see where this is hidden from anything
public void overriddenMethod()
     System.out.println("Alpha Ride");
class Beta extends Alpha
public static void hiddenMethod()
     System.out.println("Beta Hide");
public void overriddenMethod()
     System.out.println("Beta Ride");
     super.hiddenMethod();
     super.overriddenMethod();
}produces the following output:
Alpha Hide
Alpha Ride
Beta Hide
Beta Ride
Alpha Hide
Alpha Ride
Alpha Hide this is the line I don't understand
Beta Ride
Alpha Hide
Alpha Ride
If anything looks hidden, it looks like "chi.hiddenMethod()" is hidden from itself - which I think is the opposite of what the Spec says.The way I interpret the Spec is that the call "super.hiddenMethod()" should either fail or call Beta's method if Alpha.hiddenMethod() has truely been hidden from chi's scope.
So my question is in two parts:
1. What am I missing?
2. What practical use is there in hiding methods anyhow? Since hiding is said to only work with static methods, why bother hiding? If you need it, invoke the static method with a class name qualifier. If you don't need it, don't code it.
I'm confused.
Thank you one and all.
Ciao for now

There is a big difference:
Overriding:
There is no way to invoke the
overriddenMethod() method of class Alpha
for an instance of class Beta from outside
the body of Beta, no matter what the type of
the variable we may use to hold the reference to the
object.
Hiding:
It is allways possible to invoke the
hiddenMethod() method of class Alpha for
an instance of class Beta from outside
the body of Beta.
Hope that helps a bit.Given that, and what you observed in your test program, I can see why the term "hiding" is confusing. After all, it looks like the static method is the one that's not hidden, since you can get to it if you want to.
I think the idea is that the child class' method "hides" that of the parent class--i.e. if you call Child.hidden() on a Child class that doesn't have its own version of that static method, you'll get the one in the parent class, but if you call Child.hidden() on a child class that has its own version, its version "hides" the parent's version. You can still get to the parent's version by calling Parent.hidden, but from that one perspective of the Child class, Parent's method has been hidden. So from Child's perspective, if Child doesn't have its own method, it sees the parent's, and if it does, its version hides that of Parent.
That description (except for the part about being able to get to the Parent method) could apply equally well to an overridden method--that is, if the terms were switched, it wouldn't necessarily make any less sense than it does now.
So why are the terms applied the way they are? I don't know, but I hope that, even if you don't think "hiding" is the best term for what's going on, you can see that there's at least some logic behind it.
¶

Similar Messages

Hiding methods and attributes while inheriting

Hello All,
This is kinda urgent. While making a subclass I want to block access to methods and attributes of super class when anone creates an object of sub-class. In my particular situation I cannot override the methods.
Let me explain it with an example:
I have a class A which contains an attribute of type Object. All the methods accept Object type parameters and act accordingly. Now I want to create a sub-class B which acts on Strings only. I can create a wrapper to class A but I want to add some behavior which is specific to strings and use rest of the behavior as in class A. I cannot override the methods of class A because they take Objects as parameters whereas in class B the same methods take string as parameters.
I hope you have understood the problem. Please reply ASAP.
Thanks in advance

Sorry the diagram turned out wrong. ObjectClass and StringClass are both supposed to be derived
from the AbstractBaseClass.
This method is one way to achieve what you want. You make an AbstractBaseList class that has only
protected methods that take objects.
To implement a generic Object version of this class you extend it and override the protected methods in
the AbstractBaseList class to make them public.
To implement a String list you extend the AbstractBaseList class and override the protected methods to
make them public (but change the type of the parameters).
The only problem with this approach is that the return types of the methods cannot be changed. Therefore
I recommend the AbstractBaseList implement a method called
protected Object getByIndex(int i) {
// do list type stuff in here
Then the ObjectList can implement
public Object get(int i) {
return super.getByIndex(i);
and the StringList can implement
public String get(int i) {
return (String) super.getByIndex(i);
In effect all you need to do is to implement wrapper classes that enforce type casting on the Object based
set/get values.
Another option is to use JDK1.5 with its generics classes. These effectivly allow you to specify which type of
object an instance of a class accepts.
Another question. What is the matter with the Collections classes provided in the JDK?
matfud

Isn't this a typo error?

http://java.sun.com/docs/books/tutorial/java/IandI/override.html
Here's some code that's been posted on here before:
public class Animal {
    public static void testClassMethod() {
        System.out.println("The class method in Animal.");
    public void testInstanceMethod() {
        System.out.println("The instance method in Animal.");
public class Cat extends Animal {
    public static void testClassMethod() {
        System.out.println("The class method in Cat.");
    public void testInstanceMethod() {
        System.out.println("The instance method in Cat.");
    public static void main(String[] args) {
        Cat myCat = new Cat();
        Animal myAnimal = myCat;
        Animal.testClassMethod();
        myAnimal.testInstanceMethod();
}Based on what that lesson was trying to teach shouldn't the line
Animal.testClassMethod();be written as
myAnimal.testClassMethod();???

I didn't ignore this thread, just took a rest as it was late for me, sorry. Thx for the replies. However, what you've replied I've no problem in understanding. I get the point that instances of a class belong to an object whereas members of a class belong to the class. It's just that I thought the author of that lesson meant the line
Animal.testClassMethod();to be
myAnimal.testClassMethod();My reasoning was the topic of the lesson itself, "Overriding and Hiding Methods". An important point of that lesson is the following:
The distinction between hiding and overriding has important implications. The version of the overridden method that gets invoked is the one in the subclass. The version of the hidden method that gets invoked depends on whether it is invoked from the superclass or the subclass. Let's look at an example that contains two classes.As a reader at this point I'm thinking the author is going to demonstrate the above quote with the following two classes
public class Animal {
    public static void testClassMethod() {
        System.out.println("The class method in Animal.");
    public void testInstanceMethod() {
        System.out.println("The instance method in Animal.");
public class Cat extends Animal {
    public static void testClassMethod() {
        System.out.println("The class method in Cat.");
    public void testInstanceMethod() {
        System.out.println("The instance method in Cat.");
    public static void main(String[] args) {
        Cat myCat = new Cat();
        Animal myAnimal = myCat;
        Animal.testClassMethod();
        myAnimal.testInstanceMethod();
}Well, how does the line "Animal.testClassMethod();" demonstrate the above quote? It doesn't. It simply makes a direct call to a static method using its full name. It has nothing at all to do with objects, so yes, if you remove the other three lines in main() this one still works. Now if you change that line to "myAnimal.testClassMethod();" it still calls the static method from the superclass! But why? Afterall "myAnimal" holds a reference to a Cat! And so the line from the above quote,
The version of the hidden method that gets invoked depends on whether it is invoked from the superclass or the subclass.rings in my mind. So, overall I'm thinking there's a typo here and that the author meant "myAnimal.testClassMethod();". Well? I'm just being curious.

Overriding and hiding a method.. the difference?

hello,
the text says that "...a subclass cannot override methods that are declared static in the superclass. In other words, a subclass cannot override a class method. A subclass can hide a static method in the superclass by declaring a static method in the subclass with the same signature as the static method in the superclass"
what does this mean? i don't see the difference between this overriding and hiding of the methods? is it just the concepts??
what's the difference when i have a non-static method in the superclass overridden by a non-static method in the sub class and when i have a static method hidden by a static method in the subclass?

over-riding means that you declare an implemenation of some method on the current class that over-rides the implemenation inherieted from your superclass. Over-riding the toString method to print customer data would be a good example- the implemenation on the current class will be invoked, instead of the superclass. Because static methods are bound to a class, rather then instance, they can not be over-ridden. Instead, you can only replace that method with a method of same signature and name. Maybe this code makes it more clear:
Object arg = MyClass.getInstance();
//the implemenation of MyClass.toString will be
//invoked if it is over-ridden, even though Object.toString
//is being referenced
arg.toString();But, static methods, like Class.method() and SubClass.method(), have no inherieted functionality- they are totally unique methods that simply share the same name. I'm not sure if this explanation makes it clear or not, but the operative point is, there's no functional relationship between static methods.

Hiding inherited methods

hi,
I need to know how to hide a method from a subclass because it doesn't need it at all. I think using aggregation will solve the problem but how? do you have any examples regarding this please?
For example, if the class Dog defines the properties "bark," "fetch," and "eat food" then a class Cat can be derived from Dog by hiding "bark" and "fetch" and adding "purr" and "sleep." And then "bark" shouldn't appear in the Cat class, is using aggregation solve the problem? by putting the class Cat as "whole" and class Dog as its "part".

Poor design, poor use of inheritance. Cats aren't dogs, simple as that. This relationship is meaningless. Cat and Dog could be subclasses of Animal, which could have a method 'makeNoise' that both Cat and Dog could implement with their own noise. But a cat isn't a special kind of dog, so inheritance makes no sense here. Further, if you think something should be a subclass, but you have to find some way of getting rid of some methods from the superclass, chances are it isn't a subclass at all

Hiding an abstract method

Hi,
I have an abstract class with two methods, one of which is abstract and should be implemented by subclasses.
abstract class Foo() {
    abstract double calculateParameter();
    final double getParameter() {
        if (hasBeenCalculated) {
            // get parameter from somewhere
        else {
            calculateParameter();
}My problem is that if I create a class that inherits from Foo, I don't want the method calculateParameter() to be accessible/visible. To get the parameter only the getParam() should be used.
Foo obj = new Foo();
obj.calculateParameter(); // I don't want this to work
obj.getParameter(); // This should work (and works)Any ideas how to hide the calculateParameter() method?
Wouter

wSchakel wrote:
Don't really understand the 2nd method, but the 1st worked. Decided to split my application into a fixed package (including the super) and a user defined package (including the sub). Thanks.Method 2 would be like:
public interface Pirate {
     //All pirates can yarr.
     public void yarr();
public class PirateImpl implements Pirate {
     @Override
     public void yarr() {
          System.out.println(avast());
     //This pirate doesn't like people to know how he yarrs, so he hides it.
     public int avast() {
          return 1;
//Meanwhile, in the main method:
public static void main(String[] args) {
     Pirate p = new PirateImpl();
     p.yarr(); //ok
     p.avast(); //compiler goes :(
}

Hiding business-logic methods from the SOAP Client

Hello,
Is there any way to hide a method from the SOAP Client.
For Example, Lets say I have two methods in my object Foo. And the client of this web-service can create Foo thru SOAP API. The method are:
public String getName();
public Group getGroup();
I want the SOAP client to see the Foo object only with getName() and not getGroup().
Can I control this thru Java2Wsdl or something else?
Thanks,
Neeta.

You can use source2wsdd with @wlws:exclude tag for the methods you want to hide.

Access Modifiers Effect on Static Method Hiding Question

I am studying for my SCJP exam and have come across a question that I do not understand and have not yet found a satisfactory explanation.
Given:
package staticExtend;
public class A{
     private String runNow(){
          return "High";
     static class B extends A{
          public String runNow(){
               return "Low";
     public static void main(String args[]){
          A[] a=new B[]{new B(),new C()};
          for(A aa:a)
               System.out.print(aa.runNow()+" ");
class C extends A.B{
     public String runNow(){
          return "Out";
}The output is "High High". The explanation in the sample exam from ExamLab was that because the runNow() method in A was private that only an explicit cast to the B class would invoke the runNow() method in B. I have verified that that is the case, but am not clear on how the runNow() method being declared static in B and how the private access modifier in A results in this behaviour.
Any additional explanation would be greatly appreciated.
Thanks in advance.
-- Ryan

Ryan_Chapin wrote:
OK, so since runNow() in A is private the compiler determines that regardless of the available methods in any of it's sub classes that since we declared the original array reference as "A" that it will invoke the runNow() in A. It's also due to the fact that the invocation came from within A. You would have gotten a compile time error if you tried to place the code in the main method in another class.
>
My mistake about the second part that you mention. You are correct. runNow() in B is NOT static, but the class is static. I guess that was the red herring in this question I don't see how that is related. I actually think that the "red herring" was what I described above. The fact that the code was placed in A, and that private methods can't be overridden.
and the fact that the class itself is static has nothing to do with the behaviour that is being illustrated. Is that correct?Correct

Question about static method hiding

I undestand that a static method may only be hidden in a subclass not overridden. But, I don't understand why an exception type thrown by the subclass method must be a subtype of the exception type thrown by the superclass method. For example,
public class A {
public static void foo() throws ExceptionA { }
public class B extends A {
public static void foo() throws ExceptionB { }
gives a compile-time error if ExceptionB is not a subclass of ExceptionA. This makes perfect sense in the non-static case but what does it matter here?
Thanks,
Tim

I don't understand your point. In either case, static
or non-static, ExceptionB must be the same or a
subclass of ExceptionA. My question is why this
matters in the static case.I think it's for binary compatibility, that is, so that you can make changes to Java source files and recompile only the changed files. If you originally did not have the static method in class B, and called B.foo() in another class, the A.foo() method would actually be called at run time. If you then change the B class and add a foo() method, it must be compatible so that the other class's method call is still valid.
If you're unfamiliar with the concept of binary compatibility, read the chapter in the Java Language Specification. It's a critical but often overlooked aspect of the Java language.

Extending a class while hiding access to inherited public method?

A little question about extension technique:
I've designed a custom table/table model which will be used as a company wide resource. The table extends JTable and the model extends AbstractTableModel.
The table and the model are really designed to work together so I've rigged it so that the table will instantiate and assign it's own model in the table constructor. It works well - a user in my company only has to declare and instantiate a table object and doesn't have to worry about the model.
I just noticed however that the getModel() method which I inherited from JTable is public and I cannot override this method with any stricter priviledges. I'm worried that a user may call the getModel() method or setModel() and try to do operations deep in the bowels of my Table. I would really like to hide the internals from any clients of the table.
Is there any way to restrict access to the model elegantly? The only thing I have though of is to override getModel() so it always returns null and then to write my own private getXXXModel() method for my own use. But this would only result in a run-time Null pointer error at best - a compile error would be preferable!

If I were going to do it, I would generally have every
method that you need that is in JTable and essentially
every thing is going to look like this:
public void someMethod() {
hiddenJTable.someMethod();
Generally you shouldn't need to reimplement the
existing methods on JTable. I hope that helps.I'm with dubwai on this one. As he says, provide the methods needed. One option (which I've used) is for you to extend JPanel and have your class add the table to itself in the constructor. Your accessor methods can exactly copy the signature of those in JTable and simply invoke the matching method on the private JTable. This way you can still allow people to place it, resize it, etc like a normal swing component, and you've hidden the methods away that you don't want others to use.
Of course, there are workarounds in the form of getComponent and so on, but they have to work pretty hard to do this. =)

Hiding rows in Web report

I am currently hiding an entire row via ABAP classes using 'style="display:none"' however there is a thick gridline where the hiding row is. Has anyone encountered this before and is there a better way to hide rows? I have hidden columns using 'style="display:none"' and the report looks ok, but hiding rows this way leaves thick gridlines where the rows use to be.
mark

It seems the problem is the method for c_cell_td_extend will only hide the <TD>, but the <TR> will still exist, thus the gridline displaying in the report. does anyone know of a way to clear the <TR> as well for web templates?
mark
Message was edited by:
Mark Siongco

Printed front panel graphics quality (Print Panel to Printer method vs. Append Front Panel Image to Report.vi)

LV 6.02 (or 6.1)
NT 4.0
I have a vi that the front panel includes all the information I need to print except that it is on different pages of a tab control to conserve screen space. I was attempting to programatically cycle the value of the tab control in a For loop and invoke the Print Panel to Printer method to print 7 pages of the front panel, each with a different tab page selected. The printouts were excellent quality but beginning with the second consecutive Print Panel to Printer method the on screen front panel image of the VI being printed would become jumbled (sometimes, by the time 7 printings were done, the entire front panel image would disappe
ar and a bitmap of the desktop or underlying windows would be visible in the VI's panel frame) yet the subsequent Print Panel to Printer methods continued to print the panel as they should appear. The visible front panel graphics would never return to normal and the only solution was to close the vi (in the dev system) or exe (compiled) and re-launch. I tried a lot of things (like hiding the panel to print before printing and showing it after printing) with no luck. It appears that two or more of these consecutive invoke methods caused the problem regardless of whether the tabs were cycling, or even if there was no tab control and much fewer controls on the panel to be printed than normal. I also had the same problem with LV 6.1.
Finally, I was forced to switch to the report generation toolkit vi's, I cycle through the tab pages and use the Append Front Panel Image to Report.vi to append each image to the report. This is faster and control returns to my program quicker but I a
m unhappy with the printed quality of the graphics of the front panels. They are not as high of resolution as those generated via the Print Panel to Printer method.
Any suggestions?

You might try changing the way the VI is printed by going to tools >> options >> printing. Try the postscript and bitmap settings.
Jeremy

Building a method with more than one result data

Hi, everyone:
I'm a little shy to ask this question, however, it's been hanging in my mind for so long, so I think I'd rather make a confession on it. You may laugh at me if you want, I'm ready for that, but I more look forward to that someone can really give me the light, or even the link, or some hint....
For your ease of reading, I give the question first, and my whole story behind:
When I need a method which can provide more than one result( in other words, multiple outputs), how can I do it in Java? As I know, either you pass and object, or the result of the function is an object will do , for the object contains the datas you want, but that means your needs for those data have to be defined in object format in advance, won't that be inconvinient? Or Java has a better solution for that?
//And here's the whole story....
I began my career as a programmer by starting with LabVIEW, it's a graphical programming language made by National Instrument, and it's powerful on DAQ, and industrial field. One of the most important issues on design is to devide your system into multiple functions( in its own term: subVI), I think it's just like applying structured analysis method.
When we dealing with functions in LabVIEW, a programmer can define his own function with mulitiple inputs and outputs, for example, I can design a function called SumAndDevide, which accepts two input ( two variables to be summed and devided) and gives two results( result of summing and that of deviding).
The methodology has its power, at least it provide the functional decomposition, and you can compose a suitable solution in certain circumstance even they are not the smallest unit function. And testing is easy. It affects me so large that I look the trail of it when I come to other programming languages. In COBOL( well, that is a VERY old COBOL version ), I was scared to find there is no protection to the inner data on the performed sections, while making a outside subroutine to be called is cubersome and really a hard work. When I came to Delphi, I knew that using the result of a function cannot satisfy me, for it give only one output, even you can define it as variant, but I think it's vague to realize. So I use the difference of called by value and called by reference to handle the problem, that is: a value parameter for the input, and a variable paramter for the output.
Well, when I came to Java, I am stunned again, now there is no passing by reference mechanism in Java, otherwise you have to pass it as an object, but that means when you need multiple outputs, the output has to be defined in object form in advance. And that will be very inconvinient!! I tried to find some solutions, but I can't. So is there any way that in Java you can define a method with multiple output? or Java handles the problem in totally different way?
Any comments will be appreciated!!
Thanks!!
aQunx from Taiwan

You missed the most common OO solution - separation of concerns and implementation hiding.
If you have a function which returns a string, that is one method of the object that provides the service.
If you have a function which returns a real, that is a different method of the object.
If both functions require common code, move that into a private method which is called by both. If the method is costly, cache the result.
eg an aerodynamics properties class, which could be done as a multivalued return of (lift, drag), refactored to independent lift() and drag() methods, which delegate to an interpolate() method, which caches the interpolated value and uses mach, pressureHeight and _alpha to determine whether it should recalculate: /**
   * Calculates the aerodynamic drag force at a given mach, alpha and pressure height.
public double drag (final double aMach, final double aPressureHeight, final double aAlpha) {
    interpolate(aMach, aPressureHeight, aAlpha);
    return _drag;
   * Calculates the aerodynamic lift force at a given mach, alpha and pressure height.
public double lift (final double aMach, final double aPressureHeight, final double aAlpha) {
    interpolate(aMach, aPressureHeight, aAlpha);
    return _lift;
private void interpolate (final double aMach, final double aPressureHeight, final double aAlpha) {
    if (aMach != _mach) {
      setMach(aMach);
      _pressureHeight = Double.NaN;
    if (aPressureHeight != _pressureHeight) {
      setPressureHeight(aPressureHeight);
      _alpha = Double.NaN;
    if (aAlpha != _alpha) {
      setAlpha(aAlpha);
... actual interpolation happens in the private setXXX methods.

Need some help in hiding elements of my API from potential users...

Hi there folks from Java land.
How can I do the following/what keywords is needed to do:
Hiding a class in a library package, so that only classes in my package can access it- ie...
I have a bunch of classes in package foo.bar;
i want class foo.bar.Baz to be able to be called from classes that an end user writes.
class foo.bar.Baz uses class foo.bar.Bax to do some important things, and also uses foo.Bla class for other important things. I don't want the user messing around with the important classes in my *.jar distribution of my library, but if I declare these classes private , then Baz will only be able to access Bax and will be unable to see Bla as it is in a different package in my library...
This is puzzling me.
The next question is how can I write methods that can only be seen in my package and not other people who are using my package?
Regards
Jason.

fireman.sparkey wrote:
Hi there folks from Java land.
How can I do the following/what keywords is needed to do:
Hiding a class in a library package, so that only classes in my package can access it- ie...
I have a bunch of classes in package foo.bar;
i want class foo.bar.Baz to be able to be called from classes that an end user writes.
class foo.bar.Baz uses class foo.bar.Bax to do some important things, and also uses foo.Bla class for other important things. I don't want the user messing around with the important classes in my *.jar distribution of my library, but if I declare these classes private , then Baz will only be able to access Bax and will be unable to see Bla as it is in a different package in my library...
This is puzzling me.
This one is easy, and the answer is already built into Java itself: If you make all the classes in your foo.bar package package-visible only, and not public, then only classes in that package will be able to call them.
The next question is how can I write methods that can only be seen in my package and not other people who are using my package?
External clients can only call public methods on public classes.
If you declare a public interface into your package, then that will be the only way to access that package.
I think the Java access modifiers should be sufficient here.
%

Strange IE ExternalInterface Bug: "Object does not support this property or method"

We have an application on a relatively slow server (I mention
the speed because it may be relevant).
The app is flash 8 and uses ExternalInterface to call a
javascript function in its parent page. It also used the
ExternalInterface to receive a call from another function. These
calls happens separately (the outbound one calls up a list view of
items, clicking on an item calls up the details in the flash
movie). In between the calls, the flash movie is hidden by moving
it off screen using absolute positioning.
On my local development box (Windows XPSP2) this works fine
in both directions.
On our production server (LAMP) this works fine in both
directions in Firefox 1.5 and 2.0
BUT while the outbound call from Flash to the page works fine
in Internet Explorer 6 or 7, the call back from the page to the
flash movie fails with the error messgage "Object does not support
this method or property"
We've tried not hiding the flash so it is always present on
the page and still the browser > flash communication breaks in
ie.
We've tried using both the Adobe active content script and
swfobject to embed the flash in the page with no difference in the
resultset. In truth we've given up and gone to a two-page solution,
reloading the flash from the start each time but I wondered if
anyone had encountered a similar issue? Can't see why it would work
perfectly in FF but not in IE.

Not sure if this is your problem, but you do reference the
Flash object
differently, depending on the browser. In a video player we
made, that uses
JS to communicate back to Flash, I use a function like this
to modify the
variable depending on the browser:
function changeVideo(xname){
//ff
if(window.vplayer){
window.document["vplayer"].SetVariable("theXML", xname);
window.document["vplayer"].GotoFrame(2);
window.document["vplayer"].Play();
//ie
if(document.vplayer){
document.vplayer.SetVariable("theXML", xname);
document.vplayer.GotoFrame(2);
document.vplayer.Play();
The Flash is in a <div> named 'vplayer'
Dave -
Head Developer
http://www.blurredistinction.com
Adobe Community Expert
http://www.adobe.com/communities/experts/

Hiding methods

Similar Messages

Maybe you are looking for