Classes - PowerPoint PPT Presentation

Loading...

PPT – Classes PowerPoint presentation | free to download - id: 14c02f-NDEyZ



Loading


The Adobe Flash plugin is needed to view this content

Get the plugin now

View by Category
About This Presentation
Title:

Classes

Description:

Compile-time Error: Two methods (declared or hidden or overridden) with same ... This forces subclasses to re-implement the latter. final class = (no subclass) ... – PowerPoint PPT presentation

Number of Views:42
Avg rating:3.0/5.0
Slides: 46
Provided by: csWr
Learn more at: http://www.cs.wright.edu
Category:

less

Write a Comment
User Comments (0)
Transcript and Presenter's Notes

Title: 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
About PowerShow.com