OOP: Class Hierarchies

Object-Oriented Programming:
Class Hierarchies

Atit Patumvan
Faculty of Management and Information Sciences
Naresuan University

http://atit.patumvan.com

2

Subclass Definition
public class Person {
+ Person Supper Class
private String name;
-name : String private String name;
-age : int private int age;
private int age;
+toString() : String
public String toString() {
return "Name: " + name + "nAge: " + age;
return "Name: " + name + "nAge: " + age;
}
}
}
}
+ Employee Sub Class
-salary : long public class Employee extends Person {
public class Employee extends Person {
private long salary;
private long salary;
-subordinates private Manager supervisor;
0..* private Manager supervisor;
}
}
1 import java.util.Vector;
-supervisor
import java.util.Vector;
public class Manager extends Employee {
+ Manager public class Manager extends Employee {
-category : int private int category;
private int category;
private Vector subordinates;
private Vector subordinates;
}
}

Object-Oriented Programming: Class Hierarchies

3

Class Diagram Mapping
class A {
class A {
A }
}

class B extends A {
class B extends A {
B }
}


4

Class Diagram Mapping
A class A {
class A {
private int id;
private int id;
- id : int
public int getID(){
public int getID(){
+ getID() : int return id;
return id;
}
+ setID(int) : void }
public void setID(int id){
public void setID(int id){
this.id = id;
this.id = id;
}
}
}
}

class B extends A {
class B extends A {
B
}
}

: Tester Class
:
B b = new B();
B b = new B();
b.setID(10);
b.setID(10);
:
:

5

Variable and Method Inheritance
public class Person { + Person

private String name; -name : String
private String name; -age : int
private int age;
private int age;
return "Name: " + getName() + "nAge: " + getAge();
return "Name: " + getName() + "nAge: " + getAge();
}
}
public String getName() { + Employee
public String getName() {
return name;
return name; -salary : long
}
}
public void setName(String name) {
public void setName(String name) {
this.name = name;
this.name = name;
}
}
public int getAge() {
public int getAge() {
return age; Employee emp = new Employee();
return age; Employee emp = new Employee();
}
}
public void setAge(int age) { emp.setName("Alice");
public void setAge(int age) { emp.setName("Alice");
this.age = age; emp.setAge(28);
this.age = age; emp.setAge(28);
}
}
} System.out.println(emp);
} System.out.println(emp);


6

Inheritance and Type Hierarchy
+ Person

-name : String
-age : int Employee
-name : String
-age : int Person

+ Employee
-salary : long Employee
-salary : long

Employee emp = new Employee();
emp.setName("Alice");
emp.setAge(28);
emp.setAge(28);
emp.setSalary(15000);
System.out.println(emp);


7

Variable Overriding
+ Person public class Customer extends Person {
public class Customer extends Person {
-name : String
-age : int private String name;
public void showName() {
System.out.println("Customer: "+getName());
System.out.println("Person: "+super.getName());
}
+ Employee + Customer }
}
-salary : long -name : String }
+showName() : void

Customer c = new Customer();
Customer c = new Customer();
Person p = c;
Person p = c;
c.setName("Bob");
c.setName("Bob");
p.setName("Alice");
p.setName("Alice");
c.showName();
c.showName();


8

Method Overriding
:
:
@Override
@Override
public String toString(){
public String toString(){
return "Name: " + getName() + "nAge: " + getAge() + "nSalary: "+ getSalary();
return "Name: " + getName() + "nAge: " + getAge() + "nSalary: "+ getSalary();
}
}
}
}

+ Person

-name : String Employee emp = new Employee();
-age : int Person per = emp;
Person per = emp;
+toString() : String emp.setName("Alice");
emp.setAge(28);
emp.setAge(28);
+ Employee System.out.println(per);
System.out.println(per);
-salary : long



9

Inheritance and Constructors

Constructor are not inherited (and there fore cannot be overridden)
:
:
public Person() {
public Person() {
System.out.println("Instance of Person is created");
}
}
:
:
}
}

