Scott: /* Callbacks: */

2011-01-31T21:55:46Z

Callbacks:

New page

==Inheritance==

Creating a subclass:
<source lang="java">
class SubClass extends SuperClass{}
</source>

==Polymorphism==
The subclass automatically inherits the superclass's methods. These may be overridden as needed. "Dynamic binding" refers to the fact that the version of an overloaded function which gets used is decided at runtime, based on the type of the object making the call. A subclass's constructor may use the superclass's constructor as super, but this must be the first command:
<source lang="java">
public SubClass(int n){
super(n-1); //SuperClass's constructor
...other setup...
}
</source>

Accessing superclass versions of methods from a subclass: <span id="line-23" class="anchor"></span><span id="line-24" class="anchor"></span>
<source lang="java">
super.someFunction(String s);
</source>

Using subtypes and casting:super.someFunction(String s);
<source lang="java">
SuperClass a = new SubClass();
SubClass b = (SubClass)a;
(a instanceof SuperClass) //true
(a instanceof SubClass) //true
SuperClass c = new SuperClass;
(c instanceof SubClass) //false
</source>

==Abstract Classes==
Create an abstract class with
<source lang="java">
abstract class MyClass{}
</source>

An abstract class may contain abstract methods:
<source lang="java">
public abstract method1(int n);
</source>

Abstract methods don't have an implementation. Any nonabstract class that extends an abstract class must provide an implementation for any abstract methods.

==Protected==

A protected method is visible to subclasses (and to the current package).

Protected attributes should be used with caution.

==Reflection==
Given an arbitrary object at runtime, you can get all the information about its class: the type, fields, constructors, and methods. In addition, you can execute an arbitrary method.

==Interface==
This is Java's way of implementing multiple inheritance.
<source lang="java">
class MyClass implements Interface1{}
</source>

An interface can be instantiated (but not with new()). An interface doesn't have a constructor.
<source lang="java">
Interface1[] i1Array;
</source>

An interface can have subinterfaces:
<source lang="java">
interface SubInter extends SuperInter{}
</source>

===Callbacks===
Interfaces are the preferred way of having an instantiated object talk back to its instantiator:
<source lang="java">
class Instantiator implements ActionListener {
MyProcess mp;
public void doProcess(){
mp = new MyProcess(this);
mp.run();
}

public void actionPerformed(...){
...now the process is finished...
}
}

class MyProcess extends Thread {
ActionListener al;
MyProcess(ActionListener){...}
public void run(){
...do stuff..
//now call back
al.actionPerformed(...);
}
}
</source>

Java Objects - Revision history

Scott: /* Callbacks: */