Object-oriented Programming

Language (JAVA)
(面向对象程序设计)

李建欣(Jianxin Li)
lijx@act.buaa.edu.cn
lijianxin@gmail.com
School of Computer,
Beihang University
© Beihang University
Chapter 3 Review
Primitive Data Types
Statement
Array

Reminding: http://graduate.buaa.edu.cn
Selecting your lesson firstly.

2
© Beihang University
Exercise (for everyone)
1. Writing a program to output followings:
1
12
123
1234
12345
123456
2. The results?

3
© Beihang University
A Question？

class A ...{ A a1 = new A();

public String show(D obj) A a2 = new B();
{ return ("A and D"); } B b = new B();
public String show(A obj)... C c = new C();
{ return ("A and A"); } } D d = new D();
System.out.println(a1.show(b)); ①
class B extends A...{ System.out.println(a1.show(c)); ②
public String show(B obj)... System.out.println(a1.show(d)); ③
{ return ("B and B"); } System.out.println(a2.show(b)); ④
public String show(A obj)... System.out.println(a2.show(c)); ⑤
{ return ("B and A"); } } System.out.println(a2.show(d)); ⑥
System.out.println(b.show(b)); ⑦
class C extends B...{} System.out.println(b.show(c)); ⑧
class D extends B...{} System.out.println(b.show(d)); ⑨

What is its output?

4
© Beihang University
 Chapter-4

Java OOP Features

5
© Beihang University
Some key points in Java OOP

Object and Class

The Object Lifecycle
Class Creation
Overloading
Subclass

6
© Beihang University
Basic Concepts in OOP
 Three key features of OOP

Encapsulation ”封装 ”
form of software reusability
Polymorphism ”多态 ”
Write programs in a general fashion
to handle a wide variety of classes
Inheritance ” 继承 ”

7
© Beihang University
Class and Object
A class defines the variables and the methods
common to all objects of a certain kind.
Primitive data type
The abstracted date type can be realized with Java
class

Object is an instance of a class

8
© Beihang University
An Example of Java Class & Object
Class Definition：
Class EmpInfo{
String name;
String designation;
String department;
void print( ){ System.out.println(name+“is”+
designation+“at”+department);}
}
Object initialization：…
EmpInfo employee = new EmpInfo( );
employee.name = “ Robert Javaman”;
employee.designation = “Manager”;
employee.department = “Coffee shop”;
employee.print( ); ...
9
© Beihang University
The Lifecycle of Object

Creating an object

Using an object

Destroying an object

10
© Beihang University
Object Creation

Three steps to create an object：

 Declaration ”声明 ”
 Instantiation ”实例化”
 Initialization ” 初始化”

e.g.,：
Point origin_one ;
origin_one = new Point(23, 94);
Rectangle rect_one = new Rectangle(origin_one, 100, 200);
Rectangle rect_two = new Rectangle(50, 100);

11
© Beihang University
Object Instantiation Procedure
Constructing and initializing an object
Invoking new XXX();
Creating memory space (variable, method body, and
implemented code) and initializing variables member of
class
numerical value :0;
boolean: false;
String: null;
Explicit initialization: the variable declaration of class
includes some simple assignment expression
public class Initialized{
private int x = 5 ;
private String name = “Fred”;
…
 Construction function
} execution

12
© Beihang University
Garbage Collection
Garbage Collection: Java Running Environment
If an object will not been used, and delete it
If an object have no reference to it, it can be
collected as a garbage
Garbage Collector: A process involved in the JRE,
and the allocated memory of non-used object can
be released periodically.

13
© Beihang University
Garbage Collection

C++：Atype *a=new Atype( );

b c
Atype *b=a;
Atype *c=a;
// after a is used, then delete it (dangling pointer )
delete a;

Java ：A a=new A( ); a b c
A b=a; b c
A c=a;
// delete it
a= null ;

14
© Beihang University
 Creating an object
Creation of Class


15
© Beihang University
Constructor Function

Definition ： public class name

(parameters){ … }

