Object Oriented Programming using JAVA Notes

Prof. Uzair Salman Object Oriented Programming Using JAVA
Superior Group of Collage Jauharabad 1 | P a g e
Object Oriented Programming Using JAVA
Handouts
Table of Contents
Object & Classes......................................................................................................................................2
Constructor .............................................................................................................................................3
Abstraction..............................................................................................................................................3
Encapsulation..........................................................................................................................................4
Inheritance..............................................................................................................................................5
HAS-A Relationship: ............................................................................................................................6
 Single Inheritance....................................................................................................................6
 Multiple Inheritance................................................................................................................7
 Multilevel Inheritance .............................................................................................................7
 Hierarchical Inheritance ..........................................................................................................8
 Hybrid inheritance...................................................................................................................8
Up-casting & Down-casting.................................................................................................................9
Up-casting: ......................................................................................................................................9
Down-casting: .................................................................................................................................9
Interfaces ..............................................................................................................................................10
Wrapper Classes, Boxing & Unboxing, Packages..................................................................................11
 Wrapper Classes........................................................................................................................11
 Boxing & Unboxing....................................................................................................................12
 Packages....................................................................................................................................12
Exceptions.............................................................................................................................................12
Input/Output Streaming .......................................................................................................................13
 Reading Text File .......................................................................................................................14
 Writing to Text File....................................................................................................................15
Java Collection ......................................................................................................................................16
For-each loop........................................................................................................................................17
Some important Programs....................................................................................................................17

Object & Classes
A class is a blueprint or template or set of instructions to build a specific type of
object. Every object is built from a class. Each class should be designed and
programmed to accomplish some tasks.
The term ‘object’, however, refers to an actual instance of a class. Every object
must belong to a class. Objects are created and eventually destroyed – so they
only live in the program for a limited time.
Or
Object - Objects have states and behaviors. Example: A CAR has states - color,
model, speed as well as behaviors –accelerate, break. An object is an instance
of a class.
Class - A class can be defined as a template/blue print that describes the
behaviors/states that object of its type support.
Following Example illustrate class and object declaration:
public class student {
String name; //Data Members
int age; //Data Members
public void setData(String n, int a) //Member Functions
{
name = n;
age = a;
}
public void getData() //Member Functions
{
System.out.println("Name s :"+name);
System.out.println("age is :"+age);
}
public static void main (String[] arrgs) // Main function
{
student obj=new student(); // Object Creation
obj.setData("abc", 10); // Method Calling using object
obj.getData(); // Method Calling using object
}
}

Constructor
Constructor is a function in any class that is used to initialize data variables.
Every class has a constructor. If we do not explicitly write a constructor for a
class the Java compiler builds a default constructor for that class. Each time a
new object is created, at least one constructor will be invoked. The main rule of
constructors is that they should have the same name as the class and have no
return type. A class can have more than one constructor.
Example:
Abstraction
Abstraction is a process of hiding the implementation details from the user, only
the functionality will be provided to the user. An abstract class is one that cannot
be instantiated. All their functionality of the class still exists, and its fields,
methods, and constructors are all accessed in the same manner. You just cannot
create an instance of the abstract class. In Java Abstraction is achieved using
Abstract classes, and Interfaces.
Example:
String name;
int age;
public student() //constructor
{
name="abc";
age=0;
}
public void show()
{
}
public static void main (String[] arrgs)
{
student obj=new student();// constructor automatically calls
obj.show();
}
}

Encapsulation
Encapsulation in Java is a mechanism of wrapping the data (variables) and code
acting on the data (methods) together as single unit. In encapsulation the
variables of a class will be hidden from other classes, No outside class can access
private data member (variable) of other class. However if we setup public getter
and setter methods to update and read the private data fields then the outside
class can access those private data fields via public methods. This way data can
only be accessed by public methods thus making the private fields and their
implementation hidden for outside classes. That’s why encapsulation is known
as data hiding.
Example:
public abstract class student { // making class abstract using abstract keyword
String name;
int age;
public void setData(String n, int a)
{
name= n;
age= a;
}
public void getData()
{
}
{
student obj=new student(); /* Following is not allowed and raise error */
obj.show();
}
}