:
:
public Employee(){
public Employee(){
System.out.println("Instance of Employee is created");
}
}
:
:
}
}


10

Inheritance and Constructors(cont.)
:
:
public Person() {
public Person() {
}
}
public Person(String name){
public Person(String name){
this.name = name;
this.name = name;
}
}
:
:
}
}

:
:
public Employee(){
public Employee(){
}
}
public Employee(String name){
public Employee(String name){
} Employee emp = new Employee("Alice");
} Employee emp = new Employee("Alice");
: System.out.println(emp);
: System.out.println(emp);
}
}


11

Final Class

A final class cannot be subclassed.
public final class Customer extends Person {
public final class Customer extends Person {
}
}
}
}

// Error: VIPCustomer cannot be subclass
// Error: VIPCustomer cannot be subclass
public class VIPCustomer extends Customer{
public class VIPCustomer extends Customer{
}
}

Customer cus = new Customer();
Customer cus = new Customer();


12

Abstract Classes, Abstract Methods
● Abstract classes
● Cannot be instantiated
● Cannot be subclassed
● Abstract methods
● Method without code, they are declared but not defined
● Must be defined in some subclass
● Abstract class can have non-abstract methods
● An abstract method must belong to an abstract class

13

Abstract Classes: Example
public abstract class Shape { + Shape
public abstract class Shape {
abstract double area();
}
} +area() : double

public class Circle extends Shape {
public class Circle extends Shape {
+ Circle
private java.awt.geom.Point2D center;
private java.awt.geom.Point2D center; -center : java.awt.geom.Point2D
private double radius;
private double radius; -radius : double

@Override
@Override
double area() {
double area() {
return Math.PI * radius * radius;
return Math.PI * radius * radius;
}
}
}
}


14

Inherited Abstract Methods
public abstract class Shape { + Shape
}
} +area() : double

//Error: Polygon must be abstract
//Error: Polygon must be abstract
public class Polygon extends Shape{
public class Polygon extends Shape{
}
} + Polygon

public class Triangle extends Polygon {
public class Triangle extends Polygon {
private java.awt.geom.Point2D a, b, c;
private java.awt.geom.Point2D a, b, c;
@Override
@Override + Triangle
double area() {
double area() { -a : java.awt.geom.Point2D
return Math.abs((b.getX() - a.getX()) * (c.getY() - a.getY()) -b : java.awt.geom.Point2D
return Math.abs((b.getX() - a.getX()) * (c.getY() - a.getY()) -c : java.awt.geom.Point2D
- (b.getY() - a.getY()) * (c.getX() - a.getX())) / 2;
- (b.getY() - a.getY()) * (c.getX() - a.getX())) / 2;
}
}
}
}


15

Interface
● Collection of undefined methods and constant values
● Similar to an abstract class where all method are abstract and public,
and all variable are public, static and final
● Subclass a class → implement an interface
● A class may implement several interfaces


16

Using an Interface
interface Shape {
interface Shape {
public double area();
public double area();
public double volume();
public double volume();
}
}
public class Point implements Shape {
public class Point implements Shape {
static int x, y;
static int x, y;
public Point() {
public Point() {
x = 0;
x = 0;
y = 0;
y = 0;
}
}
public double area() {
return 0;
return 0;
}
}
public double volume() {
public double volume() {
return 0;
return 0;
}
}
public static void print() {
public static void print() {
System.out.println("point: " + x + "," + y);
System.out.println("point: " + x + "," + y);
}
}
}
}


17

Polymorphism
● Polymorphic, having multiple behavior
● A polymorphic method results in different actions depending on the
object being referenced
● Also knows as late binding or run-time binding


18

