CSC 240 Inheritance

CSC240 Computer Science III
Zhen Jiang
Dept. of Computer Science
West Chester University
West Chester, PA 19383
zjiang@wcupa.edu
10/30/2019 1
Table of Contents
 Introduction to inheritance
 Inheritance
 Syntax
 More!
 Overridding
 OOP (object-oriented programming)
 Polymorphism
 Modifiers
 Abstract class and interfaces
 GUI
10/30/2019 2
Introduction
 Write an Employee class with methods that
return values for the following properties of
employees at a particular company:
 Work week: 40 hours

 Annual salary: $40,000
 Paid time off: 2 weeks
 Leave of absence form: Yellow form
10/30/2019 3
// A class to represent employees
public class Employee {
public int getHours() {
return 40; // works 40 hours / week
}
public double getSalary() {

return 40000.0; // $40,000.00 / year
}
public int getVacationDays() {

return 10; // 2 weeks' paid vacation
}
public String getVacationForm() {

return "yellow"; // use the yellow form
}
}
10/30/2019 4
 Write a Secretary class with methods that return
values for the following properties of secretaries at a
particular company:
 Work week: 40 hours

 Annual salary: $40,000
 Paid time off: 2 weeks
 Leave of absence form: Yellow form
 Add a method takeDictation that takes a string

as a parameter and prints out the string prefixed by
"Taking dictation of text: ".
10/30/2019 5
// A class to represent secretaries
public class Secretary {
}

return 40000.0; // $40,000.00 / year
}

}

}
public void takeDictation(String text) {

System.out.println("Taking dictation of text: " + text);
}
}
10/30/2019 6
// A class to represent employees // A class to represent secretaries
public class Employee { public class Secretary {
public int getHours() { public int getHours() {
return 40; return 40;
} }
public double getSalary() { public double getSalary() {

return 40000.0; return 40000.0;
} }
public int getVacationDays() { public int getVacationDays() {

return 10; return 10;
} }
public String getVacationForm() { public String getVacationForm() {

return "yellow"; return "yellow";
} }
}
System.out.println("Taking dictation of text: "
+ text);
}
}
10/30/2019 7
Inheritance: Is-a relationship
 is-a relationship: A hierarchical connection where
one category can be treated as a specialized version
of another.
 Examples:
 Every secretary is an employee.
 Every square is a rectangle.
 Every dog is a mammal.
10/30/2019 8
 code reuse: The practice of writing program code once and using
it in many contexts.
 We'd like to be able to say the following:

public class Secretary {
<copy all the contents from Employee class>

+ text);
}
}
 That way we would be reusing the Employee code.

10/30/2019 9
 inheritance: A way to specify a relationship
between two classes where one class inherits the
state and behavior of another.
 The child class (also called subclass) inherits from

the parent class (also called superclass).
 The subclass receives a copy of every field and

method from the superclass.
10/30/2019 10
Syntax
 Creating a subclass, general syntax, p625:
public class <subclass name> extends <superclass name>
 Example:
public class Secretary extends Employee
{
....
}
 By extending Employee, each Secretary object

automatically has a getHours, getSalary,
getVacationDays, and getVacationForm method.
10/30/2019 11
 Improved Secretary class:

public class Secretary extends Employee
{
+ text);
}
}
10/30/2019 12
Writing even more classes
 Write a Marketer class that represents marketers
who have the same properties as general employees,
but instead of making only a paltry $40,000,
marketers make $50,000!
 Can we still leverage the Employee class or do we

have to re-write everything, because one method
(getSalary) is different?
 If only Marketer could write a new version of the

getSalary method, but inherit everything else…
10/30/2019 13
Overriding methods
 override: To write a new version of a method in a
subclass to replace the superclass's version.
 To override a superclass method, just write a new

version of it in the subclass. This will replace the
inherited version.
10/30/2019 14
Marketer class
// A class to represent marketers
public class Marketer extends Employee {
public void advertise() {
System.out.println("Act now while supplies last!");
}

return 50000.0; // $50,000.00 / year
}
}
10/30/2019 15
OOP: Based in reality or too
convenient?
 At many companies, all new employees attend a
common orientation to learn general rules (e.g., what
forms to fill out when).
 Each person receives a big manual of these rules.
 Each employee also attends a subdivision-specific