Inheritance
Inheritance can be defined as the process where one class acquires the
properties (methods and fields) of another. With the use of inheritance the
information is made manageable in a hierarchical order. In other words, the
derived class inherits the states and behaviors from the base class. The derived
class is also called subclass and the base class is also known as super-class. The
derived class can add its own additional variables and methods. These additional
variable and methods differentiates the derived class from the base class.
When we talk about inheritance, the most commonly used keyword would be
extends and implements. The superclass and subclass have “is-a” relationship
between them.
IS-A Relationship:
IS-A is a way of saying: This object is a type of that object. Let us see how the
extends keyword is used to achieve inheritance.
private String name; //Private Data Members
private int age; //private Data Members
public student() //constructor
{
name="abc";
age=0;
}
public void setData(String n, int a) //Member Functions
{
name = n;
age = a;
}
public void getData() //Member Functions
{
}
{
student obj=new student(); // Object Declaration
obj.setData("abc", 10); // Method Calling using object
obj.getData(); // Method Calling using object
}

Now, if we consider the 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
HAS-A Relationship:
Composition (HAS-A) simply mean use of instance variables that are references
to other objects. For example: Honda has Engine, or House has Bathroom.
Types of inheritance in Java:
Below are various types of inheritance in Java.
 Single Inheritance
Single inheritance is damn easy to understand. When a class extends
another one class only then we call it a single inheritance. The below flow
diagram shows that class B extends only one class which is A. Here A is a
parent class of B and B would be a child class of A.
public class Animal{
}
public class Mammal extends Animal{
}
public class Reptile extends Animal{
}
public class Dog extends Mammal{
}
CAR
Engine
IS-A
HAS-AHonda

Example:
 Multiple Inheritance
Multiple Inheritance” refers to the concept of one class extending (Or
inherits) more than one base class. Multiple Inheritance is very rarely used
in software projects. Using multiple inheritance often leads to problems
in the hierarchy. Most of the new OOP languages like Small Talk, Java, C#
do not support Multiple inheritance. Multiple Inheritance is supported in
C++.
 Multilevel Inheritance
Multilevel inheritance refers to a mechanism in OOP where one can inherit
from a derived class, thereby making this derived class the base class for the
new class. As you can see in below flow diagram C is subclass or child class of
B and B is a child class of A.
Example:
public class A
{
public void methodA()
{
System.out.println("Base class method");
}
}
public class B extends A
{
public void methodB()
{
System.out.println("Child class method");
}
public static void main(String args[])
{
B obj = new B();
obj.methodA(); //calling super class method
obj.methodB(); //calling local method
}
}

 Hierarchical Inheritance
In such kind of inheritance one class is inherited by many sub classes. In
below example class B,C and D inherits the same class A.
 Hybrid inheritance
Hybrid inheritance is a combination of Single and Multiple inheritance. A
hybrid inheritance can be achieved in the java in a same way as
multiple inheritance can be!! Using interfaces. By using interfaces you can
have multiple as well as hybrid inheritance in Java.
class A
{
public void methodA()
{
System.out.println("Class A method");
}
}
class B extends A
{
public void methodB()
{
System.out.println("class B method");
}
}
class C extends B
{
public void methodC()
{
System.out.println("class C method");
}
public static void main(String arrgs[])
{
C obj = new C();
obj.methodA(); //calling grand parent class method
obj.methodB(); //calling parent class method
obj.methodC(); //calling local method
}
}

