Download JAVA Programming MSc IT and more Study notes Object Oriented Programming in PDF only on Docsity!
Object Oriented Programming Using JAVA
Handouts
- Object & Classes...................................................................................................................................... Table of Contents
- Constructor
- Abstraction
- Encapsulation
- Inheritance
- HAS-A Relationship:
- Single Inheritance
- Multiple Inheritance
- Multilevel Inheritance
- Hierarchical Inheritance
- Hybrid inheritance
- Up-casting & Down-casting.................................................................................................................
- Up-casting:
- Down-casting:
- Interfaces
- Wrapper Classes, Boxing & Unboxing, Packages
- Wrapper Classes
- Boxing & Unboxing
- Packages
- Exceptions
- Input/Output Streaming
- Reading Text File
- Writing to Text File
- Java Collection
- For-each loop
- Some important Programs
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 } }
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() { System. out .println("Name s :"+name); System. out .println("age is :"+age); } public static void main (String[] arrgs) { 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.
public class student { 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 { 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 Declaration obj.setData("abc", 10); // Method Calling using object obj.getData(); // Method Calling using object }
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 } }
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:
public static void main (String[] arrgs) // Main function { 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(); } }
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 { public static void main (String[] arrgs) // Main function { 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.*;
catch (Exception ex) { System. out .println("Error writing to file"); } } public static void main (String[] arrgs) { 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:
public static void main (String[] arrgs) { 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; }
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; private JLabel lable2; private JLabel lable3; private JLabel lable4; 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); lable3.setBounds(20, 200, 100, 50); lable4.setBounds(20, 350, 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=no1no2; break ; case "/": if (no2>0) ans=no1/no2; else ans=0; break ; default : ans=0;
