Inheritance and Class Hierarchies Chapter 3 Fall 2007
- Slides: 47
Inheritance and Class Hierarchies Chapter 3 Fall 2007 CS 225 1
Chapter Topics • • • Inheritance and how it facilitates code reuse Polymorphism Abstract classes The Object class and its methods Method overriding Cloning and the difference between a true clone (deep copy) and a shallow copy Fall 2007 CS 225 2
Chapter Topics (continued) • Single versus multiple inheritance • Interfaces and delegation to simulate multiple inheritance • Object factory design pattern • Packages and visibility Fall 2007 CS 225 3
Inheritance and Class Hierarchies • One advantage of OOP is that it enables programmers to reuse previously written code saved as classes • All Java classes are arranged in a hierarchy, starting with Object, which is the superclass of all Java classes • Inheritance in OOP is analogous to inheritance in humans • Inheritance and hierarchical organization allow you to capture the idea that one thing may be a refinement or extension of another Fall 2007 CS 225 4
Fall 2007 CS 225 5
Is-a Versus Has-a Relationships • One misuse of inheritance is confusing the has-a relationship with the is-a relationship • The has-a relationship means that one class has the second class as an attribute • We can combine is-a and has-a relationships • The keyword extends specifies that one class is a subclass of another Fall 2007 CS 225 6
A Superclass and a Subclass • Consider two classes: Computer and Laptop • A laptop is a kind of computer and is therefore a subclass of computer Fall 2007 CS 225 7
Where would you add • • Cost Battery Time to discharge Number of expansion slots • Wireless card present Fall 2007 CS 225 8
Initializing Superclass Data • Private data fields belonging to a base class must be initialized by invoking the base class’s constructor with the appropriate parameters • If the execution of any constructor in a subclass does not invoke a superclass constructor, Java automatically invokes the no-parameter constructor for the superclass – Initializes that part of the object inherited from the superclass before the subclass starts to initialize its part of the object Fall 2007 CS 225 9
Protected Visibility • Private data fields are not accessible to derived classes • Protected visibility allows data fields to be accessed either by the class defining it or any subclass • In general, it is better to use private visibility because subclasses may be written by different programmers and it is always good practice to restrict and control access to the superclass data fields Fall 2007 CS 225 10
Method Overriding • If a derived class has a method found within its base class, that method will override the base class’s method • The keyword super can be used to gain access to superclass methods overridden by the base class • A subclass method must have the same return type as the corresponding superclass method Fall 2007 CS 225 11
Method Overloading • Method overloading: having multiple methods with the same name but different signatures in a class • Constructors are often overloaded • Example: – My. Class(int input. A, int input. B) – My. Class(int input. A, int input. B, double input. C) Fall 2007 CS 225 12
Polymorphism • A variable of a superclass type can reference an object of a subclass type • Polymorphism means many forms or many shapes • Polymorphism allows the JVM to determine which method to invoke at run time • At compile time, the Java compiler can’t determine what type of object a superclass may reference but it is known at run time Fall 2007 CS 225 13
Example Computer [] comp = new Computer[3]; comp[0] = new Computer( …); comp[1] = new Lap. Top( …); comp[2] = new Computer( …) for (int i=0; i<comp. length; i++) System. out. println( comp[I]. get. Ram. Size() + "n" + comp[I]. to. String(); Fall 2007 CS 225 14
Interfaces • An interface can declare methods but does not provide an implementation of those methods – Methods declared in an interface are called abstract methods Fall 2007 CS 225 15
Abstract Classes • An abstract class can have abstract methods, data fields, and concrete methods • Abstract class differs from a concrete class in that – it cannot be instantiated – it can declare abstract methods, which must be implemented in its subclasses Fall 2007 CS 225 16
Abstract Classes and Interfaces • Like an interface, an abstract class can’t be instantiated • An abstract class can have constructors to initialize its data fields when a new subclass is created – Subclass uses super(…) to call the constructor • May implement an interface but it doesn’t have to define all of the methods declared in the interface – Implementation is left to its subclasses Fall 2007 CS 225 17
Abstract Class Number and the Java Wrapper Classes Fall 2007 CS 225 18
Summary of Features of Actual Classes, Abstract Classes, and Interfaces Fall 2007 CS 225 19
Class Object • Object is the root of the class hierarchy • All classes inherit the methods defined in class Object but may be overridden Fall 2007 CS 225 20
The Method to. String • You should always override the to. String method if you want to represent an object’s state • If you do not override it, the to. String method for class Object will return a string…just not the string you want or are expecting Fall 2007 CS 225 21
Operations Determined by Type of Reference Variable • A variable can reference an object whose type is a subclass of the variable type – The type of reference, not the type of the object referenced, determines what operations can be performed • Java is strongly typed so the compiler needs to be able to verify that the type of the expression being assigned is compatible with the variable type Fall 2007 CS 225 22
Casting in a Class Hierarchy • Java provides casting to enable us to process an object referenced by one type through a reference variable of its actual type • Casting does not change the object referenced; it creates an anonymous reference to that object • Downcast: cast a higher type to a lower type • The instanceof operator can guard against Class. Cast. Exception errors • You can downcast an interface reference to the specific implementation type Fall 2007 CS 225 23
Java 5. 0 Reduces Need for Casting • Two new features that reduce the need for casting: – Autoboxing/unboxing – Generics • Autoboxing/unboxing eases the conversion between a primitive type and its corresponding wrapper type Fall 2007 CS 225 24
The Method Object. equals • The Object. equals method has a parameter of type Object • Compares two objects to determine whether they are equal • You must override the equals method if you want to be able to compare two objects of a class Fall 2007 CS 225 25
Cloning • The purpose of cloning in object-oriented programming is analogous to cloning in biology – Create an independent copy of an object • Initially, both objects will store the same information • You can change one object without affecting the other Fall 2007 CS 225 26
Cloning • The purpose of cloning in object-oriented programming is analogous to cloning in biology – Create an independent copy of an object • Initially, both objects will store the same information • You can change one object without affecting the other Will cause both e 1. name and e 2. name to reference “Jim” Fall 2007 CS 225 27
The Shallow Copy Problem Fall 2007 CS 225 28
• The statement e 1. set. Address. Line 1("Room 224"); creates a new String object that is referenced by e 1. address. line 1 and e 2. address. line 1 Fall 2007 CS 225 29
The Object. clone method • Java provides the Object. clone method to help solve the shallow copy problem • The initial copy is a shallow copy as the current object’s data fields are copied • To make a deep copy, you must create cloned copies of all components by invoking their respective clone methods Fall 2007 CS 225 30
Cloning • After e 1. set. Address. Line 1("Room 224"); only e 1. address. line 1 references the new String Fall 2007 CS 225 object. 31
Employee. clone() public Object clone() { try { Employee cloned = (Employee) super. clone(); cloned. address = (Address)address. clone(); return cloned; } catch (Clone. Not. Supported. Exception ex){ throw new Internal. Error(); } Fall 2007 CS 225 32
Address. clone() public Object clone() { try { Address cloned = (Address) super. clone(); return cloned; } catch (Clone. Not. Supported. Exception ex){ throw new Internal. Error(); } Fall 2007 CS 225 33
Multiple Inheritance • Multiple inheritance: the ability to extend more than one class • Multiple inheritance is a language feature that is difficult to implement and can lead to ambiguity – Therefore, Java does not allow a class to extend more than one class Fall 2007 CS 225 34
Multiple Interfaces to Emulate Multiple Inheritance Fall 2007 CS 225 35
Reuse Through Delegation • Delegation is used to reduce – duplication of modifications • problems associated with version control – A method of one class accomplishes an operation by delegating it to a method of another class Fall 2007 CS 225 36
Packages • The Java API is organized into packages • The package to which a class belongs is declared by the first statement in the file in which the class is defined using the keyword package followed by the package name • All classes in the same package are stored in the same directory or folder • All the classes in one folder must declare themselves to be in the same package • Classes that are not part of a package may access only public members of classes in the Fall 2007 CS 225 37 package
Package Visibility • There exists a default package – Files that do specify a package are considered part of the default package • If you don’t declare packages, all of your packages belong to the same, default package • Package visibility sits between private and protected Fall 2007 • Classes, data fields, and methods with package visibility are accessible to all other methods of the same package but are not accessible to methods outside of the package • Classes, data fields, and methods that are declared protected are visible to CS all 225 members of the package 38
Visibility Supports Encapsulation • The rules for visibility control how encapsulation occurs in a Java program • Private visibility is for members of a class that should not be accessible to anyone but the class, not even the classes that extend it • Package visibility allows the developer of a library to shield classes and class members from classes outside the package • Use of protected visibility allows the package developer to give control to other programmers who want to extend classes in Fall 2007 CS 225 39 the package
Visibility Summary Fall 2007 CS 225 40
Case Study: Problem Statement • We want to draw some standard geometric shapes on the screen – rectangle, circle, right triangle • Each shape has properties – position on the screen – interior color – border color • Methods for – area, perimeter Fall 2007 CS 225 41
A Shape Class Hierarchy Fall 2007 CS 225 42
Rectangle Members Fall 2007 CS 225 43
Fall 2007 CS 225 44
A Shape Class Hierarchy (continued) Fall 2007 CS 225 45
Object Factories • An object factory is a method that creates instances of other classes • Object factories are useful when: – The necessary parameters are not known or must be derived via computation – The appropriate implementation of an interface or abstract class should be selected as the result of some computation Fall 2007 CS 225 46
Object Factory Fall 2007 CS 225 47
- Goal and task hierarchy model
- Issues for goal hierarchies
- Rich feature hierarchies
- Explicit memory psychology example
- Network software protocol hierarchies
- Preying mantra wangechi mutu
- Protocol hierarchies
- Chapter 11 complex inheritance and human heredity test
- Chapter 11 section 2: complex patterns of inheritance
- Chapter 16 the molecular basis of inheritance
- Chapter 15: the chromosomal basis of inheritance
- Chapter 9 patterns of inheritance
- Chapter 16: the molecular basis of inheritance
- Chapter 15: the chromosomal basis of inheritance
- The chromosomal basis of inheritance chapter 15
- Chapter 15 the chromosomal basis of inheritance
- Chapter 11 section 1 basic patterns of human inheritance
- Chapter 11 section 1 basic patterns of human inheritance
- Chapter 13 the molecular basis of inheritance
- Chapter 9 patterns of inheritance
- Chapter 15: the chromosomal basis of inheritance
- Mitochondria non examples
- Advantages and disadvantages of inheritance in java
- Extranuclear inheritance
- Section 12-1 chromosomes and inheritance
- Encapsulation inheritance polymorphism
- Oop inheritance polymorphism encapsulation abstraction
- Inheritance
- Family resemblance test
- Mendel's first and second law of inheritance
- Harry potter and the inheritance of sex
- The cellular basis of reproduction and inheritance
- Things fall apart summary chapter 4-6
- Things fall apart 17-19 summary
- Chapter 14 summary things fall apart
- Difference between abstract class and concrete class
- Abstract concrete class relationship
- Therapeutic class and pharmacologic class
- Static vs dynamic class loading
- Prisma model inheritance
- Uml inheritance
- Priority inheritance
- Inheritance scala
- The inheritance of loss themes
- Thalassemia trait
- Rails sti vs polymorphic
- Sex linked punnet square
- Sexlinked inheritance