Classes

1. Classes Fields, methods, and constructors Inheritance Java Classes

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 Java Classes

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. Java Classes

4. Subclass • classObjectis 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 notinherited. • Class with private constructors not instantiated. • Default constructor for classC. • C( ) { super( ); } Java Classes

5. Alternatives: when scopes overlap ... Scopes of simple namexof members E1andE2overlap • 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 scopex/E2includedin scopex/E1, then • Hiding:xrefers to E2, but E1 exists and is accessible by a qualified name orsuper.x. • Overriding:xrefers to E2, and E1 does not exist. ( E1in parent reusable usingsuper.x.) Java Classes

6. Field name conflicts • Fields declared in a class must have distinct names. • Fields declared in a class hidefields 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: textualorder) Java Classes

7. Design Issues classC { class SCextendsC { TCx; TSCx; ...} ...} • 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! Java Classes

8. If overriding of fields were permitted, themethods inCcouldbreak, even ifTSCwereto be asubtypeofTC. 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 !!! Java Classes

9. In Java, typeTSCandTCare unrelated, and subclass field xhides 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. Java Classes

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. Java Classes

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)methodoverrides(resp. hides) an inherited instance(resp. static)methodwith the same signature. • Compile-time Error:if aninstance(static)methodhas same signature as aninherited static(instance)method. Java Classes

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. Java Classes

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. Java Classes

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. Java Classes

15. Overriding and Dynamic Binding class C { void p() {} } class S extends C { void p() {} } C x = new S(); x.p() Illegal Overloading and Overriding class C { void p() {} float p() {} } class S extends C { int p() {} } Java Classes

16. 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(); ...} } Hiding and Overriding Java Classes

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. Java Classes

18. Binding and Type System Java Classes

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. "); } } Java Classes

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); } } Java Classes

21. 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; pp.f(pp); pp.f(cc); pc.f(pp); pc.f(cc); cc.f(pp); cc.f(cc); Abbreviated Example Java Classes

22. pp.f(pp); pp.f(cc); pc.f(pp); pc.f(cc); cc.f(pp); cc.f(cc); >=P f(P) {} >=P f(P) {} (coercion) >=P f(P) {} >=P f(P) {} (coercion) >=C f(P) {} >=C f(C) {} Compile-time vs Run-time (binding) P f(P) {} P f(P) {} (coercion) C f(P) {} C f(P) {} (coercion) C f(P) {} C f(C) {} 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. "); } } 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); } } Java Classes

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: < Java 1.4 Fine: > Java 5 ((P) cc).f(cc); ((P) cc).f((P) cc); } } Java Classes

25. Keywords : Abstract, Final • final field = (constant declaration)(requires initializer). - finalreftype field = (fixed object , state changeable). • final class method = (subclass cannot hide). • finalinstancemethod = (subclass cannot override). • code forfinal methods can be in-lined. (no dynamic binding necessary) • abstractclassmethod = compile-time error. • abstractinstancemethod = (noimplementation). Java Classes

26. (cont’d) • An abstract method can override a non-abstractmethod. 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 fieldsfinal, all methodsabstract). Java Classes

27. Abstract Class Factors commonality for reuse : Framework. abstractclassSorters{ abstractbooleancompare(Employee e1, Employee e2); publicvoidsort( Employee [] ea) { ... } } Subclasses: Sort_Increasing, Sort_Decreasing, Sort_on_Name, Sort_on_Age, Sort_on_Salary. Java Classes

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. Java Classes

29. Classes : publicvs non-public • publicclasses are accessible outside the package usingfully-qualified nameorsingle-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. Java Classes

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; } } Java Classes

31. package morePoints; public class OnePoint { static points.Point getOne() { return new Point3d(); } } in: package different: call: points.Point p = morePoints.OnePoint.getOne(); Java Classes

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 ; Java Classes

33. Other Implicit Constraints • Access modifierof 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 throwonly a subset ofchecked exceptions in the throws clause of overridden method. • Otherwise, dynamic binding can defeat guarantees associated with checked exceptions. Java Classes

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() Java Classes

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. Java Classes

36. (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(…) invokesa 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. Java Classes

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-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 ofan instance method can require a field before it is explicitly initialized. Java Classes

38. Example: Transient field values classP3 { intm = 3; P3() {} voidmag() {System.out.println(m);} } classC2extendsP3{ intn; C2() {m = 2; n = 2;} } • In steady state, mag for P3-objects prints 3 and mag for C2-objects prints 2. Java Classes

39. (cont’d) classP3 { intm = 3; P3() {mag();} voidmag() {System.out.println(m);} } classC2extendsP3{ intn; C2() {m = 2; n = 2;} } • When aP3-object or a C2-object is created, mag prints 3. Java Classes

40. (cont’d) classP3 { intm = 3; P3() {mag();} voidmag() {System.out.println(m);} } classC2extendsP3{ intn; C2() {m = 2; n = 2;} voidmag() {System.out.println(m*n);} } • When a C2-object is created, mag prints 0, even though in the steady state mag prints 4. Java Classes

41. Transient field values (SKIP) classP3 { intm = 3; P3() {} P3() {inti = 5; mag(i);} voidmag(int x) {x = m*x;} } classC2extendsP3{ intn; C2() {m = 2; n = 2;}voidmag(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 ofC2(), 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. Java Classes

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. Java Classes

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 vsHasA relationship • Dog IsA Mammal, Dog HasA Tail • Square IsA Rectangle, Rectangle HasA Side Java Classes

44. 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. Java Classes

45. Further Updates • Java 5: Autoboxing and unboxing • Java 5: Generics Java Classes