orientation to learn rules specific to their subdivision
(e.g., marketing department).
 Everyone receives a smaller manual of these rules.

10/30/2019 16
 The smaller manual adds some rules and also changes
(read: overrides) some rules from the large manual
(e.g., "use the pink form instead of the yellow form")
10/30/2019 17
 Why not just have a 22-page manual for lawyers,
21-page manual for secretaries, 23-page manual for
marketers, etc…?
10/30/2019 18
 maintenance: If a common rule changes, only the
common manual needs to be updated.
10/30/2019 19
 The 20 page manual manner is useful to be able to
specify general rules that will apply to many groups.
 Locality
 A person can look at the manual for lawyers and
quickly discover all rules that are specific to lawyers.
 It is also useful to specify a smaller set of rules for

such a particular group, including being able to
replace rules from the overall set (overriding, e.g.,
"use the pink form instead of the yellow form").
10/30/2019 20
//base class //attribute & method inheritance
public class PubA { public class PubB extends PubA
public int x = 1; {
public void setX(){ public void setX(){
x=2; x=3;}
} }
public int getX(){
return x;
}
}
PubA a = new PubA();

PubB b = new PubB();
a.setX();
b.setX();
System.out.println(a.getX());
10/30/2019 System.out.println(b.getX()); 21
Why inheritance?
 Need for Jbutton, FlowLayout, JTextField, etc
 http://www.cs.wcupa.edu/~zjiang/Extend_action.java
 Need for a customized response from the computer for
all GUI actions
 http://www.cs.wcupa.edu/~zjiang/MultiEventSource.java
10/30/2019 22
Constructor for superclass
10/30/2019 23
private double salary;
public Employee(double initialSalary)
{
salary = initialSalary;
}
return 40; // 40 hours per week
}
return salary;
}
}
}
}
10/30/2019 24
Use the super() method to call the superclass’s constructor, p634
public class Marketer extends Employee {
// inherits double salary
public Marketer(double initialSalary)

{
//construct superclass
super(initialSalary);
}
}
- For every constructor of a subclass, the call to super() must be the

first statement in the subclass’s constructor.
- Make sure to give the same number of arguments as there are
parameters in the definition of the superclass’s constructor.
10/30/2019 25
 Question: If a method is declared private, does a
subclass inherit it?
 Actually, yes. Subclasses inherit everything that they
don’t override.
 If a method is declared private, can a subclass
call it?
 NO! Only code inside the same class can call a private
method.
 What if you want a subclass to be able to use it?
 Use the protected access level
10/30/2019 26
private double salary = 40000.00;

}

return salary;
}

}

}
}
10/30/2019 27
 Subclasses cannot see salary directly!
public class CEO extends Employee {
public void giveMyselfRaise() {
salary += 1000000.00; // Compile-time Error!
public static void main(String [] args)

{
CEO c = new CEO();
// This is fine, no error here
// Access to salary field is indirect
// We’re accessing the public getSalary() method
System.out.println(“My salary is “ + c.getSalary());
}
}
10/30/2019 28
protected double salary = 40000.00;

}

return salary;
}

}

}
}
10/30/2019 29
 Subclasses can see protected variables
and methods just fine.
salary += 1000000.00; // No longer an error
}
public static void main(String [] args)

{
CEO c = new CEO();
// This is fine, no error here
// Access to salary field is indirect
// We’re accessing the public getSalary() method
System.out.println(“My salary is “ + c.getSalary());
}
}
10/30/2019 30
What would happen if ....
private double salary = 40000.00;

}

return salary;
}
public void addToSalary(double raise) {

salary += raise;
}

}

}
}
10/30/2019 31
addToSalary(1000000.00);
}
}
 CEO still has its own copy of the salary

field, and this code will change the value of
it appropriately.
 The fact that salary is private simply means
that CEO can't access it directly. It can still
call public (or protected) superclass
methods that can access it.
10/30/2019 32
//base class //sub class
public class ProA { public class ProB extends ProA {
private int x = 1; public int getB(){
protected void setX(int a){ setX(2);
x=a; // your next step is to return x
} // but “return x” does not work
// due to the private modifier, so
protected int getX(){ return getX();
return x; }
} }
}
ProA a = new ProA();

