Inheritance
2 likes•654 views
The document discusses object-oriented programming concepts related to inheritance in Java, including: - Inheritance allows a subclass to inherit attributes and behaviors from its superclass. Subclasses can add, use, or override inherited functionality. - Abstract classes can contain abstract methods that are declared but not defined. Subclasses must define all abstract methods to be instantiated. Abstract classes prevent direct instantiation. - Polymorphism allows calling the same method on different object types, with the actual implementation determined at runtime based on the object's type. Method overriding in subclasses enables polymorphism. - Final methods and classes prevent overriding and extension, respectively. This can improve security or performance. All non-static methods are virtual by default
![Inheritance in Java!
! Inheritance is declared using the "extends" keyword!
! If inheritance is not defined, the class extends a class called Object!
!
Person
- name: String
- dob: Date
Employee
- employeeID: int
- salary: int
- startDate: Date
public class Person!
{!
!private String name;!
!private Date dob;!
![...]!
public class Employee extends Person!
{!
!private int employeID;!
!private int salary;!
!private Date startDate;!
![...]!
Employee anEmployee = new Employee();!](https://image.slidesharecdn.com/inheritance-140914051528-phpapp02/85/Inheritance-4-320.jpg)
![Constructors - Example!
public class BankAccount!
{!
!private String ownersName;!
!private int accountNumber;!
!private float balance;!
!
!public BankAccount(int anAccountNumber, String aName)!
!{!
! !accountNumber = anAccountNumber;!
! !ownersName = aName;!
!}!
![...]!
}!
!
public class OverdraftAccount extends BankAccount!
{!
!private float overdraftLimit;!
!
!public OverdraftAccount(int anAccountNumber, String aName, float aLimit)!
!{!
! !super(anAccountNumber, aName);!
! !overdraftLimit = aLimit;!
!}!
}!](https://image.slidesharecdn.com/inheritance-140914051528-phpapp02/85/Inheritance-8-320.jpg)
![Final Methods and Final Classes!
! Methods can be qualified with the final modifier!
! Final methods cannot be overridden.!
! This can be useful for security purposes.!
public final boolean validatePassword(String username, String Password)!
{!
![...]!
! Classes can be qualified with the final modifier!
! The class cannot be extended!
! This can be used to improve performance. Because there an be no
subclasses, there will be no polymorphic overhead at runtime.!
public final class Color!
{!
![...]!](https://image.slidesharecdn.com/inheritance-140914051528-phpapp02/85/Inheritance-14-320.jpg)
Inheritance
- 1. Inheritance! The objectives of this chapter are:! ! ! To explore the concept and implications of inheritance! ! Polymorphism! ! To define the syntax of inheritance in Java! ! To understand the class hierarchy of Java! ! To examine the effect of inheritance on constructors!
- 2. Terminology! ! Inheritance is a fundamental Object Oriented concept! ! ! A class can be defined as a "subclass" of another class.! ! The subclass inherits all data attributes of its superclass! ! The subclass inherits all methods of its superclass! ! The subclass inherits all associations of its superclass! ! ! The subclass can:! ! Add new functionality! ! Use inherited functionality! ! Override inherited functionality! Person - name: String - dob: Date Employee - employeeID: int - salary: int - startDate: Date superclass: subclass:
- 3. What really happens?! ! When an object is created using new, the system must allocate enough memory to hold all its instance variables.! ! This includes any inherited instance variables! ! ! In this example, we can say that an Employee "is a kind of" Person. ! ! An Employee object inherits all of the attributes, methods and associations of Person! Person - name: String - dob: Date Employee - employeeID: int - salary: int - startDate: Date Person name = "John Smith" dob = Jan 13, 1954 Employee name = "Sally Halls" dob = Mar 15, 1968 employeeID = 37518 salary = 65000 startDate = Dec 15, 2000 is a kind of
- 4. Inheritance in Java! ! Inheritance is declared using the "extends" keyword! ! If inheritance is not defined, the class extends a class called Object! ! Person - name: String - dob: Date Employee - employeeID: int - salary: int - startDate: Date public class Person! {! !private String name;! !private Date dob;! ![...]! public class Employee extends Person! {! !private int employeID;! !private int salary;! !private Date startDate;! ![...]! Employee anEmployee = new Employee();!
- 5. Inheritance Hierarchy! ! Each Java class has one (and only one) superclass.! ! C++ allows for multiple inheritance! ! ! Inheritance creates a class hierarchy! ! Classes higher in the hierarchy are more general and more abstract! ! Classes lower in the hierarchy are more specific and concrete! ! There is no limit to the Class number of subclasses a class can have! ! ! There is no limit to the depth of the class tree.! Class Class Class Class Class Class Class
- 6. The class called Object! ! At the very top of the inheritance tree is a class called Object! ! ! All Java classes inherit from Object.! ! All objects have a common ancestor! ! This is different from C++! ! ! The Object class is defined in the java.lang package! ! Examine it in the Java API Specification! Object
- 7. Constructors and Initialization! ! Classes use constructors to initialize instance variables! ! When a subclass object is created, its constructor is called.! ! It is the responsibility of the subclass constructor to invoke the appropriate superclass constructors so that the instance variables defined in the superclass are properly initialized! ! ! Superclass constructors can be called using the "super" keyword in a manner similar to "this"! ! It must be the first line of code in the constructor! ! ! If a call to super is not made, the system will automatically attempt to invoke the no-argument constructor of the superclass.!
- 8. Constructors - Example! public class BankAccount! {! !private String ownersName;! !private int accountNumber;! !private float balance;! ! !public BankAccount(int anAccountNumber, String aName)! !{! ! !accountNumber = anAccountNumber;! ! !ownersName = aName;! !}! ![...]! }! ! public class OverdraftAccount extends BankAccount! {! !private float overdraftLimit;! ! !public OverdraftAccount(int anAccountNumber, String aName, float aLimit)! !{! ! !super(anAccountNumber, aName);! ! !overdraftLimit = aLimit;! !}! }!
- 9. Method Overriding! ! Subclasses inherit all methods from their superclass! ! Sometimes, the implementation of the method in the superclass does not provide the functionality required by the subclass.! ! In these cases, the method must be overridden.! ! ! To override a method, provide an implementation in the subclass.! ! The method in the subclass MUST have the exact same signature as the method it is overriding.! ! !
- 10. Method overriding - Example! public class BankAccount! {! !private String ownersName;! !private int accountNumber;! !protected float balance;! ! !public void deposit(float anAmount)! !{! ! !if (anAmount>0.0)! ! ! !balance = balance + anAmount;! !}! ! !public void withdraw(float anAmount)! !{! ! !if ((anAmount>0.0) && (balance>anAmount))! ! ! !balance = balance - anAmount;! !}! ! !public float getBalance()! !{! ! !return balance;! !}! }!
- 11. Method overriding - Example! public class OverdraftAccount extends BankAccount! {! !private float limit;! ! !public void withdraw(float anAmount)! !{! ! !if ((anAmount>0.0) && (getBalance()+limit>anAmount))! ! ! !balance = balance - anAmount;! !}! ! }!
- 12. Object References and Inheritance! ! Inheritance defines "a kind of" relationship.! ! In the previous example, OverdraftAccount "is a kind of" BankAccount! ! ! Because of this relationship, programmers can "substitute" object references.! ! A superclass reference can refer to an instance of the superclass OR an instance of ANY class which inherits from the superclass.! ! ! BankAccount anAccount = new BankAccount(123456, "Craig");! ! BankAccount account1 = new OverdraftAccount(3323, "John", 1000.0);! anAccount BankAccount name = "Craig" accountNumber = 123456 account1 OverdraftAccount name = "John" accountNumber = 3323 limit = 1000.0
- 13. Polymorphism! ! In the previous slide, the two variables are defined to have the same type at compile time: BankAccount! ! However, the types of objects they are referring to at runtime are different! ! ! What happens when the withdraw method is invoked on each object?! ! anAccount refers to an instance of BankAccount. Therefore, the withdraw method defined in BankAccount is invoked.! ! account1 refers to an instance of OverdraftAccount. Therefore, the withdraw method defined in OverdraftAccount is invoked.! ! ! Polymorphism is: The method being invoked on an object is determined AT RUNTIME and is based on the type of the object receiving the message.!
- 14. Final Methods and Final Classes! ! Methods can be qualified with the final modifier! ! Final methods cannot be overridden.! ! This can be useful for security purposes.! public final boolean validatePassword(String username, String Password)! {! ![...]! ! Classes can be qualified with the final modifier! ! The class cannot be extended! ! This can be used to improve performance. Because there an be no subclasses, there will be no polymorphic overhead at runtime.! public final class Color! {! ![...]!
- 15. Virtual Functions! ! Every non-static method in JAVA is by default virtual method! ! Except final and private methods. ! ! The methods which cannot be inherited for polymorphic behavior is not a virtual method.! ! In Java there is no keyword names virtual!
- 16. Review! ! What is inheritance? What is a superclass? What is a subclass?! ! Which class is at the top of the class hierarchy in Java?! ! What are the constructor issues surrounding inheritance?! ! What is method overriding? What is polymorphism? How are they related?! ! What is a final method? What is a final class?!
- 17. 8-Apr-14 Abstract Classes and Interfaces
- 18. 18 Abstract methods " You can declare an object without defining it: Person p; " Similarly, you can declare a method without defining it: public abstract void draw(int size); – Notice that the body of the method is missing " A method that has been declared but not defined is an abstract method
- 19. 19 Abstract classes I " Any class containing an abstract method is an abstract class " You must declare the class with the keyword abstract: abstract class MyClass {...} " An abstract class is incomplete – It has “missing” method bodies " You cannot instantiate (create a new instance of) an abstract class
- 20. 20 Abstract classes II " You can extend (subclass) an abstract class – If the subclass defines all the inherited abstract methods, it is “complete” and can be instantiated – If the subclass does not define all the inherited abstract methods, it too must be abstract " You can declare a class to be abstract even if it does not contain any abstract methods – This prevents the class from being instantiated
- 21. Why have abstract classes? " Suppose you wanted to create a class Shape, with subclasses Oval, Rectangle, Triangle, Hexagon, etc. " You don’t want to allow creation of a “Shape” – Only particular shapes make sense, not generic ones – If Shape is abstract, you can’t create a new Shape – You can create a new Oval, a new Rectangle, etc. " Abstract classes are good for defining a general category containing specific, “concrete” classes 21
- 22. 22 An example abstract class " public abstract class Animal { abstract int eat(); abstract void breathe(); } " This class cannot be instantiated " Any non-abstract subclass of Animal must provide the eat() and breathe() methods
- 23. Why have abstract methods? 23 " Suppose you have a class Shape, but it isn’t abstract – Shape should not have a draw() method – Each subclass of Shape should have a draw() method " Now suppose you have a variable Shape figure; where figure contains some subclass object (such as a Star) – It is a syntax error to say figure.draw(), because the Java compiler can’t tell in advance what kind of value will be in the figure variable – A class “knows” its superclass, but doesn’t know its subclasses – An object knows its class, but a class doesn’t know its objects " Solution: Give Shape an abstract method draw() – Now the class Shape is abstract, so it can’t be instantiated – The figure variable cannot contain a (generic) Shape, because it is impossible to create one – Any object (such as a Star object) that is a (kind of) Shape will have the draw() method – The Java compiler can depend on figure.draw() being a legal call and does not give a syntax error
- 24. 24 A problem " class Shape { ... } " class Star extends Shape { void draw() { ... } ... } " class Crescent extends Shape { void draw() { ... } ... } " Shape someShape = new Star(); – This is legal, because a Star is a Shape " someShape.draw(); – This is a syntax error, because some Shape might not have a draw() method – Remember: A class knows its superclass, but not its subclasses
- 25. 25 A solution " abstract class Shape { abstract void draw(); } " class Star extends Shape { void draw() { ... } ... } " class Crescent extends Shape { void draw() { ... } ... } " Shape someShape = new Star(); – This is legal, because a Star is a Shape – However, Shape someShape = new Shape(); is no longer legal " someShape.draw(); – This is legal, because every actual instance must have a draw() method
- 26. 26 Interfaces " An interface declares (describes) methods but does not supply bodies for them interface KeyListener { public void keyPressed(KeyEvent e); public void keyReleased(KeyEvent e); public void keyTyped(KeyEvent e); } " All the methods are implicitly public and abstract – You can add these qualifiers if you like, but why bother? " You cannot instantiate an interface – An interface is like a very abstract class—none of its methods are defined " An interface may also contain constants (final variables)
- 27. 27 Designing interfaces " Most of the time, you will use Sun-supplied Java interfaces " Sometimes you will want to design your own " You would write an interface if you want classes of various types to all have a certain set of capabilities " For example, if you want to be able to create animated displays of objects in a class, you might define an interface as: – public interface Animatable { install(Panel p); display(); } " Now you can write code that will display any Animatable class in a Panel of your choice, simply by calling these methods
- 28. Implementing an interface I " You extend a class, but you implement an interface " A class can only extend (subclass) one other class, but it can implement as many interfaces as you like 28 " Example: class MyListener implements KeyListener, ActionListener { … }
- 29. Implementing an interface II " When you say a class implements an interface, you are promising to define all the methods that were declared in the interface " Example: class MyKeyListener implements KeyListener { public void keyPressed(KeyEvent e) {...}; public void keyReleased(KeyEvent e) {...}; public void keyTyped(KeyEvent e) {...}; 29 } – The “...” indicates actual code that you must supply " Now you can create a new MyKeyListener
- 30. Partially implementing an Interface " It is possible to define some but not all of the methods defined in an interface: abstract class MyKeyListener implements KeyListener { 30 public void keyTyped(KeyEvent e) {...}; } " Since this class does not supply all the methods it has promised, it is an abstract class " You must label it as such with the keyword abstract " You can even extend an interface (to add methods): – interface FunkyKeyListener extends KeyListener { ... }
- 31. 31 What are interfaces for? " Reason 1: A class can only extend one other class, but it can implement multiple interfaces – This lets the class fill multiple “roles” – In writing Applets, it is common to have one class implement several different listeners – Example: class MyApplet extends Applet implements ActionListener, KeyListener { ... } " Reason 2: You can write methods that work for more than one kind of class
- 32. 32 How to use interfaces " You can write methods that work with more than one class " interface RuleSet { boolean isLegal(Move m, Board b); void makeMove(Move m); } – Every class that implements RuleSet must have these methods " class CheckersRules implements RuleSet { // one implementation public boolean isLegal(Move m, Board b) { ... } public void makeMove(Move m) { ... } } " class ChessRules implements RuleSet { ... } // another implementation " class LinesOfActionRules implements RuleSet { ... } // and another " RuleSet rulesOfThisGame = new ChessRules(); – This assignment is legal because a rulesOfThisGame object is a RuleSet object " if (rulesOfThisGame.isLegal(m, b)) { makeMove(m); } – This statement is legal because, whatever kind of RuleSet object rulesOfThisGame is, it must have isLegal and makeMove methods
- 33. 33 Interfaces, again " When you implement an interface, you promise to define all the functions it declares " There can be a lot of methods interface KeyListener { public void keyPressed(KeyEvent e); public void keyReleased(KeyEvent e); public void keyTyped(KeyEvent e); } " What if you only care about a couple of these methods?
- 34. 34 Adapter classes " Solution: use an adapter class " An adapter class implements an interface and provides empty method bodies class KeyAdapter implements KeyListener { public void keyPressed(KeyEvent e) { }; public void keyReleased(KeyEvent e) { }; public void keyTyped(KeyEvent e) { }; } " You can override only the methods you care about " This isn’t elegant, but it does work " Java provides a number of adapter classes
- 35. 35 Vocabulary " abstract method—a method which is declared but not defined (it has no method body) " abstract class—a class which either (1) contains abstract methods, or (2) has been declared abstract " instantiate—to create an instance (object) of a class " interface—similar to a class, but contains only abstract methods (and possibly constants) " adapter class—a class that implements an interface but has only empty method bodies
- 36. 36 The End Complexity has nothing to do with intelligence, simplicity does. — Larry Bossidy Perfection is achieved, not when there is nothing more to add, but when there is nothing left to take away. — Antoine de Saint Exupery