Type hierarchy in Java
• Superclass can have
– Full implementation
– Partial implementation (abstract class)
– No implementation (interface)
• A subclass can
– re-implement (override) superclass methods
– provide new, additional methods
• A subclass can have access to the superclass data
– through public methods (API)
– through protected methods
– directly (non-private attributes)
• All classes inherit from Object
javaprogrammering
Person Overriding, ex
Customer Employee
(has salary)
CEO Secretary Sales person
(has benefits) (has monthly (has bonus
salary) salary)
javaprogrammering
Overriding, ex
class Employee extends Person{
private int salary;
public int getSalary() {
return salary;
}
}
class SalesPerson extends Employee{
public int getSalary() { // overridden method
return [Link]()+computeBonus();
}
private int computeBonus() { … }
}
javaprogrammering
Overriding, ex
class SalesPerson extends Employee{
public int getSalary() { // overridden method
return [Link]()+computeBonus();
}
private int computeBonus() { … }
}
class TravellingSalesPerson extends SalesPerson {
public int getSalary() { // overridden method
return [Link]()+
computeMileageAllowance();
}
private int computeMileageAllowance() { … }
}
– Can we reach getSalary() in Employee from
TravellingSalesPerson ?
javaprogrammering
Overriding, ex
Employee[] personnel; // heterogeneous collection
// fill array with Employee objects
.
.
int totalSalaryCost = 0;
for (int i=0;i<[Link];i++) {
totalSalaryCost += [Link]();
}
How does the object know what type it
is, and thus which method to invoke?
javaprogrammering
Virtual method invocation
• It is the method of the runtime type that is used (and this
is not necessarily the same as the declared type)
• Compiler only sees apparent type
• Runtime uses actual type (subtype of apparent type)
• (Also referred to as “dispatching”)
javaprogrammering
poly = “many”
Polymorphism
morph = “form”
javaprogrammering
class Pet{
Polymorphism, ex
public void sound(){
[Link](””);
}
}
class Dog extends Pet{
public void sound(){ //overridden method
[Link]("Vov");
}
}
class Cat extends Pet{
public void sound(){ //overridden method
[Link]("Mjau");
}
}
javaprogrammering
• Packade is given first in source file
Package
package brokersystem;
• Subpackages can be used
package [Link];
• If no package is defined, the class will belong to the no-
name, default package
• Use packages! (except for small test programs)
• (“java” and “javax” are reserved)
javaprogrammering
Package, ex
package brokersystem; package [Link];
import [Link]; import [Link].*;
import [Link].*; import [Link].*;
public class Broker{ public class BrokerGui[
. .
. .
. .
} }
javaprogrammering
>javac –d . *.java
or:
Package structure, ex
>javac –d . [Link]
brokersystem
gui
[Link]
[Link]
[Link]
javaprogrammering
Package, compiling
(project directory)
brokersystem
[Link]
[Link]
gui
[Link]
javaprogrammering
Why packages?
• Encapsulation – a higher level of encapsulation; only
public classes and interfaces can be used outside a
package
• Naming – a “fully qualified” name = package name + class
name (avoids name conflicts; e.g. Date in [Link]
and in [Link]).
• Organization
javaprogrammering
Access modifiers
Visibility Object of Object in Children All
same same in other
type package packages
private yes no no no
default yes yes no no
protected yes yes yes no
public yes yes yes yes
javaprogrammering
Using mutator:
Bird, ex
class Bird{
String name;
setName(String s){
name = s;
}
}
Using constructor:
class Bird{
String name;
Bird(String s){
name = s;
}
}
javaprogrammering
Constructors
• Same name as class
• No return type
• Can be overloaded
• If no constructor is defined, a no-argument default
constructor is used
• No constructor is same as:
public MyClass() {}
…which is same as:
public MyClass() { super(); }
javaprogrammering
Constructors
• Constructors are not inherited!
• Constructor of superclass is invoked before that of
subclass (first Car, then SportsCar)
• this and super must be used on first line of constructor
• (any non-private variables and methods of the superclass
can be accessed using super)
javaprogrammering
this, ex
public class Bird{
private String name;
Bird(String name){
[Link] = name;
}
Bird(){
this(“Gråsparv");
}
public static void main (String []args){
new Bird(“Trana");
new Bird();
}
}
javaprogrammering
class Car{
super, ex
int doors;
Car(int doors){
[Link] = doors;
}
Car(){
this(4);
}
public void equipment(){
[Link](”Number of doors: ” + doors);
}
}
class SportsCar extends Car{
boolean turbo;
SportsCar(boolean turbo){
super(2);
[Link] = turbo;
}
public void equipment(){
[Link]();
if (turbo) [Link](”Has turbo”);
}
}
javaprogrammering
Pet again…
Would we ever want to instantiate this class?
class Pet{
public void sound(){
[Link](””); // Typical sound?
}
}
Better to make it abstract:
abstract class Pet{
public abstract void sound();
}
javaprogrammering
Abstract classes
• Partially implemented classes
• Has one or more “abstract” methods – i.e. methods that are not
implemented
• Can have instance variables
• Cannot be instantiated – only used as superclasses
• Abstract methods implemented in subclasses
• Implemented methods can call abstract methods (example of the
Template pattern”; e.g. AbstractBankListener)
javaprogrammering
Abstract classes, ex
abstract class Vehicle{
public abstract void sound();
public void testSound(){
[Link]();
}
}
javaprogrammering
Abstract classes, ex
abstract class Vehicle{
public abstract void sound();
public void testSound(){
[Link]();
}
}
class Car extends Vehicle{
public void sound(){
[Link]("brum, brum");
}
}
class Drive{
public static void main(String [] args){
Car lada = new Car();
[Link]();
}
}
javaprogrammering
Multiple inheritance
Conceptual problems…
javaprogrammering
Multiple inheritance
• What if two superclasses have the same method?
class House {
public void maintenance() {
// repair foundation
}
}
class Boat {
public void maintenance() {
// paint hull
}
}
• In Java, multiple inheritance is not allowed (only one implementation)
javaprogrammering
Interface
Boat <<interface>>
House
extends implements
HouseBoat
javaprogrammering
Interface
• A type definition (but not its implementation)
• A form of contract
• Contains only abstract methods
• Methods always public
• A class can extend only one other class, but implement
many interfaces
javaprogrammering
class ShopOverload { Shop, ex
float sum = 0.00f;
void reset () {
sum = 0.00f;
}
float getTotal () {
return sum;
}
void regSale ( Bulldozer itemSold ) {
sum += [Link]();
}
void regSale ( Truck itemSold ) {
sum += [Link]();
}
.
.
}
• One method for each item type…
• Solution: Create a superclass! (or..?)
javaprogrammering
public abstract class Vehicle {
Shop, ex
public abstract float prize();
}
public class Bulldozer extends Vehicle {
public float prize() {
return 1500000.0f;
}
}
public class Truck extends Vehicle {
public float prize() {
return 1200000.0f;
}
}
javaprogrammering
Shop, ex
class ShopOverload {
float sum = 0.00f;
void reset () {
sum = 0.00f;
}
float getTotal () {
return sum;
}
void regSale ( Vehicle itemSold ) {
sum += [Link]();
}
}
• What if we want to start selling apples?
javaprogrammering
class ShopOverload { Shop, ex
float sum = 0.00f;
void reset () {
sum = 0.00f;
}
float getTotal () {
return sum;
}
void regSale ( Vehicle itemSold ) {
sum += [Link]();
}
void regSale ( AppleBag itemSold ) {
sum += [Link]();
}
}
• Again one method for each item type…
javaprogrammering
interface Valuable {
public float price();
Shop, ex
}
class Bulldozer extends Vehicle implements Valuable
{
public float price() {
return 1500000.00f;
}
}
class Truck extends Vehicle implements Valuable {
public float price() {
return 1200000.00f;
}
}
class AppleBag extends Fruit implements Valuable {
static float PRICE_PER_MASSUNIT = 14.90f;
float mass;
AppleBag(float mass) { [Link] = mass; }
public float price() {
return mass * PRICE_PER_MASSUNIT;
}
}
javaprogrammering
Shop, ex
class ShopInterface {
int sum = 0;
void reset () {
sum = 0;
}
int getTotal () {
return sum;
}
void regSale ( Valuable itemSold ) {
sum += [Link]();
}
}
javaprogrammering
Shop, ex
class Shop {
public static void main(String[] args) {
ShopOverload shop1 = new ShopOverload();
[Link](new Bulldozer());
[Link](new Truck());
[Link](new AppleBag(1.2f));
[Link]([Link]());
ShopInterface shop2 = new ShopInterface();
[Link](new Bulldozer());
[Link](new Truck());
[Link](new AppleBag(2.3f));
[Link]([Link]());
}
}
javaprogrammering
Femkamp, ex
interface Vapenvårdare{ void vårdaVapen(); }
interface Simmare{ void simma(); }
interface Skytt extends Vapenvårdare{ void skjut(); }
interface Ryttare{ void rid(); }
interface Löpare{ void spring(); }
interface Fäktare extends Vapenvårdare{ void fäkta(); }
class FemKampare implements Simmare, Skytt, Ryttare, Löpare,
Fäktare{
public void simma(){[Link]("simmar");}
public void skjut(){[Link]("skjuter");}
public void rid(){[Link]("rider");}
public void spring(){[Link]("springer");}
public void fäkta(){[Link]("fäktar");}
public void vårdaVapen(){[Link]("vårdar
vapen");}
}
javaprogrammering
Femkamp, ex
class Spel{
void a(Simmare s){[Link]();}
void b(Skytt s){[Link]();}
void c(Ryttare r){[Link]();}
void d(Löpare l){[Link]();}
void e(Fäktare f){f.fäkta();}
void f(Vapenvårdare vv){vv.vårdaVapen();}
public static void main(String [] args){
Spel spelet = new Spel();
FemKampare fk = new FemKampare();
spelet.a(fk); //fk behandlas som en Simmare
spelet.b(fk); //fk behandlas som en Skytt
spelet.c(fk); //fk behandlas som en Ryttare
spelet.d(fk); //fk behandlas som en Löpare
spelet.e(fk); //fk behandlas som en Fäktare
spelet.f(fk); //fk behandlas som en Vapenvårdare
}
}
javaprogrammering
static
• Variables and methods in a class can be static
• Cannot use instance variables in a static method
• Class specific, not object specific
• Kind of like “global”
• “Class-oriented” programming instead of object-oriented
programming…
• Use static only when necessary!
javaprogrammering
public class Ball{ static
private static int counter;
private int ballNo;
public Ball(){
ballNo = counter++;
}
public int getBallNo(){
return ballNo;
}
public static int getTotalNoOfBalls (){
return counter;
}
}
javaprogrammering
Exercise, bank 1
• Write a class Account representing a bank account
• The account should not be able to handle overdrafts
• Three constructors + methods for deposits and withdrawals
• Negative amounts not allowed (depositing or withdrawing)
• It must have a unique account number
• Write class TestBank to test Account
javaprogrammering
MODULE: Standard libraries
• [Link]
• [Link]
• Wrapper-classes
• Strings
javaprogrammering
Package [Link]
• Contains the most common and fundamental functionality
• Wrappers for primitive types
• Automatically imported
import [Link].*; // not necessary
javaprogrammering
Package [Link]
• contains ca 100 classes and interfaces
(subpackages included), e.g.:
Object Number Thread
String Long SecurityManager
StringBuffer Class ClassLoader
Integer Error System
Boolean Exception Math
Float OutOfMemoryError Runnable
javaprogrammering
[Link]
[Link]
[Link]
?
[Link]
[Link] ?
[Link]
[Link]
? ?
[Link] [Link]
? ? ?
[Link]
javaprogrammering
[Link]
• The base class for all other classes
• Has methods that are used or overridden by inheriting
classes, e.g.:
clone()
hashCode()
equals()
toString()
javaprogrammering
Thing, ex
class Thing extends Object implements Cloneable{
public String id;
public Object clone() throws CloneNotSupportedException {
return [Link]();
}
public boolean equals(Object obj){
boolean result = false;
if ((obj!=null) && obj instanceof Thing ){
Thing t = (Thing) obj;
if ([Link]([Link])) result = true;
}
return result;
}
public int hashCode(){
return [Link]();
}
public String toString() {
return ”Thing is: ”+id;
}
}
javaprogrammering
Thing, ex
Thing t1 = new Thing(), t2;
[Link] = “grej”;
t2 = t1; // t1 == t2 and [Link](t2)
t2 = (Thing) [Link](); // t2!=t1 but [Link](t2)
[Link] = “pryl”; // t2!=t1 and 
Object obj = t2;
[Link](obj); //””Thing = pryl”
javaprogrammering
Wrapper classes
• Primtive types are effective and requires little memory
• Wrapper classes encapsulates primitive types in objects
• All primitive types have corresponding wrappers
• Wrapper objects are immutable
• Wrapper objects allow for primitives to be used in
collections etc.
javaprogrammering
Wrapper classes
int iPrim = 10;
Primitiv Wrapper
Klass Integer iObj = new Integer(iPrim);
boolean Boolean [Link](
byte Byte
[Link]());
char Chararacter
short Short
Int Integer Integer iElem = new Integer(”123”);
long Long int i = [Link]();
float Float
double Double
Vector v = new Vector();
[Link](iElem);
javaprogrammering
[Link]
• Class Math contains mathematical constants and methods
for fundamental mathematical functions, e.g. exponential,
squareroot and trigonometric functions
• All in Math is static..
static double PI;
static double E
static int abs(int a)
static int max(int a, int b)
static double sqrt(double a)
static double random()
static long round(double a)
etc.
javaprogrammering
[Link], ex.
c c= a2 + b2
a
double a=5,b=10,c;
c = [Link]([Link](a,2)+[Link](b,2));
[Link]("c is "+[Link](c)); // ”c is 11”
javaprogrammering
[Link]
• String is a class, not a primitive type
• immutable – cannot be modified
• Overloaded operators = and +
• The statement
String s = new String(”hej”);
is equivalent with:
char chrArr[] = {’h’,’e’,’j’};
String s2 = new String(chrArr);
javaprogrammering
[Link]
Assignment, string literals
String s1 = ”Hej!”;
String s2 = new String(”Hej!”);
Concatenation
String s1 = ”1”;
String s2 = s1+”2”+3; // ”123”
Is never written over..
String s = new String(”1”);
s = ”2”; // new String created!
javaprogrammering
[Link], concatenation
s1 = s1 + s1 + 123 + ”hejdå” ;
String title = "Dr:";
String fname = "Inge";
String ename = "Glad";
[Link]("title: " + title + "\n" + "fname: "
+ fname + "\n” + "ename: " + ename);
javaprogrammering
[Link], assignment
String s1 = "hej";
String s2 = "hej";
String s3 = new String("hej");
String s4 = new String("hej");
// which ones will be written?
if (s1==s2) [Link]("s1==s2");
if (s3==s4) [Link]("s3==s4");
if ([Link](s2)) [Link]("[Link](s2)");
if ([Link](s4)) [Link]("[Link](s4)");
javaprogrammering
[Link], assignment
String s1 = ”hej”;
String s2 = ”hej”;
hej pool
String s1 = new String(”hej”);
hej pool
hej
javaprogrammering
[Link], methods
• char charAt(int index)
• String concat(String string)
• boolean equals(Object anObject)
• String replace(char oldChar, char newChar)
• String toLowerCase()
• String toUpperCase()
javaprogrammering
[Link]
• represents a sequence of characters
• Is mutable (can be modified)
• More effective when working with dynamic strings
StringBuffer sBuf = new StringBuffer();
[Link](“abc”);
[Link](“def”);
javaprogrammering
StringBuffer, ex
StringBuffer bufStr = new StringBuffer(); // empty
[Link]("bcda!e"); // contains “bcda!e”
char c = [Link](3); // extracts ‘a’
[Link](3,5); // now contains “bcde”
[Link](0,c); // now contains “abcde”
String str = [Link](); // extract the string
[Link](str); // write it to console using String
[Link](bufStr); // write it to console directly
javaprogrammering
Exercise, toString()
• Write a toString() method for a subclass
javaprogrammering
Exercise, bank 2
• Override the toString method in class Account
• Type check the name string. If it contains two names, each
should start with a capital letter. Implement the methods:
– isValidName
– formattedName
javaprogrammering
This document was created with Win2PDF available at [Link]
The unregistered version of Win2PDF is for evaluation or non-commercial use only.
