Overview of OOP in Java Tessema M. Mengistu Department of Computer - - PowerPoint PPT Presentation

Overview of OOP in Java

1

Tessema M. Mengistu Department of Computer Science Southern Illinois University Carbondale tessema.mengistu@siu.edu Room - 3131

Outline

• Java Basics
• Classes and Objects
• Encapsulation
• Inheritance
• Polymorphism

2

Java Program Structure

• Java is a pure object oriented language
• Everything is written within a class block.

[Documentation] [package statement] [import statement(s)] [interface statement(s)] [class definition(s)] main method class definition

3

Java Program Structure

// this is a java program import java.lang.*; class HelloWorld { public static void main(String[] args) { System.out.println("Hello World!"); } }

4

Java Program Structure

• Java program = Comments + Token(s) +

white space

• Comments

– Java supports three types of comment delimiters – The /* and */ - enclose text that is to be treated as a comment by the compiler – // - indicate that the rest of the line is to be treated as a comment by the Java compiler – the /** and */ - the text is also part of the automatic class documentation that can be generated using JavaDoc.

5

Java Program Structure

• Five types of Tokens in Java:

– Reserved keywords – Identifiers – Literals – Operators – Separators

6

Reserved keywords

• Words with special meaning to the compiler
• The following keywords are reserved in the Java language. They can

never be used as identifiers:

• Some are not used but are reserved for further use. (Eg.: const, goto)

abstract assert boolean break byte case catch char class const continue default do double else extends final finally float for goto if implements import instanceof int interface long native new package private protected public return short static strictfp super switch synchronized this throw throws transient try void violate while

7

Identifiers

• Programmer given names
• Identify classes, methods, variables, objects, packages.
• Identifier Rules:

– Must begin with

• Letters , Underscore characters ( _ ) or Any currency symbol

– Remaining characters

• Letters
• Digits

– As long as you like!! (until you are tired of typing) – The first letter can not be a digit – Java is case sensitive language

8

Identifiers

• Identifiers‘ naming conventions

– Class names: starts with cap letter and should be inter-cap e.g. StudentGrade – Variable names: start with lower case and should be inter- cap e.g. varTable – Method names: start with lower case and should be inter- cap e.g. calTotal – Constants: often written in all capital and use underscore if you are using more than one word.

9

Literals

• Explicit (constant) value that is used by a program
• Literals can be digits, letters or others that represent

constant value to be stored in variables – Assigned to variables – Used in expressions – Passed to methods

• E.g.

– Pi = 3.14; // Assigned to variables – C= a * 60; // Used in expressions – Math.sqrt(9.0); // Passed to methods

10

Operator

• symbols that take one or more arguments

(operands) and operates on them to produce a result

• 5 Operators

– Arithmetic operators – Assignment operator – Increment/Decrement operators – Relational operators – Logical operators

11

Separators

• Indicate where groups of codes are divided and arranged

Name Symbol

Parenthesis () braces {} brackets [] semicolon ; comma , , period

. 12

Object Oriented Programming

• Objects and Classes
• Encapsulation
• Inheritance
• Polymorphism

13

Classes and Objects

• The underlying structure of all Java programs is classes.
• Anything we wish to represent in Java must be encapsulated

in a class – defines the ―state‖ and ―behavior‖ of the basic program components known as objects.

• Classes create objects
• A class essentially serves as a template for an object and

behaves like a basic data type ―int‖.

14

15

Classes and Objects

• A class

is a collection

• f

fields (data) and methods (procedure or function) that operate on that data.

• The basic syntax for a class definition:

class ClassName { [fields declaration] [methods declaration] }

Classes and Objects