Polymorphism Example
public abstract class Shape { public class Calculator {
abstract double area(); public class Calculator {
abstract double area(); public static double calculateArea(Shape shape){
} public static double calculateArea(Shape shape){
} return shape.area();
return shape.area();
}
public class Circle extends Shape { }
public class Circle extends Shape { }
private double radius; }
private double radius;
@Override
@Override
return Math.PI * getRadius() * getRadius();
return Math.PI * getRadius() * getRadius();
}
}
:
: Circle circle = new Circle();
} Circle circle = new Circle();
} circle.setRadius(5.0);
circle.setRadius(5.0);
public class Rectangle extends Shape { Rectangle rectangle = new Rectangle();
public class Rectangle extends Shape { Rectangle rectangle = new Rectangle();
private double width; rectangle.setWidth(3.0);
private double width; rectangle.setWidth(3.0);
private double length;
private double length; rectangle.setLength(2.0);
@Override rectangle.setLength(2.0);
@Override
public double area() { System.out.println(Calculator.calculateArea(circle));
public double area() { System.out.println(Calculator.calculateArea(circle));
return width*length;
return width*length; System.out.println(Calculator.calculateArea(rectangle));
} System.out.println(Calculator.calculateArea(rectangle));
}
:
:
}
}

19

Inner Class
● It’s possible (and sometimes encouraged!) to define one class within
another.
● This provides another way to group classes that work closely together.
● Inner classes can be “shielded” so that they are unknown to the outside
world.
● Often inner classes are used to hide a class-specific implementation of
an external interface.
● Inner classes can be classified into four types, Static Nested Class or
Interface, Member Classes, Local Classes and Anonymous Class

20

Static Nested Class or Interface
class A { class A {
class A { class A {
static class B{ static class B {
static class B{ static class B {
} void print() {
} void print() {
} System.out.println("B");
}
}
}
interface C{ }
interface C{ void print() {
static class D{ void print() {
static class D{ System.out.println("A");
} System.out.println("A");
} }
} }
} }
}
class E{ public class NestedClassTest1 {
class E{ public class NestedClassTest1 {
static interface F{
static interface F{ public static void main(String[] args) {
} public static void main(String[] args) {
} A a = new A();
} A a = new A();
} a.print(); //A
a.print(); //A
A.B b = new A.B();
interface G{ A.B b = new A.B();
interface G{ b.print(); //B
static interface H{ b.print(); //B
static interface H{ }
} }
} }
} }
}


21

Member Classes
class A { class A {
class A { class A {
class B{ class B {
class B{ class B {
} void print() {
} void print() {
}
}
}
}
void print() {
void print() {
System.out.println("A");
System.out.println("A");
}
}
}
}
public class MemberClassTest {
public class MemberClassTest {
public static void main(String[] args) {
A a = new A();
A a = new A();
a.print(); //A
a.print(); //A
A.B b = a.new B();
A.B b = a.new B();
b.print(); //B
b.print(); //B
}
}
}
}


22

Local Classes
Local class is a class defined within a method or branch

class A {
class A {
A() {
A() {
class B {
class B {
B() {
B() {
System.out.println("B");
System.out.println("B");
}
}
}
}
new B();
new B();
}
}
}
}
public class LocalClassTest {
public class LocalClassTest {
new A(); // B
new A(); // B
}
}
}
}


23

Anonymous Classes
class A {
class A {
int x = 0;
int x = 0;
A(int x) {
A(int x) {
this.x = x;
this.x = x;
}
}
void f() {
void f() {
System.out.println(x);
System.out.println(x);
} public class AnoClassTest2 {
} public class AnoClassTest2 {
}
}
static void caller(A a) {
public class AnoClassTest1 { a.f();
public class AnoClassTest1 { a.f();
}
}
a.f(); public static void main(String[] args) {
a.f(); public static void main(String[] args) {
} caller(new A(1) {
} caller(new A(1) {
void f() {
void f() {
public static void main(String[] args) { System.out.println(++x);
public static void main(String[] args) { System.out.println(++x);
caller(new A(1) { }
caller(new A(1) { }
}); });
}); });
} }
} }
} }
} }


OOP: Class Hierarchies

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (9)

Similaire à OOP: Class Hierarchies

Similaire à OOP: Class Hierarchies (20)

Plus de Atit Patumvan

Plus de Atit Patumvan (20)

Dernier

Dernier (20)

OOP: Class Hierarchies