0% found this document useful (0 votes)
54 views

Part 05 - Object Oriented Programming

This document discusses object-oriented programming concepts like classes, objects, inheritance, encapsulation, and polymorphism. It defines key concepts like classes acting as templates for creating objects that bundle data and methods, and how objects communicate via messages. It also covers inheritance which allows classes to inherit attributes and behaviors from base classes, and polymorphism which means classes can have different implementations of the same method.

Uploaded by

Ja Khang
Copyright
© © All Rights Reserved
Available Formats
Download as PPTX, PDF, TXT or read online on Scribd
0% found this document useful (0 votes)
54 views

Part 05 - Object Oriented Programming

This document discusses object-oriented programming concepts like classes, objects, inheritance, encapsulation, and polymorphism. It defines key concepts like classes acting as templates for creating objects that bundle data and methods, and how objects communicate via messages. It also covers inheritance which allows classes to inherit attributes and behaviors from base classes, and polymorphism which means classes can have different implementations of the same method.

Uploaded by

Ja Khang
Copyright
© © All Rights Reserved
Available Formats
Download as PPTX, PDF, TXT or read online on Scribd
You are on page 1/ 155

ADVANCED PROGRAMMING

OBJECT ORIENTED PROGRAMMING

CLASSES AND OBJECT


Outline
 Working with Classes and Objects
 Defining Classes

 Creating Objects

 Writing and Invoking Constructors

 Using Methods
 Defining a Method

 The Static Methods and Variables

 Methods with a Variable Number of Parameters

 JavaBeans Naming Standard for Methods

 Method Overriding and Overloading

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 2/155


Outline
 Inheritance
 Abstract Classes
 Writing and Using Interfaces
 Object-Oriented Relationships
 The is-a Relationship

 The has-a Relationship

 Polymorphism
 Conversion of Data Types
 Understanding Garbage Collection

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 3/155


What is Object-Oriented Programming?
 OOP Student
Class
 Map your problem in the real - studentNo
- name - courseId
world: Real world objects and - birthday - lecturer
actions match program objects + enroll() + serLecturer()
+ getStudents()
and actions …

– Define “things” (objects)


which can do something
– Create a “type” (class) for these objects so that you don’t have to
redo all the work in defining an objects properties and behavior
 An OO program: “a bunch of objects telling each other what to
do by sending messages”. (Smalltalk)
 A strong reflection of software engineering
 Abstract data types
 Information hiding (encapsulation)

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 4/155


Goals of Object Technology
 To create a software:
– Robustness: capable of handling

unexpected inputs that are not explicitly


defined for its application.
– Adaptability: evolve over time in response

to changing conditions in its environment.


– Reusability: the same code should be

usable as a component of different systems


in various applications.

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 5/155


Important OO concepts
 Abstraction
Encapsulation
 Objects & Class
 Object state and behavior "P.I.E
 Object identity triangle
Abstraction
 Messages

Inheritance Polymorphism
 Encapsulation
 Information/implementation hiding

 Inheritance
 Polymorphism

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 6/155


Benefits of Object Technology

1) Faster application development at a lower cost


2) Decreased maintenance time
3) Less complicated and faster customization
4) Higher quality code

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 7/155


Objects
 Objects are:
 Are building blocks for systems
 Contain data that can be used or modified
 Bundle of variables and related methods
 An object possesses:
 Identity: Định danh
 A means of distinguishing it from other objects
 State: Trạng thái Student
 What the object remembers
- studentNo
 Interface: Giao tiếp - name
 Messages the object responds to - birthday

 Behavior: Ứng xử + getName()


+ enroll()
 What the object can do
Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 8/155
Object Example
 The car shown in the figure can be considered an object.
 It has an ID ("1"),

 state (its color, for instance, and other characteristics),

 an interface (a steering wheel and brakes, for example)

 and behavior (the way it responds when the steering wheel

is turned or the brakes are applied).

Many texts regard an object as


possessing only two
characteristics – state and
behavior. When considered
this way, identity is part of the
state, and the interface is
included in the behavior.

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 9/155


Classes
 A class
 Defines the characteristics and variables common to all
objects of that class
 Objects of the same class are similar with respect to:
 Interface
 Behavior (method)
 State (variable)
 Used to instantiate (create an instance of) specific
objects
 Provide the ability of reusability
 Car manufacturers use the same blueprint to build

many cars over and over


Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 10/155
Class Example
 The car at the top of the
figure represents a class
 Notice that the ID and
color (and presumably
other state details) are not
known, but the interface
and behavior are.

 Below the "class" car are


two objects which provide
concrete installations of the
2

class 2

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 11/155


Working with Classes

 The class is the basis for object-oriented


programming
 The data and the operations on the data are
encapsulated in a class
 A class is a template that contains the data
variables and the methods that operate on those
data variables following some logic
 All the programming activity happens inside classes

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 12/155


Working with Classes (cont.)
 The data variables and the methods in a class are
called class members
 Variables, which hold the data (or point to it in case
of reference variables), are said to represent the
state of an object
 The methods constitute class’ behavior

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 13/155


Message and Object Communication
 Objects communicate via messages
 Messages in Java correspond to method calls (invocations)
 Three components comprise a message:
1. The object to whom the message is addressed (Your
Car)
2. The name of the method to perform (changeGears)
3. Any parameters needed by the method (lower gear)

sender target

setSomething()
Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 14/155
Object Messaging Example
 By itself the car is incapable of
activity. The car is only useful
when it is interacted with by
another object
 Object 1 sends a message to
object 2 telling it to perform a
certain action +
 In other words, the driver
presses the car’s gas pedal to
accelerate.

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 15/155


Accessing State
 State information can be accessed two ways:
 Using messages:
 Eliminates the dependence on implementation
 Allows the developer to hide the details of the
underlying implementation

 "Accessor" messages are usually used instead of


accessing state directly
 Example: getSpeed() may simply access a state value
called "speed" or it could hide a calculation to obtain
the same value

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 16/155


Encapsulation
 Encapsulation: to group related things
together, so as to use one name to refer to the
whole group.
– Functions/procedures encapsulate instructions
– Objects encapsulate data and related
procedures

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 17/155


Information hiding
 Information hiding: encapsulate to hide internal
implementation details from outsiders
– Outsiders see only interfaces
– Programmers have the freedom in implementing
the details of a system.
– The only constraint on the programmer is to
maintain the interface
– public, private, and protected

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 18/155


Inheritance Shape

+draw()
 “is-a” relations +erase()
+move()
 The general classes can +setColor()
