MT311 (Oct 2006)Java Application Development
Tutorial 1
Object-Oriented Programming in Java
Tutor Introduction
Edmund Chiu (Group 1) Email: [email protected] OR
[email protected] Please begin your email subject with [MT311]
What is MT311?
Not a basic Java programming course– Fundamental knowledge of programming should
have been learned in MT201 and/or MT258– You can refer to Java Tutorial (
http://java.sun.com/docs/books/tutorial/) to learn the basic technique of Java programming
What is MT311?
Not only teaching you advanced Java programming technique
It teach you the concepts of programming languages – Why they are designed as they are– Which language is the best for my system
What is needed?
J2SE 1.5 SDK – You can’t write a Java program without it!!
– http://java.sun.com/j2se/1.5/download.html– NOT NetBeans IDE nor J2EE nor J2SE JRE
TextPad – A simple editor with Java syntax highlight– http://www.textpad.com– Java files can be compiled and run directly in TextPad– You may also choose to use other IDE you familiar with
Java API Specification– http://java.sun.com/j2se/1.5/docs/api/– List out all packages, classes and their details
Download Java SDK
Object-Oriented Progrmming
In object-oriented programming, a program consists of objects interaction through method invocation
Four basic principles in OOP– Abstraction– Encapsulation– Inheritance– Polymorphism
Abstraction
Everything in OOP is an object– Abstraction of real world entities and behaviors into
objects– Example: In a banking system, Account is an object
owning its state (e.g. balance) and behavior (e.g. deposit and withdraw operations)
Encapsulation
Information Hiding– Only interface is provided to others and actual implementati
on is hidden– Focus on the functional behaviours but not the implementat
ion details more modular – implementation can be updated in a more flexible w
ay– We can now control the accessibility and visibility of variabl
es and methods– Example: balance in the Account should be read-only. Bala
nce change must be done through withdraw and deposit methods
Inheritance
Extends an object by inheriting the behaviours (data and/or operations) of another object
– Behaviours of the original object can be modified– New features can be added
An is-a relationship between a parent-class (superclass) and the child-class (subclass)
Example: overdraft-account is inherited from Account with extended features – an overdraft account is still an account.
Polymorphism
Literally means multiple forms In OO, polymorphism have several meanings
– Overloading of methods/operators – same method name, a different argument list
– Dynamic binding of methods – when a method is over-ridden in the subclass (same method name, same list of argument), which methods (superclass/subclass) should be called when the subclass object is used in place of superclass object?
Overloading and Overriding
Example in overloading operator (+)– + can mean integer addition, floating point addition or even String
concatenation– Normally, it makes program more readable and concise, but does
not give new meaning to the language Example in over-riding and dynamic binding
– Overdraft-account can be manipulate as an overdraft-account or a normal account
– When withdraw from account method is called, should it be the withdraw method from account class, or from the overdraft-account class
– In Java, binding is done dynamically – the runtime inspects the object’s actual type
Object-Oriented Analysis and Design (OOAD)
Systematic steps for analyzing a problem and designing a solution in an OO way
– Analyze the problem domainYou may need to research and/or consult the domain experts
– Identify the objects and their relationship in the problemYou may need a visual language (namely UML) to draw out the interacting parties and their interactions
– Abstract the objects into Java objects/classesUsing real word as a framework to make it easier to model and be understood
Design Patterns
A Design Pattern is a high-level proven solution for solving a particular type of problem.– Well implemented and used by previous
practitioners– Very useful for less experienced programmers– It is sufficient to know the basics of patterns,
especially how to use it
Examples of Design Patterns
Observer Pattern– Linking Event source and Event listener may become unwieldy in
large system – In observer pattern, a source is Observable and the listeners are
Observers– After registration, when a relevant event happens in the
Observable, the observers will be notified automatically Model-View-Controller (MVC)
– View represents the user interface– Control is the application controller– The core data and logic is stored in model– Maps well in n-tier application, e.g., Web systems.
Object Modeling with UML
Map a solution to object A popular tool for OOAD is UML, Universal Modeling
Language– A graphical language– Can model the whole software design and be used throughout
the development process– It can be used in capturing system requirements, module
boundaries and interactions, object mapping, code generation and even physical deployment.
– You need not to have a full understanding of UML in this course, but a basic knowledge of UML should be useful
Documentation using JavaDoc and UML
Proper documentation has been a big headaches throughout the professional system development
Java provides a tool called JavaDoc making the documentation an integral part of code development
– By inserting specific comments and tags, programmers can run JavaDoc to create proper documentation for their code
UML diagrams are now also widely used as a documentation language
There are even UML extension to JavaDoc enabling the generation of UML diagrams from the code
Basic Java
The following pages introduce you the most basic components of the Java language– Data structure – how data is represented– Program statements – how to express a
computation– Control structures – how to control the execution– Compiling and linking – how to compile and link
code into executable applications
Variables
Variables are identifiers to some data structure Two types of data structures in Java – objects and primitiv
e types– Apart from the numeric and boolean data types such as long, int, flo
at, double, char and etc., all data are represented as objects in Java. The main differences in handling the two types are:
– How they are created (declared)– How they are used in method invocations
As Java is a strictly typed language, all variables must be declared with their types before used:
– Syntax: <type> <variable_name>
Expression, Statements and Blocks
Variables become expression when combined by operators Expressions when combined become program statements
– Example: c = a+b; Statements are separated by a semicolon ; and multiple
statements can be combined into a block using braces { }– Example: {
a = 1;b = 2;c = a + b;
}
Control Flow Statements
Selection statements– If-else:
if (a>b) max = a;
else max = b;
– Switch-case:switch(x) {
case 1: y=1; break;case 2: y=1; break;default: y=x*2;
}
Looping– For:
for(int i=0; i<5; i++) {sum += i;
}– While:
while(a.hasNext()) {System.out.println(a.
next());}
– Do…while
Control Flow Statements (cont’d)
Exception handling statements– Try-catch-finally
will be further discussed when in use– Throw statement
Branching statements– Break
(i) leave a loop prematurely(ii) leave a switch statement
– Continuejump to next iteration in a loop
– Returnleave a method
Linking with Other Classes
In Java, related classes can be organized into packages– Some support classes in a package is hidden from other classe
s outside the package – another kind of encapsulation– Organize a class into a package by simply add the package stat
ement at the top of the program:package myPackage;
To reference classes from another package, you need to have an import statement at the top of the program
– Example: import java.io.*; Java provides many packages you can use.
– For details, consult the API specification
My First Cup of Java
Application versionpublic class HelloWorldApp {
public static void main(String[] args) {
// Display "Hello World!"
System.out.println("Hello World!");
}
}
Applet versionimport java.applet.*;import java.awt.*; public class HelloWorld extends Appl
et { public void paint(Graphics g) { // Display "Hello World!" g.drawString("Hello world!", 50,
25); }}
Defining a Class
Example: we are to model a bank account, we need to have a state (balance) and two operations (withdraw and deposit)class BankAccount {
double balance;double withdraw(double amount) {…}double deposit(double amount) {…}
}
Narrowing the Public Interface
We need to prevent user from directly modifying balance, but still providing the accessibility of balance to our subclasses. The account balance should be read-only through the accessor methodpublic class BankAccount {
protected double balance;public double withdraw(double amount) {…}public double deposit(double amount) {…}public double getBalance() {…}
}
Creating an Object
We use the new keyword to create (instantiate) an objectBankAccount acc = new BankAccount();
– The new keyword will allocate the memory for the object and call the specified constructor. A reference to the created object will be returned.
Constructor, in general, is used to perform object initialization – initialization of instance variables and performing superclass intialization
– Complex initialization should be done through calling methods If no constructor is given in the class, default constructor
will be used (no argument, do nothing)
Constructor and Examples
It’s a good programming practice to define the constructor even it does nothing
Unlike other methods, constructors have the same name as the class and no return type
Like other methods, constructors can be overloaded with different argument listpublic class BankAccount {
protected double balance;public BankAccount () { balance = 0.0; }public BankAccount (double initBalance) { balance = initBalance; }…
}
Finalizer
In C/C++, programmer needs to write destructors for memory management – release the memory at the end of a variable’s life
In Java, programmer needs not to take care of the memory management, garbage collection in Java VM will remove the unused objects
In Java, finalizer is called automatically just before the object is garbage-collected
– No guarantee of running – if there is no need of garbage collection till the end of execution, the finalizer will never be called
Though no side effect will happen by calling finalizer explicitly multiple times, programmers should do the final swap up in a user-defined method like close() and etc.
Instance Member
To reference an instance variable (belongs to the object), we need to have an object instance first– Example: to perform withdraw operation, we must h
ave a BankAccount firstBankAccount acc = new BankAccount(500.0);
acc.withdraw(300.0);
Static Methods and Variables
Static variables and methods belong to the class rather than to a specific instance of class
– Example: you may have a common interest rate for all savings account:static double commonRate = 0.05;
– All instances will then share the same variable commonRate Static variables/methods can be called without creating any o
bject:double specialRate = BankAccount.commonRate + 0.01;
Static methods cannot refer to non-static member in the class– Static method is called through the class and does not have (this) obj
ect reference
Abstraction in Java
In Java, almost everything is an object
– Primitive data type are made for more convenience for the programmers
In Java, an object is defined in a class
– States of an object stored as member variables
– Behaviours are manifested via methods
Example: BankAccountclass BankAccount {
double balance;double withdraw(double amt) {…}void deposit(double amt) {…}
}
Encapsulation in Java
Variables and methods are bundled inside classes (which may be packed into packages)
Access modifiers are used to determine the visibility of classes, methods and variables
– Public – open to all classes– Private – hide from all classes except itself– Protected – open to subclasses (and itself) only– Default – open to classes of same package (folder)
Usually in OOP, we hide the member variables (protected/private) and give get/set (accessor/mutator) methods for reading and writing the variables
Encapsulation Example
In our bank account, we should:– Apply protected to balance
to avoid direct access to balance by other classes except those which is its subclass
– Provide get method for balance onlymake balance read-only, need to call withdraw/deposit to change the balance value
public class BankAccount {protected float balance;public double withdraw(double amt) {…}public void deposit (double amt) {…}public double getBalance() {…}
}
Inheritance in Java
Inheritance in Java is supported through the keyword extends
– class B extends A means B is the subclass, A is the superclass
– Example:public class OverdraftAccount extends BankAccount {
public double withdraw(double amt) { // override }}
– In the above example, withdraw method is overriden, but other methods (deposit, getBalance) are the same as in BankAccount
Construction and Destruction of Inherited Objects
When constructing a subclass object, the constructor of the superclass will be called, either explicitly or implicitly– Java will call super class default constructor (no arg
ument) if no explicit call to superclass constructor is existed
– Call of superclass constructor must be made as the first statement in the constructor method body
– The same applies to finalizers
Example of Constructor in Inheritance
class A {public A() { System.out.println ("Constructor A is called."); } }
class B extends A {public B() { System.out.println ("Constructor B is called."); } }
class C extends B {public C() { System.out.println ("Constructor C is called."); }public C(int i) { System.out.println ("Constructor C with " + i + " is called."); } }
class D extends C {public D(int i) { System.out.println ("Constrcutor D with " + i + " is called."); } }
class E extends C {public E(int i) { super(i);
System.out.println("Constructor E with " + i + " is called."); }
}class TestConstructor {
public static void main(String args[]) {B b = new B();System.out.println("====");C c = new C();System.out.println("====");D d = new D(10);System.out.println("====");E e = new E(100);
}}
Polymorphism in Java
Overloading– Methods using same name must have different number/type of
parameters Overriding
– Methods in subclass can use the same method name with same signature to define a new meaning for the method
Interface– Specification without implementation– A class can provide the specified features by implementing the
interface– One use of interface is to enforce typing
Example: sorting function can take comparable objects only
Dynamic Binding and Polymorphism
Binding refers to the resolution of which form of overloaded methods is to be used
Traditional languages use static binding – the binding is determined in the compile time
Java uses dynamic binding – the binding is determined in the run time by the Java VM
Dynamic binding is more flexible and powerful but requires more resource because binding is to be resolved at each invocation
Polymorphism Example
Which withdraw will be called?BankAccount a = new OverdraftAccount(0.0, 50.0);a.withdraw(25.0); // call overdraft’s withdrawBankAccount b = new BankAccount(100.0);b.withdraw(25.0); // call bankAccount’s withdrawf1(a); // call overdraft’s withdrawf2(a); // call overdraft’s withdrawf1(b); // casting errorf2(b); // call bankAccount’s withdrawdouble f1 (OverdraftAccount a) { return a.withdraw(25.0); }double f2 (BankAccount a) { return a. withdraw(25.0); }
Abstract Classes
An abstract class is similar to interface, but it may provide partial implementation
Abstract class is not instantiable, but you can inherit it and provides the missing implementation and make it instantiable.
Interface is usually used to define roles played by a class
Abstract class is often used as the base class of a family of classes
Examples on Interface and Abstract Class
public class SavingsAccount implments AutoPay– Autopay is not really an entity and should not be defined as cla
ss– An object of SavingsAccount can be casted into AutoPay and
uses the methods in AutoPay public abstract class GeneralAccount
public class SavingsAccount extends GeneralAccount– Some common attributes and methods are defined in General
Account, some methods may be abstract (e.g getBalance())– All subclasses of GeneralAccount should be concrete classes
and provide the services defined in GeneralAccount, including the implementation of those abstract methods
Final Methods and Classes
Final methods cannot be overridden and final classes cannot be subclassed– Prevent undesirable method overriding – Prevent subclassing that may undermine the design
integrity– Example: you don’t want other to alter the way you
worked in your security manager class
Final method/class binds the memory statically
Object and Class Classes
All objects in Java are subclass of the root class Object– Some common methods of object:
cloning, equality, threading, string representation and etc.– Enable us to write generic collection without using templates
Example: a vector stores a collection of Objects– Type casting is used to cast the Object to its original class
The Class class provides runtime information– getClass() in Object class returns a Class object reference– Using the Class object, you can grab some runtime information about
the class (e.g. class name, is it an array and etc.)– Instanceof operator can also used to check if an object is an instance
of a classExample: if (acc instanceof SavingsAccount) { // do something }
Cloning Objects
The assignment operator do not copy the objects– Example: Pair x = new Pair(5, 6);
Pair y = new Pair(14, 16);x = y;
Reference x will be pointing to the same object as y To make a copy of an object, we use the clone method
– Example: Pair x = new Pair(5, 6);Pair y = new Pair(14, 16);x = (Pair) y.clone();
Reference x will be pointing to a separate copy of y To enable an object of a class to use clone method, it must i
mplement Cloneable(code: Quiz2_5, Pair)
Shallow and Deep Copies
The default clone is only performing a shallow copy– Create a new object with all attributes assigned using
assignment operator (=) If the object is storing another object, the result will be
unexpected– Example:
if b is a.clone() and a has an object (o) as its attribute: when a.o is changed, it will also affect b.o a.o and b.o is referring to the same object
We need to override the default clone() method to perform a deep copy
Nested Class, Inner Class and Anonymous Class
You can use the complete Java language without knowing anything about inner classes.
These inner classes are used to make code more elegant and improve the structure of a class
Nested Class
public class outer { // the nested class …public static class inner { // enclosing class…}
} Nested classes are top-level classes and not associated
with instances of enclosing classes– Nested class has no special privileges for accessing members of
enclosing class Nested class can show a close relationship between the
nested and enclosing class, without a tight coupling of data within two classes
Inner Class
When you instantiate an inner class and the class encloses it, the two objects are crated with access to the same copies of the outer class
One benefits is that the inner class having the access to internal variables and methods can provide an effective implementation to some adaptor interface
Anonymous Inner Class
When a local inner class cannot be referenced outside the block in which the class is defined, we may choose to given no name to it, making it an anonymous inner class.
Example: new MouseListener() {
// some necessary methods here
}
Essential Packages
Java provides plenty of class in its API and third party packages are also available on the Internet
Some commonly used packages in Java API are:– Java.applet– Java.io– Java.awt– Javax.swing– Java.net– Java.util– Java.text– Java.sql– Java.text and much more
Java Component Model
Beans – a component consists of number of classes packaged into a single compressed JAR archive file– Put into a bean container at runtime – can be linked
at runtime without importing it at source code level JavaBean – simpler components typically used
for graphics object EJB – complex beans defined in J2EE dealing
with business objects