Up-casting & Down-casting
Casting in java means converting from type to type. When it comes to the talking
about up-casting and down-casting concepts we are talking about converting
the objects references types between the child type classes and parent type
class. Suppose that we have three classes (A, B, C). Class B inherit from class A.
Class C inherit from class B. As follows
Up-casting:
The up casting is casting from the child class to base class. The up casting in java
is implicit which means that you don't have to put the braces (type) as an
indication for casting. Below is an example of up casting where we create a new
instance from class C and pass it to a reference of type A. Then we call the
function display.
Down-casting:
The up casting is casting from the base class to child class. The down-casting in
java is explicit which means that you have to put the braces (type) as an
indication for casting. Below is an example of down-casting
class A
{
void display(){}
}
class B implements A
{
public void display() {
System.out.println("Am in class B");
}
}
class C extends B
{
System.out.println("Am in class C");
}
}
{
A obj=new C(); // up-casting from subclass to super class
obj.display(); // Method Calling of class C
}

Interfaces
Interface looks like class but it is not a class. An interface can have methods and
variables just like the class but the methods declared in interface are by default
abstract (only method signature, no body). Also, the variables declared in an
interface are public, static & final by default. We cannot instantiate an interface.
Also an interface does not have any constructor.
Since methods in interfaces are abstract and do not have body, they have to be
implemented by the class before you can access them. The class that
implements interface must implement all the methods of that interface. Also,
java programming language does not support multiple inheritances, using
interfaces we can achieve this as a class can implement more than one
interfaces.
Key Points:
 We can’t instantiate an interface in java.
 Interface provides complete abstraction as none of its methods can have
body.
 Implements keyword is used by classes to implement an interface.
 Any interface can extend any other interface but cannot implement it.
Class implements interface and interface extends interface.
 A class can implements any number of interfaces.
 An interface is written in a file with a .java extension, with the name of
the interface matching the name of the file.
 The interface keyword is used to declare an interface.
Example:
{
A obj=new C(); // upcasting from subclass to
super class
obj.display(); // Method Calling of class C
B objB=(B) obj; //Downcasting of reference to
subclass reference
objB.display(); //method calling of class C
}

Wrapper Classes, Boxing & Unboxing, Packages
 Wrapper Classes
Each of Java's eight primitive data types (int, byte, shot, long, float, double,
Boolean, char) has a class dedicated to it. These are known as wrapper classes,
because they "wrap" the primitive data type into an object of that class. So there
is an Integer class that holds an int variable, there is a Double class that holds a
double variable, and so on. The wrapper classes are part of the java.lang
package, which is imported by default into all Java programs.
The following two statements illustrate the difference between a primitive
data type and an object of a wrapper class:
int x = 25;
Integer y = new Integer(33);
interface vehicle
{
/* All of the methods are abstract by default */
public void accelerate();
public void breaking();
}
class CAR implements vehicle
{
public void accelerate() {
System.out.println("Car is accelerating");
}
public void breaking() {
System.out.println("Break applied");
}
public static void main(String[] arrgs)
{
CAR obj=new CAR(); //object of Class CAR
obj.accelerate();
obj.breaking();
}
}

The first statement declares an int variable named x and initializes it with the
value 25. The second statement instantiates an Integer object. The object is
initialized with the value 33 and a reference to the object is assigned to the
object variable y.
 Boxing & Unboxing
o Conversion of a primitive type to the corresponding reference type is
called boxing, such as an int to a java.lang.Integer.
o Conversion of the reference type to the corresponding primitive type is
called unboxing, such as Byte to byte.
 Packages
Packages are used in Java in order to prevent naming conflicts, to control
access, to make searching/locating and usage of classes, interfaces,
enumerations and annotations easier, etc. A Package can be defined as a
grouping of related types (classes, interfaces, enumerations and annotations)
providing access protection and name space management.
Some of the existing packages in Java are::
o java.lang - bundles the fundamental classes
o java.io - classes for input , output functions are bundled in this package
Programmers can define their own packages to bundle group of
Classes/interfaces, etc.
Exceptions
An exception (or exceptional event) is a problem that arises during the execution
of a program. When an Exception occurs the normal flow of the program is
disrupted and the program terminates abnormally, therefore these exceptions
are to be handled. An exception can occur for many different reasons, below
given are some scenarios where exception occurs.
o A user has entered invalid data.
o A file that needs to be opened cannot be found.

