Invoking method of final subclass of abstract class is slow

hi,
I've diagnosed a performance regression in my code which boils down to the example at the end of the post.
Would it be possible to have the vm dynamically figure out that within the hotspot in the test method, its
safe to ditch the dynamic dispatch and skip that overhead?
I thought marking the method as final would allow the vm to peform some run-time optimisations - I'm pretty sure I've been able to measure that in different situations; marking the test method's parameter (a) as final, also doesn't help.
Rather than have an abstract class, its looking like the performance requirements will dictate some copy and paste to
help the vm along - does anyone know if I'm missing something here?
thanks in advance,
asjf
The output I see (using 6.0 update 10) is:
B foo 28
B bar 95
C foo 29
C bar 86
D foo 26
D bar 92
E foo 29
E bar 82
public class MethodCallPerfTest {
     public static void main(String[] args) {
          test(new B());
          test(new C());
          test(new D());
          test(new E());
     public static void test(A a) {
               long start= System.currentTimeMillis();
               for(int i=0; i<8000000; i++)
                    a.foo();
               System.out.println(a.getClass().getSimpleName()+" foo "+(System.currentTimeMillis() - start));
               long start= System.currentTimeMillis();
               for(int i=0; i<8000000; i++)
                    a.bar();
               System.out.println(a.getClass().getSimpleName()+" bar "+(System.currentTimeMillis() - start));
abstract class A {
     int j;
     final void foo() {j++;}
     abstract void bar();
final class B extends A {
     int k;
     void bar() {k++;}
final class C extends A {
     int l;
     final void bar() {l++;}
class D extends A {
     int m;
     final void bar() {m++;}
class E extends A {
     int n;
     void bar() {n++;}
}

is it because references to the final fields are resolved at compile-time ?
such that the compiler must know the value of USE in:if(USE){
// a
// b at compile time so it can remove either "b" or "a". I think so. hmm.

Similar Messages

Final field in abstract class

Hi ... consider the code:abstract class It {
     protected final boolean
          USE;
public class Test extends It {
     public Test(){
          USE = true;
} upon compiling there is an error (infact, two errors).
final may not be assigned, can't assign to final.
of course, if "It" was not abstract, the first error might be true ... but it is abstract, so
shouldn't this checking of assignment to final be delayed until the class is inheritied
as concrete ? it would seem to make sense ... i can't see a reason for this not being
the case.
if it was the case, we could delay assignment until our constructor of "Test" where it
would assign to the final variable of "It".
it shouldn't be an error, should it ?
java version:java version "1.4.2_03"
Java(TM) 2 Runtime Environment, Standard Edition (build 1.4.2_03-b02)
Java HotSpot(TM) Client VM (build 1.4.2_03-b02, mixed mode)

is it because references to the final fields are resolved at compile-time ?
such that the compiler must know the value of USE in:if(USE){
// a
// b at compile time so it can remove either "b" or "a". I think so. hmm.

Non-abstract methods in a Abstract class

Abstract Class can contain Non-abstract methods.
and Abstract Classes are not instantiable as well
So,
What is the purpose of Non-abstract methods in a Abstract class.
since we can't create objects and use it
so these non-abstract methods are only available to subclasses.
(if the subclass is not marked as abstract)
is that the advantage that has.(availability in subclass)
??

For example, the AbstractCollection class (in
java.util) provides an implementation for many of the
methods defined in the Collection interface.
Subclasses only have to implement a few more methods
to fulfill the Collection contract. Subclasses may
also choose to override the AbstractCollection
functionality if - for example - they know how to
provide an optimized implementation based on
characteristics of the actual subclass.Another example is the abstract class MouseAdapter that implements MouseListener, MouseWheelListener, MouseMotionListener, and that you can use instead of these interfaces when you want to react to one or two types of events only.
Quoting the javadocs: "If you implement the MouseListener, MouseMotionListener interface, you have to define all of the methods in it. This abstract class defines null methods for them all, so you can only have to define methods for events you care about."

Abstract class with set and get methods

hi
how to write set and get methods(plain methods) in an abstartc class
ex: setUsername(String)
String getUsername()
and one class is extending this abstract class and same methods existing in that sub class also..... how to write......plz provide some ideas
am new to programming....
asap
thnx in advance

yes... as i told u.... i am new to coding......
and my problem is ..... i have 2 classes one is abstract class without abstract methods.. and another class is extending abstract class.....
in abstract class i have 2 methods...one is setusername(string) and getusername() ..... how to write these two methods.... in abstract class i have private variables username...... when user logins ..... i need to catch the user name and i need to validate with my oracle database and i need to identify the role of that user and based on role of that user i need to direct him to appropriate jsp page.......
for that now i am writing business process classes..... the above mentioned two classes are from business process.....
could u help me now
thnx in advance

About Abstract class

Hi All,
I m inherting from abstract class . So is it mandatory for me to provide implemenation for all methods that r defined in abstract class
i m getting error like this:
subclass class is not abstract ,does not override abstract method "methodname" in superclass
Thanks in advance
Waiting for replies
Amar

- you need to override all methods from your abstract
superclass.....You don't have to override anything unless you want to, but you have to supply implementation for all abstract classes. If you don't you will have to declare the subclass abstract and let another subclass down the hierarchy finish the job. Eventually all abstract classes must be implemented otherwise objects cannot be instantiated. For that a class must be fully concrete.

Doubt on abstract classes

Hi,
I have doubt in abstract classes,please clarify my doubt.....my doubt is
I have one abstract class,in that i have three methods...
Now I have created one subclass for that abstract class....
I defined all those methods that are there in abstract class in the sub class......and I wrote some other methods in that sub class....
Now my question is ----->can I make the methods that are declared in abstract class invisible to the people who are using the sub class???
Please tell me the answer...
Thanks in advance,
sirisha.

ya I got it....
Please see the code and tell me wether it is correct or not...
abstract class One
int i=10;
private void display()
System.out.println("One:display");
public void show()
System.out.println("One:show");
public abstract int intadd(int j);
class Two extends One
int i=100;
public void display()
super.display();
System.out.println("TestThr:display");
public void show()
//super.show();
System.out.println("TestThr:show");
public int intadd(int j)
if (j==1)
     return i;
     else
return super.i;
public class TestThr
public static void main(String args[])
Two t=new Two();
     t.display();
     t.show();
     System.out.println(t.intadd(1));
}

Abstract classes, Interfaces, and concrete classes

I have another technical interview tomorrow and somehow I keep getting asked the same question and I feel my answer is not really up to par. The question is:
"What is the advantage of subclassing an abstract class versus concrete class?"
"What is the difference of using an interface versus an abstract class, which is better to use?"
For the first question, I usually answer performance is the advantage because you don't have to instantiate the class.
For the second question, I usually say that you can put implementation in an abstract class and you can't in an interface. I really can't answer the second part to this question.
Any ideas?

For the first question, I usually answer performance
is the advantage because you don't have to instantiate
the class. Try invoking the class B in the following somewhere in another class.
abstract class A{
A(){
System.out.println("abstract instantiated");
class B extends A{
B(){super();}
}

What's the difference between Abstract Class and Interface?

Dear all,
Can anyone give me some hints about this topic?
Thanks.
Leo

an abstract class may have some methods already implemented in the abstract class but an interface has no methods implemented
I think it's just that simple.
For your design needs, you just choose what you need : )
Cheers
Stephen

Casting & abstract class & final method

what is casting abstract class & final method in ABAP Objects give some scenario where actually use these.

Hi Sri,
I'm not sure we can be any more clear.
An Abstract class can not be instantiated. It can only be used as the superclass for it's subclasses. In other words it <b>can only be inherited</b>.
A Final class cannot be the superclass for a subclass. In other words <b>it cannot be inherited.</b>
I recommend the book <a href="http://www.sappress.com/product.cfm?account=&product=H1934">ABAP Objects: ABAP Programming in SAP NetWeaver</a>
Cheers
Graham

Final methods in abstract classes?

Hi, why is it possible to define a final method in an abstract class? The theory behind a final method doesn't say that a final method couldn't be overridden?
Marco

So it's formally correct but it doesn't have any
sense, does it?You sound very confused. A final method in an
abstract class has just the same semantics and
makes just as much sense as in a non-abstract
class.
The semantics of a final method is simply that
it cannot be overridden in subclassed. Both
abstract and non-abstract classes can be
subclasses. So why do you think there should be any
difference?Actually i was confused now it's clear. I was too binded to the concept that the extending class SHOULD(not for a formal reason, but for a 'design' one) write the implementation of the methods defined in the abstract class. Now i see that, actually, by defining a final method in an abstract class we are defining our design as implemented and clients(i.e. subclasses) can only use it.
Thank you,
Marco

Dynamically invoke methods of abstract class?

Hi,
I am using reflection to write a class (ClassA) to dynamically invoke methods of classes. I have an abstract class (ClassB) that has some of the methods already implemented, and some of the methods that are declared abstract. Is there any way that I can:
(a) invoke the methods that are already implemented in ClassB;
(b) I have another class (ClassC) that extends ClassB, some of the methods are declared in both classes. Can I dynamically invoke these methods from ClassB?
Thanks in advance,
Matt.

Ok, the program is quite long, as it does other things as well, so I'll just put in the relevant bits.
What I have is a JTree that displays classes selected by the user from a JFileChooser, and their methods.
// I declare a variable called executeMethod
private static Method executeMethod;
// objectClass is a class that has been chosen by the user. I create a new instance of this class to execute the methods.
Object createdObject = objectClass.newInstance();
// methodName is the method selected by the user. objectClassMethods is an array containing all the methods in the chosen class.
executeMethod = objectClassMethods[j].getDeclaringClass().getMethod(methodName, null);
Object executeObject = executeMethod.invoke(createdObject, new Object[]{});Ok, here are the test classes:
public abstract class ClassB{
     private int age;
     private String name;
     public ClassB(){ age = 1; name="Me";}
     public int getAge(){ return age; }
     public String getName(){ return name; }
     public void PrintAge(){System.out.println(age);}
     public void PrintName(){System.out.println(name);}
     public abstract void PrintGreeting();
public class ClassC extends ClassB{
     public ClassC(){super();}
     public void PrintAge(){
          System.out.println("I am " + getAge() + " years old.");
     public void PrintGreeting(){
       System.out.println("Hello");
}Now, I can print out the PrintAge method from ClassC (i.e. have it output "Hello" to the command line, how can I, say, get it to output the result of PrintName from ClassB, this method does not appear in ClassC. As you can see at the top, I can create a new instance of a normal method (in this case, ClassC), and have it output to the command line, but I know that I can't create a new instance of an abstract class. And since PrintName is implemented in abstract class ClassB, how do I get it to output to the command line?
Thanks,
Matt.

Abstract class & final class

Which is more correct... Or which is the more preferred way.
abstract class A
final method1(){}
final method2(){}
final method30(){}
}or
final class A
private A(){}
method1(){}
method2(){}
method3(){}
}My understanding is that both classes cannot be instantiated. The first one requires writing 'final' for EACH method. The second one involves writing a private constructor.

It depends on what you are trying to do. If you are trying to make a class that can be sub-classed but has some methods that cannot be overriden, then "abstract class A" with final methods is the way to go. If you want a class that cannot be sub-classed or instantiated then "final class A" with private constructor is the way to go.
classes cannot be instantiatedOnly true for "final class A" because you made the only constructor private. Not true for the abstract one.// you forgot return values for the methods
abstract class A
final static /*void*/ method1(){} // package private
final static /*void*/ method2(){} // package private
final static /*void*/ method30(){} // package private
// this would work
A a = new A(){};
// if I am in the same package as A, then this would work
a.method1();
// or this
public class B extends A
public B(String whatever)
    // Although, I cannot override the super methods
    // becuase they are all declared as final
    // I can only invoke them if I am in the same package. You
    // declared them as package private instead of class "private"
}Using final as a class modifier disables the ability to sub-class it but does not disable the ability to create an object of that class. You must make a private constructer. If the only constructor is "private" then you can't subclass or instantiate, so making the class final is uneeded.

Enforce setting private variable in subclass with abstract method

Hi,
Is this something that is common usage/practice?:
public abstract class Base {
    private int importantPrivateVariable = setImportantPrivateVariable();
    protected abstract int setImportantPrivateVariable();
}I would like to enforce the extender of the class to set a private variable, but as there is no abstract variable in java, I can only use a method for it.
Thanks,
lemonboston
Edit: the variable could be protected as well, I suppose this is not important here, but correct me if I am wrong

lemonboston wrote:
Hi,
Is this something that is common usage/practice?:I don't think that's so common, but that's code easily understandable. However there are several problems with this approach:
public abstract class Base {
private int importantPrivateVariable = setImportantPrivateVariable();
protected abstract int setImportantPrivateVariable();
}I would like to enforce the extender of the class to set a private variableThat's no what your code implements: your base class forces the subclasses to return an int value, and the Base class uses that value to assign it to the variable.
Therefore the method should be called get<Something> (e.g. <TT>getInitialValueOfImportantVariable()</TT>+ to have a naming consistent with its signature (it returns a value, whereas a regular setter method should declare a void return type: <TT>protected abstract void setImportantPrivateVariable(int someValue);</TT>).
Edit: the variable could be protected as well, I suppose this is not important here,Well, yes, this is "important" - at least, there a noticeable difference: the variable being private, the base class is free to handle it as it sees fit (e.g., assign the value at construction time and never modify it afterwards). If the variable was protected, the subclass could modify in ways and at times not known by the base class.
but correct me if I am wrongThere's a trap in this construct: the method is called in the variable initializer, that is, behind the scenes, approximately during the execution of the Base class constructor, so before the subclass constructor. So, you are calling a method on an object that is not fully initialized (e.g. some of its attributes may still be <TT>null</TT> at this stage). There is a rule that discourages such situations, that goes something like "don't call non-private and non-final methods from a constructor".
To avoid this trap, two options:
- require an int argument in the Base class's constructor , as was suggested above
- don't get and set the value of the important variable in the initializer or constructor code, but from a special method in the base class instead:
public abstract class Base {
    private int importantPrivateVariable; // default value is zero
// or alternatively:
//    private int importantPrivateVariable = ...; // Some default value
    protected abstract int getImportantPrivateVariable();
    public void initializeImportantPrivateVariable() {
        importantPrivateVariable = getImportantPrivateVariable();
}That construct is a degenerate form of a common design pattern known under the name of Template Method (where a base class method calls generally several subclass methods in a specified order and with a specified chaining, leaving it to the subclass to implement the details of the methods).
The drawback is that the client code (the one that uses the Base instance) has to know when to call that initialization method, whereas the constructor-based initialization lets the client code free to not care at all.
Much luck,
J.

Why does this abstract class and method work without implement it?

hi,
I have seen many times that in some examples that there are objects made from abstract classes directly. However, in all books, manual and tutorials that I've read explain that we MUST implement those methods in a subclass.
An example of what I'm saying is the example code here . In a few words that example makes Channels (java.nio.channel) and does operations with them. My problem is in the class to make this channels, because they used the ServerSockeChannel class and socket() method directly despite they are abstracts.
   // Create a new channel: if port == 0, FileChannel on /dev/tty, else
   // a SocketChannel from the first accept on the given port number
private static ByteChannel newChannel (int netPort)
      throws Exception
      if (netPort == 0) {
         FileInputStream fis = new FileInputStream ("/dev/tty");
         return (fis.getChannel());
      } else {
//CONFLICT LINES
         ServerSocketChannel ssc = ServerSocketChannel.open(); //<--I have never thought do that!! Anyway, how it is static method may work.
         ssc.socket().bind (new InetSocketAddress (netPort)); //<--but here, this method (socket) is abstract. WHY RETURN A SOCKET???????? this mehod should be empty by default.
         System.out.print ("Waiting for connection on port "
            + netPort + "...");
         System.out.flush();
         ByteChannel channel = ssc.accept();
         ssc.close();
         System.out.println ("Got it");
         return (channel);
   } I test this code and works fine. So why can it be??
Also, I read that the abstract classes can't have static methods. Is it true???
Please Help!!
PS: i have seen this kind of code many times. So i feel that I don't understand how its really the abstract methods are made.
PS2: I understand that obviously you don't do something like this: *"obj = new AbstractClass(); "*. I dont understand how it could be: ServerSocketChannel ssc = ServerSocketChannel.open(); and the compiler didn't warn.

molavec wrote:
ServerSocketChannel ssc = ServerSocketChannel.open(); //<--I have never thought do that!! Anyway, how it is static method may work.
The static method creates an instance of a class which extends ServerSocketChannel, but is actually another non-abstract class.I thought that, but reading the documentation I saw that about open() method:
Opens a server-socket channel.
The new channel is created by invoking the openServerSocketChannel method of the system-wide default SelectorProvider object.
The new channel's socket is initially unbound; it must be bound to a specific address via one of its socket's bind methods before connections can be accepted.
...and the problem is the same openServerSocketChannel is abstract, so i don't understand how it could return a ServerSocketChannel.There is a concrete implementation class that has implemented that method.
I guess that really the open() method use a SelectorProvider's subclase but it doesn't appear in the doc.It doesn't need to. First, you don't care about those implementation details, and second, you know that if the class is abstract, it must use some concrete subclass.
Ok, I speak Spanish by default (<-- this sounds like "I am a machine", ^_^' ). So, I didn't know how to say that the method would be {}. Is there a way to say that?? I recommendable for me to know, for the future questions o answers.Not sure what you're saying here. But the other respondent was trying to explain to you the difference between an abstract method and an empty method.
// abstract method
public abstract void foo();
// empty method
public void bar() {
Which class does extend ServerSocketChannel? I can not see it.It may be a package-private class or a private nested class. There's no need to document that specific implementation, since you never need to use it directly.

Protected methods in abstract classes

Hello All
I have some problem which I cannot find a workaround for.
I have three classes:
package my.one;
public abstract class First {
protected void do();
protected void now();
package my.one;
public class NotWantToHave extends First {
protected First obj;
public NotWantToHave(First O) { obj = O; }
public void do() { obj.do(); }
public void now() { obj.now(); }
package my.two;
public class Second extends my.one.First {
protected void do() { System.out.println("Second does"); }
protected void now() { System.out.println("Second does now"); }
package my.three;
public class Three extends my.one.First {
protected my.one.First obj;
public Three(my.one.First O) { obj = O; }
protected void do() { System.out.println("Doing"); }
protected void now() { obj.now(); } // Not possible, see later text
Problem is, as one can read in http://java.sun.com/docs/books/tutorial/java/javaOO/accesscontrol.html , it says that you cannot access protected members and methods from classes if they are in a different package. However, since my class Three should not concern about the method now() but should use from some other class that implements (i.e. class Second), the question I have is how to do?
One way would be to implement a class that simply make a forward call to any protected method in the same package the abstract class is in like in class NotWantToHave and pass it to the constructor of class Third while this class was created with an instance of class Second. However, such a call would look very clumsy (new my.three.Third(new my.one.NotWantToHave(new my.two.Second()));). Furthermore, everyone could create an instance of class NotWantToHave and can invoke the methods defined as protected in class First, so the access restriction would be quite useless.
Does anyone has a good idea how to do?

Hi
One way I found is to have a nested, protected static final class in my super-class First and provide a protected static final method that returns a class where all methods of the super-class are made public and thus accessible from sub-classes at will. The only requirement is that a sub-class must invoke this method to encapsulate other implementations of the super-class and never publish the wrapper class instance. This will look as follows:
package my.one;
public abstract class First {
protected final static class Wrap extends First { // extend First to make sure not to forget any abstract method
    protected First F;
    public void do() { F.do(); }
    public void now() { F.now(); }
    protected Wrap(First Obj) { F = Obj; }
} // end Wrap
protected final static First.Wrap wrap(First Obj) { return new First.Wrap(Obj); }
protected abstract void do();
protected abstract void now();
} // end First*******
package my.two;
public class Second extends my.one.First {
protected void do() { System.out.println("Second does"); }
protected void now() { System.out.println("Second does now"); }
} // end Second*******
package my.three;
public class Three extends my.one.First {
protected my.one.First.Wrap obj;
public Three(my.one.First O) { obj = my.one.First.wrap(O); }
protected void do() { System.out.println("Doing"); }
protected void now() { obj.now(); } // Not possible, see later text
} // end Third*******
In this way, I can access all methods in the abstract super class since the Wrap class makes them public while the methods are not accessible from outside the package to i.e. a GUI that uses the protocol.
However, it still looks clumsy and I would appreciate very much if someone knows a more clear solution.
And, please, do not tell me that I stand on my rope and wonder why I fall down. I hope I know what I am doing and of course, I know the specification (why else I should mention about the link to the specification and refer to it?). But I am quite sure that I am not the first person facing this problem and I hope someone out there could tell me about their solution.
My requirements are to access protected methods on sub-classes of a super-class that are not known yet (because they are developed in the far, far future ...) in other sub-classes of the same super-class without make those methods public to not inveigle their usage where they should not be used.
Thanks

Invoking method of final subclass of abstract class is slow

Similar Messages

Maybe you are looking for