+getColor()

be specialized to
more specific classes
Circle Square Triangle

+flipVertical()
+flipHorizontal()

 Reuse of interfaces & implementation


 Mechanism to allow derived classes to possess
attributes and operations of base class, as if they were
defined at the derived class
 We can design generic services before specialising
them
Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 19/155
Polymophism Shape

 Polymorphism: +draw()
+erase()
+move()
– Ability to assume +setColor()
+getColor()
different forms or shapes.
– To exist in more than
one form Circle Square Triangle

+draw() +draw() +draw()


 Object polymorphism: +move() +move() +move()

– Objects of different derived classes can be treated as if


they are of the same class – their common base class
– Objects of different classes understand the same
message in different ways
• example: on receiving message draw(), Rectangle and
Triangle objects perform different draw() methods

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 20/155


Java Class
Java Classes

public class Student {


Data private int age;
members private String name;
private Date birthDate;
Method public int getAge() {
return age;
}
}

Class Student with data members and an instance


method (accessor)

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 22/155


Classes
 Encapsulate attributes (fields) and behavior
(methods)
 Attributes and behavior are members of the class
 Members may belong to either of the following:
 The whole class
 Class variables and methods, indicated by the keyword
static
 Individual objects
 Instance variables and methods
 Classes can be
 Independent of each other
 Related by inheritance (superclass / subclass)
 Related by type (interface)
Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 23/155
Working with Objects
 Objects of pre-defined classes must be explicitly created by
new operator
– Allocate dynamic memory in heap memory

– A constructor will be called to initialize the newly created

object.
 Objects are manipulated via references
 Invoke object’s methods:
<object reference>.<method_name>(<arguments>)

public class StringTest {


public static void main(String args[]) {
String s1 = new String("Hello, ");
String s2 = s1.concat("world!");
System.out.println("Here is the greeting" + s2);
}
}
Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 24/155
Defining a Class
 A class declaration specifies a type
– The identifier: specifies the name of the class
– Attributes, methods, and access control
 Attributes: public class BankAccount {
private String ownerName;
– object's instance variables private double balance;
public void getOwnerName() {
 Methods: return ownerName;
– tasks that the objects can do }
...
 Access modifiers:
– public : Accessible anywhere by anyone
– protected : Accessible only to the class itself and to its
subclasses or other classes in the same “package”
– private : Only accessible within the current class
– default (no keyword): accessible within the current package
Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 25/155
Implementing Classes
 Classes are grouped into packages
 A package contains a collection of logically-related
classes

 Source code files have the extension .java


 There is one public class per .java file

 A class is like a blueprint; we usually need to create


an object, or instance of the class

26
Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 26/155
The Elements of a class

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 27/155


Class Declaration
 A class declaration specifies a type
 The identifier
 Specifies the name of the class
 The optional extends clause
 Indicates the superclass
 The optional implements clause
 Lists the names of all the interfaces that the class
implements

public class BankAccount extends Account


implements Serializable, BankStuff {

// class body
}
28
Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 28/155
Declaring Classes
Class Declaration Elements
Element Function
(Optional) An annotation (sometimes called meta-
@annotation data)
public (Optional) Class is publicly accessible
abstract (Optional) Class cannot be instantiated
final (Optional) Class cannot be subclassed
class NameOfClass Name of the class

<TypeVariables> (Optional) Comma-separated list of type variables

extends Super (Optional) Superclass of the class


implements Interfaces (Optional) Interfaces implemented by the class
{
ClassBody Provides the class's functionality
}

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 29/155


Class Modifiers
 Class modifiers affect how the class can be used.
 Examples: public, abstract, final
 public classes
 May be accessed by any java code that can access its
containing package
 Otherwise it may be accessed only from within its
containing package
 abstract classes
 Can contain anything that a normal class can contain
 Variables, methods, constructors
 Provide common information for subclasses
 Cannot be instantiated
 A class is declared final if it permits no subclasses.
Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 30/155
Constructors
 A method that sets up a new instance of a class
 The class body contains at least one constructor
 Use the new keyword with a constructor to create
instances of a class

Class instantiation

BankAccount account = new BankAccount();

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 31/155


Writing and Invoking Constructors
 If you do not provide any constructor for a class you
write, the compiler provides the default constructor
for that class
 If you write at least one constructor for the class, the
compiler does not provide a constructor
 In addition to the constructor (with no parameters),
you can also define non-default constructors with
parameters
 From inside a constructor of a class, you can call

another constructor of the same class


 You use the keyword this to call another constructor
in the same class

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 32/155


Writing and Invoking Constructors

ComputerLab csLab = new ComputerLab();


 When the Java runtime system encounters this

statement, it does the following, and in this order:


1. Allocates memory for an instance of class
ComputerLab
2. Initializes the instance variables of class
ComputerLab
3. Executes the constructor ComputerLab()

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 33/155


More about Constructors
 Used to create and initialize objects
 Always has the same name as the class it
constructs (case-sensitive)
 No return type
 Constructors return no value, but when used with
new, return a reference to the new object

public class BankAccount { Constructor


public BankAccount(String name)
setOwner(name); definition
}
}
Constructor use

BankAccount account = new BankAccount("Joe Smith");

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 34/155


Default Constructors
 Default constructor
 constructor with no arguments
 The Java platform provides a one only if you do not
explicitly define any constructor
 When defining a constructor, you should also provide
a default constructor

public class BankAccount {


public BankAccount() {
}

public BankAccount(String name)


setOwner(name);
}
}

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 35/155


Overloading Constructors
 Overloading
 When there are a number of constructors with
different parameters
 Constructors are commonly overloaded to allow
for different ways of initializing instances

BankAccount newAccount = new BankAccount();

BankAccount knownAccount =
new BankAccount(accountNumber);
BankAccount namedAccount =
new BankAccount("My Checking Account");

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 36/155


Constructor Example

 In a constructor, the keyword this is used to refer to other


constructors in the same class

...
public BankAccount(String name) {
super();
owner = name;
}

public BankAccount() {
this("TestName");
}

public BankAccount(String name, double initialBalance) {


this(name);
setBalance(initialBalance);
}
...

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 37/155


Constructor Chaining
 Constructor chaining
 When one constructor invokes another within the class
 Chained constructor statements are in the form:
this(argument list);
 The call is only allowed once per constructor
 It must be the first line of code
 Do this to share code among constructors

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 38/155


More on Constructor Chaining
• Superclass objects are built before the subclass
super (argument list)
– initializes superclass members

• The first line of your constructor can be:


super (argument list);
this (argument list);
• You cannot use both super() and this() in the
same constructor.
• The compiler supplies an implicit super()
constructor for all constructors.

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 39/155


Java Destructors?
 Java does not have the concept of a destructor for
objects that are no longer in use
 Deallocation is done automatically by the JVM
 The garbage collector reclaims memory of unreferenced
objects
 The association between an object and an object
reference is severed by assigning another value to the
object reference, for example:
 objectReference = null;
 An object with no references is a candidate for
deallocation during garbage collection

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 40/155


Declaring Member Variables - Fields
 Fields
 Defined as part of the class definition
 Objects retain state in fields
 Each instance gets its own copy of the instance variables
 Fields can be initialized when declared
 Default values will be used if fields are not initialized

access modifier type

package com.megabank.models;

public class BankAccount { name


private String owner;
private double balance = 0.0;
}
Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 41/155
Declaring Member Variables
Variable Declaration Elements
Element Function
accessLevel
public, protected, (Optional) Access level for the variable
private
static (Optional) Declares a class variable
(Optional) Indicates that the variable's value
final cannot change
transient (Optional) Indicates that the variable is
transient (should not be serialized)
volatile (Optional) Indicates that the variable is
volatile
type name The type and name of the variable

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 42/155


Controlling Access to Members of a Class

Access Levels

Specifier Class Package Subclass World

private Y N N N

no specifier Y Y N N

protected Y Y Y N

public Y Y Y Y

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 43/155


Encapsulation
 Private state can only be accessed from methods
in the class
 Mark fields as private to protect the state
 Other objects must access private state through
public methods
package com.megabank.models;

public class BankAccount {


private String owner;
private double balance = 0.0;
}

public String getOwner() {


return owner;
}

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 44/155


Messages
 Use messages to invoke behavior in an object

BankAccount account = new BankAccount();


account.setOwner("Smith");
account.credit(1000.0);
account.debit(50.5);

account.debit(50.5)

parameters
receiver
message

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 45/155


Methods
 Methods define
 How an object responds to messages
 The behavior of the class
 All methods belong to a class

return method
access type name parameter list
modifier

public void debit (double amount) {


// Method body
// Java code that implements method behavior
}

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 46/155


Method Signatures
 A class can have many methods with the same name
 Each method must have a different signature
 The method signature consists of
 The method name
 Argument number and types

method name argument type

public void credit(double amount) {


...
}
signature
Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 47/155
Method Parameters
 Arguments (parameters) are passed by
 Value for primitive types
 Object reference for reference types
 Primitive values cannot be modified when passed as
an argument

public void method1() {


int a = 0;
System.out.println(a); // outputs 0
method2(a);
System.out.println(a); // outputs 0
}
void method2(int a) {
a = a + 1;
}

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 48/155


Returning from Methods
 Methods return, at most, one value or one object
 If the return type is void, the return statement is
optional
 There may be several return statements
 Control goes back to the calling method upon executing
a return

public void debit(double amount) {


if (amount > getBalance()) return;
setBalance(getBalance() - amount);
}

public String getFullName() {


return getFirstName() + " " + getLastName();
}

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 49/155


Invoking Methods
 To call a method, use the dot operator
– The same operator is used for both class and instance methods

– If the call is to a method of the same class, the dot operator is

not necessary

BankAccount account = new BankAccount();


account.setOwner("Smith");
account.credit(1000.0);
System.out.println(account.getBalance());
...
BankAccount method

public void credit(double amount) {


setBalance(getBalance() + amount);
}
Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 50/155
Method Overriding
 Method Overriding
 method overriding is a feature of Java that lets the

programmer declare and implement a method in a


subclass that has the same signature as a method in
the superclass
 Rules for method overriding
 You cannot override a method that has the final

modifier.
 You cannot override a static method to make it non-

static.
 The overriding method and the overridden method

must have the same return type.


 The number of parameters and their types in the

overriding method must be same as in the overridden


method and the types must appear in the same order.
However, the names of the parameters may be
different.

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 51/155


Method Overriding
 Rules for method overriding (cont.)
 You cannot override a method to make it less

accessible.
 If the overriding method has a throws clause in its

declaration, then the following two conditions must be


true:
 The overridden method must have a throws clause,

as well.
 Each exception included in the throws clause of the

overriding method must be either one of the


exceptions in the throws clause of the overridden
method or a subclass of it.
 If the overridden method has a throws clause, the

overriding method does not have to.


Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 52/155
Overloading Methods
 Signatures permit the same name to be used for many
different methods
 Known as overloading
 Two or more methods in the same class may have the
same name but different parameters
 The println() method of
System.out.println() has 10 different parameter
declarations:
 boolean, char[], char, double, float, int,
long, Object, String and one with no parameters
 You don't need to use different method names, for
example "printString", "printDouble", ...

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 53/155


Overriding
 Override a method when a new implementation in a
subclass is provided, instead of inheriting the method with
the same signature from the superclass
public class BankAccount {
private float balance;
public int getBalance() {
return balance;
}
}
public class InvestmentAccount extends BankAccount{
private float cashAmount
private float investmentAmount;
public int getBalance() {
return cashAmount + investmentAmount;
}
}
Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 54/155
Variable – Length Arguments
 The printf method takes any number of arguments
 You could use overloading to define a few versions of printf with
different argument lengths, but it takes any number of arguments
 To do this yourself, use "type ... variable"
 variable becomes an array of given type
 Only legal for final argument of method
 Examples
 public void printf(String format, Object ... args)

 public int max(int ... numbers)

 Can call max(1, 2, 3, 4, 5, 6) or max(someArrayOfInts)

 Use sparingly
 You usually know how many arguments are possible

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 55/155


Methods with Variable Argument Lists (var-args)
 Var-arg type When you declare a var-arg parameter,
you must specify the type of the argument(s) this
parameter of your method can receive. (This can be a
primitive type or an object type.)
 Basic syntax To declare a method using a var-arg
parameter, you follow the type with an ellipsis (...), a
space, and then the name of the array that willhold
the parameters received.
 Other parameters It's legal to have other
parameters in a method that uses a var-arg.
 Var-args limits The var-arg must be the last
parameter in the method‘s signature, and you can
have only one var-arg in a method.
Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 56/155
Varargs: Example
public class MathUtils {
public static int min(int ... numbers) {
int minimum = Integer.MAX_VALUE;
for (int number: numbers) {
if (number < minimum) {
minimum = number;
}
}
return minimum;
}

public static void main(String[] args) {


System.out.printf("Min of 2 nums: %d.%n", min(2,1));
System.out.printf("Min of 7 nums: %d.%n",
min(2,4,6,8,1,2,3));
}
}
Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 57/155
main Method
 An application cannot run unless at least one class has a