A method catches an exception using a combination of the try and catch
keywords. A try/catch block is placed around the code that might generate an
exception. The syntax for using try/catch looks like the following:
try{
//Do something
}
catch(Exception ex)
{
//Catch exception hare using exception argument ex
}
The code which is prone to exceptions is placed in the try block, when an
exception occurs, that exception occurred is handled by catch block associated
with it.
Example:
public class ExceptionSample {
{
int no1, no2; //Data variables
no1=5; //Contain some value
no2=0; //contain some value
try // Try block
{
System.out.println(no1/no2); //attempt to divide number
by 0
}
catch (Exception ex) // Catch block receive exception
{
/* Display exception message */
System.out.println("Error with defination:
"+ex.getMessage()); }
}
}
Input/Output Streaming
The java.io package contains nearly every class you might ever need to
perform input and output (I/O) in Java. All these streams represent an input
source and an output destination. A stream can represent many different
kinds of sources and destinations, including disk files, devices, other programs,
and memory arrays. Streams support many different kinds of data, including
simple bytes, primitive data types, localized characters, and objects. Some

streams simply pass on data; others manipulate and transform the data in
useful ways.
1: Reading information into program using StreamReader
2: Writing information from program using StreamWriter
You can read files using these classes:
• FileReader for text files in your system's default encoding (for example,
files containing Western European characters on a Western European
computer).
• FileInputStream for binary files and text files that contain 'weird'
characters
FileReader (for text files) should usually be wrapped in a BufferedFileReader.
This saves up data so you can deal with it a line at a time or whatever instead of
character by character. If you want to write files, basically all the same stuff
applies, except you'll deal with classes named FileWriter with
BufferedFileWriter for text files, or FileOutputStream for binary files.
 Reading Text File
If you want to read an ordinary text file in your system's default encoding, use
FileReader and wrap it in a BufferedReader. In the following program, we read
a file called "myFile.txt" and output the file line by line on the console.
import java.io.*;

public class fileHandling {
String textFile;
String line;
public void ReadTextFile(String FileName)
{
textFile = FileName;
try {
FileReader Reader = new FileReader(textFile);
BufferedReader bufferedReader = new BufferedReader(Reader);
while((line = bufferedReader.readLine()) != null) {
System.out.println(line);
}
bufferedReader.close(); // close files.
}
catch(Exception ex) {
System.out.println("Error Reading File");
}
}
{
fileHandling obj=new fileHandling();
obj.ReadTextFile("c:MyFile.txt");
}
}
 Writing to Text File
To write a text file in Java, use FileWriter instead of FileReader, and
BufferedOutputWriter instead of BufferedOutputReader. Here's an
example program that creates a file called 'temp.txt' and writes some lines
of text to it.
import java.io.*;
public class fileHandling {
String textFile;
public void WriteFile(String File)
{
textFile = File;
try {
FileWriter Writer = new FileWriter(textFile);
BufferedWriter bufferedWriter =new BufferedWriter(Writer);
bufferedWriter.write("Hello there,");
bufferedWriter.newLine();
bufferedWriter.write("We are writing");
bufferedWriter.close(); // Always close files.
}

catch(Exception ex) {
System.out.println("Error writing to file");
}
}
{
fileHandling obj=new fileHandling();
obj.WriteFile("c:MyFile.txt");
}
}
Java Collection
Collections in java is a framework that provides an architecture to store and
manipulate the group of objects. All the operations that you perform on a
data such as searching, sorting, insertion, manipulation, deletion etc. can be
performed by Java Collections.
Java Collection simply means a single unit of objects. Java Collection
framework provides many interfaces (Set, List, Queue, Deque etc.) and
classes (ArrayList, Vector, LinkedList, PriorityQueue, HashSet, LinkedHashSet,
TreeSet etc).

For-each loop
Anew way of iteration was introduced in Java 5 and offers a more convenient
way of iterating over arrays and collections. It is an extension to the classic
for loop and it is widely known as “enhanced for” or “for-each”. The main
difference between the classic for loop and the new loop is the fact that it
hides the iteration variable. As a result, usage of the for-each loop leads to a
more readable code with one less variable to consider each time we want to
create a loop thus the possibility of ending up with a logic error is smaller.
We can use it over both arrays and collections.
Example:
{
ArrayList arr=new ArrayList();
arr.add("A");
arr.add("B");
arr.add("C");
arr.add("D");
arr.add("E");
//Using foreach over collection
for (Object s : arr) {
System.out.println(s);
}
Some important Programs
 Write a program that has three fields hours, minute, second. To initialize
these fields it has constructor getter and setter methods, and a print time
method to display time. Also override toString method in this class.
public class TimeClass{
private int hour;
private int minute;
private int second;
public TimeClass()
{
hour = minute = second = 0;
}

public void setter(int h, int m, int s)
{
if ( ( h >= 0 && h < 24 ) && ( m >= 0 && m < 60 ) && ( s >= 0 && s < 60 ) )
{
hour = h;
minute = m;
second = s;
}
}
public int getHour() {
return hour;
}
public int getMinute() {
return minute;
}
public int getSecond() {
return second;
}
public String toString()
{
return String.format( "%d:%02d:%02d %s",
( ( hour == 0 || hour == 12 ) ? 12 : hour % 12 ),
minute, second, ( hour < 12 ? "AM" : "PM" ) );
} // end method toString
public static void main(String[] arrgs)
{
TimeClass obj=new TimeClass();
obj.setter(12, 36, 25); // set time to 12:36:25
System.out.println(obj.toString()); // output: 12:36:25 PM
}
}
 Write a java program that has two classes point and circle. Circle class
extends point class. Demonstration up casting by using circle class.
class point
{
System.out.println("method of class point");
}
}
class Circle extends point
{
System.out.println("method of class circle");
}
{

point obj=new Circle(); // up-casting from subclass to super
class
obj.display(); // Method Calling of class circle
}
}
 Use java swing library to create a simple four function arithmetic
