object oriented programming concepts using java

Object Oriented Programming

Old Programming Technique: Structures

struct queue{int a[5];int head;int tail;

};

struct stack{int a[5];int top;

}

void main(){

struct queue Q;struct stack S;

print( Q.a[2] );print( S.a[2] );

add(S, 3);add(Q, 2);

}

void add(queue Z, int x){ <codes for

adding queueelements here>

}

void remove(queue Z, int x){ <codes for

removing queueelements here>

}

void add(stack Z, int x){ <codes for

adding stackelements here>

}

void remove(stack Z, int x){ <codes for

removing stackelements here>

}

?

New Programming Technique: Object-Oriented

void main(){

queue Q;stack S;

print( Q.a[2] );print( S.a[2] );

S.add(3);Q.add(2);

}

class queue{int a[5];int head;int tail;

void add(int x){ <codes here>}

void remove(int x){ <codes here>}

};

class stack{int a[5];int top;

void add(int x){ <codes here>}

void remove(int x){ <codes here>}

}

Chapter 3 - Object-Orientation

What is OO Programming

A type of programming in which programmers define not only the data type of a data structure, but also the types of operations (functions) that can be applied to the data structure.

In this way, the data structure becomes an object that includes both data and functions.

In addition, programmers can create relationships between one object and another.

For example, objects can inherit characteristics from other objects.

Stack

int top;push();pop();add();

Linked List

int content;initialize();

Queue

int end;enqueue();dequeue();

add();

inherits inherits

Object-orientation is a new technology based on objects and classes. It presently represents the best methodological framework for software designers to develop complex large scale systems.

One of the principal advantages of object-oriented programming techniques over procedural programming techniques is that they enable programmers to create modules that do not need to be changed when a new type of object is added.

A programmer can simply create a new object that inherits many of its features from existing objects. This makes object-oriented programs easier to modify.


What is OOP?

Stack

int top;push();pop();add();

Linked List

int x;initialize();

Queue

int end;enqueue();dequeue();

add();

inherits inherits

Old class is not modified

New classes can be created based on an old class.

Classes, Objects, and Packages

What is a Class?

In manufacturing, a blueprint is a description of a device from which many physical devices are constructed

In software, a class is a description of an object

A class describes the data that each object includes

A class describes the behaviour that each object exhibit

In Java, classes support three key features of OOP

encapsulation

inheritance

polymorphism


What is an Object?

An object is an instance of the class. Objects store data and provides method for accessing and modifying this data


data/properties/fields – are the attributes of the object

methods – are functions that manipulate the data

Class: Vehicle Blue Print

Object: Actual Auto

Object: Actual Bus

Object: Actual Jeep

Class Objects

Data

Behaviour

Properties

Methods

Just a description. The concrete working thing.


Declaring Java Classes

<modifier> class <classname> {

<attribute_declaration>

<method_declaration>}

where: <modifier> = public, private, protected

Example:public class Test{ public static int x,y,z; public static void main(String args[]){

System.out.println(“Hello”); }}


Chapter 3 - Object-OrientationChapter 3 - Object-Orientation

Declaring Attributes:

<modifier> <type> <name> [= default value]

where: modifier = public, private, protectedtype = int, float, double, long, short, byte, boolean, char

Example:

public int number = 30;

Chapter 3 - Object-OrientationChapter 3 - Object-Orientation

Declaring Methods:

<modifier> <returnType> <name>(parameters){

<statements>

}

where: modifier = public, private, protected

returnType = int, float, double, long, short, byte,

boolean, char

Example:

public static void main(String args[]){

statements here.....

}


Constructors •Constructors are useful for initializing objects before they are being used.•Parameters can be passed to the constructor in the same way as for a method.

•Constructors are special purpose methods; •a constructor is only used during instantiation to initialize the object and is never used again.

•A constructor must follow the following rules:

1. A constructor's name must be the name of the class.2. A constructor does not have any return type.


Constructors

Syntax:<modifier> <classname>(parameters){

<statements>

}

Example:

String school = new String(“JAVA University”);

String school = new String( );

Instantiating a Class

• Creating Objects:

<class name> <object name> = new <constructor call>;

String school = new String(“JAVA University”);


Accessing Object Members:

The “dot” notation <object>.<member>

This is used to access object members including attributes and methods

Examples:

thing1.setX(47);

thing1.x=47; // valid only if x is public

Continue Here


Packages

Class:Faculty

Class:Student

Package: DMPCS

Object:BSCS

Object:BSAM

Object:BSCS

Object:BSAM

JAVA PACKAGES The standard Java classes are organized into packages.

Packages are a way of grouping related classes to avoid potential naming conflicts.

The standard Java packages are java.lang java.awt java.applet java.awt.image java.awt.peer java.io java.net java.util


Package

Class1 Class 2 Class 3 Class n

Attributes

Methods

Attributes

Methods

Attributes

Methods

Attributes

Methods

class1 class2

class3 class4

class1 class2

class3 class4

package1 package2

Wildcard usage:

import <packagename>.*;

Example:

import package1.*;

