Objects represent some concepts or things and like any other objects in the real Objects in programming language have certain behavior, properties, type, and identity. In OOP based language the principal aim is to find out the objects to manipulate and their relation between each other. OOP offers greater flexibility and compatibility and is popular in developing larger application.
Java is a object oriented programming and to understand the functionality of OOP in Java, we first need to understand several fundamentals related to objects. These include class, method, inheritance, encapsulation, abstraction, polymorphism etc.
Class - It is the central point of OOP. In Java everything happens within class and it describes a set of objects with common behavior. The class definition describes all the properties, behavior, and identity of objects present within that class. A class is the blueprint from which individual objects are created.
In the real world, you'll often find many individual objects all of the same kind. There may be thousands of other bicycles in existence, all of the same make and model. Each bicycle was built from the same set of blueprints and therefore contains the same components
The following Bicycle class is one possible implementation of a bicycle:
class Bicycle {
-- Variable declartions
int cadence = 0;
int speed = 0;
int gear = 1;
-- Below are the methods like our procedure/functions in plsql
void changeCadence(int newValue) {
cadence = newValue;
}
void changeGear(int newValue) {
gear = newValue;
}
void speedUp(int increment) {
speed = speed + increment;
}
void applyBrakes(int decrement) {
speed = speed - decrement;
}
void printStates() {
System.out.println("cadence:"+cadence+" speed:"+speed+" gear:"+gear);
}
}
/* public static int is a function returning int.
public static void is a procedure */
OBJECTS - Objects are key to understanding object-oriented technology. Look around right now and you'll find many examples of real-world objects: your dog, your bicycle.
Real-world objects share two characteristics: They all have state and behavior. Dogs have state (name, color, breed, hungry) and behavior (barking, fetching, wagging tail). Bicycles also have state (current gear, current pedal cadence, current speed) and behavior (changing gear, changing pedal cadence, applying brakes). Identifying the state and behavior for real-world objects is a great way to begin thinking in terms of object-oriented programming.
class BicycleDemo {
public static void main(String[] args) {
// Create two different Bicycle objects
-- This is the syntax to create a object for any class.
Bicycle bike1 = new Bicycle();
Bicycle bike2 = new Bicycle();
// Invoke methods on those objects.we can acees all the methods and variables in the class using the object.
bike1.changeCadence(50);
bike1.speedUp(10);
bike1.changeGear(2);
bike1.printStates();
bike2.changeCadence(50);
bike2.speedUp(10);
bike2.changeGear(2);
bike2.changeCadence(40);
bike2.speedUp(10);
bike2.changeGear(3);
bike2.printStates();
}
}
Methods - We know that a class can define both attributes and behaviors. Again attributes are defined by variables and behaviors are represented by methods. In other words, methods define the abilities of an object.
Inheritance - In object oriented programming classes can inherit some common behavior and state from others. Object-oriented programming allows classes to inherit commonly used state and behavior from other classes. In this example, Bicycle now becomes the superclass of MountainBike, RoadBike, and TandemBike. In the Java programming language, each class is allowed to have one direct superclass, and each superclass has the potential for an unlimited number of subclasses:
Bicycle
/ | \
/ Road \
Mount Bike \
Bike \
tandem Bike
Mountain bikes, road bikes, and tandem bikes, for example, all share the characteristics of bicycles (current speed, current pedal cadence, current gear). Yet each also defines additional features that make them different: tandem bicycles have two seats and two sets of handlebars; road bikes have drop handlebars; some mountain bikes have an additional chain ring, giving them a lower gear ratio.
class MountainBike extends Bicycle {
// new fields and methods defining a mountain bike would go here
// the MountainBike subclass adds one field
public int seatHeight;
/* the MountainBike subclass has one constructor.Constructors are similar to methods, but with some important differences.
• Constructor name is class name. A constructors must have the same name as the class its in.
• Default constructor. If you don't define a constructor for a class, a default parameterless constructor is automatically created by the compiler. The default constructor calls the default parent constructor (super()) and initializes all instance variables to default value (zero for numeric types, null for object references, and false for booleans).
public MountainBike(int startHeight, int startCadence, int startSpeed, int startGear) {
super(startCadence, startSpeed, startGear);
seatHeight = startHeight;
}
// the MountainBike subclass adds one method
public void setHeight(int newValue) {
seatHeight = newValue;
}
}
Extends is the key word for inheriting a class.
This gives Mountain Bike all the same fields and methods as Bicycle, yet allows its code to focus exclusively on the features that make it unique.
Abstraction - The process of abstraction in Java is used to hide certain details and only show the essential features of the object. In other words, it deals with the outside view of an object (interface).
Abstraction in Java allows the user to hide non-essential details relevant to user.
To explain you this with an example.i will do that with acess specifiers.
Encapsulation :Encapsulation is the technique of making the fields in a class private and providing access to the fields via public methods. If a field is declared private, it cannot be accessed by anyone outside the class, thereby hiding the fields within the class. For this reason, encapsulation is also referred to as data hiding.
Encapsulation can be described as a protective barrier that prevents the code and data being randomly accessed by other code defined outside the class. Access to the data and code is tightly controlled by an interface.
Below is a table showing the effects of access specifiers for class members. “Y” means yes. Blank means No.
Specifier class subclass package world
private Y
protected Y Y Y
public Y Y Y Y
(none) Y Y
/* File name : EncapTest.java */
public class EncapTest{
private String name;
private String idNum;
private int age;
public int getAge(){
return age;
}
}
Here in the above example Variables/attributes are not accessible but methods are.
Polymorphism – Polymorphism is the ability of an object to take on many forms.I can have a same method name for many bt changing the calling parameters.
Here is example
class hai
{
public void saysomething(int newValue) {
s.o.p(‘Hai’);//s.o.p-> system.out.println
}
}
class hai
{
public void saysomething (int newValue,int oldValue) {
s.o.p(‘Bye’);;
}
}
I have same method name in the class.
This Is End of OOPS Concepts.
collection concepts: We definitely need this for ADF.
As the name indicates, collections is a group of objects known as its elements. Basically it is a package of data structures that includes ArrayLists, LinkedLists, HashSets, etc. A collection is simply an object that groups multiple elements into a single unit. It is also called as a container sometimes. It is used to store, retrieve, manipulate, and communicate aggregate data. Typically, it represents data items that form a natural group and allows duplicate elements while others do not. It consists of both ordered and unordered elements.
ArrayLists example:
/*
Java ArrayList example.
This Java ArrayList example describes the basic operations performed on the ArrayList.
*/
import java.util.ArrayList;
import java.util.Iterator;
public class ArrayListExample{
public static void main(String args[]){
// constructs a new empty ArrayList
ArrayList arrayList = new ArrayList();
/*
To specify initial capacity, use following constructor.
ArrayList ArrayList = new ArrayList(100);
To create ArrayList from Collection use following constructor
ArrayList ArrayList = new ArrayList(Collection collection);
In this case the initial capacity would be 110% of the size of the collection.
*/
/*
To add value into ArrayList use add() method.
Signature of the add() method is,
boolean add(Object object)
The value would be appended to the list.
To insert value into ArrayList at particular index, use
void add(int index, Object object)
This method will shifts the subsequent elements of the list.
To append all elements of the collection to existing list, use
boolean addAll(Collection c)
To insert all elements of the collection into existing list, use
boolean addAll(int index, Collection collection)
To replace particular element in the ArrayList, use
Object set(int index, Object value)
It returns the previous element present at the specified index.
*/
arrayList.add(new Integer(1)); //adding value to ArrayList
arrayList.add(new Integer(2));
arrayList.add(new Integer(3));
/*
IMPORTANT : We CAN NOT add primitives to the ArrayList. We have to wrap it
into one of the wrapper classes before adding.
*/
//get number of keys present in the ArrayList
System.out.println("ArrayList contains " + arrayList.size() + " elements.");
/*
To check whether ArrayList is empty or not, use isEmpty() method.
isEmpty() returns true is ArrayList is empty, otherwise false.
Finding particular value from the ArrayList:
ArrayList's contains() method returns boolean depending upon the
presence of the value in given ArrayList.
Signature of the containsValue method is,
boolean contains(Object value)
*/
if( arrayList.contains( new Integer(1) ) ){
System.out.println("ArrayList contains 1 as value");
}else{
System.out.println("ArrayList does not contain 1 as value");
}
/*
Use get method of ArrayList to get value.
Signature of the get method is,
Object get(int index)
*/
Integer one = (Integer) arrayList.get(0);
System.out.println("Value at 0 index is " + one);
/*
IMPORTANT: get method returns Object, so we need to downcast it.
*/
/*
To search element within the ArrayList, use
int indexOf(Object element)
it returns the index of first occurrence of the specified element.
To find last occurrence of the specified element, use
int lastIndexOf(Object element)
*/
System.out.println("Index of first occurrence of 1 is " + arrayList.indexOf(new Integer(1)));
/*
To convert ArrayList to object array, use
Object[] toArray() method.
This method returns an Object array containing all elements of the ArrayList
in the correct order.
*/
System.out.println("Converting ArrayList to Object array");
Object[] elements = arrayList.toArray();
for(int i=0; i < elements.length ; i++) System.out.println(elements[i]); /* To remove particular element from the ArrayList use, Object remove(int index) It returns the element that was removed from the list. To remove multiple elements from the ArrayList use, void removeRange(int fromIndex, int toIndex). It removes elements from the list whose index is between startIndex (inclusive) and toIndex(Exclusive). To remove all elements of the ArrayList use, void clear(). It removes all elements of the ArrayList. */ System.out.println("Is 1 removed from the ArrayList ? " + arrayList.remove(new Integer(1))); } } /* OUTPUT of the above given Java ArrayList Example would be: ArrayList contains 3 key value pair. ArrayList contains 1 as value Value at 0 index is 1 Index of first occurrence of 1 is 0 Converting ArrayList to Object array 1 2 3 Is 1 removed from the ArrayList ? true */ LinkedList Example: import java.util.*; public class LinkedListExample{ public static void main(String[] args) { System.out.println("Linked List Example!"); LinkedList
int num1 = 11, num2 = 22, num3 = 33, num4 = 44;
int size;
Iterator iterator;
//Adding data in the list
list.add(num1);
list.add(num2);
list.add(num3);
list.add(num4);
size = list.size();
System.out.print( "Linked list data: ");
//Create a iterator
iterator = list.iterator();
while (iterator.hasNext()){
System.out.print(iterator.next()+" ");
}
System.out.println();
//Check list empty or not
if (list.isEmpty()){
System.out.println("Linked list is empty");
}
else{
System.out.println( "Linked list size: " + size);
}
System.out.println("Adding data at 1st location: 55");
//Adding first
list.addFirst(55);
System.out.print("Now the list contain: ");
iterator = list.iterator();
while (iterator.hasNext()){
System.out.print(iterator.next()+" ");
}
System.out.println();
System.out.println("Now the size of list: " + list.size());
System.out.println("Adding data at last location: 66");
//Adding last or append
list.addLast(66);
System.out.print("Now the list contain: ");
iterator = list.iterator();
while (iterator.hasNext()){
System.out.print(iterator.next()+" ");
}
System.out.println();
System.out.println("Now the size of list: " + list.size());
System.out.println("Adding data at 3rd location: 55");
//Adding data at 3rd position
list.add(2,99);
System.out.print("Now the list contain: ");
iterator = list.iterator();
while (iterator.hasNext()){
System.out.print(iterator.next()+" ");
}
System.out.println();
System.out.println("Now the size of list: " + list.size());
//Retrieve first data
System.out.println("First data: " + list.getFirst());
//Retrieve lst data
System.out.println("Last data: " + list.getLast());
//Retrieve specific data
System.out.println("Data at 4th position: " + list.get(3));
//Remove first
int first = list.removeFirst();
System.out.println("Data removed from 1st location: " + first);
System.out.print("Now the list contain: ");
iterator = list.iterator();
//After removing data
while (iterator.hasNext()){
System.out.print(iterator.next()+" ");
}
System.out.println();
System.out.println("Now the size of list: " + list.size());
//Remove last
int last = list.removeLast();
System.out.println("Data removed from last location: " + last);
System.out.print("Now the list contain: ");
iterator = list.iterator();
//After removing data
while (iterator.hasNext()){
System.out.print(iterator.next()+" ");
}
System.out.println();
System.out.println("Now the size of list: " + list.size());
//Remove 2nd data
int second = list.remove(1);
System.out.println("Data removed from 2nd location: " + second);
System.out.print("Now the list contain: ");
iterator = list.iterator();
//After removing data
while (iterator.hasNext()){
System.out.print(iterator.next()+" ");
}
System.out.println();
System.out.println("Now the size of list: " + list.size());
//Remove all
list.clear();
if (list.isEmpty()){
System.out.println("Linked list is empty");
}
else{
System.out.println( "Linked list size: " + size);
}
}
}
HashMap Example.
*
Java HashMap example.
This Java HashMap example describes the basic operations performed on the HashMap.
*/
import java.util.HashMap;
import java.util.Iterator;
public class HashMapExample{
public static void main(String args[]){
// constructs a new empty HashMap with default initial capacity
HashMap hashMap = new HashMap();
/*
To specify initial capacity, use following constructor
HashMap HashMap = new HashMap(100);
To create HashMap from map use following constructor
HashMap HashMap = new HashMap(Map myMap);
*/
hashMap.put("One", new Integer(1)); // adding value into HashMap
hashMap.put("Two", new Integer(2));
hashMap.put("Three", new Integer(3));
/*
IMPORTANT : We CAN NOT add primitives to the HashMap. We have to wrap it into
one of the wrapper classes before adding.
*/
/*
To copy all key - value pairs from any Map to HashMap use putAll method.
Signature of putAll method is,
void putAll(Map m)
*/
//get number of keys present in the HashMap
System.out.println("HashMap contains " + hashMap.size() + " key value pairs.");
/*
To check whether HashMap is empty or not, use isEmpty() method.
isEmpty() returns true is HashMap is empty, otherwise false.
/*
Finding particular value from the HashMap:
HashMap's containsValue method returns boolean depending upon
the presence of the value in given HashMap
Signature of the containsValue method is,
boolean containsValue(Object value)
*/
if(hashMap.containsValue(new Integer(1))){
System.out.println("HashMap contains 1 as value");
}else{
System.out.println("HashMap does not contain 1 as value");
}
/*
Finding particular Key from the HashMap:
HashMap's containsKey method returns boolean depending upon the
Presence of the key in given HashMap
Signature of the method is,
boolean containsKey(Object key)
*/
if( hashMap.containsKey("One") ){
System.out.println("HashMap contains One as key");
}else{
System.out.println("HashMap does not contain One as value");
}
/*
Use get method of HashMap to get value mapped to particular key.
Signature of the get method is,
Object get(Object key)
*/
Integer one = (Integer) hashMap.get("One");
System.out.println("Value mapped with key \"One\" is " + one);
/*
IMPORTANT: get method returns Object, so we need to downcast it.
*/
/*
To get all keys stored in HashMap use keySet method
Signature of the keysSet method is,
Set keySet()
*/
System.out.println("Retrieving all keys from the HashMap");
Iterator iterator = hashMap.keySet().iterator();
while(iterator. hasNext()){
System.out.println(iterator.next());
}
/*
To get all values stored in HashMap use entrySet() method.
Signature of the entrySet() method is,
Set entrySet()
*/
System.out.println("Retrieving all values from the HashMap");
iterator = hashMap.entrySet().iterator();
while(iterator. hasNext()){
System.out.println(iterator.next());
}
/*
To remove particular key - value pair from the HashMap use remove method.
Signature of remove method is,
Object remove(Object key)
This method returns value that was mapped to the given key,
otherwise null if mapping not found.
*/
System.out.println( hashMap.remove("One") + " is removed from the HashMap.");
}
}
/*
OUTPUT of the above given Java HashMap Example would be :
HashMap contains 3 key value pair.
HashMap contains 1 as value
HashMap contains One as key
Value mapped with key "One" is 1
Retrieving all keys from the HashMap
Three
Two
One
Retrieving all values from the HashMap
Three=3
Two=2
One=1
1 is removed from the HashMap.
*/
Hashmap needs Key and the value.
Very soon i am posting few usefull concepts on J2EE.
