inheritance and polymorphism
Post on 01-Nov-2014
19 Views
Preview:
DESCRIPTION
TRANSCRIPT
Inheritance and PolymorphismInheritance and Polymorphism
Object-Oriented Object-Oriented Programming in Programming in
JavaJava
ContentsContents
1.1. Inheritance in JavaInheritance in Java
• Inheriting ClassesInheriting Classes
• The The supersuper Reference Reference
• Overriding MethodsOverriding Methods
• PolymorphismPolymorphism
• The The instanceofinstanceof Operator Operator
• final Methods and Classesfinal Methods and Classes
2
Contents (2)Contents (2)
1.1. Abstract ClassesAbstract Classes
• Abstract MethodsAbstract Methods
2.2. InterfacesInterfaces
• Defining InterfacesDefining Interfaces
• Implementing InterfacesImplementing Interfaces
3.3. Using Interfaces (Demo)Using Interfaces (Demo)
3
Access ModifiersAccess Modifierspublic, private, protected, default public, private, protected, default
(package)(package)
Access ModifiersAccess Modifiers
• The most common modifiers are the access The most common modifiers are the access modifiers:modifiers:
• publicpublic
• privateprivate
• protectedprotected
• (default)(default)
• Access modifiers control which classes Access modifiers control which classes may use a membermay use a member
5
Access Modifiers RulesAccess Modifiers Rules
• The variables that you declare and use The variables that you declare and use within a class’s methods may not have within a class’s methods may not have access modifiersaccess modifiers
• The only access modifier permitted to non-The only access modifier permitted to non-inner classes is inner classes is publicpublic
• A member may have at most one access A member may have at most one access modifiermodifier
6
publicpublic
• The most generous access modifier is The most generous access modifier is publicpublic
• A A publicpublic class, variable, or method may be class, variable, or method may be used in any Java program without used in any Java program without restrictionrestriction
• Any Any publicpublic method may be overridden by method may be overridden by any subclassany subclass
7
privateprivate
• The least generous access modifier is The least generous access modifier is privateprivate
• Top-level (that is, not inner) classes may Top-level (that is, not inner) classes may not be declared not be declared privateprivate
• A A privateprivate variable or method may be used variable or method may be used only by an instance of the class that only by an instance of the class that declares the variable or methoddeclares the variable or method
8
protectedprotected
• Only variables and methods may be Only variables and methods may be declared declared protectedprotected
• A A protectedprotected member of a class is member of a class is available to all classes in the same available to all classes in the same package, just like a default memberpackage, just like a default member
• A A protectedprotected member of a class can be member of a class can be available in certain limited ways to all available in certain limited ways to all subclasses of the class that owns the subclasses of the class that owns the protectedprotected member. It is visible in member. It is visible in subclasses in different packages too.subclasses in different packages too.9
(default)(default)
• DefaultDefault is the name of the access of is the name of the access of classes, variables, and methods if you classes, variables, and methods if you don’tdon’t specify an access modifierspecify an access modifier
• A class’s data and methods may be default, A class’s data and methods may be default, as well as the class itselfas well as the class itself
• A class’s default members are accessible to A class’s default members are accessible to any class in the same package as the class any class in the same package as the class in questionin question
• A default method may be overridden by any A default method may be overridden by any subclass that is in the same package as the subclass that is in the same package as the superclasssuperclass 10
Applying Encapsulation in Applying Encapsulation in JavaJava
• Instance variables should be Instance variables should be declared as declared as privateprivate
• Only instance methods can Only instance methods can access access privateprivate instance instance variablesvariables
Movie mov1 = new Movie();Movie mov1 = new Movie();String rating = mov1.getRating();String rating = mov1.getRating();String r = mov1.rating; // Error: privateString r = mov1.rating; // Error: private ......if (rating.equals("G"))if (rating.equals("G"))
var
aMethod
aMethod()
PackagesPackages
What Are Java Packages?What Are Java Packages?
• A package is a container of classes that are logically related
• A package consists of all the Java classes within a directory on the file system
• Package names and used within a JRE to manage the uniqueness of identifiers
• They segment related parts of complex applications into manageable parts
Grouping Classes in a Grouping Classes in a PackagePackage
• Include the Include the packagepackage keyword followed by keyword followed by one or more names separated by dots at the one or more names separated by dots at the top of the Java source filetop of the Java source file
• If omitted the compiler places the class in If omitted the compiler places the class in the default “unnamed” packagethe default “unnamed” package 14
package utils;package utils;
public class MathUtils {public class MathUtils { ......}}
Grouping Classes in a Grouping Classes in a PackagePackage
• To run a To run a main()main() method in a packaged method in a packaged class requires:class requires:
• The CLASSPATH to contain the directory The CLASSPATH to contain the directory having the root name of the package treehaving the root name of the package tree
• The class name must be qualified by itsThe class name must be qualified by itspackage namepackage name
15
java –cp . myPackage.MainClassjava –cp . myPackage.MainClass
The CLASSPATH with The CLASSPATH with PackagesPackages
• Includes the directory containing the top level Includes the directory containing the top level of the package treeof the package tree
16C:\>set CLASSPATH=E:\Curriculum\courses\java\C:\>set CLASSPATH=E:\Curriculum\courses\java\practices\les06practices\les06
Package name .class location
CLASSPATH
Importing PackagesImporting Packages
• To use a class defined in other package To use a class defined in other package (not in current) you should do either:(not in current) you should do either:
• Import the class or all classes in the Import the class or all classes in the package:package:
• Use the full name of the class:Use the full name of the class:
17
import utils.MathUtils;import utils.MathUtils;......int sq = MathUtils.FastCalculateSqrt(12345);int sq = MathUtils.FastCalculateSqrt(12345);
int sq = utils.MathUtils.FastCalculateSqrt(12345);int sq = utils.MathUtils.FastCalculateSqrt(12345);
Inheritance and Inheritance and PolymorphismPolymorphismCode Reuse TechniquesCode Reuse Techniques
Key Object-Oriented Key Object-Oriented ComponentsComponents
InheritanceInheritance
Constructors referenced by subclassConstructors referenced by subclass
PolymorphismPolymorphism
Inheritance is an OO fundamentalInheritance is an OO fundamental
InventoryItemInventoryItem
MovieMovie GameGame BookBook
Superclass
Subclasses
Example of Inheritance Example of Inheritance
The The InventoryItemInventoryItem class defines methods class defines methods and variablesand variables
Movie extends Movie extends InventoryItemInventoryItem and can: and can:
Add new variables Add new variables
Add new methodsAdd new methods
Override methods in Override methods in InventoryItemInventoryItem class class
InventoryItemInventoryItem
MovieMovie
Specifying Inheritance in Specifying Inheritance in JavaJava
Inheritance is achieved by specifying which Inheritance is achieved by specifying which superclass the subclass extendssuperclass the subclass extends
Movie inherits all the variables and methods Movie inherits all the variables and methods of of InventoryItemInventoryItem
public class InventoryItem {public class InventoryItem { … … }}
public class Movie public class Movie extendsextends InventoryItem { InventoryItem { … … }}
What Does a Subclass What Does a Subclass Object Look Like?Object Look Like?
A subclass inherits all the instance A subclass inherits all the instance variables of its superclassvariables of its superclass
Movie
titletitlelengthlength
pricepriceconditioncondition
public classpublic class Movie extends InventoryItem {Movie extends InventoryItem { private String title;private String title; private int length; … private int length; … }}
public class InventoryItem {public class InventoryItem { private float price;private float price; private String condition; … private String condition; … }}
Default InitializationDefault Initialization
What happens when a What happens when a subclass object is created?subclass object is created?
If no constructors are defined: If no constructors are defined:
First, the default First, the default parameterless constructor is parameterless constructor is called in the superclasscalled in the superclass
Then, the default Then, the default parameterless constructor is parameterless constructor is called in the subclasscalled in the subclass
Movie movie1 = new Movie();Movie movie1 = new Movie();
Movie
titletitlelengthlength
pricepriceconditioncondition
The The supersuper Reference Reference
Refers to the base classRefers to the base class
Is useful for calling base class Is useful for calling base class constructorsconstructors Must be the first line in the derived class Must be the first line in the derived class
constructorconstructor
Can be used to call any base class Can be used to call any base class methodsmethodspublic class Movie extends InventoryItem {public class Movie extends InventoryItem { public Movie() {public Movie() { super("Matrix 8");super("Matrix 8"); } } }}
The The supersuper Reference Reference ExampleExample
public class InventoryItem {public class InventoryItem { InventoryItem(String cond) {InventoryItem(String cond) { System.out.println("InventoryItem");System.out.println("InventoryItem"); … … }}}}class Movie extends InventoryItem {class Movie extends InventoryItem { Movie(String title) {Movie(String title) { super(title);super(title); … … System.out.println("Movie");System.out.println("Movie"); }}}}
Base class Base class constructorconstructor
Calls baseCalls baseclassclass
constructorconstructor
Using Superclass Using Superclass ConstructorsConstructors
• Use Use super()super() to call a superclass to call a superclass constructor:constructor:
public class InventoryItem {public class InventoryItem { InventoryItem(float p, String cond) {InventoryItem(float p, String cond) { price = p;price = p; condition = cond;condition = cond; } … } …
public class Movie extends InventoryItem public class Movie extends InventoryItem {{ Movie(String t, float p, String cond) {Movie(String t, float p, String cond) { super(p, cond); super(p, cond); title = t;title = t; } … } …
Specifying Additional Specifying Additional MethodsMethods
The superclass defines methods for all The superclass defines methods for all types of types of InventoryItemInventoryItem
The subclass can specify additional The subclass can specify additional methods that are specific to methods that are specific to MovieMovie
public class InventoryItem {public class InventoryItem { public float calcDeposit()… public float calcDeposit()… public String calcDateDue()…public String calcDateDue()… … …
public class Movie extends InventoryItem {public class Movie extends InventoryItem { public void getTitle()… public void getTitle()… public String getLength()… public String getLength()…
Overriding Superclass Overriding Superclass MethodsMethods
A subclass inherits all the methods of its A subclass inherits all the methods of its superclasssuperclass
The subclass can override a method with its The subclass can override a method with its own specialized versionown specialized version
Must have the same signature and semantics Must have the same signature and semantics as the superclass methodas the superclass method
In Java all methods are virtual (unless In Java all methods are virtual (unless declared as declared as finalfinal)) This forces the This forces the late bindinglate binding mechanism on mechanism on
each method calleach method call
Overriding Superclass Overriding Superclass Methods – ExampleMethods – Example
public class InventoryItem {public class InventoryItem { … … public float calcDeposit(int custId) {public float calcDeposit(int custId) { return itemDeposit;return itemDeposit; }}}}
public class Movie extends InventoryItem {public class Movie extends InventoryItem { … … public float calcDeposit(int custId) {public float calcDeposit(int custId) { if (specialCustomer(custId) { if (specialCustomer(custId) { return itemDeposit / 2;return itemDeposit / 2; } else {} else { return itemDeposit;return itemDeposit; } } }}}}
Invoking Superclass Invoking Superclass MethodsMethods
If a subclass overrides a method, it can still If a subclass overrides a method, it can still call the original superclass methodcall the original superclass method
Use Use super.method()super.method() to call a superclass to call a superclass method from the subclassmethod from the subclasspublic class InventoryItem {public class InventoryItem { public float calcDeposit(int custId) {public float calcDeposit(int custId) { if … if … return 33.00;return 33.00; }}
public class Movie extends InventoryItem {public class Movie extends InventoryItem { public float calcDeposit(int custId) {public float calcDeposit(int custId) { itemDeposit = super.calcDeposit(custId); itemDeposit = super.calcDeposit(custId); return (itemDeposit + vcrDeposit); return (itemDeposit + vcrDeposit); }}
Treating a Subclass as Its Treating a Subclass as Its SuperclassSuperclass
A Java object instance of a subclass is plug A Java object instance of a subclass is plug compatible with its superclass definitioncompatible with its superclass definition You can assign a subclass object to a You can assign a subclass object to a
reference declared with the superclass:reference declared with the superclass:
The compiler treats the object via its The compiler treats the object via its reference, that is, in terms of its superclass reference, that is, in terms of its superclass definitiondefinition
The JVM creates a subclass object, executing The JVM creates a subclass object, executing subclass methods, if overriddensubclass methods, if overridden
31
public static void main(String[] args) {public static void main(String[] args) { InventoryItem item = new Movie();InventoryItem item = new Movie(); double deposit = item.calcDeposit();double deposit = item.calcDeposit();}}
Acme Video and Acme Video and PolymorphismPolymorphism
Acme Video started renting only videosAcme Video started renting only videos
Acme Video added games and VCRsAcme Video added games and VCRs
What’s next?What’s next?
Polymorphism solves the problemPolymorphism solves the problem
ShoppingBasketShoppingBasketvoid addItem(InventoryItem item) {void addItem(InventoryItem item) { // this method is called each time// this method is called each time // the clerk scans in a new item// the clerk scans in a new item float deposit = item.calcDeposit();float deposit = item.calcDeposit(); … …}}
InventoryItemInventoryItem
VCRVCR MovieMovie
calcDeposit(){…}calcDeposit(){…}
calcDeposit(){…}calcDeposit(){…}calcDeposit(){…}calcDeposit(){…}
How It WorksHow It Works
Using the Using the instanceofinstanceof OperatorOperator
The true type of an object can be The true type of an object can be determined by using an determined by using an instanceofinstanceof operatoroperator
An object reference can be downcast to the An object reference can be downcast to the correct type, if neededcorrect type, if needed
public void aMethod(InventoryItem i) {public void aMethod(InventoryItem i) { … … if (i instanceof Movie)if (i instanceof Movie) ((Movie)i).playTestTape();((Movie)i).playTestTape();}}
Limiting Methods and Limiting Methods and Classes with Classes with finalfinal
A method can be marked as A method can be marked as finalfinal to prevent to prevent it from being overriddenit from being overridden
A whole class can be marked as A whole class can be marked as finalfinal to to prevent it from being extendedprevent it from being extended
public final class Color {public final class Color { … … }}
public final boolean checkPassword(String p) {public final boolean checkPassword(String p) { … … }}
When to Use Inheritance?When to Use Inheritance?
Inheritance should be used only for “is a Inheritance should be used only for “is a kind of” relationships:kind of” relationships: It must always be possible to substitute a It must always be possible to substitute a
subclass object for a superclass objectsubclass object for a superclass object
All methods in the superclass should make All methods in the superclass should make sense in the subclasssense in the subclass
Inheritance for short-term convenience Inheritance for short-term convenience leads to problems in the futureleads to problems in the future
Abstract Classes and Abstract Classes and InterfacesInterfaces
Defining Abstract ClassesDefining Abstract Classes
Abstract classes model abstract Abstract classes model abstract concepts from the real worldconcepts from the real world Cannot be instantiated directlyCannot be instantiated directly Should be subclasses to be instantiatedShould be subclasses to be instantiated
Abstract methods must be implemented Abstract methods must be implemented by subclassesby subclasses
Abstract superclass
Concrete subclasses
InventoryItemInventoryItem
MovieMovie VCRVCR
Creating Abstract ClassesCreating Abstract Classesin Javain Java
Use the Use the abstractabstract keyword to declare a keyword to declare a class as abstractclass as abstract
public public abstract classabstract class InventoryItem { InventoryItem { private float price;private float price; public boolean isRentable()… public boolean isRentable()… }}
public class Movie public class Movie extends InventoryItem {extends InventoryItem { private String title;private String title; public int getLength()…public int getLength()…
public class Vcr public class Vcr extends InventoryItem {extends InventoryItem { private int serialNbr;private int serialNbr; public void setTimer()…public void setTimer()…
What Are Abstract What Are Abstract Methods?Methods?
An abstract method:An abstract method: Is an implementation placeholderIs an implementation placeholder
Is part of an abstract classIs part of an abstract class
Must be overridden by a concrete subclassMust be overridden by a concrete subclass Each concrete subclass can implement the Each concrete subclass can implement the
method differentlymethod differently
Defining Abstract MethodsDefining Abstract Methodsin Javain Java
Use the abstract keyword to declare a method Use the abstract keyword to declare a method as as abstractabstract:: Provide the method signature onlyProvide the method signature only
The class must also be abstractThe class must also be abstract
Why is this useful?Why is this useful? Declare the structure of a class without Declare the structure of a class without
providing complete implementation of every providing complete implementation of every methodmethod
public abstract class InventoryItem {public abstract class InventoryItem { public public abstractabstract boolean isRentable(); boolean isRentable(); … …
Defining and Using Defining and Using InterfacesInterfaces
An interface is like a fully abstract class:An interface is like a fully abstract class: All of its methods are abstractAll of its methods are abstract
All variables are All variables are public static finalpublic static final
An interface lists a set of method signatures, An interface lists a set of method signatures, without any code detailswithout any code details
A class that implements the interface must A class that implements the interface must provide code details for all the methods of provide code details for all the methods of the interfacethe interface
A class can implement many interfaces but A class can implement many interfaces but can extend only one classcan extend only one class
Example of InterfacesExample of Interfaces
Interfaces describe an aspect of behavior Interfaces describe an aspect of behavior that different classes requirethat different classes require
For example, classes that can be steered For example, classes that can be steered support the “steerable” interfacesupport the “steerable” interface
Classes can be unrelatedClasses can be unrelated
SteerableNonsteerable
Creating an InterfaceCreating an Interface
Use Use interfaceinterface keyword keyword
All methods All methods public abstractpublic abstract All variables All variables public static finalpublic static final
public public interfaceinterface Steerable { Steerable { int MAXTURN_DEGREES = 45; int MAXTURN_DEGREES = 45; void turnLeft(int deg);void turnLeft(int deg); void turnRight(int deg);void turnRight(int deg);}}
Implementing an InterfaceImplementing an Interface
• Use Use implementsimplements keyword keyword
public class Yacht extends Boatpublic class Yacht extends Boatimplementsimplements Steerable Steerable
public void turnLeft(int deg) {…} public void turnLeft(int deg) {…} public void turnRight(int deg) {…}public void turnRight(int deg) {…}}}
Sort: A Real-World ExampleSort: A Real-World Example
Is used by a number of unrelated classesIs used by a number of unrelated classes Contains a known set of methodsContains a known set of methods Is needed to sort any type of objectsIs needed to sort any type of objects Uses comparison rules known only to the Uses comparison rules known only to the
sortable objectsortable object Supports good code reuseSupports good code reuse
Overview of the ClassesOverview of the Classes
Created by the sort expert:Created by the sort expert:
Created by the movie expert:Created by the movie expert:
public class public class MovieSortApplicationMovieSortApplication
public class Moviepublic class Movie implements Sortable implements Sortable
public interface public interface Sortable Sortable
public classpublic class SortSort
MyApplicationMyApplication passes passes an array of movies to an array of movies to Sort.sortObjects()Sort.sortObjects()
11
2233sortObjects()sortObjects() asks a asks a movie to compare itself movie to compare itself
with another moviewith another movie
The movie returns The movie returns the result of the the result of the
comparisoncomparison
44sortObjects()sortObjects()
returns the returns the sorted listsorted list
SortSort
MovieMovie
MyApplicationMyApplication
How the Sort Works?How the Sort Works?
The The SortableSortable InterfaceInterface
• Specifies the Specifies the compare()compare() method method
public interface Sortable {public interface Sortable { // compare(): Compare this object // compare(): Compare this object // to another object// to another object // Returns:// Returns: // 0 if this object is equal to obj2 // 0 if this object is equal to obj2 // a value < 0 if this object < obj2// a value < 0 if this object < obj2 // a value > 0 if this object > obj2// a value > 0 if this object > obj2 int compare(Object obj2);int compare(Object obj2);} }
The The SortSort Class Class
• Implements sorting functionality: the Implements sorting functionality: the method method sortObjects()sortObjects()
public class Sort { public class Sort { public static void sortObjects(Sortable[] items) {public static void sortObjects(Sortable[] items) { // Perform "Bubble sort" algorithm// Perform "Bubble sort" algorithm for (int i = 1; i < items.length; i++) {for (int i = 1; i < items.length; i++) { for (int j = 0; j < items.length-1; j++) {for (int j = 0; j < items.length-1; j++) { if (items[j].compare(items[j+1]) > 0) {if (items[j].compare(items[j+1]) > 0) { Sortable tempItem = items[j+1];Sortable tempItem = items[j+1]; items[j+1] = items[j];items[j+1] = items[j]; items[j] = tempItem;items[j] = tempItem; }} }} }} }}} }
public class Movie extends InventoryItempublic class Movie extends InventoryItem implements Sortableimplements Sortable { {
private String title;private String title; public int compare(Object movie2)public int compare(Object movie2) { { String title1 = this.title;String title1 = this.title; String title2 = ((Movie)movie2).getTitle();String title2 = ((Movie)movie2).getTitle(); return(title1.compareTo(title2));return(title1.compareTo(title2)); }}}}
• Implements Implements SortableSortable
The The MovieMovie Class Class
Using the SortUsing the Sort
• Call Call Sort.sortObjects(Sortable [])Sort.sortObjects(Sortable []) with an array of with an array of MovieMovie as the argument as the argument
public class MovieSortApplication {public class MovieSortApplication {
Movie[] movieList;Movie[] movieList;
public static void main(String[] args) {public static void main(String[] args) { … … // Build the array of Movie objects// Build the array of Movie objects … … Sort.sortObjects(movieList);Sort.sortObjects(movieList); }}}}
Sorting with InterfacesSorting with Interfaces
Live DemoLive Demo
Inner ClassesInner Classes
What Are Inner Classes?What Are Inner Classes?
• Inner classes are classes defined within a Inner classes are classes defined within a classclass
• Enforce a relationship between two classesEnforce a relationship between two classes
• Are of four types:Are of four types:
• Static Static
• MemberMember
• LocalLocal
• AnonymousAnonymous
public class Outer { … public class Outer { … class Inner { …class Inner { …
}}}}
Defining Static Inner Defining Static Inner ClassesClasses
• public class Outer {public class Outer {
• private static float varFloat = 3.50f;private static float varFloat = 3.50f;
• private String varString;private String varString;
• … …
• static class InnerStatic {static class InnerStatic {
• … …
• }}
• … …
• }}
• Defined at class levelDefined at class level
• Can access only static members of the outer Can access only static members of the outer classclass
Defining Member Inner Defining Member Inner ClassesClasses
• public class Outer {public class Outer {
• private static float varFloat = 3.50f;private static float varFloat = 3.50f;
• private String varString;private String varString; ... ... class InnerMember { class InnerMember { ... ... Outer.this Outer.this ... ... } }
• }}
• Defined at class levelDefined at class level
• Instance of the outer is neededInstance of the outer is needed
• Keyword Keyword thisthis used to access the outer instance used to access the outer instance
Defining Local Inner Defining Local Inner ClassesClasses
• Are defined at the method levelAre defined at the method level
• Are declared within a code blockAre declared within a code block
• Have access only to final variablesHave access only to final variables
• Cannot have a constructorCannot have a constructorpublic class Outer {public class Outer {...... public void outerMethod(final int var1){public void outerMethod(final int var1){ final int var2=5; ...final int var2=5; ...
class InnerLocal {class InnerLocal {private int localVar = var1 + var2; ...private int localVar = var1 + var2; ...
}} } }}}
Defining Anonymous Inner Defining Anonymous Inner ClassesClasses
• Defined at method levelDefined at method level
• Declared within a code blockDeclared within a code block
• Missing the Missing the classclass, , extendsextends, and , and implementsimplements keywords keywords
• Cannot have a constructorCannot have a constructor
public class Outer {public class Outer { public void outerMethod(){ public void outerMethod(){
myObject.myAnonymous(new SomeClass(){myObject.myAnonymous(new SomeClass(){ ... ... } )} ) } }}}
Using Using instanceofinstanceof with with InterfacesInterfaces
Use the Use the instanceofinstanceof operator to check if operator to check if an object implements an interfacean object implements an interface
Use downcasting to call methods defined Use downcasting to call methods defined in the interfacein the interface
public void aMethod(Object obj) {public void aMethod(Object obj) { … … if (obj if (obj instanceofinstanceof Sortable) { Sortable) { result = ((Sortable)obj).compare(obj2);result = ((Sortable)obj).compare(obj2); … … }}}}
Class DiagramsClass Diagrams
UML is a standard graphical notation UML is a standard graphical notation (language) for software modeling(language) for software modeling
Class diagrams are standard UML notation for Class diagrams are standard UML notation for representing classes and their relationshipsrepresenting classes and their relationships
Classes are represented by rectangles Classes are represented by rectangles containing their memberscontaining their members
Relationships are represented by arrowsRelationships are represented by arrows Several types of relations: associations, Several types of relations: associations,
aggregations, compositions, dependenciesaggregations, compositions, dependencies
Class diagrams visualize the class hierarchies Class diagrams visualize the class hierarchies obtained by inheriting classes and interfacesobtained by inheriting classes and interfaces
61
Class Diagrams – ExampleClass Diagrams – Example
62
Shape
#m Position:Point
structPoint
+m X:int+m Y:int
+Point
interfaceISurfaceCalculatable
+CalculateSurface:in t
Rectangle
-m W idth:int-m Height:in t
+Rectangle+CalculateSurface:in t
Square
-m S ize:in t
+Square+CalculateSurface:in t
FilledSquare
-m Color:Color
+FilledSquare
structColor
+m RedValue:byte+m G reenValue:byte+m BlueValue:byte
+Color
FilledRectangle
-m Color:Color
+FilledRectangle
QuestionsQuestions??
Inheritance and PolymorphismInheritance and Polymorphism
ProblemsProblems
1.1. Create an interface Create an interface IAnimalIAnimal that represents that represents an animal from the real world. Define the an animal from the real world. Define the method method talk()talk() that prints on the console the that prints on the console the specific scream of the animal ("jaff" for dogs, specific scream of the animal ("jaff" for dogs, "muaw" for cats, etc.). Add a boolean method "muaw" for cats, etc.). Add a boolean method coultEat(IAnimal)coultEat(IAnimal) that returns if given that returns if given animal eats any other animal.animal eats any other animal.
2.2. Create classes Create classes DogDog and and FrogFrog that implement that implement IAnimalIAnimal interface. Use interface. Use instanceofinstanceof operator operator in the method in the method couldEat(IAnimal)couldEat(IAnimal)..
3.3. Create an abstract class Create an abstract class CatCat that partially that partially implements the interface implements the interface IAnimalIAnimal..
64
ProblemsProblems
1.1. Inherit from the base abstract class Inherit from the base abstract class CatCat and and create subclasses create subclasses KittenKitten and and TomcatTomcat. These . These classes should fully implement the classes should fully implement the IAnimalIAnimal interface and define an implementation for the interface and define an implementation for the abstract methods from the class abstract methods from the class CatCat..
2.2. Write a class Write a class TestAnimalsTestAnimals that creates an that creates an array of animals (array of animals (IAnimal[]IAnimal[]): ): DogDog, , FrogFrog, , KittenKitten, , TomcatTomcat and calls their methods and calls their methods through through IAnimalIAnimal interface to ensure the interface to ensure the classes are implemented correctly.classes are implemented correctly.
65
HomeworkHomework
1.1. Create a class diagram for the hierarchy Create a class diagram for the hierarchy IAnimalIAnimal, , DogDog, , FrogFrog, , CatCat, , KittenKitten, , TomcatTomcat..
66
ProblemsProblems
1.1. Create a project, modeling a restaurant Create a project, modeling a restaurant system. You need to model the Restaurant, system. You need to model the Restaurant, People (Personnel and Clients), Orders from a People (Personnel and Clients), Orders from a client and Products for orders. Products could client and Products for orders. Products could be Meals or Beverages.be Meals or Beverages.
2.2. Client has one order and could buy many Client has one order and could buy many products. Orders are limited to a maximum products. Orders are limited to a maximum bill. No products could be added above the bill. No products could be added above the maximum.maximum.
3.3. Clients could pay with tip included (bill = price Clients could pay with tip included (bill = price + tip) + tip) 67
ProblemsProblems
1.1. Tasks:Tasks:
• Model the scheme and conventionsModel the scheme and conventions
• Find the top 5 clients with largest billsFind the top 5 clients with largest bills
• Sort clients by name in a collectionSort clients by name in a collection
• Design a function to find the day revenue of Design a function to find the day revenue of the restaurantthe restaurant
• Find the waiter with most tipsFind the waiter with most tips
68
top related