calculator
import java.awt.event.*;
import javax.swing.*;
public class LoanCalc extends JFrame{
private JButton btnCalc;
private JTextField number1;
private JTextField number2;
private JTextField op;
private JTextField result;
private JLabel lable1;
LoanCalc()
{
setTitle("Basic Calculator");
setBounds(200,200,400,500);
btnCalc=new JButton("Calculate");
number1=new JTextField();
number2=new JTextField();
op=new JTextField();
result=new JTextField();
lable1=new JLabel("First Number");
lable2=new JLabel("Second Number");
lable3=new JLabel("Operation");
lable4=new JLabel("Result");
setLayout(null);
number1.setBounds(120, 100, 200, 50);
number2.setBounds(120, 150, 200, 50);
op.setBounds(120, 200, 200, 50);
result.setBounds(120, 350, 200, 50);
lable1.setBounds(20,100, 100,50);
lable2.setBounds(20, 150, 100, 50);

btnCalc.setBounds(150, 280, 100, 50);
btnCalc.addActionListener(new listner());
btnCalc.setActionCommand("Calculate");
add(number1);
add(number2);
add(op);
add(result);
add(btnCalc);
add(lable1);
add(lable2);
add(lable3);
add(lable4);
}
public class listner implements ActionListener
{
@Override
public void actionPerformed(ActionEvent e) {
// TODO Auto-generated method stub
String btn=e.getActionCommand();
int no1,no2, ans=0;
String opration;
if(btn=="Calculate")
{
no1= Integer.parseInt(number1.getText());
no2= Integer.parseInt(number1.getText());
opration= op.getText();
switch (opration) {
case "+":
ans=no1+no2;
break;
case "-":
ans=no1-no2;
break;
case "*":
ans=no1*no2;
break;
case "/":
if(no2>0)
ans=no1/no2;
else
ans=0;
break;
default:
ans=0;

break;
}
result.setText(Integer.toString(ans));
}
}
}
}

Object Oriented Programming using JAVA Notes

Recommended

More Related Content

What's hot (20)

Viewers also liked (20)

Similar to Object Oriented Programming using JAVA Notes (20)

Recently uploaded (20)

Object Oriented Programming using JAVA Notes