Adding methods to base classes

How are new methods proposed and adopted for the base classes?

Your question is unclear and I doubt if it has anything to do with JNDI.

Similar Messages

Explizit using methods of base class

when using a base class reference from an abstract class A and creating an object of subclass B
A ref_A = new B();
assuming we have implemented the method m() in A and B, then
ref_a.m()
calls Method m of subclass B
(dynamic binding, fine)
Is there a possibility to force explicitely the call of method m of superclass A.
(i mean not a call from Method m in B with super())

are you absolutely sure ?I am sure. Perhaps you are thinking of C++ (and if you're not, I am!) where you can write: ref_A.A::m(),
but there's no way from the client code to do that in Java. If you really need to do this, your
design of A should reflect it:
public abstract class A {
    public final void mOldSchool() {...}
    public void m() { mOldSchool(); }
public class B extends A {
    public void m() {...}
}I agree with Kayaman, though: question your design. In the abstract, this is a shakey design.

Implement abstract method from base class problem

Here is the example:
public abstract class AbstractClass{
protected double aVariable;
protected abstract double abstractMethod();
public class RealClass extends AbstractClass{
public double abstractMethod(){
return aVariable;
Error message:
RealClass should be declared abstract; it does not define abstractMethod() in AbstractClass

I also compiled the code with Jdk1.3 and it
worked.. The code would not have compiled
if the access modifier in the derived class
was more restrictive(eg private )...

Ramifications of extending subclass by creating abstract method in base

What r the ramification of extending subclass functionality by creating abstract method in base class?

javax.swing.JComponent is an example of an abstract
class with no abstract methods. That is why the
following works:
JComponent component = new JComponent(){};
Not to forget you cannot instantiate abstarct classes
public abstract class Test
public String getName()
return "Mike";
public static void main(String[] args)
Test tt = new Test();
System.out.println(tt.getName());
}and you would get the error
The type Test cannot be instantiated.
You remove the abstract keyword and it would compile
good.No I am not misinterpreting I know what he is saying but I am closing the door of misinterpretation which I felt was possible. ;)
cheers

JVM crash when adding method to class

Hello,
I am getting some kind of problem with the virtual machine. The JVM crashes when making a class (with new). It happened when I was adding some functionality to the class, I worked my way backwards and discovered it crashes when I add any new methods, if I comment them out again everything works, adding a method by any name causes to crash.
I went in debug to find out where it was happening, and it happens on this line:
public PerspectiveActionToolBarHeader createPerspectiveActionToolBarHeader() {
     PerspectiveActionToolBarHeader ret = null;
     ret = new PerspectiveActionToolBarHeader(this); // << here
     return ret;
}The PerspectiveActionToolBarHeader is the class where adding methods causes it to fail. For example, it has the method
public Container getContainer() {
     return this;
}and works, but if I add:
public void anything(){} it causes a crash on the new PerspectiveActionToolBarHeader(this);
When stepped into with the debugger it goes to the (source not found) ClassNotFoundException and eventually before the crash the (stack?) looks like this:
Launcher$AppClassLoader(ClassLoader).loadClass(String) line: not available
MaldiSoftwareOptionsUIEnsemble(PerspectiveUIEnsemble).createPerspectiveActionToolBarHeader() line: 72
and the debugger describes the class just before the crash:
Launcher$AppClassLoader (id=44)
arg0     "saiman.uiobjnew.PerspectiveToolBarButton" (id=51) << has just changed
and the log file (not sure how much to copy here!):
# A fatal error has been detected by the Java Runtime Environment:
# EXCEPTION_ILLEGAL_INSTRUCTION (0xc000001d) at pc=0x005c0001, pid=15504, tid=20112
# JRE version: 6.0_24-b07
# Java VM: Java HotSpot(TM) Client VM (19.1-b02 mixed mode windows-x86 )
# Problematic frame:
# C 0x005c0001
# If you would like to submit a bug report, please visit:
# http://java.sun.com/webapps/bugreport/crash.jsp
--------------- T H R E A D ---------------
Current thread (0x011ca000): JavaThread "main" [_thread_in_vm, id=20112, stack(0x01140000,0x01190000)]
siginfo: ExceptionCode=0xc000001d
Registers:
EAX=0x13e13248, EBX=0x6da0daa8, ECX=0x13e13250, EDX=0x13e131f8
ESP=0x0118f93c, EBP=0x0118f9a0, ESI=0x011ca9b0, EDI=0x011ca9ac
EIP=0x005c0001, EFLAGS=0x00010206
Register to memory mapping:
EAX=0x13e13248
{method}
- klass: {other class}
EBX=0x6da0daa8
0x6da0daa8 is pointing to unknown location
ECX=0x13e13250
{method}
- klass: {other class}
EDX=0x13e131f8
{constMethod}
- klass: {other class}
- method: 0x13e13248 {method} 'flipVisible' '(I)V' in 'saiman/uiobjnew/PerspectiveActionToolBarHeader'
- exceptions: 0x13bf11e8
ESP=0x0118f93c
0x0118f93c is pointing into the stack for thread: 0x011ca000
"main" prio=6 tid=0x011ca000 nid=0x4e90 runnable [0x0118f000]
java.lang.Thread.State: RUNNABLE
EBP=0x0118f9a0
0x0118f9a0 is pointing into the stack for thread: 0x011ca000
"main" prio=6 tid=0x011ca000 nid=0x4e90 runnable [0x0118f000]
java.lang.Thread.State: RUNNABLE
ESI=0x011ca9b0
0x011ca9b0 is pointing to unknown location
EDI=0x011ca9ac
0x011ca9ac is pointing to unknown location
Top of Stack: (sp=0x0118f93c)
0x0118f93c: 6d94272d 011ca370 13e17d40 011ca000
0x0118f94c: 011ca000 01a30950 011ca748 011ca9b4
0x0118f95c: 011cab3c 0118fb28 011c6748 011ca348
0x0118f96c: 011ca370 011ca73c 6da0daa8 011ca350
0x0118f97c: 011ca370 0118f9cc 011ca9a8 0118f9c8
0x0118f98c: 011ca788 011ca370 011ca9b0 011ca000
0x0118f99c: 13e17d40 0118f9cc 6d943009 00000910
0x0118f9ac: 011ca9ac 00000001 011ca000 011ca000
Instructions: (pc=0x005c0001)
0x005bfff1: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ff
0x005c0001: ff ff 7f 00 00 00 00 00 00 00 00 ff ff ff ff 00
Stack: [0x01140000,0x01190000], sp=0x0118f93c, free space=318k
Native frames: (J=compiled Java code, j=interpreted, Vv=VM code, C=native code)
C 0x005c0001
V [jvm.dll+0x153009]
V [jvm.dll+0xdecdb]
V [jvm.dll+0xe1887]
V [jvm.dll+0xe1c46]
V [jvm.dll+0xec09a]
j saiman.uiobjnew.PerspectiveUIEnsemble.createPerspectiveActionToolBarHeader()Lsaiman/uiobjnew/PerspectiveActionToolBarHeader;+2
j saiman.mv.ModelViewPerspectiveUIEnsemble.createPerspectiveActionToolBarHeader()Lsaiman/uiobjnew/PerspectiveActionToolBarHeader;+1
j saiman.uiobjnew.PerspectiveUIEnsemble.addButtons()V+1
j saiman.uiobjnew.PerspectiveUIEnsemble.<init>(Lsaiman/uiobjnew/MultiPerspectiveFrame;)V+21
j saiman.mv.ModelViewPerspectiveUIEnsemble.<init>(Lsaiman/uiobjnew/MultiPerspectiveFrame;)V+2
j saiman.uiobjnew.SoftwareOptionsUIEnsemble.<init>(Lsaiman/uiobjnew/MultiPerspectiveFrame;)V+2
j saiman.wmaldi.MaldiSoftwareOptionsUIEnsemble.<init>(Lsaiman/uiobjnew/MultiPerspectiveFrame;)V+2
j saiman.newuiimpl.MassSpectrumMainFrameImpl.main([Ljava/lang/String;)V+173
v ~StubRoutines::call_stub
V [jvm.dll+0xf0ab9]
V [jvm.dll+0x1837d1]
V [jvm.dll+0xf0b3d]
V [jvm.dll+0xfa0d6]
V [jvm.dll+0x101cde]
C [javaw.exe+0x2155]
C [javaw.exe+0x8614]
C [kernel32.dll+0x51194]
C [ntdll.dll+0x5b3f5]
C [ntdll.dll+0x5b3c8]
Java frames: (J=compiled Java code, j=interpreted, Vv=VM code)
j saiman.uiobjnew.PerspectiveUIEnsemble.createPerspectiveActionToolBarHeader()Lsaiman/uiobjnew/PerspectiveActionToolBarHeader;+2
j saiman.mv.ModelViewPerspectiveUIEnsemble.createPerspectiveActionToolBarHeader()Lsaiman/uiobjnew/PerspectiveActionToolBarHeader;+1
j saiman.uiobjnew.PerspectiveUIEnsemble.addButtons()V+1
j saiman.uiobjnew.PerspectiveUIEnsemble.<init>(Lsaiman/uiobjnew/MultiPerspectiveFrame;)V+21
j saiman.mv.ModelViewPerspectiveUIEnsemble.<init>(Lsaiman/uiobjnew/MultiPerspectiveFrame;)V+2
j saiman.uiobjnew.SoftwareOptionsUIEnsemble.<init>(Lsaiman/uiobjnew/MultiPerspectiveFrame;)V+2
j saiman.wmaldi.MaldiSoftwareOptionsUIEnsemble.<init>(Lsaiman/uiobjnew/MultiPerspectiveFrame;)V+2
j saiman.newuiimpl.MassSpectrumMainFrameImpl.main([Ljava/lang/String;)V+173
v ~StubRoutines::call_stub
--------------- P R O C E S S ---------------
Java Threads: ( => current thread )
0x01b05400 JavaThread "AWT-Windows" daemon [_thread_in_native, id=19680, stack(0x18560000,0x185b0000)]
0x01b04800 JavaThread "Java2D Disposer" daemon [_thread_blocked, id=19516, stack(0x18140000,0x18190000)]
0x01b04000 JavaThread "Low Memory Detector" daemon [_thread_blocked, id=20064, stack(0x18040000,0x18090000)]
0x01b03c00 JavaThread "CompilerThread0" daemon [_thread_blocked, id=20276, stack(0x17ff0000,0x18040000)]
0x01aeb000 JavaThread "JDWP Command Reader" daemon [_thread_in_native, id=16832, stack(0x17fa0000,0x17ff0000)]
0x01aea000 JavaThread "JDWP Event Helper Thread" daemon [_thread_blocked, id=16360, stack(0x17ef0000,0x17f40000)]
0x01ae8000 JavaThread "JDWP Transport Listener: dt_socket" daemon [_thread_blocked, id=20084, stack(0x17ea0000,0x17ef0000)]
0x01ade400 JavaThread "Attach Listener" daemon [_thread_blocked, id=19772, stack(0x17d90000,0x17de0000)]
0x01add400 JavaThread "Signal Dispatcher" daemon [_thread_blocked, id=20192, stack(0x17d40000,0x17d90000)]
0x01ab2800 JavaThread "Finalizer" daemon [_thread_blocked, id=17344, stack(0x17cf0000,0x17d40000)]
0x01aabc00 JavaThread "Reference Handler" daemon [_thread_blocked, id=19964, stack(0x17ca0000,0x17cf0000)]
=>0x011ca000 JavaThread "main" [_thread_in_vm, id=20112, stack(0x01140000,0x01190000)]
Other Threads:
0x01aa7c00 VMThread [stack: 0x011d0000,0x01220000] [id=19144]
0x01b17400 WatcherThread [stack: 0x180f0000,0x18140000] [id=12792]
VM state:not at safepoint (normal execution)
VM Mutex/Monitor currently owned by a thread: None
Heap
def new generation total 4928K, used 768K [0x03bf0000, 0x04140000, 0x09140000)
eden space 4416K, 5% used [0x03bf0000, 0x03c30380, 0x04040000)
from space 512K, 100% used [0x040c0000, 0x04140000, 0x04140000)
to space 512K, 0% used [0x04040000, 0x04040000, 0x040c0000)
tenured generation total 10944K, used 1858K [0x09140000, 0x09bf0000, 0x13bf0000)
the space 10944K, 16% used [0x09140000, 0x09310948, 0x09310a00, 0x09bf0000)
compacting perm gen total 12288K, used 9598K [0x13bf0000, 0x147f0000, 0x17bf0000)
the space 12288K, 78% used [0x13bf0000, 0x1454fb70, 0x1454fc00, 0x147f0000)
No shared spaces configured.
Edited by: hanvyj on 07-Jun-2011 02:39
Edited by: hanvyj on 07-Jun-2011 02:43

I think I may have stumbled across the answer, It seems that the abstract class PerspectiveToolBar implements
the interface with the method public Container getContainer() but does not declare it, this should be fine because the method is abstract but it crashes. When I add the method public abstract Container getContainer(); to the abstract sub-class there is no error. I'm going to try make a small compilable example to see if I can reproduce it.
edit its actually only one of the two interface methods, and not getContainer(), but another one. If anyone is interested here is the interface:
public interface IMassSpectrometerPassableControlContainer
     Container getContainer();
     void reloadWidgetsOnVisible(boolean visible);
}and it works only if there is "public abstract void reloadWidgetsOnVisible(boolean visible);" in the abstract class PerspectiveToolBar implementing IMassSpectrometerPassableControlContainer.
I tried to reproduce it, but I can't get another class to repeat the behaviour, so I don't think I can post a bug report on it. Here is my attempt anyway:
import javax.swing.JToolBar;
* Class     Test.java
* Date:     7 Jun 2011
* @author     tofuser
public class Test extends Subclass
     public static void main(String args[])
          System.out.println("in main method");
          Test t = new Test();
          t.interfaceMethod();
     @Override
     public void interfaceMethod()
          System.out.println("interface method");
abstract class Subclass extends JToolBar implements Interface
     private static final long serialVersionUID = 1L;
     //this line is where it breaks in my code, including it works
     //public abstract void interfaceMethod();
interface Interface
     public abstract void interfaceMethod();
}Edited by: hanvyj on 07-Jun-2011 03:56

To access a method frm a class derived frm a base class with the same name

Here' s an example:-
class TestA {
public void start() {
System.out.println("TestA");
class TestB extends TestA {
public void start() {
System.out.println("TestB");
}In main method I do this:-
TestA testA = new TestA();
TestB testB = new TestB();
((TestA)testB).start();Output :-
TestB.
Now when i define the method as static :-
class TestA {
public static void start() {
System.out.println("TestA");
class TestB extends TestA {
public static void start() {
System.out.println("TestB");
}Then output is :-
TestA.
Can anyone let me know that when i say ((TestA)testB).start(); i.e i am type casting TestB obect to it base call then TestA should be printed but it doesn't print but when i declare method as static is does print TestA.
Thanks,
Heena

>
>
Secondly, when i say ((TestA).testB).start(); output is TestB. But when i define start() method as static output is TestA. I need clarity for the same.In the static case, all that the compiler is interested in is the class of the expression before the ".". Because you've put in an explicit cast the type of expression is assumed to be TestA the compiler doesn't know what kind of object will actually be referenced at runtime. In the static case which method is called is determined at compile time.
In the instance method case what determines the method called is determined the class of the actual, run time, value of the expression, and despite your cast, the actual value is still a reference to a TestB instance, so the TestB method is called. In the instance case which method called is determined at run time.

Synchronization In Base Class Method

I have a base class that has a synchronized method. Therefore, for example:
class TheBaseClass {
public synchronized doSomething() {
// do something
class A extends TheBaseClass {
class B extends TheBaseClass {
}If I instantiate two new classes, new A() and new B(), and call doSomething() in each of them, is the lock shared between the two of them? Or do both objects get their own object lock? (I assume this is the case but I want to double check).
Michael

Since a synchronized instance method syncs on the instance on which its called, each instance in your example is locked independently of the other. Furthermore, this: A a1 = new A();
A a2 = new A();
B b1 = new B();
B b2 = new B();
TheBaseClass a3 = new A();
TheBaseClass b3 = new B();leads to 6 distinct locks, and calling doSomething on any of those objects does not obtain a lock for any of the others.

Where to put methods in a abstract base class - subclasses system

Hi,
I’d like to ask a question on some basic design practice.
When there are methods which are common in some subclasses so I would like to “move them up” in the base abstract class, I would also like to make sure that the ADT concept of the base class itself is not broken. So I don’t want to have methods in the base class that are not general enough to be there. How to resolve this?
For example I create a base abstract class Vehicle. Then I create subclasses Plane and Tanker and realize that the startEnginge() method in them is the same and in order remove the duplicated code, I can put it in Vehicle. But later there may be Bicycle or Sled subclasses which don’t need startEngine().
In a broader sense, I would like to keep the Vehicle class as similar to the real word concept of vehicles as possible. And not evey vehicle have engine of course.
What is the solution?
Extending the class hierarchy by injecting another abstract class between the base and the subclasses? (e.g: VehicleWithEngine)
I suppose I can’t use Interfaces because I need to have the common implemenations as well.
Thanks for any comments in advance,
lemonboston
ps: I am a beginner and don't know the terminology, so if there are programming expression for the followings for example, I would be thankful if someone could help with this too:
- moving common methods up in the class hierarchy
- injecting a class in the hierarchy
- abstract base class - subclasses system

lemonboston wrote:
Hi,
I’d like to ask a question on some basic design practice.
When there are methods which are common in some subclasses so I would like to “move them up” in the base abstract class, I would also like to make sure that the ADT concept of the base class itself is not broken. So I don’t want to have methods in the base class that are not general enough to be there. How to resolve this?
You are talking about code.
Instead you need to talk about the design.
The base class represents conceptually a 'type' of something. That 'type' defines behavior. That behavior is what goes in the base class nothing else (in terms of design.)
If you have common functionality which does not fit into the definition (design) of the 'type' then you put it in another class and use (composition) that class in the sub class.
For example I create a base abstract class Vehicle. Then I create subclasses Plane and Tanker and realize that the startEnginge() method in them is the same and in order remove the duplicated code, I can put it in Vehicle. But later there may be Bicycle or Sled subclasses which don’t need startEngine(). No that is not how it works.
You have specific examples of some vehicles and then you need to manage those types generically. That is the first step.
Second step is then to determine what the exact 'type' is that you want to manage. And you use the requirements of the need to create the 'type'.
Then you look at the specific examples to determine how they will meet the needs of the type.
Thus if I have an application that must start the engines of all the vehicles in the city then I must have a vehicle class which has startEngine.
But if I have an application that manages vehicles as inventory (like a retail store) and then decide that because my examples both have engines that I might as well move it into the base class. In that case there is no 'need' for the application to manage starting vehicles. The fact that both have engines is irrelevant.
So looking back at your example you have stated functionality about your specific types but you have not stated anything about why your application needs to deal with that functionality generically.
Another way to think about it is that you do not put the shared functionality in the base because you can but rather because you must.

Override a private method in a Base class?

How can a subclass override a final method in its superclass.
This code compiles cleanly.
How is this possible?
Or Am I overlooking any point?
class MySuperClass{
private final String getMessage(){
     return "hello";
protected String getAnotherMessage(){
     return getMessage() + "world";
class MySubClass extends MySuperClass{
private final String getMessage(){
     return "hi";
public String getAnotherMessage(){
   return "anothermessage";
}

getMessage is declared as private in the base class, and therefor cannot be overridden in any subclass.
Edit: I think I understand the question better now. You want to know why it compiles when you think it shouldn't. It's because the private method isn't really inherited at all. Your subclass created a brand new private method of the same signature, but it's completely unrelated.

How to call a method of a base class if the base class is abstract...

This is my sample code>>>>
abstract class b {
     public void display() {
          System.out.println("I am in Base Class");
class test extends b {
     public static void main(String[] args) {
          test obj = new test();
          obj.display();
     public void display() {
          System.out.println("I am in Derived Class");
I want to call base class version of display with derived class object.........is it possible....

* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
* headdesk *
Enough with the friggin' zombie threads already!

How do I go about adding my own method to the class Calendar?

I want to add a method to the class Calendar that will parse a string and set it's date and time with what it parsed from the string. I allready have the parsing code written but I want to know how I can add this to the Calendar class.
I thought I could extend the Calendar class with something like this...
public abstract class myCalendar extends Calendar{
    public myCalendar() {
    public int parseDaytime(String givenLine){
        int flag = 1; //used to report errors
     //do some parsing
        return flag;
}But then in my main program I cannot use any of the Calendar methods...
            myCalendar timeFromServer;
         timeFromServer = timeFromServer.getInstance(); //error, it won't let me use the Calendar methods
            if(timeFromServer.parseDaytime(readFromServer) == 0){
                System.out.println("Error parsing time data from server.");
            }

Aside from my original question, I do not understand why extending Java classes is over kill. You listed the example of extending Thread as a big one. Everytime I create a worker Thread the class I create extends Threads because thats what I learned from every example I have looked at.
Okay. I should be good at writing this by now, so here goes....
You only get to inherit from a superclass once. You can implement as many interfaces as desired. As such, whenever you inherit from a class, you are limiting any other possible inheritance from another superclass. So, all things being equal, you should prefer interfaces to inheritance.
This is why java.lang.Runnable exists. There is almost never a reason to extend Thread. The normal 'is a' test is somewhat misleading in this case when determining whether to extend Thread or not. You may say, "My class is threaded, so I should extend Thread." However, while there exists an 'is a' relationship here, it is not salient. Your class undoubtedly is something else as well. The fact that it is threaded should be thought of as an aspect of feature of your class.
So, in general, you should implement Runnable and not extend Thread.
public class Foo implements Runnable {
   final public void run() {
       // cool asynchronous code goes here
public class FooUser {
   private void someMethod() {
       Thread thread = new Thread(new Foo());
       thread.start();
}- Saish

CS5 and AS3 external base class

In CS5.....
I have set my path to the file folder where classes are: desktop/folder/movie/classes
Inside that have another folder and 'interactive' folder, then the class inside that: classes/otherFolder/interactive/myclass.as
in the 'movie' folder I have a 'movie.fla' file. I changed the movie clip property base class to: 'otherFolder.interactive.myclass
(this is a lynda.com tut) Well it still can't find or changes back to the original movie clip class.
I'm in CS5 now and don't know how to get to the class to activate the component.
CS3 had not problem. Can someone please tell me what I'm doing wrong?
All I need to do is call the class from movie clip component or can't you do that in CS5?
Thanks,
Alex

Hi Kglad,
Nothing in Main.swf is referencing anything within ContentHolder.swf and the first thing the code in Frame 1 of ContentHolder.swf does is load Main.swf into a movieclip within ContentHolder.swf.
Code within ContentHolder.swf:
import mainClassCode;          //Class imported
var mnContent:Object;
var currentPage:Number = 1;
var pageScrolled:Number = 1;
var mLoader = new Loader();
var context:LoaderContext   = new LoaderContext();
context.applicationDomain   = new ApplicationDomain()
//_loadedApplicationDomain    = context.applicationDomain;
var mRequest:URLRequest = new URLRequest("Main.swf");
mLoader.contentLoaderInfo.addEventListener(Event.COMPLETE, contentLoaded);
mLoader.contentLoaderInfo.addEventListener(ProgressEvent.PROGRESS, contentLoading);
mLoader.load(mRequest, context);
function contentLoading(mProgress:ProgressEvent)
var percent:Number = mProgress.bytesLoaded/mProgress.bytesTotal;
trace(percent);
function contentLoaded(loadEvent:Event)
loadedSWF = loadEvent.currentTarget.content as MovieClip;
mcholder.addChild(loadedSWF);          //Main.swf added
trace("inside content loaded");
nxt.addEventListener(MouseEvent.CLICK, nextPge); // a button on stage
function nextPge(e:MouseEvent){
mnContent = new mainClassCode(); // object of Main.swf's class
mnContent.changeNextView();
First of a million error's :|
C:\Adobe\Flash CS4\Projects\proj\Classes\mainClassCode.as, Line 9 1180: Call to a possibly undefined method pages_Scroller.
pages_Scroller is a movieclip within the Main.swf library, which is being added onto the stage later in the code. This is the first line in mainClassCode.as
public class mainClassCode extends MovieClip {
var pagescroll:MovieClip = new pages_Scroller(); //This is the first error
var pageprev:MovieClip = new pages_previous(); //Second error and so on
All of it works absolutely fine when I only run Main.swf by itself. I hope this explains my problem

Unable to locate specified base class 'resources.style1.HelpButtonIcon' for component class

Hi,
I have a Flex (4.1.0) project, which has many skinnable custom components. The application allows a user to choose another style which changes these skins via loading a new compiled CSS. These non-default skins are in a separate Flex project. I've not had a problem with this method until now.
The custom component I am skinning contains several icons which are defined in the component like this:
[SkinPart(required="true", type="mx.core.IVisualElement")]
public var componentIconHelp:IFactory;
then I use the iconRendererFunction to return the appropriate component part:
private function iconRendererFunction(item:Object):IFactory
     //truncated method
     return componentIconHelp;
Within the skin for "style1", I then have
<s:Skin xmlns:fx="http://ns.adobe.com/mxml/2009"
     xmlns:s="library://ns.adobe.com/flex/spark"
     xmlns:mx="library://ns.adobe.com/flex/mx"
     xmlns:style1="resources.style1.*">

<fx:Metadata>
     [HostComponent("myApp.components.ButtonComponent")]
</fx:Metadata>
<fx:Declarations>
     <fx:Component id="componentIconHelp">
          <style1:HelpButtonIcon />
     </fx:Component>
</Declarations>
When I try to compile this, I get the "Unable to locate specified base class 'resources.style1.HelpButtonIcon' for component class 'resources.style1.ButtonComponentSkinInnerClass0'" error.
If I remove the HelpButtonIcon from the <fx:Component> declaration, and just put it in the main body of the skin, it compiles and renders, but I need it to be a component (there's multiple components I have to choose from to display, similar to the ButtonBar skin).
Any ideas why it's not compiling and what I need to do to achive this?
Thanks

Thanks, one step closer (or further away :-)
I tried adding the airspark.swc to the library path for the project and it made no difference so I added:
-external-library-path /Applications/Adobe Flash Builder 4/sdks/4.0.0/frameworks/libs/air/airspark.swc
to the external tools configuration and now get the error:
command line: Error: unable to open 'Flash'
The project itself runs fine, it's only the ASDocs that's causing problems.

Introspector calling the Base Class multiple times

Hi
I am having a Java Bean C (which extends B which in turn extends A) ...and each of these Classes have the BeanInfo classes .. ABeanInfo , BBeanInfo , CBeanInfo....
And i had written my beaninfos such a way that they are optimised by extending the basebeaninfo and calling super.getPropertyDescriptors and adding them to the Descriptoirs of extra methods like
Class A
private String name;
public void getName()
Class B extends A
private String city ;
public void getCity
class ABeanInfo extends SimpleBeanInfo
public PropertyDescriptors[] getPropertyDescriptors()
// Got the property descriptor for name
// return by forming array
My Class B bean info will look like this
class BBeanInfo extends ABeanInfo
public PropertyDescriptors[] getPropertyDescriptors()
PropertyDescriptors[] baseDesc = super.getPropertyDescriptors();
// Get the property descriptor for City
// Club the base class desc and the new ones added
// return by forming array
But when i use Introspector.getBeanInfo(B.class) , the A.getPropertyDescriptors method is getting called twice (One internally by the introspector and the other when my super.get...)
How can this be avoided ?? Ofcourse after the first time , the introspector is caching the instances of BeanInfos...
If this is the implicit behaviour , can i change my BeanInfo classses in such a way that it won't get called

Why is this a problem?

Initialize/set a base class from a another base class instance

Hi,
How can I initialize/set a base class from a another base class instance? I do not want to do a copy of it.
It would look something like:
class A {...}
class B extends A
    B(A a)
        // super = a;
    setA(A a)
        // super = a;
}Thank you.

erikku wrote:
Thanks Winton. It is what I did first but A has lots of methods and if methods are later added to A, I will have to edit B again. For those two reasons, I wanted to use inheritance. The part I was not sure with was the way to initialize B's base (A).You pays your money and you takes your choice. One way (this way) you have to provide forwarders; the other way (inheritance) you have to provide constructors (and if A has a lot of em, you may be writing quite a few).
Ask yourself this question: is every B also an A? No exceptions. Ever.
If the answer is 'yes', then inheritance is probably the best way to go.
However, if there is even the remotest chance that an instance of B should not exhibit 100% of the behaviour of A, now or in the future, then the wrapper style is probably what you want.
Another great advantage of the wrapper style is that methods can be added to A without affecting the API for B (unless you want to).
Winston
PS: If your Class A has a constructor or constructors that take a pile of parameters, you might also want to look at the Builder pattern. However, that's not really what we're talking about here, and it should probably be implemented on A anyway.

Adding methods to base classes

Similar Messages

Maybe you are looking for