ProB b = new ProB();
System.out.println(b.getB());
10/30/2019 33
Polymorphism
 A reference variable of type T can refer to an object
of any subclass of T.
Employee Laura = new Lawyer();
Employee Mark = new Marketer();
 polymorphism: The ability for the same code to be

used with several different types of objects and
behave differently depending on the type of object
used, p664.
10/30/2019 34
Employee Laura = new Lawyer();
System.out.println(Laura.getSalary()); // 40000.0
System.out.println(Laura.getVacationForm()); // "pink"
 You can call any method from Employee on the

person variable, but not any method specific to
Lawyer (such as sue).
 Once a method is called on that object, it behaves in

its normal, overridden way (as a Lawyer, not as a
normal Employee).
10/30/2019 35
public class Secretary extends Employee public class Marketer extends Employee {
{ public void advertise() {
public void takeDictation(String text) { System.out.println("Act now while supplies last!");
System.out.println("Taking dictation of text: " }
+ text);
} public double getSalary() {
} return 50000.0; // $50,000.00 / year
}
}
public class EmployeeMain {

public static void main(String[] args) {
Secretary laura = new Secretary();
Marketer mark = new Marketer(); Polymorphism
printInfo(laura);
printInfo(mark); and
}
parameters
public static void printInfo(Employee empl) {
System.out.println("salary = " + empl.getSalary());
System.out.println("days = " + empl.getVacationDays());
System.out.println("form = " + empl.getVacationForm());
System.out.println();
}
}
Output:
salary = 40000.0
vacation days = 10
vacation form = yellow
salary = 50000.0
vacation days = 10
vacation form = yellow
10/30/2019 36
public class EmployeeMain2 {
public static void main(String[] args) {
Employee[] employees = {new Secretary(), new Marketer() };
for (int i = 0; i < employees.length; i++) {
System.out.println("salary = " + employees[i].getSalary());
System.out.println("vacation days = " +
employees[i].getVacationDays());
}
}
}
Polymorphism
Output:
and
salary = 40000.0
vacation days = 10 arrays
salary = 50000.0
vacation days = 10
10/30/2019 37
Exercises
 Assume that the following four classes have been declared:
public class Foo { public class Baz extends Foo {
public void method1() { public void method1() {
System.out.println("foo 1"); System.out.println("baz 1");
} }
public void method2() { public String toString() {

System.out.println("foo 2"); return "baz";
} }
}
public String toString() {
return "foo"; public class Mumble extends Baz {
} public void method2() {
} System.out.println("mumble 2");
}
public class Bar extends Foo { }
public void method2() {
System.out.println("bar 2");
}
}
10/30/2019 38
 What would be the output of the following client
code?
Foo[] pity = { new Baz(), new Bar(),

new Mumble(), new Foo() };
for (int i = 0; i < pity.length; i++) {
System.out.println(pity[i]);
pity[i].method1();
pity[i].method2();
}
10/30/2019 39
10/30/2019 40
 The code produces the following output:
baz
baz 1
foo 2
foo
foo 1
bar 2
baz
baz 1
mumble 2
foo
foo 1
foo 2
10/30/2019 41
 Kind of override under the standard of
superclass!
10/30/2019 42
Variable Shadowing:
Something to avoid!!
 Polymorphism applies to methods in Java
 But not to fields! A a1 = new A();
A a2 = new B();
public class A { System.out.println(a1.method()); // prints 1
int x = 1; System.out.println(a2.method()); // prints 2
int method() { return 1; } System.out.println(a1.x);

// prints 1
} System.out.println(a2.x);
// prints 1 still!
public class B extends A { // Not like method, which prefers to its own.
int x = 2;
int method() { return 2; }
}
10/30/2019 43
 Variable Shadowing:
 When a class extends another class and
defines a field with the same name, each
object of the subclass contains two fields
with that name.
 The supclass’s version of the field is said
to shadow the subclass’s version, making

the subclass’s version invisible within that
class.
 This is called variable shadowing.
10/30/2019 44
public class A {
protected int x = 1; A a = new A();
protected void setX(int a){ B b = new B();
x=a; System.out.println(a.getX());
} System.out.println(b.getX());
protected int getX(){ System.out.println(b.getB());
return x;} System.out.println(a.x);
} System.out.println(b.x);
public class B extends A { A a = new A();

protected int x = 3; A b = new B();
public int getX(){ System.out.println(b.getX());
return x; } //System.out.println(b.getB());
System.out.println(a.x);
public int getB(){ System.out.println(b.x);
return x;}
} 10/30/2019 45

