Classes

1
Classes

• Fields, methods, and constructors
• Inheritance

2
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

3
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.

4
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.
• C( ) super( )

5
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. )

6
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)

7
Design Issues

• class C class SC extends C
• TC x 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!

8

• 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 return x
• class SC extends C
• TSC x
• new SC().p()
• ERROR x y / y x unless TC has same type as
  entity !!!

9

• 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.

10
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.

11
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.

12
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.

13
Inheritance

• A class inherits from its direct super-class
  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.

14

• 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.

15

• Illegal Overloading
• and Overriding
• class C
• void p()
• float p()
• class S extends C
• int p()

• Overriding and Dynamic Binding
• class C
• void p()
• class S extends C
• void p()
• C x new S()
• x.p()

16
Hiding and Overriding

• 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())

• 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()
• ...

17
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.

18
Binding and Type System
19
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. ")

20

• 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)

21
Abbreviated Example

• pp.f(pp)
• pp.f(cc)
• pc.f(pp)
• pc.f(cc)
• cc.f(pp)
• cc.f(cc)

• class P
• public void f(P p)
• class C extends P
• public void f(P p)
• public void f(C c)
• P pp new P()
• C cc new C()
• P pc cc

22
Compile-time vs Run-time (binding)

• pp.f(pp)
• pp.f(cc)
• pc.f(pp)
• pc.f(cc)
• cc.f(pp)
• cc.f(cc)

• gtP f(P)
• gtP f(P)
• (coercion)
• gtP f(P)
• gtP f(P)
• (coercion)
• gtC f(P)
• gtC f(C)

P f(P)
P f(P) (coercion)
C f(P)
C f(P) (coercion)
C f(P)
C f(C)
23

• 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() C cc new C()
• P pc cc
• pp.f(cc) pc.f(pp)
• pc.f(cc) cc.f(pc)
• cc.f(cc)
• ((P) cc).f(cc) ((P) cc).f((P)
  cc)

24

• 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() C cc new C()
• P pc cc
• pp.f(cc) pc.f(pp)
• pc.f(cc) cc.f(pc)
• cc.f(cc) // Error lt Java 1.4 Fine
  gt Java 5
• ((P) cc).f(cc) ((P) cc).f((P)
  cc)

25
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).

26
(contd)

• 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).

27
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.

28
Implementing method

• An inherited (a declared) method from (in)
  super-class (class) implements/overrides methods
  with the same signature (multiply) inherited from
  super-interfaces.
• Methods are overridden on a signature-by-signature
  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.

29
Classes public vs non-public

• public classes are accessible outside the package
  using fully-qualified name or single-type-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
  non-public subclass (of a public class) may be
  accessed / invoked indirectly through dynamic
  binding.

30

• 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

31

• package morePoints
• public class OnePoint
• static points.Point getOne()
• return new Point3d()
• in package different
• call points.Point p
• morePoints.OnePoint.getOne()

32

• 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 package different
• call ( new Point4d() ).z

33
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.

34
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()

35
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 super-class.

36
(contd)

• 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.

37
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-classs 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.

38
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.

39
(contd)

• 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.

40
(contd)

• 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(mn)
  
• When a C2-object is created, mag prints 0, even
  though in the steady state mag prints 4.

41
Transient field values (SKIP)

• class P3
• int m 3
• P3()
  P3() int i 5 mag(i)
• void mag(int x) x mx
• class C2 extends P3
• int n
• C2() m 2 n 2 void mag(int
  x) x mnx
• 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.

42
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.

43
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

44

• The reference type Object can be used to
  approximate parameterized types.
• Cf. Ada generics, C templates, MLs
  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.

45
Further Updates

• Java 5 Autoboxing and unboxing
• Java 5 Generics