main method
 The JVM loads a class and starts execution by calling the
main(String[] args) method
 public: the method can be called by any object
 static: no object need be created first
 void: nothing will be returned from this method

public static void main(String[] args) {


BankAccount account = new BankAccount();
account.setOwner(args[0]);
account.credit(Integer.parseInt(args[1]));
System.out.println(account.getBalance());
System.out.println(account.getOwner());
}

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 58/155


More about method - Using Methods
 Methods represent operations on data and also hold
the logic to determine those operations
 Using methods offer two main advantages:
 A method may be executed (called) repeatedly from
different points in the program
 Methods help make the program logically segmented,
or modularized. A modular program is less error prone,
and easier to maintain

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 59/155


More about method - Defining a Method
 Defining a method in a program is called method
declaration
 A method consists of the following elements:
 Name: The name identifies the method and is also used to
call (execute) the method. Naming a method is governed
by the same rules as those for naming a variable
 Parameter(s): A method may have zero or more
parameters defined in the parentheses
 Argument(s): The parameter values passed in during the
method call
 Return type: A method may optionally return a value as a
result of a method call. Special void return type
 Access modifier: Each method has a default or specified
access modifier

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 60/155


Defining a Method (cont.)

 The method name and return type are


mandatory in a method declaration
 Methods and variables visibility:
 In a normal case, methods and variables visible
only within an instance of the class, and hence
each instance has its own copy of those methods
and variables
 Those that are visible from all the instances of
the class. Those are called static

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 61/155


Defining Methods

 Access level: public, protected, private


Default is package private
Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 62/155
Defining Methods
Element Function
@annotation (Optional) An annotation
accessLevel (Optional) Access level for the method
static (Optional) Declares a class method
<TypeVariables> (Optional) Comma-separated list of type
variables.
abstract (Optional) Indicates that the method must be
implemented in concrete subclasses.
final (Optional) Indicates that the method cannot be
overridden
synchronized (Optional) Guarantees exclusive access to this
method
returnType methodName The method's return type and name
( paramList ) The list of arguments to the method
throws exceptions (Optional) The exceptions thrown by the method

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 63/155


Creating Objects
 Point originOne = new Point(23, 94);
 Rectangle rectOne = new
Rectangle(originOne,100,200);
 Rectangle rectTwo = new Rectangle(50, 100);
Each statement has the following three parts:
1. Declaration: The code set in bold are all variable
declarations that associate a variable name with an
object type.
2. Instantiation: The new keyword is a Java operator
that creates the object. As discussed below, this is
also known as instantiating a class.
3. Initialization: The new operator is followed by a call to
a constructor. For example, Point(23, 94) is a call to
Point's only constructor. The constructor initializes the
new object.
Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 64/155
Declaring a Variable to Refer to an Object
type name
 This notifies the compiler that you will use name to
refer to data whose type is type. The Java
programming language divides variable types into two
main categories: primitive types, and reference types.
 The declared type matches the class of the object:
MyClass myObject = new MyClass(); or
MyClass myObject;
 The declared type is a parent class of the object's class:
MyParent myObject = new MyClass(); or
MyParent myObject
 The declared type is an interface which the object's
class implements:
MyInterface myObject = new MyClass(); or
MyInterface myObject
 A variable in this state, which currently references no
object, is said to hold a null reference.
Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 65/155
Initializing an Object
public class Point {
public int x = 0;
public int y = 0;
public Point(int x, int y) {
this.x = x;
this.y = y;
}
}
Point originOne = new Point(23, 94);

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 66/155


Initializing an Object
public class Rectangle {
public int width;
public int height;
public Point origin;
public Rectangle(Point p, int w, int h) {
origin = p;
width = w;
height = h;
}
}

Rectangle rectOne = new


Rectangle(originOne, 100, 200);
Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 67/155
Using Objects
 You can use an object in one of two ways:
 Directly manipulate or inspect its variables
 Call its methods
 Referencing an Object's Variables

The following is known as a qualified name:


objectReference.variableName
System.out.println("Width of rectOne: " +
rectOne.width);
System.out.println("Height of rectOne: " +
rectOne.height);
int height = new Rectangle().height;
 Calling an Object's Methods

objectReference.methodName(); or
objectReference.methodName(argumentList);
System.out.println("Area of rectOne: " +
rectOne.area());
rectTwo.move(40, 72);
Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 68/155
The Static Methods and Variables
 The static modifier may be applied to a variable, a
method, and a block of code
 A static element of a class is visible to all the instances
of the class
 If one instance makes a change to it, all the instances
see that change
 A static variable is initialized when a class is loaded,
 An instance variable is initialized when an instance

of the class is created


 A static method also belongs to the class, and not to a
specific instance of the class
 Therefore, a static method can only access the

static members of the class.

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 69/155


Static Members
 Static fields and methods belong to the class
 Changing a value in one object of that class changes the
value for all the objects
 Static methods and fields can be accessed without
instantiating the class
 Static methods and fields are declared using the
static keyword
public class MyDate {
public static long getMillisSinceEpoch(){

}
}
...
long millis = MyDate.getMillisSinceEpoch();
Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 70/155
The Static Methods
 A method declared static in a class cannot access the
non static variables and methods of the class
 A static method can be called even before a single
instance of the class exists
 Static method main(), which is the entry point for

the application execution


 It is executed without instantiating the class in

which it exists

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 71/155


Example
 Hãy định nghĩa lớp “kiến” (Ant):
 Mỗi một đối tượng tạo ra từ lớp Ant này là 1 con kiến
 Tất cả các con kiến tạo ra từ cùng lớp Ant này tạo ra
một đàn kiến
 giả sử kiến không chết
 Hãy thiết kế lớp Ant sao cho khi hỏi 1 con kiến bất kỳ
trong đàn thì nó cũng cho ta biết tổng số con kiến có
trong đàn

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 72/155


class MyClass {
String salute = "Hello";
public static void main(String[] args){
System.out.println("Salute: " + salute);
}
} Error: Cannot access a non
static variable from inside a
static method

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 73/155


Using Modifiers
 You cannot specify any modifier for the variables
inside a method
 You cannot specify the protected modifier for a
top-level class
 A method cannot be overridden to be less
public.

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 74/155


Final Modifiers
 The final Modifier
 The final modifier may be applied to a class, a

method, or a variable. It means, in general, that