Specific usage:

<packagename>.<classname>;

Examples:

package1.class1;

package2.class1;


java.lang package--- contains the various classes that are essential to the definition of the Java language or that, by their nature, need to access the internals of Java in a way that most classes cannot do.

Java.lang classes: Boolean, Byte, Character, Character.Subset, Character.UnicodeBlock, Class, ClassLoader Compiler, Double, Float, InheritableThreadLocal Integer, Long, Math, Number, Object, Package, Process Runtime, RuntimePermission, SecurityManager, Short String, StringBuffer, System, Thread, ThreadGroup ThreadLocal, Throwable and Void

Chapter 3 - Object-OrientationJava.lang package

Objectclone,

finalize, getClass,

notify, notifyAll,

wait, wait, wait

Boolean•booleanValue()•equals(Object obj)•getBoolean(String name)•hashCode()•toString()•toString(boolean b)•valueOf(boolean b)•valueOf(String s)

Number

Byte

String

Double Float

Chapter 3 - Object-OrientationJava.lang package

Class String

charAt(int index) int compareTo(Object o) int compareTo(String anotherString) int compareToIgnoreCase(String str) String concat(String str) static String copyValueOf(char[] data) static String copyValueOf(char[] data, int offset, int count) boolean endsWith(String suffix) boolean equals(Object anObject) booleanequalsIgnoreCase(String anotherString) byte[] getBytes() void getBytes(int srcBegin, int srcEnd, byte[] dst, int dstBegin)


Methods of Class String of the java.lang package

• public int length()

• public char charAt(int index)

• public String substring(int beginIndex, int endIndex)

To create an instance of String:

String proglang = “JAVA”;

To use method length:

x = proglang.length();

ENCAPSULATION


Encapsulation•Is the process of compartmentalizing the elements of an abstraction that constitute its structure and behavior

•It is achieved through information hiding, which is the process of hiding all the secrets of an object that do not contribute to its essential characteristics; typically the structure of an object is hidden, as well as the implementation of the methods.

•Forces the user to use an interface to access data

•Makes the code more maintainable


Information Hiding

- is the process of hiding details of an object/function.

-is designing a method so that it can be used without any need to understand the fine detail of the code.

- An object is composed of a public interface and a private section that can be a combination of internal data and methods. The internal data and methods are the sections of the object hidden.

-The primary benefit is that these sections can change without affecting other parts of the program

ABSTRACTION & ENCAPSULATION

BENEFITS OF ENCAPSULATION



• Modularity. This means that an object can be maintained independently of other objects. Because the source code for the internal sections of an object is maintained separately from the interface, you are free to make modifications with confidence that your object won't cause problems to other areas. This makes it easier to distribute objects throughout a system.

BENEFITS OF ENCAPSULATION


Method and Member VisibilityEncapsulation hides a class internal details for the outside world; if we were to provide getter and setter methods but leave Account class member declaration as public

This is because public allows virtually any one to access the member. By using private, we have effectively closed all members to the outside world.

By doing this, we are enforcing encapsulation.



Java provides the following visibility keywords which can be used on members or methods:

public A method or member that is declared public is accessible from any class.

protected A method or member that is declared protected is accessible only to its subclass and the class itself.

private A private method or member of a class is only accessible from within that class. Other classes including subclass cannot access this member or method.

Keyword Self Subclass Others

Public yes yes yes

Protected yes yes no

Private yes no no


Declaring Java Classes:

public class Thing{

public int x;

Thing (); //we dnt nd }

public class TestThing{

public static void main(String args[]{

Thing thing1 = new Thing();

thing1.x = 47;

System.out.println(“Thing1 = “+ thing1.x);

}

}

Instantiating a Class:


public class Thing{

private int x; public int getter(){ return x; } public void setter(int newx){ x = newx; }}

Public class TestThing{



thing1.x = 47; // invalid

thing1.setter(47);

System.out.println(“Thing1 = “

+ thing1.getter();

}

}


ABSTRACTION


Abstraction denotes the essential characteristics of an object that distinguish it from all other kinds of objects focuses on the outside view of the object

Kinds of AbstractionEntity abstraction – an object that represents a useful model of a problem-domain or solution domain.

Action Abstraction – an object that provides a generalized set of operations, all of which perform the same kind of functions.

More examples


public class Thing{

public int x;

}

public class TestThing{



thing1.x = 47;

System.out.println(“Thing1 = “+ thing1.x);

}

}


public class Thing{

private int x; public int getX(){ return x; } public void setX(int newx){ x = newx; }}

Public class TestThing{



thing1.setX(47);

System.out.println(“Thing1 = “

+ thing1.getX();

}

}



Accessing Object Members:

The “dot” notation <object>.<member>

This is used to access object members including attributes and methods

Examples:

thing1.setX(47)

thing1.x=47; // valid only if x is public


public class Account3 {

private String name;

private int acctNo;

private float balance;

private boolean overdraft;

public Account3(String n, int no) {

name = n;

acctNo = no;

balance = 4000F;

overdraft = false;

}

public void deposit(float amt) { ---- }

public void withdrawal(float amt) { ---- }

public void transfer(Account from, float amt) { ---- }

Information Hiding



public void setName(String n){ name = n; } public String getName(){ return name; } public float getBalance(){ return balance; } public void setAccountNo(int ac){ acctNo = ac; } public int getAccountNo(){ return acctNo; }

public void setOverdraft(boolean x)

{ overdraft = x; } public boolean getOverdraft(){ return overdraft; }}



public class TestAccount3{


Account3 myAccount = new Account3(“Bin", 007);

// System.out.println("This account belongs to: " + myAccount.name);

System.out.println("Account of " + myAccount.getName());

// System.out.println("Current Balance is = "+ myAccount.balance);

System.out.println("Current Balance is ="+myAccount.getBalance());

System.out.println("After withdrawing P2000......");

myAccount.withdrawal(2000);

System.out.println("After withdrawing P100 ......");


// System.out.println("The new balance is = " + myAccount.balance);

System.out.println("The new balance is = " + myAccount.getBalance()); }}


Chapter 3 - Object-OrientationABSTRACTION & ENCAPSULATION

Open Account3.java and TestAccount3.java

Since TestAccount3.java has an object of type Account, compile TestAccount3.java to compile the two files

EXERCISE: Exploring Classes and Objects

More Classes and Objects Examples

Sample Class

public class Account{ public String name; public int acctNo; public float balance; public boolean overdraft;

public void deposit(float amt) { if (amt >= 0) balance += amt; } public void withdrawal(float amt) { if ((amt <= balance) && (amt >= 0)) balance = balance - amt; } public void transfer(Account from, float amt) { if (amt < 0) return; from.withdrawal(amt); deposit(amt); }}


Attributes/Fields

Methods


To instantiate an Account object we use new.

public class TestAccount{ public static void main(String args[]){ Account myAccount = new Account(); myAccount.name = “Bin"; myAccount.acctNo = 007; myAccount.balance = 4000; myAccount.overdraft = false;

System.out.println("Current Balance is = “ + myAccount.balance); System.out.println("After withdrawing P2000......"); myAccount.withdrawal(2000); System.out.println("After withdrawing P100 ......"); myAccount.withdrawal(100); System.out.println("The new balance is = “ + myAccount.balance); }}


class Student {String fname;String lname;int age;String course;public Student(){ } public Student(String f, String l, String c, int a){

fname = f;lname = l;course = c;age = a; }

public Student(String f, String l){fname = f;lname = l;course = "BSCS";age = 20;

}

}

class TestStudent1 {


Student s1 = new Student();

}

}

class Student {String fname; String lname; int age; String course;public Student(){ }

}



Student s2 =new Student("Vic", "Calag", "BSCS", 37);

System.out.println("First Name = "+ s2.fname);

System.out.println("Last Name = "+ s2.lname);

System.out.println("Course = "+ s2.course);

System.out.println("Age = "+ s2.age);

}

}

class Student {String fname; String lname; int age; String course;public Student(String f, String l, String c, int a){

fname = f;lname = l;course = c;age = a; }

}



Student s3 = new Student("Fernando", "Poe");

System.out.println("First Name = "+ s3.fname);

System.out.println("Last Name = "+ s3.lname);

System.out.println("Course = "+ s3.course);

System.out.println("Age = "+ s3.age);

} }

class Student {String fname; String lname; int age; String course;public Student(String f, String l){

fname = f;lname = l;course = "BSCS";age = 20;

}}


public class Account2 { public String name; public int acctNo; public float balance; public boolean overdraft; public Account2(String n, int no) { name = n;

acctNo = no; balance = 4000F; overdraft = false; } public void deposit(float amt) public void withdrawal(float amt) public void transfer(Account from, float amt)

}


public class TestAccount2 {


Account2 myAccount = new Account2("Bin", 007);

// myAccount.name = "Bin"; myAccount.acctNo = 007;

// myAccount.balance = 4000; myAccount.overdraft = false;

System.out.println("This account belongs to: "+ myAccount.name);

System.out.println("Current Balance is = "+ myAccount.balance);





System.out.println("The new balance is = " + myAccount.balance);

}

}


public class Account3 { public String name; public int acctNo; public float balance; public boolean overdraft; public Account3(String n, int no, float bal, boolean od) { name = n;

acctNo = no; balance = bal; overdraft = od; } public void deposit(float amt) public void withdrawal(float amt) public void transfer(Account from, float amt)

}


public class TestAccount3 {


Account3 myAccount = new Account3("Bin", 007, 5000,true);

// myAccount.name = "Bin"; myAccount.acctNo = 007;

// myAccount.balance = 5000; myAccount.overdraft = true;

System.out.println("This account belongs to: "+ myAccount.name);

System.out.println("Current Balance is = "+ myAccount.balance);





System.out.println("The new balance is = " + myAccount.balance);

}

}

object oriented programming concepts using java

Education

new object

object includesa class

new type of object

class queue

class stack

objectorientedvoid main

object exhibitin java

public static int x