http://www.cs.wcupa.edu/~zjiang/240modifier_inheritance.pdf
10/30/2019 46
 Exercises
 Slide 39
 PolymorphismDemo in
 http://www.cs.wcupa.edu/~zjiang/Poly.zip
10/30/2019 47
 How to determine overriding and
shadow?
 Method, overriding, own study processing
 Attribute, shadow, >60 is a passing score
so that you cannot override it
10/30/2019 48
Modifiers
 Public
 A class, method, constructor, interface etc declared public
can be accessed from any other class. Therefore fields,
methods, blocks declared inside a public class can be
accessed from any class belonging to the Java Universe.
 Because of class inheritance, all public methods and
variables of a class are inherited by its subclasses.
10/30/2019 49
 Private
 Methods, Variables and Constructors that are declared
private can only be accessed within the declared class itself.
 Private access modifier is the most restrictive access level.
Class and interfaces cannot be private.
 Variables that are declared private can be accessed outside
the class only if public accessor methods are present in the
class.
10/30/2019 50
 Protected
 Variables, methods and constructors which are declared
protected in a superclass can be accessed only by the
subclasses.
 Protected access gives the subclass a chance to use the
helper method or variable, while preventing a nonrelated
class from trying to use it.
10/30/2019 51
 Default (like public)
 Default access modifier means we do not explicitly declare
an access modifier for a class, field, method etc.
 A variable or method declared without any access control
modifier is available to any other class in the same package.
 For example:
public class Logger {
String format;
String getFormat() { return this.format; }
public void setFormat(String f) { format = f; }
}
10/30/2019 52
Abstract and Interfaces
 What have you learnt from the above exercises
on “extends”?
 Is it good to block the use of subclass method that is
not declared in super class?
 Good, because methods can be in template. In the
security control, no leakage!

 Is it good to have the direct access of attribute?
 Better not, if it is not in your control. See how
complicate it is in the variable shadowing.

 Suppose we’ve defined an Employee class, and we
don’t want someone to come along and muck it up
 E.g., we don’t want a CEO subclass that gives itself a raise
 The final keyword indicates that some definition

(of a class, method, or field) cannot be changed or
overridden by a subclass.
54
final Example
// A class to represent employees
}
public final double getSalary() {

return 40000.0; // $40,000.00 / year
}

}

}
}
No subclass is allowed to change the definition of getSalary()! 55
final fields, methods, and
classes
The final keyword can be applied to fields (as we’ve seen before):
// no code may change the value of salary,
//including a subclass’s code
public final double salary = 40000.0;
Or to methods:
// subclasses cannot override the getSalary method
public final double getSalary() { return salary; }
Or even to classes:
// the Employee class cannot be extended
// It can’t have any subclasses at all!
public final class Employee { ... }
56
Opposite of final
 The final keyword prevents subclasses from
changing (overriding) code
 Sometimes, you want to do the opposite:
Force another programmer or piece of code

to finish parts of a class.
Example: Employee salary
 Let’s say you want every subclass of
Employee to have a salary, but you
want the subclass to decide what the
salary should be.
We can define an “abstract” getSalary()

method, p668:
public abstract double
getSalary();
Abstract Rules (1)
If a class has an abstract method (p669), or it
inherits an abstract method that it doesn’t
override, then the class must be declared
abstract (p669).
public abstract class Employee {

public abstract double getSalary();
// you can mix abstract and non-abstract methods
// in an abstract class
public int getHours() { // Note: not abstract!
return 40;
}
Abstract Rules (2)
If a class is abstract, it can’t have a constructor.
 No Employee object can be constructed
 But you can declare Employee references.

public static void main(String [] args) {

Employee e; // NO ERROR: reference is fine
e = new Employee(); // ERROR! No constructor
}
}
Extending an abstract class
public class Lawyer extends Employee {
// since Employee declares an abstract getSalary,
// Lawyer must define getSalary by overriding it
// or else Lawyer must be an abstract class
return 45000.0;
}