the element is final
 If the element declared final is a variable, that

means the value of the variable is constant, and


cannot be changed
 If a class is declared final, it means the class

cannot be extended
 If a final method cannot be overridden

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 75/155


Final Modifiers
class Calculator {
final int dime = 10;
int count = 0;
Calculator (int i) {
count = i;
}
} Error: calc is final
class RunCalculator {
public static void main(String[] args) {
final Calculator calc = new Calculator(1);
calc = new Calculator(2);
calc.count = 2; OK: default access
calc.dime = 11;
Error: dime is final
System.out.println("dime: " + calc.dime);
}
}
Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 76/155
Final Members
 A final field is a field which cannot be modified
 This is the java version of a constant
 Constants associated with a class are typically declared
as static final fields for easy access
 A common convention is to use only uppercase letters in
their names

public class MyDate {


public static final long
SECONDS_PER_YEAR = 31536000;
...
}
...
long years = MyDate.getMillisSinceEpoch()/
(1000 * MyDate.SECONDS_PER_YEAR);
Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 77/155
Passing Arguments into Methods
 Assume you declare a variable in your method, and
then you pass that variable as an argument in a
method call
 The question is: What kind of effect can the called
method have on the variable in your method?
 There are two kind:
 pass-by-value

 pass-by-reference

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 78/155


Passing a Primitive Variable
 When a primitive variable is passed as an argument in
a method call, only the copy of the original variable is
passed
 Any change to the passed variable in the called
method will not affect the variable in the calling
method
 It is called pass-by-value

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 79/155


Passing Primitive Variables
public class SwapNumber extends TestCase{
public void swap(int a, int b){
int c = a;
a = b;
b = c;
}
public void test(){
int a = 1, b = 2;
System.out.println("Before swap a: "+
a + " , b: "+b);
swap(a,b);
System.out.println("After swap a: "+
a + " , b: "+b);
}
}

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 80/155


Passing Primitive Variables
public class SwapNumber extends TestCase{
public void swap(Integer a1, Integer b1){
Integer c = a1;
a1 = b1;
b1 = c;
}
public void test(){
Integer a = new Integer (1),
b = new Integer (2);
System.out.println("Before swap a: "+
a + " , b: "+b);
swap(a,b);
System.out.println("After swap a: "+
a + " , b: "+b);
}
}

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 81/155


Passing Object Reference Variables
 When you pass an object variable into a method, you
must keep in mind that you're passing the object
reference, and not the actual object itself.
import java.awt.Dimension;
class ReferenceTest {
public static void main (String [] args) {
Dimension d = new Dimension(5,10);
ReferenceTest rt = new ReferenceTest();
System.out.println("Before modify() d.height = "+
d.height);
rt.modify(d);
System.out.println("After modify() d.height = "+ d.height);
}
void modify(Dimension dim) {
dim.height = dim.height + 1;
System.out.println("dim = " + dim.height);
}
}

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 82/155


Passing Object Reference Variables

Before modify() d.height = 10


dim = 11
After modify() d.height = 11

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 83/155


Passing Object Reference Variables
public class PassingVar extends TestCase{
public void modify(Student st){
st.setName("Tran Thi B");
st = new Student("Le Van C");
}

public void test() {


Student sv1 = new Student("Nguyen Van A");
System.out.println("Before modify():"+sv1);
modify(sv1);
System.out.println("After modify():"+sv1);
}
}
Before modify():Nguyen Van A
After modify():Tran Thi B
Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 84/155
Passing a Reference Variable
 When you pass a reference variable in a method, you
pass a copy of it and not the original reference
variable
 The called method can change the object properties
by using the passed reference
 Changing the object and the reference to the object
are two different things, so note the following:
 The original object can be changed in the called

method by using the passed reference to the object


 However, if the passed reference itself is changed

in the called method, for example, set to null or


reassigned to another object, it has no effect on the
original reference variable in the calling method

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 85/155


JavaBeans Naming Standard for Methods
 Methods can be used to set the values of the class
variables and to retrieve the values
 Methods written for these specific purposes are called
get and set methods (also known as getter and
setter)
 In special Java classes, called JavaBeans, the rules for
naming the methods (including get and set) are
enforced as a standard
 The private variables of a JavaBean called properties
can only be accessed through its getter and setter
methods

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 86/155


JavaBeans Naming Standard for Methods
 The rules
 The naming convention for a property is: the first

letter of the first word in the name must be


lowercase and the first letter of any subsequent
word in the name must be uppercase, e.g., myCow
 The name of the getter method begins with get

followed by the name of the property, with the first


letter of each word uppercased
 A getter method does not have any parameter and

its return type matches the argument type


 The setter method begins with set followed by the

name of the property, with the first letter of each


word uppercased
 A setter method must have the void return type

 The getter and setter methods must be public

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 87/155


JavaBeans Naming Standard for Methods
public class ScoreBean {
private double meanScore;
// getter method for property meanScore
public double getMeanScore() {
return meanScore;
}
// setter method to set the value of the property meanScore
public void setMeanScore(double score) {
meanScore = score;
}
}

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 88/155


Inheritance & Polymorphism

Object-Oriented Programming 89
Inheritance
 Based on "is-a" relationship Person

 Subclass: more specialized,


superclass: more general Student Employee

 Subclass is derived
or inherits from superclass FullTimeStudent PartTimeStudent Manager

 In essence:
 Objects in the same class have the same set of
attributes (different values though) and operations
 Objects of subclass have all members of superclass
plus some more
 Objects of a subclass can also be treated as objects of
its superclass

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 90/155


Inheritance
 An Employee “is a” Person,
 apart from its own members,
salary and getSalary(), Person

it also has name, birthday, -name


-birthday
getName() without having +getName()
to declare them +getBirthday()

 Employee is the subclass (derived) of


Person
Employee
 Person is the superclass (base) of -salary
Employee +getSalary()

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 91/155


Inheritance
 Inheritance tree can Person

have many levels -name: String


-birthday: Date
 A Manager object inherits +getName(): String

what an Employee has, +getBirthday(): Date

including what a Person


has.
Student Employee

-id: String -salary: double

+...() +getSalary(): double

Manager

-assistant: Employee

+setAssistant(emp: Employee)

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 92/155


Defind inheritance in Java

 Using extends clause

public class Person {


private String name;
private Date birthday;
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
} class Employee extends Person {
} private double salary;
public void setSalary(double salary) {
this.salary = salary;
}
}

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 93/155


New attributes/operations

//application code
...
Employee e = new Employee();
e.setName("John"); call to Person’s setName() method
System.out.print(e.getName());
e.setSalary(3.0);

