1 / 17

Introduction to Java 2 Programming

This lecture provides an overview of inheritance in Java programming, including concepts such as inheritance, encapsulation, constructors, methods, and controlling inheritance. It also covers topics like method overriding, method overloading, and the relationship between inheritance and encapsulation.

jharms
Download Presentation

Introduction to Java 2 Programming

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  1. Introduction to Java 2 Programming Lecture 5 Inheritance

  2. Overview • Inheritance • …and Encapsulation • …and Constructors • …and Methods • Including overriding and overloading • Controlling Inheritance

  3. Quick Recap • Inheritance defines parent-child relationships • Base (or super) class, and derived (or sub-) class • Child inherits all functionality of its parent • Typically add new methods and member variables • One of the basic features of all OO languages • Already encountered it in Robocode • All your robots extend a provided Robot base class • All robocode events extend an Event base class • You can extend almost any object • With a couple of extensions as we’ll see…

  4. Using Inheritance • Use the extends keyword in the class definition: public class MyRobot extends Robot { } • A class can only extend one base class • Unlike C++ Java doesn’t allow multiple inheritance • All Java classes extend a common base class (java.lang.Object) • Automatically assumed by the compiler, unless you say otherwise • Provides some basic functionality, e.g. toString() and equals() public class Calculator extends Object { }

  5. Inheritance and Encapsulation • Sub-classes inherit all their superclass member variables • But may not be able to access them directly! • The visibility modifiers, public, protected, and private apply • Only public and protected are accessible • Private member variables of a base class cannot be altered by a sub-class (except via a method) • Tip: Try to avoid breaking encapsulation by making variables private, unless you’re expecting the class to “have children”

  6. Inheritance and Encapsulation public class Person { private String _name; private String _email; //can be access by sub-classes protected int _salary; public String getName() {…} public String setName() {…} }

  7. Constructors Revisited • Constructors can call one another • Allows initialisation code to be kept in one place (not duplicated between constructors) • Use the this keyword to call another constructor in the same class • Must be first line in the constructor public class Bookmark { public Bookmark(String url) { this( new URL(url) ); } public Bookmark(URL url) { //other initialisation code } }

  8. Inheritance and Constructors • An class must ensure that its parent is properly initialised, by calling one of its constructors • Use the super keyword • Even if a constructor isn’t explicitly called a call to the default constructor is added by compiler • Base class constructors are called first • Inheritance happens from the top down • …ancestors, parent, child…

  9. Constructors public class Parent { private String msg; public Parent() {} public Parent(String message) { msg = message; } } public class Child extends Parent {   public Child()  {    super("Parent message");  } } public class OtherChild extends Parent { }

  10. Method Overloading • A Java class can define several methods with the same name, so long as • the parameters are different, the return type is the same public int doSomething(String s, String s2); public int doSomething(String s); public int doSomething(int x, int y); • Java determines the correct method to call by checking the parameters • Useful to provide variants of a method that work on different types of object • Typically one method does all the work, and the others call it • As with constructors, this collects common code into a single method

  11. Method Overriding • A sub-class can define a method with the same name and parameters as as base class • Known as overriding • Useful when some aspect of the base class behaviour must be altered • To completely change the implementation, just define a new version (in the child) • To partially change the implementation use the super keyword to refer to the parents original implementation

  12. Inheritance and Methods • What happens when we call a method? • The JVM tries to find the implementation of that method and then execute the code • Starts searching with the objects class, then works upward to its parent…its parent’s parent…etc, etc. • Searching for methods works from the bottom-up • Reverse of how constructors are called • Also explains how a sub-class can substitute its own behaviour for a base class • JVM finds that first.

  13. Worked Example • In an E-Commerce system we might have a class responsible for calculating prices e.g: public class Pricer { public float calculatePrice(Product p) {  //implementation details irrelevant for example } } • The Product parameter lets the Pricer calculate the price

  14. Worked Example • Assume we want to extend this functionality so that the calculation also includes tax (i.e. adding on VAT). • US purchases don't include tax, but UK ones do, so we can't just rewrite the original method. • Instead we create a subclass, called UKPricer that does the extra work. public class UKPricer extends Pricer { public float calculatePrice(Product p) {  //this implementation will also add on VAT… } }

  15. Worked Example • Ideally we want to reuse the code in the base class, as all we need to do is add on the extra 17.5% to the final price. • We can do better than copy-and-paste using super… public class UKPricer extends Pricer { public float calculatePrice(Product p) {    //call the superclass method   float withoutTax = super.calculatePrice(p);   float tax = withoutTax * 17.5 / 100;  return withoutTax + tax; } }

  16. Controlling Inheritance – Restricting • Inheritance can be restricted using the final keyword • Applies to both methods and classes • A final class cannot be extended • A final method cannot be overridden public final class MyClass { } public class OtherClass { public final int aMethod() { … } }

  17. Controlling Inheritance – Enforcing • Inheritance can be forced by using the abstract keyword • Again applies to both methods and classes • An abstract class must be extended, cannot be used to create objects • An abstract method must be overrided by a sub-class • A class with at least one abstract method must be declared abstract public abstract class SomeOtherClass { public int aMethod() { … } public abstract void otherMethod(); }

More Related