Classes Fields methods and constructors Inheritance CS 884

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 E 1 and E 2 overlap • Overloading: Both E 1 and E 2 available. – If both are methods, use x if resolvable by signature. – If both are constant fields, use qualified names. If scope x/E 2 included in scope x/E 1, then • Hiding: x refers to E 2, but E 1 exists and is accessible by a qualified name or super. x. • Overriding: x refers to E 2, and E 1 does not exist. ( E 1 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 Dynamic. Binding { 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) {} (coercion) pc. f(pp); pc. f(cc); cc. f(pp); cc. f(cc); CS 884 (Prasad) >=P f(P) {} (coercion) >=C f(P) {} >=C f(C) {} Java Classes P 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 DYNAMIC 2 { 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 e 1, Employee e 2); 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 more. Points; class Point 3 d 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 more. Points; public class One. Point { static points. Point get. One() { return new Point 3 d(); } } in: package different: call: points. Point p = more. Points. One. Point. get. One(); CS 884 (Prasad) Java Classes 31

package more. Points; public class Point 4 d extends Point 3 d { 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 Point 4 d() ). 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 P 3 { int m = 3; P 3() {} void mag() {System. out. println(m); } } class C 2 extends P 3{ int n; C 2() {m = 2; n = 2; } } • In steady state, mag for P 3 -objects prints 3 and mag for C 2 -objects prints 2. CS 884 (Prasad) Java Classes 38

(cont’d) class P 3 { int m = 3; P 3() {mag(); } void mag() {System. out. println(m); } } class C 2 extends P 3{ int n; C 2() {m = 2; n = 2; } } • When a P 3 -object or a C 2 -object is created, mag prints 3. CS 884 (Prasad) Java Classes 39

(cont’d) class P 3 { int m = 3; P 3() {mag(); } void mag() {System. out. println(m); } } class C 2 extends P 3{ int n; C 2() {m = 2; n = 2; } void mag() {System. out. println(m*n); } } • When a C 2 -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 P 3 { int m = 3; P 3() {} void mag(int x) {x = m*x; } } class C 2 extends P 3{ int n; C 2() {m = 2; n = 2; } } P 3() {int i = 5; mag(i); } void mag(int x) {x = m*n*x; } • mag for P 3 -objects (C 2 -objects) triples (doubles) its arg. • However, if mag is invoked in P 3(), on behalf of C 2(), it triples, not doubles, its arg. • If mag is now overridden in C 2 to quadruple its arg, it actually zeros its arg when invoked in P 3() for C 2. 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. • validate. Password • Is. A relationship vs Has. A relationship • Dog Is. A Mammal, Dog Has. A Tail • Square Is. A Rectangle, Rectangle Has. A 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