call to Employee’s setSalary() method

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 94/155


Overide Method
 A subclass can redefine methods inherited from its
superclass.
 To specialise these methods to suit the new problem
 Objects of the subclass will work with the new version
of the methods
 Dynamic binding
 Superclass’s methods of the same name can be
reused by using the keyword super

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 95/155


Overriding

public class BankAccount {


private float balance;
public int getBalance() {
return balance;
}
}

public class InvestmentAccount extends BankAccount {


private float cashAmount
private float investmentAmount;
public int getBalance() {
return cashAmount + investmentAmount;
}
}

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 96/155


More Example

 Subclass's version calls superclass's version then


does something extra
Call method of the superclass
public class Person { from within the subclass.
protected String name; Keyword super is the
protected Date birthday; reference to the superclass
public void display() {
System.out.print (name + "," + birthday);
}
... public class Employee extends Person {
} ...
public void display() {
super.display();
System.out.print ("," + salary);
}
}

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 97/155


Method overriding - Rules
 New and old version must have the same prototype:
 Same return type
 Same argument type
 Private methods cannot be overriden
 Private members are hidden from subclass

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 98/155


Access control levels

Modifier Accessible within


Same Same Subclasses Universe
class package

private yes
package yes yes
(default)
protected yes yes yes
public yes yes yes yes

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 99/155


protected access level
 protected members of a superclass are directly
accessible from inside its subclasses.

public class Person { Subclass can directly access


protected String name; superclass‘s protected members
protected Date birthday;
...
} public class Employee extends Person {
...
public String toString() {
String s;
s = name + "," + birthday; //no error.
s += "," + salary;
return s;
}
}

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 100/155


In the same package

 Default access level is “package”, which means those


with “package” access level can be accessed directly
from within the same package
package people;
public class Person {
package people; String name;
public class Employee extends Person { Date birthday;
... ...
public String toString() {
String s;
s = name + "," + birthday; //no error.
s += "," + salary;
return s;
}
}

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 101/155


In different packages
 Members with “package” access level cannot be
accessed directly by subclasses from outside the
package
package people;
public class Person {
package other;
String name;
Date birthday;
import people.Person;
...
public class Employee extends Person {
...
public String toString() {
String s;
s = name + "," + birthday; // error.
s += "," + salary;
return s;
}
}

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 102/155


In different packages
 Members with “protected” access level can be
accessed directly by subclasses from outside the
package
package people;
public class Person {
package other;
protected String name;
protected Date birthday;
import people.Person;
...
public class Employee extends Person {
...
public String toString() {
String s;
s = name + "," + birthday; // OK
s += "," + salary;
return s;
}
}

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 103/155


Constructor of subclass
 Subclass inherits all attributes/ methods of superclass
 Subclass must initialize inherited members
 But, constructors are NOT inherited
 syntactically, they have different names
 Two ways to call constructors of the baseclass
1. (Implicit) use default constructors
2. Explicit calls to constructors of the baseclass

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 104/155


Call default constructor

class Shape { The compiler supplies an


protected int x, y; implicit super() constructor
public Shape() {}
for all constructors.
public Shape(int x, int y) {
this.x = x;
this.y = y;
} Default constructor Shape() is called
}
class Circle extends Shape {
protected int radius;
public Circle() {}
}

// client code Cannot found Circle(int, int).


Shape p = new Shape(10, 10); Shape(int, int) is not inherited
Circle c1 = new Circle();
Circle c2 = new Circle(10, 10); // error

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 105/155


Calling constructors of baseclass
 The initializing superclass ' attributes should be carried
out by baseclass' constructors
 Why?
 Superclass' constructors can be called using reference
super
 Superclass' constructors must run first
super(argument list);
 If superclass has no default constructor then its
constructor must be called explicitly

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 106/155


Calling constructors of baseclass

class Shape {
protected int x, y;
public Shape(int x, int y) {
this.x = x;
this.y = y;
}
} Explicit calls to
Shape(int, int)
class Circle extends Shape {
protected int radius;
public Circle(int x, int y, int radius) {
super(x, y);
this.radius = radius;
}
} // client code
Shape p = new Shape(10, 10);
Circle c2 = new Circle(10, 10, 5); // OK

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 107/155


Calling constructors of baseclass

class Shape {
protected int x, y;
public Shape(int x, int y) {
this.x = x;
this.y = y;
}
} Error! Default constructor
Shape() is not found
class Circle extends Shape {
protected int radius;
public Circle(int x, int y, int radius) {
this.x = x;
this.y = y;
this.radius = radius;
}
}

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 108/155


toString() method

 Inherits from Object class

class Shape {
protected int x, y;
public String toString() {
return "<" + x + "," + y + ">";
}
} Overriding Object's toString()
class Circle extends Point { New versions are used in
protected int radius; System.out.println()
public String toString() {
return super.toString() + "," + radius;
}
} // client code
Circle c = new Circle();
System.out.println(c);

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 109/155


Reusing Classes
 Object classes with similar or related attributes and
behaviour
 Person, Student, Manager,…
 Code reuse
 Composition – “has-a” relationship
 the new class is composed of objects of existing classes.
 reuse the functionality of the existing class, not its form
 Inheritance – “is-a” relationship
 create a new class as a type of an existing class

 new class absorbs the existing class's members and


extends them with new or modified capabilities

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 110/155


Reusing classes - composition