Note：
•The name of method must be the same as
the name of class.
•No return type

16
© Beihang University
Default Constructor
If there is no constructor function, a default
constructor will be invovled during the Java codes
compiling. For example, public Employee( ){ };
Once you declared a new constructor function, the
default constructor will not be involved into the
source code.

17
© Beihang University
Class Function Member
Format
<modifiers><return_type><name>
([<argument_list>])[throws <exception>]{<block>}

18
© Beihang University
Example:

public class PassTest{

float ptValue;
public PassTest(float x){
ptValue= x;
}
public static void main(String args[ ] ){
PassTest pt= new PassTest(10 );
System.out.println(“Int value is:” +pt.ptValue);
}
}

19
© Beihang University
Encapsulation of Data

Data Hiding: Using private to define variable, and

this variable can only be used in the function member.
Class Date{
public int day, month, year;
void setDate( int a, int b, int c){
day = a;
month = b;
year = c ;
}
}
…
Date d1;
d1 = new Date( );
d1.setDate(30,9,2001);
d1.day = 30;
...
20
© Beihang University
Encapsulation
One of the four fundamental OOP concepts
The other three are inheritance, polymorphism, and
abstraction.
A technique of making the fields in a class private
and providing access to the fields via public methods
,also referred to as data hiding.
It is a protective barrier that prevents the code and
data being randomly accessed by other code defined
outside the class. Access to the data and code is
tightly controlled by an interface.
The main benefit of encapsulation is
maintainability, flexibility and extensibility to our code.

21
© Beihang University
Example

22
© Beihang University
Why Encapsulation is Important
A real life example.
class BankAccounts{
public float AccountBalance;
…}
--------------------------------------------------------
myBankAccount.AccountBalance=-100; // without encapsulation
----------------------------------------------------------
Bool setAccountBalance(float amount) // with encapsulation
{
if (amount>=0 && someOtherConditions)
AccountBalance = amount;
return true;
else

return false;
}

23
© Beihang University
Keyword : this

Key words this is used to pointer the object itself

