Constructors under inheritance Variable Shadowing Inheritance II Constructors under inheritance Variable Shadowing 2/17/2019 Inheritance & constructors (c) Eraj Basnayake

Inheritance & constructors (c) Eraj Basnayake Let there be light…Constructor chaining under inheritance class Light{ protected int noOfWatts; //wattage protected boolean indicator; //on/off protected String location; //placement private static int counter=0; //no of light objects public Light(){ this(0,false); } public Light(int noOfWatts, boolean indicator){ setNoOfWatts(noOfWatts); if (indicator) switchOn(); else switchOff(); public void switchOn() {indicator = true;} public void switchOff() {indicator = false;} public boolean isOn() { return indicator;} public void setNoOfWatts(int watts){… } public static void writeCounter(){ System.out.println(“Number of lights: “ +counter); //… class TubeLight extends Light{ private int tubeLength; private int color; public TubeLight(){ setTubeLength(3); setColor(1); } public TubeLight(int length, int color){ this(length, color,30); public TubeLight(int l, int c, int w){ super(w, false); setTubeLength(length); setColor(color); //… public static void main(String[] args){ TubeLight t1 = new TubeLight(); TubeLight t2 = new TubeLight(3,1); TubeLight t3 = new TubeLight(3,1,50); 2/17/2019 Inheritance & constructors (c) Eraj Basnayake

Implicit call to “Light()” Constructors under inheritance… The keyword super refers to the superclass, from the perspective of the current-class, while the keyword this refers to the current-class. Java’s rule: If first line of constructor is not an explicit call to a superclass (or this) constructor, Java will implicitly put super() as the fist line, calling the superclass’s default constructor. A call to a superclass constructor has to be the first line of code of a constructor, or not at all. public TubeLight(){ setTubeLength(3); setColor(1); } public TubeLight(int length, int color){ this(length, color,30); public TubeLight(int l, int c, int w){ super(w, false); setTubeLength(length); setColor(color); Implicit call to “Light()” None of Super’s constructors will be called from here. Explicit call to “Light(int, int)” 2/17/2019 Inheritance & constructors (c) Eraj Basnayake

Inheritance & constructors (c) Eraj Basnayake Question: if a super class had at least 1 non-default constructor and no default constructor, would a subclass explicitly have to invoke a super class constructor? More “super” and “this” super(xxx) calls a superclass constructor must be first line of a subclass constructor super.xxx accesses superclass variables usable anywhere in the code of a sub class super.xxx(xxx) calls a superclass method usable anywhere in the code of a sub class this(xxx) calls a current-class constructor must be first line of current class constr. this.xxx accesses a current-class variable usable anywhere in the code this.xxx(xxx) calls a current-class method usable anywhere in the code super.super.xxx invalid statement invalid statement 2/17/2019 Inheritance & constructors (c) Eraj Basnayake

Important Difference between methods and variables under inheritance Variable Shadowing A subclass cannot override variables of a superclass - but it can shadow them. That means, it can have its own variable of the same type as the superclass without a conflict with that of the superclass. A subclass can use super to access the inherited member variable. When a method is invoked using a reference it is the class of the current object , not the reference that determines which method to run. However, in the case of a variable, it is the class of the reference, not the class of the current object denoted by the reference, that determines which variable will actually be accessed Important Difference between methods and variables under inheritance 2/17/2019 Inheritance & constructors (c) Eraj Basnayake

Inheritance & constructors (c) Eraj Basnayake Example: Remember the class “Light”, Tubelight, … shadowing public class Light{ public String billType = “Small bill” //… protected double getBill(int noOfHours){ double smallAmount = 10.0; smallAmount = smallAmount * noOfHours; System.out.println(billType+”:”+smallAmount); return smallAmount; } public void banner(){ System.out.println(“Let there be light!”); public class TubeLight extends Light{ public String billType = “Large bill”; //… public double getBill(int noOfHours){ double largeAmount = 100.0; largeAmount = largeAmount * noOfHours; System.out.println(billType+”:”+largeAmount); return largeAmount; } public double getBill(){ System.out.println(“no bill”); return 0.0; 2/17/2019 Inheritance & constructors (c) Eraj Basnayake

Inheritance & constructors (c) Eraj Basnayake class NeonLight extends TubeLight{ //… public void demonstrate(){ this.banner(); this.getBill(20); this.getBill(); System.out.println(this.billType); TubeLight tl = this; tl.banner(); tl.getBill(20); tl.getBill(); System.out.println(tl.billType); Light l = this; l.banner(); l.getBill(20); l.getBill(); System.out.println(l.billType); } public class Client{ public static void main(String args[]){ NeonLight neonRef = new NeonLight(); neonRef.demonstrate(); What’s the output? Why? 2/17/2019 Inheritance & constructors (c) Eraj Basnayake

Inheritance & constructors (c) Eraj Basnayake class NeonLight extends TubeLight{ //… public void demonstrate(){ this.banner(); this.getBill(20); this.getBill(); System.out.println(this.billType); super.banner(); super.getBill(20); super.getBill(); System.out.println(super.billType); ((Light) this).banner(); ((Light) this).getBill(20); ((Light) this).getBill(); System.out.println(((Light) this).billType); } public class Client{ public static void main(String args[]){ NeonLight neonRef = new NeonLight(); neonRef.demonstrate(); what’s going on here? Now can you tell what the output is and why? Output Let there be light! Large bill 2000.0 No bill Large bill <compiler Error> Small bill Reasoning Inheritance Method Overriding Extending the super class Most local variable Method overriding Variable Shadowing Can only access methods that are in Light 2/17/2019 Inheritance & constructors (c) Eraj Basnayake