public class Rectangle{ // my rectangle class }

16

Rectangle Length Width Perimeter() area()

17

Adding Fields

• The fields and methods are called class members
• Add fields:
• The fields (data) are also called the instance variables.

public classRectangle { public double length; public double width; }

18

Adding Methods

• A class with only data fields has no life. Objects created by

such a class cannot respond to any messages.

• Methods are declared inside the body of the class but

immediately after the declaration of data fields.

• The general form of a method declaration is:

type MethodName (parameter-list) { Method-body; }

19

Adding Methods

public class Rectangle { public double length public double width; // //Methods to return perimeter and area public double perimeter() { return 2 *(length+width); } public double area() { return length * width; } }

Method Body

20

Creating an Object

• An object is an instance of a class
• Uniquely identified by

– its name – defined state,

• represented by the values of its attributes in a particular

time

Creating an Object

• Creating an object is a two step process

– Creating a reference variable

–

Syntax: <class idn><ref. idn>;

• eg. Rectangle r1;

– Setting or assigning the reference with the newly created object. – Syntax: <ref. idn> = new <class idn>(…); r1 = new Rectangle(); – The two steps can be done in a single statement Rectangle r1 = new Rectangle();

21

22

Creating an Object

• Example

– Rectangle aRec,bRec;

• aRec, bRec simply refers to a Rectangle object, not an object

itself.

aRec

null

bRec

null

Creating an Object

• Objects are created dynamically using the

new keyword.

• aRec and bRec refer to Rectangle objects

23

bRec= new Rectangle() ; aRec= new Rectangle();

24

Creating an Object

aCircle = new Circle(); bCircle = new Circle() ; bCircle = aCircle; aCircle bCircle Before Assignment aCircle bCircle After Assignment

25

Accessing Object Data

• We use dot (“.”) operator

Rectangle aRec= new Rectangle(); aRec.length = 2.0 // initialize length aRec.width = 2.0 //initialize width

ObjectName.VariableName ObjectName.MethodName(parameter-list)

26

Executing Methods in Object/Circle

• Using Object Methods:

Rectangle aRec= new Rectangle(); double area; aCircle.r= 1.0; area = aRec.area(); sent ‘message’ to aRec

27

Using Rectangle Class

//Add Rectangle class code here class MyMain { public static void main(String args[]) { Rectangle aRec; // creating reference aRec= new Rectangle(); aRec.length = 2.0 // initialize length aRec.width = 2.0 //initialize width double area = aRec.area(); // invoking method double per = aRec.perimeter(); System.out.println(“Area is “+area); System.out.println(“Perimeter is “+ per); } }

28

What is encapsulation?

• Hiding the data within the class
• Making it available only through the

methods

• Each object protects and manages its
• wn data. This is called self-governing.

Methods Data

29

Why encapsulation?

• To hide the internal implementation details
• f your class so they can be easily changed
• To protect your class against accidental or

willful mistakes

• In general

– Encapsulation separates the implementation details from the interface

30

Visibility Modifiers

• In Java we accomplish encapsulation using

visibility modifiers.

– Public

• least restrictive
• Can be directly referenced from outside of an object.
• visible to any class in the Java program

– Private

• most restrictive
• Can’t

be accessed by anywhere

• utside

the enclosing class

• Cannot be referenced externally.
• Instance data should be defined private.

– Package - default

• Intermediate b/n private and public
• access only to classes in the same package

– Protected

• access to classes in the same package and to all subclasses

31

Using Set and Get Methods

• A class‘s private fields can manipulate only by

methods of that class

• How can we access those data outside?

– Using set and get methods

• Set methods

– public method that sets private variables – Does not violate notion of private data

• Change only the variables you want

– Called mutator methods (change value)

• Get methods

– public method that displays private variables – Again, does not violate notion of private data

• Only display information you want to display

– Called accessor or query methods

32

Inheritance

• Inheritance allows a software developer to derive a new

class from an existing one

• For the purpose of

– reuse – enhancement, – adaptation, etc

• The existing class is called the parent class or superclass
• The derived class is called the child class or subclass.
• Classes often have a lot of state and behavior in common

– Result: lots of duplicate code!

• Super classes are more generic and sub classes are

specific version of the super classes

33

Inheritance

• Two ways of expressing class relationships

– Generalization/Specialization

• ‗is a‖ relationship
• Circle is a shape

– Whole-part

• Part of or ―has a‖ relationship
• Employee class has a BirthDate class
• Called aggregation
• Inheritance creates an is-a relationship

34

Inheritance

• The child class inherits the methods and data

defined for the parent class

• To tailor a derived class, the programmer can

add new variables or methods, or can modify the inherited ones

• Software reuse is at the heart of inheritance
• By using existing software components to

create new ones, we capitalize on all the effort that went into the design, implementation, and testing of the existing software

35

Deriving Subclasses

• In Java, we use the reserved word extends to

establish an inheritance relationship

• Syntax

class subClassName extends superClassName

{ // body of class } e.g.

class 2D_Shape extends Shape { // class contents }

36

Some Inheritance Details

• An instance of a child class does not

rely on an instance of a parent class

– Hence we could create a Circle object without having to create a Shape object first

• Inheritance is a one-way street

– The Shape class cannot use variables or methods declared explicitly in the Triangle class

37

Multiple Inheritance

• Java supports single inheritance, meaning that a derived

class can have only one parent class

• Multiple inheritance allows a class to be derived from two
• r more classes, inheriting the members of all parents
• Collisions, such as the same variable name in two

parents, have to be resolved

• In most cases, the use of interfaces gives us aspects of

multiple inheritance without the overhead (will discuss later)

38

Interfaces

• Interface is a conceptual entity similar to a class.
• But :

– Can contain only constants (final variables) and abstract method (no implementation) - Different from classes.

• Use when a number of classes share a common

interface.

• Each class should implement the interface.

39

Interfaces

• An interface is basically a kind of class—it contains

methods and variables, but they have to be only abstract methods and final fields/variables.

• Therefore,

it is the responsibility

• f

the class that implements an interface to supply the code for methods.

• A class can implement any number of interfaces, but

cannot extend more than one class at a time.

• Therefore, interfaces are considered as an informal way of

realizing multiple inheritance in Java.

40

Interfaces Definition

• Syntax (appears like abstract class):
• Example:

interface InterfaceName { // Constant/Final Variable Declaration // Methods Declaration – only method body } interface Shape { public double area( ); }

41

Implementing Interfaces

• Interfaces are used like super-classes who

properties are inherited by classes. This is achieved by creating a class that implements the given interface as follows:

class ClassName implements InterfaceName [, InterfaceName2, …] { // Body of Class }

42

Interfaces and Software Engineering

• Interfaces provide templates of behaviour that other

classes are expected to implement.

• Separates out a design hierarchy from implementation

hierarchy. This allows software designers to enforce/pass common/standard syntax for programmers implementing different classes.

• Pass method descriptions, not implementation
• Classes implement interfaces.

Polymorphism

• The term polymorphism literally means "having many

forms‖

• Polymorphism is an object-oriented concept that allows us

to create versatile software designs

• In OOP, polymorphism promotes code reuse by calling the

method in a generic way.

• For example we can calculate the area

by calling the area() method on all shape objects. But depending on the type of shape(whether Circle or Rectangle) the correct version of area() will be called.

43

Binding

• Consider the following method invocation:
• bj.doIt();
• At some point, this invocation is bound to the definition of the

method that it invokes

• If this binding occurred at compile time, then that line of code

would call the same method every time

• However, Java defers method binding until run time -- this is

called dynamic binding or late binding

44

Polymorphism

• Suppose we create the following reference variable:

Shape myShapes;

• Java allows this reference to point to an Shape object,
• r to any object of any compatible type
• This compatibility can be established using inheritance
• r using interfaces
• Careful use of polymorphic references can lead to

elegant, robust software designs

45

46