 A class can have references to objects of other


classes as members.
 This is called composition and is sometimes
referred to as a has-a relationship.

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 111/155


Example

public class Student {


private String name;
private Date birthday;

public Student(String name, public class Date {


Date birthday) { private int day;
this.name = name; private int month;
this.birthday = birthday; private int year;
}
} public Date(int day,
int month,
int year) {
this.day = day;
this.month = month;
this.year = year;
}
}

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 112/155


What is polymorphism?
 Polymorphism: exist in many forms
 Polymorphism in programming
 Function polymorphism: same name, different
arguments
 Object polymorphism:
 An object can be treated in different ways
 A Manager object can be seen as an Employee object as
well
 Different objects interpret the same message differently
 How do kangaroos and frogs "jump"?

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 113/155


class Animal {
...
public void makeASound() {
System.out.print ("Uh oh!");
}
}
class Cat extends Animal {
...
public void makeASound() {
System.out.print ("Meow...");
}
} Polymorphism:
class Cow extends Animal { The same message "makeASound"
... is interpreted differently
public void makeASound() {
System.out.print ("Moo..."); Meow... Moo...
}
} Animal myPets[] = new Animal[2];
myPets[0] = new Cat("tom");
myPets[1] = new Cow("mini");
for ( int i = 0; i < myPets.length; i++ ) {
myPets[i].makeASound();
}
Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 114/155
class Animal {
...
public void makeASound() {
System.out.print ("Uh oh!");
} Polymorphism: The same message
public void introduce() { "makeASound" is interpreted differently
makeASound();
System.out.println(" I'm " + name);
}
}
class Cat extends Animal {
...
public void makeASound() {
Animal pet1 = new Cat("Tom Cat");
System.out.print("Meow...");
Animal pet2 = new Cow("Mini Cow");
}
pet1.introduce();
}
pet2.introduce();
class Cow extends Animal {
...
public void makeASound() { Meow... I'm Tom Cat
System.out.print("Moo..."); Moo... I'm Mini Cow
}
}

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 115/155


Dynamic & static binding
 Method binding: connect a method call to a method
body
 Static/early binding: performed by compiler/linker
before the program is run.
 The only option of procedural languages.
 Dynamic/late binding: performed during run-time
 Java uses late binding, except for static, final, and
private methods.
 private methods are implicitly final.

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 116/155


Abstract class
 Sometimes we don't Shape

want objects of a base +area()


+perimeter()
class to be created
Circle Square Triangle

 Examples: +area()
+perimeter()
+area()
+perimeter()
+area()
+perimeter()
 Animal, Cat, Cow, Dog,…
 An Animal object makes no sense
 What sort of sound does it make?
 Shape, Point, Rectangle, Triangle, Circle
 What does a generic Shape look like?
 How to draw it?
 Solution: make it an abstract base class
Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 117/155
Abstract Classes
 Abstract classes cannot be instantiated – they are
intended to be a superclass for other classes
 abstract methods have no implementation
 If a class has one or more abstract methods, it is
abstract, and must be declared so
 Concrete classes have full implementations and can be
instantiated

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 118/155


Shape CartesianPoint
# CartesianPoint location - int x
- int y
+ double area()

Dot Square Circle


- int size - int radius
+ double area()
+ double area() + double area()

119
Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 119/155
public class CartesianPoint {
private int x;
private int y;
public CartesianPoint(int x, int y) {
this.x = x;
this.y = y;
}
public int getX() {
return x;
}
public int getY() {
return y;
}
} public abstract class Shape {
protected CartesianPoint location;
public Shape(CartesianPoint location) {
this.location = location;
}
public abstract double area();
public abstract double perimeter();
public abstract void draw();
}

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 120/155


public class Circle extends Shape {
private int radius;

public Circle(CartesianPoint location, int radius) {


super(location);
this.radius = radius;
}

public double area() {


return Math.PI * radius * radius;
}

public double perimeter() {


return 2 * Math.PI * this.radius;
}

public void draw() {


System.out.println("Draw circle at ("+ x + ","
+ y + ")");
}

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 121/155


Inner Class
Introduction
 Inner classes let you define one class within
another
 They provide a type of scoping for your classes
since you can make one class a member of
another class
 Just as classes have member variables and
methods, a class can also have member classes

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 123/155


Inner Class
 Sometimes, though, you find yourself designing
a class where you discover you need behavior
that belongs in a separate, specialized class,
but also needs to be intimately tied to the class
you’re designing
 Event handlers are perhaps the best example
of this
 A Chat client specific methods in the

ChatClient class, and put the event-handling


code in a separate event-handling class

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 124/155


Inner Class (cont.)
 One of the key benefits of an inner class is the
“special relationship” an inner class instance shares
with an instance of the outer class
 That “special relationship” gives code in the inner class
access to members of the enclosing (outer) class, as if
the inner class were part of the outer class
 An inner class instance has access to all members of
the outer class, even those marked private

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 125/155


Regular Inner Class
 A regular inner class can’t have static declarations of
any kind
 The only way you can access the inner class is through
a live instance of the outer class
 Declare inner class

class MyOuter {
class MyInner { }
}

 When compile MyOuter, It creates two classes


MyOuter.class and MyOuter$MyInner.class

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 126/155


Regular Inner Class (cont.)
class MyOuter {
private int x = 7;
// inner class definition
class MyInner {
public void seeOuter() {
System.out.println("Outer x is " + x);
}
} // close inner class definition
} // close outer class

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 127/155


Anonymous Inner Classes
 Inner classes declared without any class name are
called anonymous
 You can even define anonymous classes within an
argument to a method

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 128/155


class Popcorn {
public void pop() {
System.out.println("popcorn");
} declare a new class which has no
} name, but which is a subclass of
Popcorn
class Food {
Popcorn p = new Popcorn() {
Overriding the pop()
public void pop() { method
System.out.println("anonymous popcorn");
}
}; End of the anonymous class definition

}
Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 129/155
interface Cookable { Anonymous Inner
public void cook(); Classes with Interface
}
class Food {
Cookable c = new Cookable() {
public void cook() {
System.out.println("anonymous cookable implementer");
}
};
}

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 130/155


class MyWonderfulClass {
void go() {
Anonymous Inner
Bar b = new Bar(); Classes as Arguments
b.doStuff(new Foo() {
public void foof() {
System.out.println("foofy");
} // end foof method
}); // end inner class def, arg, and end statement
} // end go()
} // end class

interface Foo {
void foof();
}
class Bar {
void doStuff(Foo f) { }
}

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 131/155


Interface
Java interfaces
 Java does not support multiple inheritance
 This is often problematic
 What if we want an object to be multiple things?
 Interfaces
 A special type of class which
 Defines a set of method prototypes
 Does not provide the implementation for the prototypes
 Can also define final constants

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 133/155


Interfaces

 Declared types in Java are either classes or


interfaces
 Interfaces represent a promise of support
services to the objects which implement the
interface – a “contract”

public interface File {


public void open(String name);
public void close();
}

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 134/155


Protocols
 An interface defines a protocol (a set of methods)
 If a class implements a given interface, then that class
implements that protocol.
 An interface can impose a common protocol on a group
of classes that are not related by inheritance
 In the chain of classes related by inheritance, the common
protocol is imposed through subclassing
<<interface>>
Comparable
+compareTo()

Date Integer String

+compareTo() +compareTo() +compareTo()

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 135/155


Declaring an Interface
 Interface definition has two components
– Interface declaration
– Interface body
 The interface declaration declares various attributes about the
interface
– Name
– Whether it extends other interfaces

Interface public interface StockWatcher {


Declaration final string sunTicker = "SUNW";
Constant
Interface final string oracleTicker = "ORCL";
Declarations
Body final string ciscoTicker = "CSCO";
void valueChanged(String tickerSymbol, Method
double newvalue); Declaration
}

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 136/155


Implementing Interface Methods