e.g.,：class Date {
private int day, month,year;
public Date getTommorrow( ){
this.day++;
…
}

24
© Beihang University
Keyword: super
Super is used to point to the superclass。

Public class Empolyee {

private String name ;
private int salary;
public String getDetails( ){
return “Name: ”+name+“\nSalary:”+salary;
}
}
public class Manager extends Empolyee {
private String department ;
public String getDetails( ){
return super.getDetailes( )+‘\nDepartment: “+
department;
}
}

25
© Beihang University
Subclass

Subclass is a belonging ( is a ) relation.

e.g.,：public class Employee { public class Manager {
String name ; String name ;
Date hireDate ; Date hireDate ;
Date dateofBirth ; Date dateofBirth ;
String jobTitle ; String jobTitle ;
int grade ; int grade ;
… String department ;
} Employee [ ] subordinates;
…
}

26
© Beihang University
Extends
Keyword extends is used.
public class Employee { public class Manager extends Employee
String name ; {
Date hireDate ;
String department ;
Date dateofBirth ;
String jobTitle ; Employee [ ] subordinates;
int grade ;
… }
}

Subclass is a method to create a new class

based on an existing class
27
© Beihang University
Subclass
Subclass can inherit the attributes, function of
Superclass, and subclass declares its own
special variables and functions
The variables and functions with private modifier
can not be inherited.
The constructor function can not be inherited
How to invoke the constructor in a method?
this();
How to invoke the constructor in a super class?
super();
super is a key work for get the super class.

28
© Beihang University
Invoking function of Superclass

class Employee{ ...

public Employee( String n){
name=n;
}
}
class Manager entends Emplyee{
public Manager( String s,String d){
super(s);
... }
}

29
© Beihang University
(重载)Overloading
In a class, one method can be defined many
times.
classScreen {
public void print( int i){ … }
public void print( float i){ … }
public void print( String str ){ … }
}
Principals：
• the list of parameter must be different to
distinguish difference function implementation.
•The return type and access modifier may be
same or different.
30
© Beihang University
(重写)Overriding
A subclass can modify the behaviors inherited from
super class
The return type, method name, parameter list must
be same with the methods defined in the super class

31
© Beihang University
 Overriding Example

public class Stack

{
private Vector items;
// code for Stack's methods and constructor not shown
// overrides Object's toString method
public String toString() {
int n = items.size();
StringBuffer result = new StringBuffer();
result.append("[");
for (int i = 0; i < n; i++) {
result.append(items.elementAt(i).toString());
if (i < n-1) result.append(",");
}
result.append("]");
return result.toString();
}
} © Beihang University
32
Polymorphism

33
© Beihang University
Polymorphism

The dictionary definition of polymorphism refers

to a principle in biology in which an organism or
species can have many different forms or stages.
This principle can also be applied to object-
oriented programming and languages like the
Java language. Subclasses of a class can define
their own unique behaviors and yet share some
of the same functionality of the parent class.

34
© Beihang University
Polymorphism

Java permits the variable of superclass object can be the

variable of subclass object.
E.g.,：Employee e = new Manager( );
But use this variable (e.g., e), you only can access the
methods provided by the supercalss, the special method of
subclass will be hidden.
During the running time, the method is identified.
Employee e = new Manager();
e.getDetails();

35
© Beihang University
Polymorphism
Overloaded methods are methods with the same name
signature but either a different number of parameters or
different types in the parameter list. By defining a method for
handling each type of parameter you achieve the effect that
you want.
Overridden methods are methods that are redefined within
an inherited or subclass. They have the same signature and
the subclass definition is used.
Don't confuse the concepts of overloading and overriding.
 Overloading deals with multiple methods in the same class with the same
name but different signatures.
 Overriding deals with two methods, one in a parent class and one in a child
class, that have the same signature.
 Overloading lets you define a similar operation in different ways for different
data.
 Overriding lets you define a similar operation in different ways for different
object types.

36
© Beihang University
Polymorphism
Polymorphism is the capability of an action or method to do
different things based on the object that it is acting upon. This
is the third basic principle of object oriented programming.
Overloading and overriding are two types of polymorphism .
dynamic method binding.
Assume that three subclasses (Cow, Dog and Snake)
have been created based on the Animal abstract class,
each having their own speak() method.
Notice that although each method reference was to an
Animal (but no animal objects exist), the program is able to
resolve the correct method related to the subclass object
at runtime. This is known as dynamic (or late) method
binding.

37
© Beihang University
Polymorphism Example
public class AnimalReference{
public static void main(String args[])
Animal ref; // set up var for an Animal
Cow aCow = new Cow("Bossy"); // makes specific objects
Dog aDog = new Dog("Rover");
Snake aSnake = new Snake("Earnie");
// now reference each as an Animal
ref = aCow;
ref.speak();
ref = aDog;
ref.speak();
ref = aSnake;
ref.speak();
}

38
© Beihang University
Object class
Some methods can be overriding in the subclass of
Object
clone
equals
finalize
toString

39
© Beihang University
Object clone
aCloneableObject.clone();
aCloneableObject must implement Cloneable interface
Object.clone() is shallow copy, and not is deep copy

40
© Beihang University
Object.clone

public class Stack implements Cloneable {

private Vector items;
// code for Stack's methods and constructor not shown
protected Object clone() {
try {
Stack s = (Stack)super.clone(); // clone the stack
s.items = (Vector)items.clone(); // clone the vector
return s; // return the clone
} catch (CloneNotSupportedException e) { }
}
}

41
© Beihang University
Object.toString()
Return the string of an object representation .

E.g.,：
System.out.println(Thread.currentThread().toString());

Thread[main,5,main]

42
© Beihang University
Hashcode & equal

43
© Beihang University
Preparation
Package
Static
Abstract, Interface

44
© Beihang University
Following Chapters
Chapter 5
Essential JAVA Language

45
© Beihang University
 46
© Beihang University