Employee e; // Fine, no problem
e = new Lawyer(); // Also fine (polymorphism)
e = new Employee(); // ERROR! No constructor!
}
}
Abstract classes: what’s the
point?
 If you can’t construct objects for a class,
what’s the point of the class? How can we
use it?
 Short Answer: polymorphism.
 We can use references of type Employee as a
place to store Lawyers, Secretaries, CEOs, etc.
 Because getSalary() is declared in Employee,
e.getSalary() is legal syntax, even though
getSalary() is not defined in Employee.
http://docs.oracle.com/javase/tutorial/java/Iand
I/abstract.html
Exercise
 Create an abstract ClosedShape class
with an abstract getArea() method
 Write non-abstract subclasses
Rectangle and Circle
 Write main methods for each that
construct an object and print its area.
Do not use attribute to store area
information.
public abstract class Closedshape{ public class shapeApp {
public abstract double getArea(); } public static void main(String [] args){
Rectangle r = new Rectangle(2, 3);
public class Circle extends Closedshape{ Circle c = new Circle(1.5);
private double radius; System.out.println(r.getArea());
public Circle (double r){ System.out.println(c.getArea());
radius = r; } }
}
public double getArea (){
return Math.PI*radius*radius; } 6.0
7.0685834705770345
public double getCircumference(){
return radius; }
}
public class Rectangle extends Closedshape{

private int length=0;
private int width=0;
public Rectangle(int l, int w){
length=l;
width=w; }

return length*width; }
} 10/30/2019 65
Going full abstract
 What if our abstract class had no non-
abstract methods?
public abstract int getHours();
public abstract String getVacationForm();
}
Each subclass would have different definitions.

They share only the names of their methods.
Java has an alternative way to do this:
interfaces (p675).
66
Interfaces
 Let's say you have the following two
related classes:
public class Scientist { public class Engineer {
public void discover() { public void discover() {
System.out.println(“Eureka! I System.out.println(“Cool, what did
have found it!“); I just do?“);
} }
public void publish() { public void publish() {
System.out.println(“My System.out.println(“I don't
research is better than yours.”); know how this happened, but it
} works.”);
}
}
}
 Neither of their methods do the same thing.

67
Code Reuse
 But they're still similar – they both discover
and publish. Can we get code reuse?
interface Researcher {
void discover();
void publish();
}
 Now we can create Researcher references
68
Using Interface Objects
public static void researchCycle(Researcher r) {
r.discover();
r.publish();
}

Researcher researcher1 = new Scientist();
Researcher researcher2 = new Engineer();
// Interfaces have no constructors
// They can only be used as types for references
researcher2 = new Researcher(); // ERROR!
researchCycle(researcher1);
researchCycle(researcher2);
}
69
Using Interfaces
 Interfaces are a way of specifying what objects are
capable of, without saying how.
 Interface variables can execute any of the methods listed

in the interface, but the behavior depends on the class of
the object
 That is, interface variables are polymorphic.
 There are no constructors for interfaces. They are not

classes, and no objects of that run-time type are created.
They are compile-time types for references.
70
Implementing Interfaces
public class Scientist implements Researcher {
public void discover() {

System.out.println(“Eureka! I have found it!“);
}
public void publish() {

System.out.println(“My research is better than yours.”);
}
}
71
public class Engineer implements Researcher {
public void discover() {
System.out.println(“Whoa, what did I just do?“);
}
public void publish() {

System.out.println(“I don't know how this happened, but
it works.”);
}
}
72
Exercise
 Create an interface Measurable class
with an non-abstract getArea() method
 Write subclasses Rectangle and Circle to
implement the above interface
 Write main methods for each that
