Upload
others
View
26
Download
0
Embed Size (px)
Citation preview
CSC 308 2.0
System Development with Java
Budditha Hettige
Department of Statistics and Computer Science
1
Object Oriented Programming with Java
Budditha Hettige
Advantages of OOP
• Provides a clear modular structure for programs
• OOP makes it easy to maintain and modify existing
code (new objects can be created with small
differences to existing ones)
• OOP provides a good framework for code libraries
• Software components can be easily adapted and
modified by the programmer.
2 Budditha Hettige
Concepts of OOP
• Objects
• Classes
• Data Abstraction
• Encapsulation
• Inheritance
• Polymorphism
3 Budditha Hettige
What is an Objects?
• Object is a software bundle of related state and
behavior
• Characteristics:
– state and behavior
4 Budditha Hettige
What is a class?
• A Java class is a group of Java methods and
variables
• Object is an instance of a class
5 Budditha Hettige
Object Oriented Concepts
6 Budditha Hettige
Budditha Hettige 7
Constructors
• Very similar to C++
• You can create multiple constructors, each must
accept different parameters.
• If you don't write any constructor, the compiler will
(in effect) write one for you:
classname() {}
• If you include any constructors in a class, the
compiler will not create a default constructor!
Budditha Hettige 8
Multiple Constructors
• One constructor can call another.
• You use "this", not the classname: class Foo {
int i;
Foo() {
this(0);
}
Foo( int x ) {
i = x;
}
A call to this must be the first
statement in the constructor!
Budditha Hettige 9
Destructors
• No!
• There is a finalize() method that is called
when an object is destroyed.
– you don't have control over when the object is
destroyed (it might never be destroyed).
– The JVM garbage collector takes care of
destroying objects automatically (you have limited
control over this process).
Class Modifiers
• Public
• Abstract
• Final
• Default (none)
10 Budditha Hettige
Budditha Hettige 11
Class Modifiers
• public: anyone can create an object of the
defined class.
– only one public class per file, must have same
name as the file (this is how Java finds it!).
• default: is non-public (if you don't specify
"public").
Budditha Hettige 12
Class Modifiers
• Abstract: modifier means that the class can be
used as a superclass only.
– no objects of this class can be created.
• Final: if its definition is complete and no
subclasses are desired or required
– a final class never has any subclasses, the methods
of a final class are never overridden
Field Modifiers
• public
• protected
• private
• none or package or default
• Static
• Final
13 Budditha Hettige
Budditha Hettige 14
Field Modifiers
• public: any method (in any class) can access the
field.
• protected: any method in the same package can
access the field, or any derived class.
• private: only methods in the class can access the
field.
• Default: is that only methods in the same package
can access the field.
Budditha Hettige 15
Field Modifiers
• Static: Fields declared static are called class fields (class variables). others are called instance fields. There is only one copy of a static field, no matter how many objects are created.
• Final:class and instance variables (static and non-static fields) may be declared final. The keyword final means: once the value is set, it can never be changed – static final int BUFSIZE=100;
– final double PI=3.14159;
Method Modifiers
• public
• protected
• none or package or default
• private
• final
• abstract
• static
• native
• synchronized
16 Budditha Hettige
Budditha Hettige 17
Method Modifiers
• private/protected/public:
– same idea as with fields.
• abstract: no implementation given, must be
supplied by subclass.
– the class itself must also be declared abstract
Budditha Hettige 18
Method Modifiers
• static: the method is a class method, it doesn't depend on any instance fields or methods, and can be called without first creating an object.
• final: the method cannot be changed by a subclass (no alternative implementation can be provided by a subclass).
Budditha Hettige 19
Method Modifiers
• native: the method is written in some local code (C/C++) - the implementation is not provided in Java.
• synchronized: only one thread at a time can call the method.
Budditha Hettige 20
Method Overloading
• You can overload methods:
– same method name, different parameters.
– you can't just change return type, the
parameters need to be different.
• Method overloading is resolved at compile
time. int CounterValue() {
return counter;
}
double CounterValue() {
return (double) counter;
}
int CounterValue() {
return counter;
}
double CounterValue() {
return (double) counter;
}
Won't Work!
All Possible Combinations of Features
and Modifiers
21
Modifier Class Variable Method Constructor
public yes yes yes yes
protected no yes yes yes
None (default) yes yes yes yes
private no yes yes yes
final yes yes yes no
abstract yes no yes no
static no yes yes no
native no no yes no
transient no yes no no
volatile no yes no no
synchronized no no yes no
strictfp yes no yes yes
Budditha Hettige
Java Modifier Summary
22
Modifier Used on Meaning
abstract
Class
Contains unimplemented methods and cannot
be instantiated
interface All interfaces are abstract. Optional in
declarations
method
No body, only signature. The enclosing class is
abstract
Budditha Hettige
Java Modifier Summary
23
Modifier Used on Meaning
Final
Class
Cannot be subclassed
method
Cannot be overridden and dynamically
looked up
field
Cannot change its value. static final
fields are compile-time constants.
variable Cannot change its value.
Budditha Hettige
Java Modifier Summary
24
Modifier Used on Meaning
Native method Platform-dependent. No body, only signature
Modifier Used on Meaning
Private member Accessible only in its class
Modifier Used on Meaning
protected member Accessible only within its package and its subclasses
Budditha Hettige
Java Modifier Summary
25
Modifier Used on Meaning
None
Class Accessible only in its package
Interface Accessible only in its package
Member Accessible only in its package
Budditha Hettige
Java Modifier Summary
26
Modifier Used on Meaning
Public
Class
Accessible anywhere
interface Accessible anywhere
Member
Accessible anywhere.
Budditha Hettige
Java Modifier Summary
27
static
class
method
field
initializer
Make an inner class top-level class
A class method, invoked through the class
name.
A class field, invoked through the class
name
one instance, regardless of class instances
created.
Run when the class is loaded, rather than
when an instance is created.
Budditha Hettige
Packages
28 Budditha Hettige
Package
• defined as a grouping of related types
• existing packages in Java are:
– java.lang - bundles the fundamental classes
– java.io - classes for input , output functions are
bundled in this package
29 Budditha Hettige
Creating a Package
• Put a package statement with the package name
• At the top of every source file that contains the
classes, interfaces, enumerations, and annotation
types that you want to include in the package
• The package statement should be the first line in
the source file
• There can be only one package statement in each
source file, and it applies to all types in the file
30 Budditha Hettige
Example
/* File name : Animal.java */
package animals;
interface Animal
{
public void eat();
}
package animals;
/* File name : MammalInt.java */
public class Mammal implements Animal
{
public void eat()
{
System.out.println("Mammal eats");
}
Now you compile these two files and put them in a sub-directory called animals
31 Budditha Hettige
The Import Keyword
• If a class wants to use another class in the same
package, the package name does not need to be
used. Classes in the same package find each other
without any special syntax
• The fully qualified name of the class can be used.
– import animals.Mamal
• The package can be imported using the import
keyword and the wild card (*)
– import animals.*;
32 Budditha Hettige
Abstraction
33 Budditha Hettige
Abstraction
• Refers to the ability to make a class abstract in
OOP
• Abstract class
– Cannot be instantiated
– Other functionality of the class still exists
– Cannot create an instance of the abstract class
34 Budditha Hettige
Abstract Class
• Use the abstract keyword to declare a class
abstract public abstract class Employee
{
private String name;
private String address;
...
}
Cannot use Employee e = new Employee();
35
Employee.java: xx: Employee is abstract; cannot be instantiated Employee e = new Employee(); ^ 1 error1
Employee.java: xx: Employee is abstract; cannot be instantiated Employee e = new Employee(); ^ 1 error1
Budditha Hettige
Extending Abstract Class
public class Salary extends Employee
{
private double salary;
Salary(String name, String address,
int number, double salary)
{
super(name, address, number);
setSalary(salary);
}
...
}
36
Extend Employee class
Extend Employee class
Call Employee class
Budditha Hettige
Abstract Methods
• Can declare the method in the parent class as abstract
• Abstract methods consist of a method signature, but no method body
public abstract class Employee
{
private String name;
private String address;
private int number;
public abstract double computePay();
//Remainder of class definition
}
37 Budditha Hettige
Declaring a Method as Abstract
• The class must also be declared abstract
• Any child class must either override the
abstract method or declare itself abstract
– A child class that inherits an abstract method must
override it
– If they do not, they must be abstract,and any of
their children must override it
38 Budditha Hettige
Salary is Extending Employee class
• it is required to implement computePay() method public class Salary extends Employee
{
private double salary; //Annual salary
public double computePay()
{
System.out.println("Computing " + getName());
return salary/52;
}
//Remainder of class definition
}
39 Budditha Hettige
Example
40 Budditha Hettige
Example(1)
41
Employee -------------
Name
Address Number
computePay() mailCheck()
toString() getName()
…
Employee -------------
Name
Address Number
computePay() mailCheck()
toString() getName()
…
Budditha Hettige
Salary class
42
Employee
Salary
Budditha Hettige
Abstract Demonstration
43
Employee
Salary
Budditha Hettige
Exercise
• Remove computePay() methods in the Salary class and re-run the program.
• Change the computePay() as
public abstract double computePay() ;
And re-run the program
• Identify the correct usage of the
– Abstract class
– Abstract methods
44 Budditha Hettige
Encapsulation
45 Budditha Hettige
Budditha Hettige 46
Encapsulation
• Information Hiding.
• Don't need to know how some component is
implemented to use it.
• Implementation can change without effecting
any calling code.
• "protects us from ourselves"
Encapsulation
• is the technique of making the fields in a class
private and providing access to the fields via
public methods
• is also referred to as data hiding
• Benefit
– is the ability to modify our implemented code without
breaking the code of others who use our code
• Encapsulation gives maintainability, flexibility
and extensibility to our code
47 Budditha Hettige
Example
public class Encap
{
private String name;
private String idNum;
private int age;
public int getAge()
{
return age;
}
public String getName()
{
return name;
}
48
public String getIdNum() { return idNum; } public void setAge( int newAge) { age = newAge; } public void setName(String newName) { name = newName; } public void setIdNum( String newId) { idNum = newId; } }
Budditha Hettige
Example
public class RunEncap
{
public static void main(String args[])
{
EncapTest encap = new EncapTest();
encap.setName("James");
encap.setAge(20);
encap.setIdNum("12343ms");
System.out.println("Name : " + encap.getName()+ " Age : "+ encap.getAge());
}
}
49 Budditha Hettige
Benefits of Encapsulation:
• The fields of a class can be made read-only or
write-only.
• A class can have total control over what is
stored in its fields.
• The users of a class do not know how the class
stores its data. A class can change the data type
of a field, and users of the class do not need to
change any of their code.
50 Budditha Hettige
Inheritance
51 Budditha Hettige
Budditha Hettige 52
Inheritance
• On the surface, inheritance is a code re-use
issue.
– we can extend code that is already written in a
manageable manner.
• Inheritance is more, it supports polymorphism
at the language level!
• Information is made manageable in a
hierarchical order
Inheritance cont.
• With Inheritance, new class can be derived from existing classes as a building block
• New class Inherit properties and methods from the existing class
• New class can also added Its own properties and methods
• Keyword
– Extends
– Implements
53 Budditha Hettige
Budditha Hettige 54
Inheritance cont.
• Take an existing object type (collection of fields and methods) and extend it.
– create a special version of the code without re-writing any of the existing code (or even explicitly calling it!).
– End result is a more specific object type, called the sub-class / derived class / child class.
– The original code is called the super class / parent class / base class.
IS-A Relationship (Example)
public class Animal
{
}
public class Mammal extends Animal
{ }
public class Reptile extends Animal
{ }
public class Dog extends Mammal
{ }
55
Animal
Mamal
extends
Budditha Hettige
IS-A Relationship (Example)
public class Dog extends Mammal
{
public static void main(String args[])
{
Animal a = new Animal();
Reptile r = new Reptile();
Mammal m = new Mammal();
Dog d = new Dog();
System.out.println(m instanceof Animal);
System.out.println(d instanceof Mammal);
System.out.println(d instanceof Animal);
}
}
56
Animal
Mamal Dog Reptile
Budditha Hettige
IS-A Relationship
• In Object Oriented terms following are true:
– Animal is the superclass of Mammal class.
– Animal is the superclass of Reptile class.
– Mammal and Reptile are sub classes of Animal
class.
– Dog is the subclass of both Mammal and Animal
classes.
57 Budditha Hettige
IS-A Relationship
• IS-A relationship we can say:
– Mammal IS-A Animal
– Reptile IS-A Animal
– Dog IS-A Mammal
– Hence : Dog IS-A Animal as well
• Use of the extends keyword the subclasses will be able to inherit all the properties of the superclass except for the private properties of the superclass
58 Budditha Hettige
Budditha Hettige 59
Accessing superclass methods
• Can use super() to access all (non-private)
superclass methods.
– even those replaced with new versions in the
derived class.
• Can use super() to call base class
constructor.
Budditha Hettige 60
Single Inheritance
• You can't extend more than one class!
– the derived class can't have more than one base
class.
• You can do multiple inheritance with interface
inheritance.
Budditha Hettige 61
Inheritance Example cont.
• Employee: name, email, phone
– FulltimeEmployee: also has salary, office, benefits, …
• Manager: CompanyCar, can change salaries, rates contracts,
offices, etc.
– Contractor: HourlyRate, ContractDuration, …
• A manager a special kind of FullTimeEmployee,
which is a special kind of Employee.
• The relationship modeled by inheritance is often
referred to as a “is a” relationship
Inheritance Example
62
Employee ------------------ Name Email Phone
Employee ------------------ Name Email Phone
FulltimeEmployee ------------------------ Salary Office
FulltimeEmployee ------------------------ Salary Office
Manager ------------------ CompanyCar Email Phone
Manager ------------------ CompanyCar Email Phone
Contractor ------------------ HourlyRate, ContractDuration
Contractor ------------------ HourlyRate, ContractDuration
Budditha Hettige
Inheritance Example
63
Employee ------------------ Name Email Phone
Employee ------------------ Name Email Phone
FulltimeEmployee ------------------------ Salary Office
FulltimeEmployee ------------------------ Salary Office
Manager ------------------ CompanyCar Email Phone
Manager ------------------ CompanyCar Email Phone
Contractor ------------------ HourlyRate, ContractDuration
Contractor ------------------ HourlyRate, ContractDuration
Is a
Is a Is a
Budditha Hettige
Inheritance Example
• Manager is a full time employee
• Full time employee is a employee
64 Budditha Hettige
HAS-A Relationship
• relationships are mainly based on the usage
• determines whether a certain class HAS-A
certain thing
• helps to reduce duplication of code as well as
bugs
65 Budditha Hettige
Example
public class Vehicle
{}
public class Speed
{}
public class Van extends Vehicle
{
private Speed sp;
}
• class Van HAS-A Speed
– Reuse the Speed class in multiple applications
66
Vehicle
Van
Van sp sp
Budditha Hettige
Interface
67 Budditha Hettige
Budditha Hettige 68
Interfaces
• is a collection of abstract methods
• An interface is not a class
– A class describes the attributes and behaviors of an
object
– An interface contains behaviors that a class
implements
Interfaces cont.
• Interfaces have the following properties:
– An interface is implicitly abstract. You do not need
to use the abstract keyword when declaring an
interface.
– Methods in an interface are implicitly public.
69 Budditha Hettige
Interfaces cont.
• An interface is a definition of method
prototypes and possibly some constants (static
final fields).
• An interface does not include the
implementation of any methods, it just defines
a set of methods that could be implemented.
70 Budditha Hettige
Budditha Hettige 71
Implement an interfaces
• A class can implement an interface, this
means that it provides implementations for all
the methods in the interface.
• Java classes can implement any number of
interfaces (multiple interface inheritance).
Budditha Hettige 72
Interfaces
• Creation (definition) of interfaces can be done using inheritance:
– one interface can extend another.
• Sometimes interfaces are used just as labeling mechanisms:
– Look in the Java API documentation for interfaces like Cloneable.
Interfaces
• An interface is similar to a class in the following
ways:
– An interface can contain any number of methods.
– An interface is written in a file with a .java extension,
with the name of the interface matching the name of
the file.
– The bytecode of an interface appears in a .class file.
– Interfaces appear in packages, and their corresponding
bytecode file must be in a directory structure that
matches the package name.
73 Budditha Hettige
Interfaces
• An interface is different from a class in several ways, including: – You cannot instantiate an interface.
– An interface does not contain any constructors.
– All of the methods in an interface are abstract.
– An interface cannot contain instance fields. The only fields that can appear in an interface must be declared both static and final.
– An interface is not extended by a class; it is implemented by a class.
– An interface can extend multiple interfaces.
74 Budditha Hettige
Declaring Interfaces
• The interface keyword is used to declare an interface public class MammalInt implements Animal
{
public void eat()
{
System.out.println("Mammal eats");
}
public static void main(String args[])
{
MammalInt m = new MammalInt();
m.eat();
}
}
75
interface Animal { public void eat(); }
interface Animal { public void eat(); }
Budditha Hettige
Extending Interfaces
• An interface can extend another interface public interface Sports
{
public void setHomeTeam(String name);
}
public interface Football extends Sports
{
public void homeTeamScored(int points);
}
public interface Hockey extends Sports
{
public void homeGoalScored();
}
76
Sport
Football Hockey
Budditha Hettige
Multiple Interfaces
• A Java class can only extend one parent class.
• Multiple inheritance is not allowed
• An interface can extend more than one parent
interface
• Extends keyword is used once, and the parent
interfaces are declared in a comma-separated list.
– public interface Hockey extends Sports, Event
77 Hockey
Sports Event
Budditha Hettige
The “instanceof” Keyword
• the instanceof operator to check determine
whether Mammal is actually an Animal, and
dog is actually an Animal
78 Budditha Hettige
Polymorphism
79 Budditha Hettige
Polymorphism
• is the ability of an object to take on many
forms
• OOP occurs when a parent class reference is
used to refer to a child class object
80 Budditha Hettige
Budditha Hettige 81
Polymorphism
• Create code that deals with general object
types, without the need to know what specific
type each object is.
• Generate a list of employee names:
– all objects derived from Employee have a name
field!
– no need to treat managers differently from anyone
else.
Budditha Hettige 82
Polymorphism
• The real power comes with methods/behaviors.
• A better example:
– shape object types used by a drawing program.
– we want to be able to handle any kind of shape someone wants to code (in the future).
– we want to be able to write code now that can deal with shape objects (without knowing what they are!).
Example
public interface Vegetarian {}
public class Animal{}
public class Deer extends Animal implements Vegetarian{}
• Deer class is considered to be polymorphic since this has
multiple inheritance
– A Deer IS-A aAnimal
– A Deer IS-A Vegetarian
– A Deer IS-A Deer
– A Deer IS-A Object
83 Budditha Hettige
Types of Polymorphism
• Overloading
• Overriding
• Dynamic method binding
84 Budditha Hettige
Example
public static void main ( String ary[ ] )
{
Box x;
Box b1 =new Box( );
WoddenBox wb=new WoddenBox( );
SteelBox s1=new SteelBox( );
LargeWoddenBox p1=new LargeWoddenBox( );
b1.info( );
wb.info( );
s1.info( );
p1.info( );
System.out.println("-------------------------");
Box b[]=new Box[5];
b[1]=new Box();
b[2]=new WoddenBox();
b[3]=new SteelBox();
b[4]=new LargeWoddenBox();
for(int i=1;i<5;i++)
b[i].info();
}
85
Box
WoddenBox SteelBox
LargeWoddenBox
Budditha Hettige