Download Classes

Classes
Fields, methods, and constructors
Inheritance
CS 884 (Prasad)
Java Classes
1
Class Declaration
• Fields
(Type + Field initializer)
• Class variables (static)
• Instance variables
• Methods
( Signature + Code)
• Class methods (static)
• Instance methods
• Static Initializers ( Code to initialize class vars)
• Constructors (Code to initialize instance vars)
• Initialization blocks
CS 884 (Prasad)
Java Classes
2
Method Declaration
• Formal parameter names are distinct and
cannot be hidden.
• Actual arguments are passed by value.
• Method body is a block.
• Methods cannot be nested.
• (Mutual) Recursion is permitted.
• The body of a static (class) method can
refer only to static members.
CS 884 (Prasad)
Java Classes
3
Subclass
• class Object is the root of class hierarchy.
• Subclass Members
• (public/protected/default?) members inherited
from direct super-class.
• members inherited from direct super-interface.
• members explicitly declared in the subclass.
• Constructors and static initializers are not
inherited.
• Class with private constructors not instantiated.
• Default constructor for class C.
–
CS 884 (Prasad)
C( ) { super( ); }
Java Classes
4
Alternatives: when scopes overlap ...
Scopes of simple name x of members
E1 and E2 overlap
• Overloading: Both E1 and E2 available.
– If both are methods, use x if resolvable by signature.
– If both are constant fields, use qualified names.
If scope x/E2 included in scope x/E1, then
• Hiding: x refers to E2, but E1 exists and is
accessible by a qualified name or super.x.
• Overriding: x refers to E2, and E1 does not
exist. ( E1 in parent reusable using super.x. )
CS 884 (Prasad)
Java Classes
5
Field name conflicts
• Fields declared in a class must have distinct
names.
• Fields declared in a class hide fields inherited
(from the super-class or super-interfaces) with the
same simple name.
• Instance (static) field can hide static (instance) field.
• Fields inherited with same simple name must be
referred to using unambiguous names.
• Initialization: final fields, static fields, instance fields
(in each catergory: textual order)
CS 884 (Prasad)
Java Classes
6
Design Issues
class C {
TC x;
...}
class SC extends C {
TSC x;
...}
• If field redefinition were banned, adding a
“conflicting” field to C can invalidate SC.
Thus, while updating a class, a programmer
would have had to look into all the subclasses
before choosing a name!
CS 884 (Prasad)
Java Classes
7
• If overriding of fields were permitted, the
methods in C could break, even if TSC were to
be a subtype of TC. This is because type
correctness of assignments can be violated.
class C {
TC x;
TC y;
TC p() { x = y; y = x;
}
class SC extends C {
TSC x;
}
new SC().p();
return x; }
• ERROR: “x = y / y = x” unless TC
has same type as entity !!!
CS 884 (Prasad)
Java Classes
8
• In Java, type TSC and TC are unrelated,
and subclass field x hides class field x.
• In languages such as C++, addition of a field in
a parent class requires recompilation of
subclasses because storage requirement for a
subclass instance has changed.
– In Ada, clients of a package need to be recompiled
even when the private-section is modified
because storage requirements might have changed.
(Client code however remains unaltered.)
– In Modula-2, clients are not recompiled because
only reference types are used in this situation and
storage requirements are fixed a priori.
CS 884 (Prasad)
Java Classes
9
Solving Fragile Superclass Problem
• The Java compiler passes symbolic
references to members, while the interpreter
performs final name resolution at link-time.
• The storage layout of objects is not
determined by the compiler, but is deferred
to run time and determined by the
interpreter. Updated classes with new
instance variables or methods can be linked
in without affecting existing code.
CS 884 (Prasad)
Java Classes
10
Method name conflicts
• Method (Constructor) Signature
• name of the method
• number, type, and order of formal parameters
• Overloading: A class may not declare two methods with
the same signature.
• A declared instance (resp. static) method overrides (resp.
hides) an inherited instance (resp. static) method with the
same signature.
• Compile-time Error: if an instance (static) method has same
signature as an inherited static (instance) method.
CS 884 (Prasad)
Java Classes
11
Hidden/overidden members
• Compile-time Error: Two methods (declared or
hidden or overridden) with same signature but
different return types (or void ).
– Simplifies overload-resolution. (Cf. Ada)
• S func(int x) {} neither overloads nor overrides
T func(int x) {} if S =/= T.
• Hidden fields/ (static) methods can be accessed
using a name or a cast to super-class type or
using super.
• Overridden (instance) methods and parent
constructors can be accessed only using super.
CS 884 (Prasad)
Java Classes
12
Inheritance
A class inherits from its direct superclass and direct super-interfaces all the
fields and methods (whether
abstract or not) of the parents that
are accessible to the code (e.g.,
protected, but not private) and
are neither overridden nor hidden by a
declaration in the class.
CS 884 (Prasad)
Java Classes
13
• A class can inherit two or more fields with the
same name either from two interfaces or from its
super-class and an interface.
– Multiply inherited fields may be disambiguated using
qualified names.
• Hidden fields and private fields are implemented
by a subclass instance, that is, has storage
allocated for it.
• Hidden/overridden members may be accessed in
the subclass using qualified names or super.
• Private members declared in a class are not
accessible in a subclass.
CS 884 (Prasad)
Java Classes
14
Overriding and
Dynamic Binding
Illegal Overloading
and Overriding
class C {
void p() {}
}
class S extends C {
void p() {}
}
class C {
void p() {}
float p() {}
}
class S extends C {
int p() {}
}
C x = new S();
x.p()
CS 884 (Prasad)
Java Classes
15
Hiding and Overriding
class C {
int a = 84;
static int q() {}
int p() {...}
}
class S extends C {
int a = 77;
static int q() {
C.q();
...}
int p() {...
super.p();
...}
}
CS 884 (Prasad)
S x = new S();
C y = x;
(x.a == 77)
(y.a == 84)
(((C) x).a == 84)
(x.p() == y.p())
(((C)x).p() == y.p())
(x.q() != y.q())
(((C) x).q() == y.q())
Java Classes
16
Dynamic Binding
When an instance method is
invoked through an object reference,
the actual class of the object governs
which implementation is used. (In
contrast, when a field or a static
method is accessed, the declared type
of the reference is used.
CS 884 (Prasad)
Java Classes
17
Binding and Type System
CS 884 (Prasad)
Java Classes
18
Dynamic Binding in Java
class P {
public void f(P p) {
System.out.println("f(P) in P. ");
}
}
class C extends P {
public void f(P p) {
System.out.println("f(P) in C. ");
}
public void f(C cp) {
System.out.println("f(C) in C. ");
}
}
CS 884 (Prasad)
Java Classes
19
class DynamicBinding {
public static void
main(String[] args) {
P pp = new P();
C cc = new C();
P pc = cc;
pp.f(pp);
pp.f(cc);
pc.f(pp);
pc.f(cc);
cc.f(pp);
cc.f(cc);
}
}
CS 884 (Prasad)
Java Classes
20
Abbreviated Example
class P {
public void f(P p){}
}
class C extends P {
public void f(P p){}
public void f(C c){}
}
P pp
C cc
P pc
pc.f(pp);
pc.f(cc);
cc.f(pp);
cc.f(cc);
= new P();
= new C();
= cc;
CS 884 (Prasad)
pp.f(pp);
pp.f(cc);
Java Classes
21
Compile-time vs Run-time (binding)
pp.f(pp);
pp.f(cc);
>=P f(P) {}
>=P f(P) {}
(coercion)
pc.f(pp);
pc.f(cc);
cc.f(pp);
cc.f(cc);
CS 884 (Prasad)
>=P f(P) {}
>=P f(P) {}
(coercion)
>=C f(P) {}
>=C f(C) {}
Java Classes
P f(P) {}
P f(P) {}
(coercion)
C f(P) {}
C f(P) {}
(coercion)
C f(P) {}
C f(C) {}
22
Static binding of Signatures, Dynamic binding of Code
class P {
public void f(P p){System.out.println("f(P) in P. "); }
}
class C extends P {
public void f(P p){System.out.println("f(P) in C. ");}
public void f(C c){System.out.println("f(C) in C. "); }
}
class DYNAMIC2 {
public static void main(String[] args) {
P pp
= new P();
P pc
= cc;
C cc
= new C();
pp.f(cc);
pc.f(pp);
pc.f(cc);
cc.f(pc);
cc.f(cc);
((P) cc).f(cc);
((P) cc).f((P) cc);
}
}
CS 884 (Prasad)
Java Classes
23
Static binding of Signatures, Dynamic binding of Code
class P {
public void f(P p){System.out.println("f(P) in P. "); }
public void f(C c){System.out.println("f(C) in P. "); }
}
class C extends P {
public void f(P p){System.out.println("f(P) in C. ");}
}
class DYNAMIC {
public static void main(String[] args) {
P pp
= new P();
P pc
= cc;
C cc
= new C();
pp.f(cc);
pc.f(pp);
pc.f(cc);
cc.f(pc);
cc.f(cc);
// Error: < Java 1.4 Fine: > Java 5
((P) cc).f(cc);
((P) cc).f((P) cc);
}
}
CS 884 (Prasad)
Java Classes
24
Keywords : Abstract, Final
• final field = (constant declaration) (requires initializer).
- final ref type field = (fixed object , state changeable).
• final class method = (subclass cannot hide).
• final instance method = (subclass cannot override).
• code for final methods can be in-lined.
(no dynamic binding necessary)
• abstract class method = compile-time error.
• abstract instance method = (no implementation).
CS 884 (Prasad)
Java Classes
25
(cont’d)
• An abstract method can override a non-abstract
method. This forces subclasses to re-implement
the latter.
• final class = (no subclass).
• abstract class = (can contain abstract method).
(cannot be instantiated).
• final and abstract = compile-time error.
• interface = (all fields final, all methods abstract).
CS 884 (Prasad)
Java Classes
26
Abstract Class
Factors commonality for reuse : Framework.
abstract class Sorters {
abstract boolean compare (Employee e1, Employee e2);
public void sort( Employee [] ea) {
... }
}
Subclasses: Sort_Increasing, Sort_Decreasing,
Sort_on_Name, Sort_on_Age, Sort_on_Salary.
CS 884 (Prasad)
Java Classes
27
“Implementing” method
• An inherited (a declared) method from (in) superclass (class) implements/overrides methods with
the same signature (multiply) inherited from
super-interfaces.
• Methods are overridden on a signature-bysignature basis.
• The actual method executed when an instance
method is invoked on an object is determined at
run-time, using dynamic method lookup.
• Static method invocation is fixed at compile-time.
CS 884 (Prasad)
Java Classes
28
Classes : public vs non-public
• public classes are accessible outside the
package using fully-qualified name or singletype-import declaration.
• non-public classes are not accessible.
• However, an instance of a non-public subclass
(of a public class) may get assigned indirectly.
• However, a public field / method of a nonpublic subclass (of a public class) may be
accessed / invoked indirectly through dynamic
binding.
CS 884 (Prasad)
Java Classes
29
package points;
public class Point {
public int x, y;
public void move(int dx, int dy) {
x += dx; y += dy;
}
}
package morePoints;
class Point3d extends points.Point {
public int z;
public void move(int dx,int dy,int dz){
super.move(dx, dy); z += dz;
}
}
CS 884 (Prasad)
Java Classes
30
package morePoints;
public class OnePoint {
static points.Point getOne() {
return new Point3d();
}
}
in: package different:
call: points.Point p =
morePoints.OnePoint.getOne();
CS 884 (Prasad)
Java Classes
31
package morePoints;
public class Point4d extends Point3d {
public int w;
public void move(int dx, int dy,
int dz, int dw) {
super.move(dx, dy, dz);
w += dw;
}
}
in:
call:
CS 884 (Prasad)
package different:
( new Point4d() ).z
Java Classes
;
32
Other Implicit Constraints
• Access modifier of an hiding/overriding method
must provide at least as much access as the
hidden/overridden method.
• Otherwise, access barrier beaten by casting.
• An implementing/overriding method can throw
only a subset of checked exceptions in the throws
clause of overridden method.
• Otherwise, dynamic binding can defeat guarantees
associated with checked exceptions.
CS 884 (Prasad)
Java Classes
33
Dynamic binding :
Banned Access Control, Exceptions
class C {
public void p() {}
int q() {}
}
class S extends C {
private void p() {}
int q() throws Exception {}
}
C x = new S();
x.p()
CS 884 (Prasad)
Java Classes
34
Constructors
• Modifiers
• Legal: public, protected, private
• Illegal: abstract, final, static
• In the absence of explicit constructor
definition, a default no-argument
constructor is supplied.
• this, super
– Normally, this refers to the current object,
and super to (compile-time) direct superclass.
CS 884 (Prasad)
Java Classes
35
(cont’d)
• this, super as constructor calls
– In the first statement of a constructor
body, this(…) invokes another
constructor of the same class, and
super(…) invokes a constructor of the
direct super-class.
• Enables reuse of initialization code.
• Factoring common code.
– In the absence of explicit constructor
invocation (this(...)/super(...)), the default
super(); is called.
CS 884 (Prasad)
Java Classes
36
Constructor Initialization Sequence
• When an object is created, all the fields are set to default
values for their respective types before a constructor is
invoked.
• Each constructor has three phases:
– Invoke a super-class’s constructor.
– Initialize the fields using their initializers and
initialization blocks (in the order of appearance).
– Execute the body of the constructor.
• Interaction with dynamic lookup : the body of an instance
method can require a field before it is explicitly
initialized.
CS 884 (Prasad)
Java Classes
37
Example: Transient field values
class P3 {
int m = 3;
P3() {}
void mag() {System.out.println(m);}
}
class C2 extends P3{
int n;
C2() {m = 2; n = 2;}
}
• In steady state, mag for P3-objects prints 3 and
mag for C2-objects prints 2.
CS 884 (Prasad)
Java Classes
38
(cont’d)
class P3 {
int m = 3;
P3() {mag();}
void mag() {System.out.println(m);}
}
class C2 extends P3{
int n;
C2() {m = 2; n = 2;}
}
• When a P3-object or a C2-object is created, mag
prints 3.
CS 884 (Prasad)
Java Classes
39
(cont’d)
class P3 {
int m = 3;
P3() {mag();}
void mag() {System.out.println(m);}
}
class C2 extends P3{
int n;
C2() {m = 2; n = 2;}
void mag() {System.out.println(m*n);}
}
• When a C2-object is created, mag prints 0, even
though in the steady state mag prints 4.
CS 884 (Prasad)
Java Classes
40
Transient field values (SKIP)
class P3 {
int m = 3;
P3() {}
void mag(int x) {x = m*x;}
}
class C2 extends P3{
int n;
C2() {m = 2; n = 2;}
}
P3() {int i = 5; mag(i);}
void mag(int x) {x = m*n*x;}
• mag for P3-objects (C2-objects) triples (doubles)
its arg.
• However, if mag is invoked in P3(), on behalf of
C2(), it triples, not doubles, its arg.
• If mag is now overridden in C2 to quadruple its
arg, it actually zeros its arg when invoked in P3()
for C2.
CS 884 (Prasad)
Java Classes
41
Protected Members: revisited
• The protected constructors / protected overridden
methods of a class are accessible to its subclass
(even outside the package) through super.
• The protected fields of a class are present in the
instances of its subclass (even outside the
package), and the protected methods are
inherited.
• A protected member of a class can be accessed
from a subclass (even outside the package)
through an object reference that is at least the
same type as the subclass.
CS 884 (Prasad)
Java Classes
42
Miscellaneous
• Wrapper Classes needed to make objects
out of primitive types.
• Primitive types int, boolean, etc. associated with
wrapper classes Integer, Boolean, etc.
• Marking methods and classes as final can
improve security.
• validatePassword
• IsA relationship vs HasA relationship
• Dog IsA Mammal,
Dog HasA Tail
• Square IsA Rectangle, Rectangle HasA Side
CS 884 (Prasad)
Java Classes
43
• The reference type Object can be used to
approximate parameterized types.
• Cf. Ada generics, C++ templates, ML’s
polymorphic types.
• E.g., the utility classes such as Vector,
Stack, etc can declare the type of element as
Object, enabling them to be used for any
instance.
– Type casts are however needed to ensure
type safety.
CS 884 (Prasad)
Java Classes
44
Further Updates
• Java 5: Autoboxing and unboxing
• Java 5: Generics
CS 884 (Prasad)
Java Classes
45