 Methods declared in an interface are implemented in the


classes which support that interface

public interface File {


public void open(String name);
public void close();
}

public class TextFile implements File {


public void open(String name) {
// implementation of open method
}
public void close() {
// implementation of close method
}
}

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 137/155


Syntax
 In a class declaration, the naming of the superclass
precedes any interfaces supported by the class:
public class Directory extends Secure implements File {
...
}

 Multiple Interfaces:
 If a class implements multiple interfaces, the interfaces
are all listed, separated by commas
public class Directory implements File, Secure {
...
}

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 138/155


Implementing an Interface
 A class which implements an interface must
implement every method defined by that interface

 If one or more methods is not implemented, Java will


generate a compiler error

 Subclasses automatically implement all interfaces that


their superclass implements

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 139/155


Cloneable Interface
 Some interfaces, such as Cloneable, do not contain
any methods
 In the case of Cloneable
 it alerts the JVM that objects of the implementing class
can be copied via the clone() method
 These act as a signal to Java that a class observes a
certain protocol that may not be expressible as a
specific set of methods
 Only the objects that implement the Cloneable
interface can be copied, or cloned.

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 140/155


Typing and Interfaces
 A variable's type can be an interface

 Stipulations
 Only objects whose class implements that interface can
be bound to that variable
 Only messages defined by the interface can be used
 Interfaces cannot appear in a new expression

File r = new File(); // Error


File f = new TextFile(); // OK!

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 141/155


Subinterfaces
 Interfaces can be extended
 Interface hierarchy is independent of the class hierarchy
 The interface which extends another interface inherits all
of its method declarations
interface File {
public void open(String name);
public void close();
}
interface ReadableFile extends File {
public byte readByte();
}
interface WritableFile extends File {
public void writeByte(byte b);
}
interface ReadWriteFile
extends ReadableFile, WritableFile {
public void seek(int position);
}
Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 142/155
Using Interfaces
 Using interfaces allows
 Cross-hierarchy polymorphism
 Access to methods in separate class trees
 Substitution of an object for another object which is not
related via the class hierarchy

 Classes that implement the same interface understand


the same messages
 Regardless of their location in the class hierarchy

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 143/155


More Advantages of Using Interfaces
 Allows more control over how objects are used

 The programmer can define a method's parameters as


interfaces
 This restricts the use of those parameters
 The programmer knows which message the objects will
respond to

 Improves reusability of code

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 144/155


Naming Conventions for Interfaces
• Make "able" interfaces
– Cloneable, Serializable, ...
• Name interfaces using proper nouns and provide
"Impl" implementation of your interfaces
– Bank, BankImpl, BankAccount, BankAccountImpl
– With this convention, the interface typically contains a
definition for all (or most) of the implementation class'
public methods
• Prefix interface names with "I" and use proper nouns
for your classes
– IBank, Bank, IBankAccount

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 145/155


The Interface Comparable
interface Comparable{
// compare this object with the given object
// produce negative result if this is 'smaller' than the given object
// produce zero if this object is 'the same' as the given object
// produce positive result if this is 'greater' than the given object
int compareTo(Object obj);
}

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 146/155


Case study: Comparable Interface
public class Employee implements Comparable{
private String name;
private double salary;

public Employee(String n, double s) {


name = n;
salary = s;
}

@Override
public int compareTo(Object o) {
Employee emp = (Employee)o;
return this.getName().compareTo(emp.getName());
}
}
Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 147/155
Sort Array of Comparable Objects
public class EmployeeSortTest {
public static void main(String[] args) {
Employee[] staffs = new Employee[3];

staffs[0] = new Employee("Harry Hacker", 35000);


staffs[1] = new Employee("Carl Cracker", 75000);
staffs[2] = new Employee("Tony Tester", 38000);

Arrays.sort(staffs);

// print out information about all Employee


for (Employee e : staffs)
System.out.println("Name = " + e.getName()
+ ", Salary = " + e.getSalary());
}
Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 148/155
Sort Array using Comparator Interface
public class Employee {
private String name;
private double salary;
public Employee(String n, double s) {
name = n; salary = s;
}
} public class EmployeeSortTest {
public static void main(String[] args) {
Employee[] staffs = new Employee[3];
staffs[0] = new Employee("Harry Hacker", 35000);
staffs[1] = new Employee("Carl Cracker", 75000);
staffs[2] = new Employee("Tony Tester", 38000);
Arrays.sort(staffs, new Comparator<Employee>() {
public int compare(Employee o1, Employee o2) {
return o1.getName().compareTo(o2.getName());
}
});
// print out information about all Employee
for (Employee e : staffs)
System.out.println("Name = " + e.getName()
+ ", Salary = " + e.getSalary());
}

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 149/155


Conversion of Data Types
 Two kinds of Conversion of Data Types
 Conversion of Primitive Data Types

 Conversion of Reference Data Types

 Conversion of Data Types


 Implicit type conversion: The programmer does

not make any attempt to convert the type


 Explicit type conversion: Conversion is initiated

by the programmer by making an explicit request


for conversion (type casting)

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 150/155


Conversion of Data Types
 Assignment Conversion
<sourceType> s = new <sourceType>();
<targetType> t = s; // Implicit conversion of
<sourceType> to <targetType>
 Method Call Conversion

 Arithmetic Conversion

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 151/155


Implicit Primitive Type Conversion
 Two general rules for implicit primitive type conversion
are the following:
 There is no conversion between boolean and non-

boolean types.
 A non-boolean type can be converted into another

non-boolean type only if the conversion is not


narrowing—that is, the size of the target type is
greater than or equal to the size of the source type.

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 152/155


Implicit Primitive Type Conversion
public class ConversionToWider{
public static void main(String[] args) {
int i = 15;
short s = 10;
s= i; Error: Illegal conversion
System.out.println("Value of i: " + i );
}
}

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 153/155


Implicit Primitive Type Conversion

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 154/155


Explicit Primitive Type Conversion
 In a narrowing conversion, casting is
mandatory
 However, casting to a narrower type runs the
risk of losing information and generating
inaccurate results
 You cannot cast a boolean to a non-boolean
type.
 You cannot cast a non-boolean type to a
boolean type.

Khoa CNTT – ĐH Nông Lâm TP. HCM 01/2007 155/155

You might also like