construct an object and print its area.
Do not use attribute to store area
information.
public interface Measurable{ public class shapeApp {
Rectangle r = new Rectangle(2, 3);
public class Circle implements Measurable{ Circle c = new Circle(1.5);
private double radius; System.out.println(r.getArea());
public Circle (double r){ System.out.println(c.getArea());
radius = r; } }
}
return Math.PI*radius*radius; } 6.0
7.0685834705770345
public double getCircumference(){
return radius; }
}
public class Rectangle implements Measurable{

private int width=0;
public Rectangle(int l, int w){
length=l;
width=w; }

return length*width;}
} 10/30/2019 74
public interface Measurable{ public class shapeApp {
// Rectangle r = new Rectangle(2, 3);
public class Circle implements Measurable{ // Circle c = new Circle(1.5);
private double radius; // System.out.println(r.getArea());
public Circle (double r){ // System.out.println(c.getArea());
radius = r; } Measurable r = new Rectangle(2, 3);
//polymorphism
public double getArea (){ display(r);
return Math.PI*radius*radius; } Circle c = new Circle(1.5);
Measurable m = c;
public double getCircumference(){ display(m);
return radius; } // (m.getCircumference()); not allowed
} Circle t = (Circle) m;
System.out.println(t.getCircumference());
public class Rectangle implements Measurable{
}
public static void display (Measurable fig){
private int width=0; System.out.println(fig.getArea());
public Rectangle(int l, int w){ }
length=l;
width=w; }
6.0
public double getArea (){ 7.0685834705770345
return length*width;} 1.5
} 10/30/2019 75
Comparable interface
 Define the Comparable interface
public interface Comparable {
public int compareTo(Object other);
}
public interface Comparable<T> {

public int compareTo(T other);
}
Return a comparable value!

 Fruit.java
 FruitDemo.java
 Contained in the zip file:
http://www.cs.wcupa.edu/~zjiang/Poly.zip
10/30/2019 77
 Explanation of
interfacehttp://docs.oracle.com/javase/tutoria
l/java/concepts/interface.html
 Exercises
 Revisit ButtonDemo.java in
http://www.cs.wcupa.edu/~zjiang/button.zip
10/30/2019 79
GUI
 Window interface, p755
 JFrame
 Basic components
 Button
 see the button sample available in Chapter 0 from class website
 Event
 Multiple events (e.g., which button is clicked?)
 Label
 Text field
 Layouts, p787
 https://docs.oracle.com/javase/tutorial/uiswing/layout/visual.html
 Other Buttons
 https://docs.oracle.com/javase/tutorial/uiswing/components/button.html
 Color
 Complete package of the samples of the above
 https://www.cs.wcupa.edu/~zjiang/csc142_java_sample.htm

CSC 240 Inheritance

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

CSC 240 Inheritance

Uploaded by

Copyright:

Available Formats

CSC240 Computer Science III

 Work week: 40 hours

public double getSalary() {

public int getVacationDays() {

public String getVacationForm() {

 Work week: 40 hours

 Add a method takeDictation that takes a string

public double getSalary() {

public int getVacationDays() {

public String getVacationForm() {

public void takeDictation(String text) {

public double getSalary() { public double getSalary() {

public int getVacationDays() { public int getVacationDays() {

public String getVacationForm() { public String getVacationForm() {

 We'd like to be able to say the following:

public void takeDictation(String text) {

 That way we would be reusing the Employee code.

 The child class (also called subclass) inherits from

 The subclass receives a copy of every field and

 By extending Employee, each Secretary object

// A class to represent secretaries

 Can we still leverage the Employee class or do we

 If only Marketer could write a new version of the

 To override a superclass method, just write a new

public double getSalary() {

 Each person receives a big manual of these rules.

 Each employee also attends a subdivision-specific

 Everyone receives a smaller manual of these rules.

 It is also useful to specify a smaller set of rules for

PubA a = new PubA();

public Marketer(double initialSalary)

- For every constructor of a subclass, the call to super() must be the

public int getHours() {

public double getSalary() {

public int getVacationDays() {

public String getVacationForm() {

public void giveMyselfRaise() {

salary += 1000000.00; // Compile-time Error!

public static void main(String [] args)

public int getHours() {

public double getSalary() {

public int getVacationDays() {

public String getVacationForm() {

public static void main(String [] args)

public int getHours() {

public double getSalary() {

public void addToSalary(double raise) {

public int getVacationDays() {

public String getVacationForm() {

public void giveMyselfRaise() {

 CEO still has its own copy of the salary

ProA a = new ProA();

 polymorphism: The ability for the same code to be

 You can call any method from Employee on the

 Once a method is called on that object, it behaves in

public class EmployeeMain {

public void method2() { public String toString() {

Foo[] pity = { new Baz(), new Bar(),

int method() { return 1; } System.out.println(a1.x);

to shadow the subclass’s version, making

public class B extends A { A a = new A();

security control, no leakage!