![Java - Overview
A high-level programming language.
Originally developed by Sun Microsystems which was initiated by James
Gosling and released in 1995 as core component of Sun Microsystems'
Java platform (Java 1.0 [J2SE]).
Java runs on a variety of platforms, such as Windows, Mac OS, and the
various versions of UNIX.
Java compiler is in Java itself.
Java is a general purpose programming language and deployed
wherever advanced processing power is required.
With the advancement of Java and its widespread popularity, multiple
configurations were built to suite various types of platforms. Ex: J2EE for
Enterprise Applications, J2ME for Mobile Applications.
Java is guaranteed to be Write Once, Run Anywhere.](https://image.slidesharecdn.com/oopsjava-220912110812-2443c372/85/OOPS-JAVA-pdf-2-320.jpg)
![ Stringargs[ ]: this is the parameter list of function main(). It says that the
main() function can accept an array of String objects that represent the
command-line argument passed by the user at the time of execution.
String is the name of predefined class.
System.out.println: System is predefined class used to access the keyboard
and monitor. It defines various data members and methods, that can use
by placing a period(.) after the class name and before the member name.
Here, we are using the ‘out’ property which refers to the console/monitor. It
defines an output stream used to output something on the monitor.
The println() is the function of this output stream and is used to print
different type of variables and text.
{ } these braces are used to define class body and method body.](https://image.slidesharecdn.com/oopsjava-220912110812-2443c372/85/OOPS-JAVA-pdf-16-320.jpg)
![Comments in Java
Java supports single-line and multi-line comments very similar to c and c++.
All characters available inside any comment are ignored by Java compiler.
public class MyFirstJavaProgram{
/* This is my first java program.
* This will print 'Hello World' as the output
* This is an example of multi-line comments. */
public static void main(String []args){
// This is an example of single line comment
/* This is also an example of single line comment. */
System.out.println("Hello World");
}
}
A line containing only whitespace, possibly with a comment, is known as a
blank line, and Java totally ignores it.](https://image.slidesharecdn.com/oopsjava-220912110812-2443c372/85/OOPS-JAVA-pdf-29-320.jpg)
![Java: Variables
Local variables
o Example:
public class Test{
public void myAge(){
int age = 0;
age = age + 7;
System.out.println(“My age is : " + age);
}
public static void main(String args[])
{ Test test = new Test();
test.myAge(); }
}
My age is: 7
public class Test{
public void myAge(){
int age ;
age = age + 7;
System.out.println(“My age is : " + age);
}
public static void main(String args[])
{ Test test = new Test();
test.myAge(); }
}
Test.java:4:variable number might not
have been initialized
age = age + 7;
^ 1 error](https://image.slidesharecdn.com/oopsjava-220912110812-2443c372/85/OOPS-JAVA-pdf-37-320.jpg)
![Java: Variables
Instance variables
Example:
public class Employee{
// this instance variable is visible for any child
class.
public String name;
// salary variable is visible in Employee class
only.
private double salary;
// The name variable is assigned in the
constructor.
public Employee (String empName){
name = empName; }
// The salary variable is assigned a value.
public void setSalary(double empSal){
salary = empSal; }
// This method prints the employee details.
public void printEmp(){
System.out.println("name : " + name );
System.out.println("salary :" + salary); }
public static void main(String args[]){
Employee empOne = new
Employee("Ransika");
empOne.setSalary(1000);
empOne.printEmp();
} }
name : Ransika
salary :1000.0](https://image.slidesharecdn.com/oopsjava-220912110812-2443c372/85/OOPS-JAVA-pdf-40-320.jpg)
![Java: Variables
Class/Static variables
Example:
public class Employee{
// salary variable is a private static variable
private static double salary;
// DEPARTMENT is a constant
public static final String DEPARTMENT = "Development ";
public static void main(String args[]){
salary = 1000;
System.out.println(DEPARTMENT+"average salary:"+salary);
} }
Development average salary:1000
Note: If the variables are access from an outside class the constant should be accessed
as Employee.DEPARTMENT](https://image.slidesharecdn.com/oopsjava-220912110812-2443c372/85/OOPS-JAVA-pdf-43-320.jpg)
![Getting Text Input
You can use the pre-written methods (functions) in the Scanner class.
General structure:
import java.util.Scanner;
main (String [] args)
{
Scanner <name of scanner> = new Scanner (System.in);
<variable> = <name of scanner> .<method> ();
}
Creating a
scanner
object
(something
that can scan
user input)
Using the capability of
the scanner object
(actually getting user
input)](https://image.slidesharecdn.com/oopsjava-220912110812-2443c372/85/OOPS-JAVA-pdf-53-320.jpg)
![Getting Text Input (2)
The name of the online example: MyInput.java
import java.util.Scanner;
public class MyInput
{
public static void main (String [] args)
{
String str1;
int num1;
Scanner in = new Scanner (System.in);
System.out.print ("Type in an integer: ");
num1 = in.nextInt ();
System.out.print ("Type in a line: ");
in.nextLine ();
str1 = in.nextLine ();
System.out.println ("num1:" +num1 +"t str1:" + str1);
}
}](https://image.slidesharecdn.com/oopsjava-220912110812-2443c372/85/OOPS-JAVA-pdf-54-320.jpg)
![Reading A Single Character
Name of the (more complete example): MyInputChar.java
import java.util.Scanner;
public class MyInputChar
{
public static void main (String [] args)
{
final int FIRST = 0;
String selection;
Scanner in = new Scanner (System.in);
System.out.println("GAME OPTIONS");
System.out.println("(a)dd a new player");
System.out.println("(l)oad a saved game");
System.out.println("(s)ave game");
System.out.println("(q)uit game");
System.out.print("Enter your selection: ");
selection = in.nextLine ();
System.out.println ("Selection: " + selection.charAt(FIRST));
}
}](https://image.slidesharecdn.com/oopsjava-220912110812-2443c372/85/OOPS-JAVA-pdf-57-320.jpg)
![Example Program: If-Else
Name of the online example: BranchingExample1.java
import java.util.Scanner;
public class BranchingExample1
{
public static void main (String [] args)
{
Scanner in = new Scanner(System.in);
final int WINNING_NUMBER = 131313;
int playerNumber = -1;
System.out.print("Enter ticket number: ");
playerNumber = in.nextInt();
if (playerNumber == WINNING_NUMBER)
System.out.println("You're a winner!");
else
System.out.println("Try again.");
}
}](https://image.slidesharecdn.com/oopsjava-220912110812-2443c372/85/OOPS-JAVA-pdf-61-320.jpg)
![If, Else-If (2)
Name of the online example:
BranchingExample.java
import java.util.Scanner;
public class BranchingExample2
{
public static void main (String [] args)
{
Scanner in = new Scanner(System.in);
int gpa = -1;
System.out.print("Enter letter grade: ");
gpa = in.nextInt();
if (gpa == 4)
System.out.println("A");
else if (gpa == 3)
System.out.println("B");
else if (gpa == 2)
System.out.println("C");
else if (gpa == 1)
System.out.println("D");
else if (gpa == 0)
System.out.println("F");
else
System.out.println("Invalid letter
grade");
}
}](https://image.slidesharecdn.com/oopsjava-220912110812-2443c372/85/OOPS-JAVA-pdf-63-320.jpg)
![Switch: When To Use/When Not To Use
(2)
Name of the online example: SwitchExample.java
import java.util.Scanner;
public class SwitchExample
{
public static void main (String [] args)
{
final int FIRST = 0;
String line;
char letter;
int gpa;
Scanner in = new Scanner (System.in);
System.out.print("Enter letter grade: ");](https://image.slidesharecdn.com/oopsjava-220912110812-2443c372/85/OOPS-JAVA-pdf-67-320.jpg)
![Example: Post-Test Implementation
Name of the online example: PostTestExample.java
public class PostTestExample
{
public static void main (String [] args)
{
final int FIRST = 0;
Scanner in = new Scanner(System.in);
char answer;
String temp;
do
{
System.out.println("JT's note: Pretend that we play our game");
System.out.print("Play again? Enter 'q' to quit: ");
temp = in.nextLine();
answer = temp.charAt(FIRST);
} while ((answer != 'q') && (answer != 'Q'));
}
}](https://image.slidesharecdn.com/oopsjava-220912110812-2443c372/85/OOPS-JAVA-pdf-77-320.jpg)
![Example: Pre-Test Implementation
Name of the online example: PreTestExample.java
public class PreTestExample
{
public static void main (String [] args)
{
final int FIRST = 0;
Scanner in = new Scanner(System.in);
char answer = ' ';
String temp;
while ((answer != 'q') && (answer != 'Q'))
{
System.out.println("JT's note: Pretend that we play our game");
System.out.print("Play again? Enter 'q' to quit: ");
temp = in.nextLine();
answer = temp.charAt(FIRST);
}
}
}](https://image.slidesharecdn.com/oopsjava-220912110812-2443c372/85/OOPS-JAVA-pdf-78-320.jpg)
![Now What Happens???
import java.util.Scanner;
public class PreTestExample
{
public static void main (String [] args)
{
final int FIRST = 0;
Scanner in = new Scanner(System.in);
char answer = ' ';
String temp;
while ((answer != 'q') && (answer != 'Q'))
System.out.println("JT's note: Pretend that we play our game");
System.out.print("Play again? Enter 'q' to quit: ");
temp = in.nextLine();
answer = temp.charAt(FIRST);
}
}](https://image.slidesharecdn.com/oopsjava-220912110812-2443c372/85/OOPS-JAVA-pdf-79-320.jpg)
![Java : Objects & Classes
Attributes
o An attribute is basically a state.
o Anatomy of an Attribute:
<modifier> <type> <name> [ = <initial_value>];
o Examples:
public class Foo {
private int x;
private float y = 10000.0F;
private String name = "Bates Motel";
}](https://image.slidesharecdn.com/oopsjava-220912110812-2443c372/85/OOPS-JAVA-pdf-86-320.jpg)
![ Creating an Object:
o Example:
public class Dog{
Private String name;
public Dog(String nameDog){
// This constructor has one parameter, name.
name=nameDog;
}
public static void main(String[]args){
// Following statement would create an object myDog
Dog myDog =new Dog("tommy");
}
}
Java : Objects & Classes](https://image.slidesharecdn.com/oopsjava-220912110812-2443c372/85/OOPS-JAVA-pdf-95-320.jpg)
![ Accessing Instance Variables and Methods
public class Puppy{
int puppyAge;
public Puppy(String name){
// This constructor has one parameter, name.
System.out.println("Name is :"+ name);
}
public void setAge(int age ){
puppyAge = age; }
public int getAge(){
System.out.println(puppyAge );
return puppyAge; }
public static void main(String[]args){
/* Object creation */
Puppy myPuppy =new Puppy("tommy");
/* Call class method to set puppy's age */
myPuppy.setAge(2);
/* Call another class method to get puppy's age
*/
myPuppy.getAge();
/* You can access instance variable as follows
as well */
System.out.println(myPuppy.puppyAge
); } }
Java : Objects & Classes](https://image.slidesharecdn.com/oopsjava-220912110812-2443c372/85/OOPS-JAVA-pdf-97-320.jpg)
![Method Overloading: Example
public class Movie
{
double cost;
void setCost ()
{
cost = 3.5;
}
void setCost (double ncost) //Overloaded Method
{
cost = ncost;
}
public static void main (String[]args)
{
Movie m1 = new Movie ();
m1.setCost ();
m1.setCost (3.25);
}
}](https://image.slidesharecdn.com/oopsjava-220912110812-2443c372/85/OOPS-JAVA-pdf-103-320.jpg)
![this Reference: Example
class Movie
{
String title;
String rating;
double cost;
void setDetails (String title, String nrating,
double ncost)
{
this.title=title;
rating=nrating;
cost=ncost;
}
}
class test3
{
public static void main (String[]args)
{
Movie m1 = new Movie ();
m1.setDetails("Lost Paradise","pG", 7.6);
}
}](https://image.slidesharecdn.com/oopsjava-220912110812-2443c372/85/OOPS-JAVA-pdf-105-320.jpg)
![Using this() to invoke current class
constructor
// Java code for using this() to
// invoke current class constructor
class Test
{
int a;
int b;
//Default constructor
Test()
{
this(10, 20);
System.out.println("Inside default constructor n");
}
//Parameterized constructor
Test(int a, int b)
{
this.a = a;
this.b = b;
System.out.println("Inside parameterized
constructor");
}
public static void main(String[] args)
{
Test object = new Test();
}
}](https://image.slidesharecdn.com/oopsjava-220912110812-2443c372/85/OOPS-JAVA-pdf-106-320.jpg)
![Using this to return current class instance
//Java code for using 'this' keyword
//to return the current class instance
class Test
{
int a;
int b;
//Default constructor
Test()
{
a = 10;
b = 20;
}
//Method that returns current class instance
Test get()
{
return this;
}
//Displaying value of variables a and b
void display()
{
System.out.println("a = " + a + " b = " +
b);
}
public static void main(String[] args)
{
Test object = new Test();
object.get().display();
}
}](https://image.slidesharecdn.com/oopsjava-220912110812-2443c372/85/OOPS-JAVA-pdf-107-320.jpg)
![Using this keyword as Method
Parameter
// Java code for using 'this'
// keyword as method parameter
class Test
{
int a;
int b;
// Default constructor
Test()
{
a = 10;
b = 20;
}
// Method that receives 'this' keyword as parameter
void display(Test obj)
{
System.out.println("a = " +obj.a + " b = " +
obj.b);
}
// Method that returns current class instance
void get()
{
display(this);
}
public static void main(String[] args)
{
Test object = new Test();
object.get();
}
}](https://image.slidesharecdn.com/oopsjava-220912110812-2443c372/85/OOPS-JAVA-pdf-108-320.jpg)
![Call by value or Pass by value
public class CallByValue
{
public void display(int y)
{
y = 20;
}
public static void main(String args[])
{
CallByValue cbv = new CallByValue();
int x = 10;
cbv.display(x);
System.out.println(x); // prints 10 and not 20
}
}](https://image.slidesharecdn.com/oopsjava-220912110812-2443c372/85/OOPS-JAVA-pdf-110-320.jpg)
![Call by reference or Pass by Reference
public class CallByReference
{
public void display(StringBuffer sb2)
{
sb2.append("World");
System.out.println(sb2); // prints HelloWorld
}
public static void main(String args[])
{
CallByReference cbr = new CallByReference();
StringBuffer sb1 = new StringBuffer("Hello");
cbr.display(sb1);
System.out.println(sb1); // prints HelloWorld
}
}](https://image.slidesharecdn.com/oopsjava-220912110812-2443c372/85/OOPS-JAVA-pdf-111-320.jpg)
![Single Inheritance: Example
// Java program to illustrate the
// concept of single inheritance
import java.io.*;
import java.lang.*;
import java.util.*;
class one {
public void print_geek()
{
System.out.println("Geeks");
}
}
class two extends one {
public void print_for() {
System.out.println("for"); }
}
// Driver class
public class Main {
public static void main(String[] args)
{
two g = new two();
g.print_geek();
g.print_for();
g.print_geek();
}
}](https://image.slidesharecdn.com/oopsjava-220912110812-2443c372/85/OOPS-JAVA-pdf-116-320.jpg)
![Example:
/* superclass Person */
class Person
{
Person()
{
System.out.println("Person class
Constructor");
}
}
/* subclass Student extending the Person class */
class Student extends Person
{
Student()
{
// invoke or call parent class constructor
super();
System.out.println("Student class Constructor");
}
}
/* Driver program to test*/
class Test
{
public static void main(String[] args)
{
Student s = new Student();
}
}](https://image.slidesharecdn.com/oopsjava-220912110812-2443c372/85/OOPS-JAVA-pdf-119-320.jpg)
![Example:
/* Base class vehicle */
class Vehicle
{
int maxSpeed = 120;
}
/* sub class Car extending vehicle */
class Car extends Vehicle
{
int maxSpeed = 180;
void display()
{
/* print maxSpeed of base class (vehicle) */
System.out.println("Maximum Speed: " +
super.maxSpeed);
}
}
/* Driver program to test */
class Test
{
public static void main(String[] args)
{
Car small = new Car();
small.display();
}
}
Output:
Maximum Speed: 120](https://image.slidesharecdn.com/oopsjava-220912110812-2443c372/85/OOPS-JAVA-pdf-121-320.jpg)
![Example:
/* Base class Person */
class Person
{
void message()
{
System.out.println("This is person class");
}
}
/* Subclass Student */
class Student extends Person
{
void message()
{
System.out.println("This is student class");
}
// Note that display() is only in Student class
void display()
{
// will invoke or call current class message() method
message();
// will invoke or call parent class message() method
super.message();
}
}
/* Driver program to test */
class Test
{
public static void main(String args[])
{
Student s = new Student();
// calling display() of Student
s.display();
}
}](https://image.slidesharecdn.com/oopsjava-220912110812-2443c372/85/OOPS-JAVA-pdf-123-320.jpg)
![Example:
class A
{
A()
{
System.out.println(“Inside A’s Constructor”);
}
}
Class B extends A
{
B()
{
System.out.println(“Inside B’s Constructor”);
}
}
class C extends B
{
C()
{
System.out.println(“Inside C’s Constructor”);
}
}
class inherit6
{
public static void main(String args[])
{
C c1= new C();
}
}
Output:
Inside A’s Constructor
Inside B’s Constructor
Inside C’s Constructor](https://image.slidesharecdn.com/oopsjava-220912110812-2443c372/85/OOPS-JAVA-pdf-127-320.jpg)
![Example:
//Java Program to illustrate the use of Java Method Overriding
//Creating a parent class.
class Vehicle{
//defining a method
void run(){System.out.println("Vehicle is running");}
}
//Creating a child class
class Bike2 extends Vehicle{
//defining the same method as in the parent class
void run(){System.out.println("Bike is running safely");}
public static void main(String args[]){
Bike2 obj = new Bike2();//creating object
obj.run();//calling method
}
}](https://image.slidesharecdn.com/oopsjava-220912110812-2443c372/85/OOPS-JAVA-pdf-130-320.jpg)
![String Constructors
The String class has several constructors defined. To create an empty string
the default constructor is used. For example:
String(): Creates a new, empty string.
String s = new String();
It will create the instance of the string with no characters in it.
String (String astring): constructs a new string that is a copy of the string
astring.
If we want to initialize the string with values we can use following constructor.
String(char chars[])
For example:
char chars[] = {‘h’, ‘e’, ‘l’, ‘l’, ‘o’};
String s = new String(chars);](https://image.slidesharecdn.com/oopsjava-220912110812-2443c372/85/OOPS-JAVA-pdf-136-320.jpg)
![ String(char arrayOfChars[ ], int startingCharacter, int lengthOfSubarray):
Constructs a new string in the same way as the previous constructor. The
difference is that instead of copying the entire array, it just copies the
length of subarray elements beginning with index startingCharacter.
char chars[ ]={‘a’, ‘b’, ‘c’, ‘d’, ‘e’, ‘f’};
String str = new String(chars, 2, 3);
The string gets initialized to the string “cde”.
String(byte[ ] array): Constructs a new string from an array of byte values.](https://image.slidesharecdn.com/oopsjava-220912110812-2443c372/85/OOPS-JAVA-pdf-137-320.jpg)
![// Java program to illustrate
// working of toString() method
class Best_Friend {
String name;
int age;
String college;
String course;
String address;
Best_Friend
(String name, int age, String college, String
course, String address)
{
this.name = name;
this.age = age;
this.college = college;
this.course = course;
this.address = address;
}
public String toString()
{
return name + " " + age + " " + college +
" " + course + " " + address;
}
public static void main(String[] args)
{
Best_Friend b =
new Best_Friend("Gulpreet Kaur", 21, "BIT
MESRA", "M.TECH", "Kiriburu");
System.out.println(b);
System.out.println(b.toString());
}
}](https://image.slidesharecdn.com/oopsjava-220912110812-2443c372/85/OOPS-JAVA-pdf-141-320.jpg)
![getchars()
getchars(): to extract more than one character at a time, the method is
void getChars( int sourceStart, int sourceEnd, char target[ ], int
targetStart)
String S= “String class is a final class.”;
int start = 7;
int end = 23;
char buf[ ] = new char [end-start];
S.getChars(start, end, buf, 0);
System.Out.println(buf);
Output:
class is a final](https://image.slidesharecdn.com/oopsjava-220912110812-2443c372/85/OOPS-JAVA-pdf-143-320.jpg)
![toCharArray()
It is used to convert all the characters in a string object into a character
array.
char[ ] toCharArray()
char[ ] c = “Hello”.toCharArray();
This stores the characters of “Hello” string into character array c.](https://image.slidesharecdn.com/oopsjava-220912110812-2443c372/85/OOPS-JAVA-pdf-144-320.jpg)
![CREATING THREADS EXAMPLE:-
class A extends Thread
{
public void run()
{
for(int i=1;i<=5;i++)
{
System.out.println("From ThreadA : i = "+ i);
}
System.out.println("Exit from A");
}
}
class B extends Thread
{
public void run()
{
for(int j=1;j<=5;j++)
{
System.out.println("From ThreadB : j = "+ j);
}
System.out.println("Exit from B");
}
}
class C extends Thread
{
public void run()
{
for(int k=1;k<=5;k++)
{
System.out.println("From ThreadA : k = "+ k);
}
System.out.println("Exit from C");
}
}
public class threadtest {
public static void main(String[] args) {
new A().start();
new B().start();
new C().start();
}
}
OUTPUT:-
From ThreadB : j = 1
From ThreadA : k = 1
From ThreadA : i = 1
From ThreadA : k = 2
From ThreadA : k = 3
From ThreadA : k = 4
From ThreadA : k = 5
Exit from C
From ThreadB : j = 2
From ThreadB : j = 3
From ThreadB : j = 4
From ThreadB : j = 5
Exit from B
From ThreadA : i = 2
From ThreadA : i = 3
From ThreadA : i = 4
From ThreadA : i = 5
Exit from A](https://image.slidesharecdn.com/oopsjava-220912110812-2443c372/85/OOPS-JAVA-pdf-187-320.jpg)
![USING THREAD METHODS:-
class A1 extends Thread
{
public void run()
{
for(int i=1;i<=5;i++)
{
if(i==1)
yield();
System.out.println("From ThreadA : i = "+ i);
}
System.out.println("Exit from A");
}
}
class B1 extends Thread
{
public void run()
{
for(int j=1;j<=5;j++)
{
System.out.println("From ThreadB : j = "+ j);
if(j==3)
stop();
}
System.out.println("Exit from B");
}
}
class C1 extends Thread
{
public void run()
{
for(int k=1;k<=5;k++)
{
System.out.println("From ThreadA : k = "+ k);
if(k==1)
sleep(1000);
}
System.out.println("Exit from C");
}
}
OUTPUT:-
Started thread A
Started thread B
Started thread C
End of main thread
From ThreadA : k = 1
From ThreadA : i = 1
From ThreadB : j = 1
From ThreadB : j = 2
From ThreadB : j = 3
From ThreadA : i = 2
From ThreadA : i = 3
From ThreadA : i = 4
From ThreadA : i = 5
Exit from A
From ThreadA : k = 2
From ThreadA : k = 3
From ThreadA : k = 4
From ThreadA : k = 5
Exit from C
public class thread2 {
public static void main(String[] args) {
A1 threadA = new A1();
B1 threadB = new B1();
C1 threadC = new C1();
System.out.println("Started thread A");
threadA.start();
System.out.println("Started thread B");
threadB.start();
System.out.println("Started thread C");
threadC.start();
System.out.println("End of main thread");
}
}](https://image.slidesharecdn.com/oopsjava-220912110812-2443c372/85/OOPS-JAVA-pdf-188-320.jpg)
Ad
More Related Content
Similar to OOPS JAVA.pdf (20)
Recently uploaded (20)
Ad
OOPS JAVA.pdf
- 2. Java - Overview A high-level programming language. Originally developed by Sun Microsystems which was initiated by James Gosling and released in 1995 as core component of Sun Microsystems' Java platform (Java 1.0 [J2SE]). Java runs on a variety of platforms, such as Windows, Mac OS, and the various versions of UNIX. Java compiler is in Java itself. Java is a general purpose programming language and deployed wherever advanced processing power is required. With the advancement of Java and its widespread popularity, multiple configurations were built to suite various types of platforms. Ex: J2EE for Enterprise Applications, J2ME for Mobile Applications. Java is guaranteed to be Write Once, Run Anywhere.
- 3. Why JAVA is important? Two reasons : Trouble with C/C++ language is that they are not portable and are not platform independent languages. Also memory consumption and crashing. Emergence of World Wide Web, which demanded portable programs. Portability and security necessitated the invention of Java
- 4. What is JAVA A general-purpose object-oriented language. Write Once Run Anywhere (WORA). Designed for easy Web/Internet applications. Widespread acceptance. Platform Independent Programming Language.
- 5. How JAVA is different from C Language C Language: Major difference is that C is a structure oriented language and Java is an object oriented language and has mechanism to define classes and objects. Java does not support an explicit pointer type Java does not have preprocessor, so we cant use #define, #include and #ifdef statements. Java does not include structures, unions and enum data types. Java does not include keywords like goto, sizeof and typedef. Java adds labeled break and continue statements. Java adds many features required for object oriented programming.
- 6. How JAVA is different from C++ C++ language Features removed in java: Java doesn’t support pointers to avoid unauthorized access of memory locations. Java does not include structures, unions and enum data types. Java does not support operator over loading. Preprocessors plays less important role in C++ and so eliminated entirely in java. Java does not perform automatic type conversions that result in loss of precision.
- 7. Java does not support global variables. Every method and variable is declared within a class and forms part of that class. Java does not allow default arguments. Java does not support inheritance of multiple super classes by a sub class (i.e., multiple inheritance). This is accomplished by using ‘interface’ concept. It is not possible to declare unsigned integers in java. In java objects are passed by reference only. In C++ objects may be passed by value or reference.
- 8. New features added in Java: Multithreading, that allows two or more pieces of the same program to execute concurrently. C++ has a set of library functions that use a common header file. But java replaces it with its own set of API classes. It adds packages and interfaces. Java supports automatic garbage collection. break and continue statements have been enhanced in java to accept labels as targets. The use of unicode characters ensures portability.
- 9. Features that differ: Though C++ and java supports Boolean data type, C++ takes any nonzero value as true and zero as false. True and false in java are predefined literals that are values for a Boolean expression. Java has replaced the destructor function with a finalize() function. C++ supports exception handling that is similar to java's. However, in C++ there is no requirement that a thrown exception be caught.
- 10. Java- Characteristics Object oriented Platform Independent Simple Secure architectural- neutral Portable Robust Multithreaded Interpreted High performance Distributed dynamic
- 11. Java Object Oriented: In Java, everything is an Object. Java can be easily extended since it is based on the Object model. Platform independent: Unlike many other programming languages including C and C++, when Java is compiled, it is not compiled into platform specific machine, rather into platform independent byte code. This byte code is interpreted by virtual Machine (JVM) on which ever platform it is being run. Simple: Java is designed to be easy to learn. If you understand the basic concept of OOP Java would be easy to master. Secure: With Java's secure feature it enables to develop virus-free, tamper- free systems. Authentication techniques are based on public-key encryption.
- 12. Multithreaded: With Java's multithreaded feature it is possible to write programs that can do many tasks simultaneously. Interpreted: Java byte code is translated on the fly to native machine instructions and is not stored anywhere. The development process is more rapid and analytical since the linking is an incremental and light weight process. Architectural-neutral :Java compiler generates an architecture-neutral object file format which makes the compiled code to be executable on many processors, with the presence of Java runtime system. Portable: Being architectural-neutral and having no implementation dependent aspects of the specification makes Java portable.
- 13. Robust: Java makes an effort to eliminate error prone situations by emphasizing mainly on compile time error checking and runtime checking. High Performance: With the use of Just-In-Time compilers, Java enables high performance. Distributed: Java is designed for the distributed environment of the internet. Dynamic: Java is considered to be more dynamic than C or C++ since it is designed to adapt to an evolving environment. Classes are stored in separate files and are loaded into the Java interpreter only when needed. This means that an application can decide as it is running what classes it needs and can load them when it needs them.
- 15. A Simple Java Program public: public is an access modifier used to define access restriction. class: this keyword is used to define a class and precedes the user defined class name, i.e. “Simple” in this program. static: this keyword states that the function main() is a class function which can be called without instantiating the class. All static functions have only one copy to be used for all the instances of the class. void: refers to the return type and shows that the function main() does not return any value.
- 16. Stringargs[ ]: this is the parameter list of function main(). It says that the main() function can accept an array of String objects that represent the command-line argument passed by the user at the time of execution. String is the name of predefined class. System.out.println: System is predefined class used to access the keyboard and monitor. It defines various data members and methods, that can use by placing a period(.) after the class name and before the member name. Here, we are using the ‘out’ property which refers to the console/monitor. It defines an output stream used to output something on the monitor. The println() is the function of this output stream and is used to print different type of variables and text. { } these braces are used to define class body and method body.
- 17. Compilers, Interpreters, and the JVM 3 compile compile interpret source code source code Compiled Languages (e.g. C, C++) bytecode binary code execute Java interpret source code Interpreted Languages (e.g. JavaScript, Perl, Ruby) Small, easy to write Interpreter is unique to each platform Interpreter translates code into binary and executes it Compiler is unique to each platform JVM is unique to each platform Bytecode is platform independent Java Virtual Machine (JVM)
- 18. Compiling and Running Java 4 Java Code Java Bytecode JRE for Linux JRE for Windows Java compiler Simple.java javac Simple.java Simple.class Java interpreter (JVM) translates bytecode to machine code in JRE
- 19. Phases of Program Creation and Execution Edit : • Creating a Java program consists of using an editor program. • Java source code files are saved with the file extension “.java”. • Source files can be created using a simple text editor, or an IDE (Integrated Development Environment), such as JCreator, Eclipse, JBuilder, etc. • IDEs provide tools to support the development process, including editors for writing programs and debugging for locating logic errors in programs.
- 20. Phases of Program Creation and Execution Compile During this phase, the programmer compiles the program using a command at the command line, or tools from the IDE. At this step, the Java source code is translated into bytecodes. If you are running the Java compiler from the command prompt, the command to enter is: Command: javac Hello.java* Running this command would compile the Java source file, Hello.java, and generate a bytecode class file named, Hello.class. Compiler is available as part of the Java Development Kit (JDK)
- 21. Phases of Program Creation and Execution Load The program must be placed in memory before it can execute. In loading, the class loader takes the “.class” files, created in the previous step, and transfers them to primary memory. The class loader also loads the .class files provided by Java, that your program uses.
- 22. Phases of Program Creation and Execution Verify As the classes are loaded, a bytecode verifier examines the bytecodes to ensure they are valid and don’t violate any security restrictions. Execute During the last phase, the JVM executes a programs bytecodes, performing the actions specified by the program. Command: java Hello A version of Java Runtime Environment (JRE) which incorporates a JVM is required to execute the bytecode and the Java library packages.
- 23. JRE / JDK JRE: Java Runtime Environment. It is basically the Java Virtual Machine where your Java programs run on. It also includes browser plugins for Applet execution. JDK: It's the full featured Software Development Kit for Java, including JRE, and the compilers and tools (like JavaDoc, and Java Debugger) to create and compile programs. Usually, when you only care about running Java programs on your browser or computer you will only install JRE. It's all you need. On the other hand, if you are planning to do some Java programming, you will also need JDK.
- 24. Naming convention Case Sensitivity Java is case sensitive Example: Hello and hello would have different meaning in Java. Class Names For all class names the first letter should be in Upper Case. If several words are used to form a name of the class, each inner word's first letter should be in Upper Case. Example class MyFirstJavaClass
- 25. Naming convention Method Names All method names should start with a Lower Case letter. If several words are used to form the name of the method, then each inner word's first letter should be in Upper Case. Example public void myMethodName()
- 26. Naming convention Program File Name Name of the program file should exactly match the class name. When saving the file, you should save it using the class name and append '.java' to the end of the name. If the file name and the class name do not match your program will not compile Example : Assume 'MyFirstJavaProgram' is the class name. Then the file should be saved as 'MyFirstJavaProgram.java‘
- 27. Java Identifiers All Java components require names. Names used for classes, variables and methods are called identifiers. In Java, there are several points to remember about identifiers. All identifiers should begin with a letter (A to Z or a to z), currency character ($) or an underscore (_). After the first character identifiers can have any combination of characters. A key word cannot be used as an identifier. Identifiers are case sensitive. Examples of legal identifiers: age, $salary, _value, __1_value Examples of illegal identifiers: 123abc, -salary
- 28. Java Keywords These reserved words may not be used as constant or variable or any other identifier names. abstract assert boolean break byte case catch char class const continue default do double else enum 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 volatile while
- 29. Comments in Java Java supports single-line and multi-line comments very similar to c and c++. All characters available inside any comment are ignored by Java compiler. public class MyFirstJavaProgram{ /* This is my first java program. * This will print 'Hello World' as the output * This is an example of multi-line comments. */ public static void main(String []args){ // This is an example of single line comment /* This is also an example of single line comment. */ System.out.println("Hello World"); } } A line containing only whitespace, possibly with a comment, is known as a blank line, and Java totally ignores it.
- 30. Java: Datatypes There are two data types available in Java: Primitive Data Types Reference/Object Data Types
- 31. Java: Datatypes Data Type Default Value Default size boolean false 1 bit char 'u0000' 2 byte byte 0 1 byte short 0 2 byte int 0 4 byte long 0L 8 byte float 0.0f 4 byte double 0.0d 8 byte Why char uses 2 byte in java and what is u0000 ? because java uses unicode system rather than ASCII code system. u0000 is the lowest range of unicode system.
- 32. Java: Datatypes Examples: int a, b, c; // Declares three ints, a, b, and c. int a = 10, b = 10; // Example of initialization byte B = 22; // initializes a byte type variable B. double pi = 3.14159; // declares and assigns a value of PI. char a = 'a'; // the char variable a is initialized with value 'a'
- 33. Java: Variables Variable is name of reserved area allocated in memory. int data=50;//Here data is variable
- 34. Java: Variables Types of variable local instance class A variable that is declared inside the method is called local variable. A variable that is declared inside the class but outside the method is called instance variable . It is not declared as static. A variable that is declared as static is called static (also class) variable. It cannot be local.
- 35. Java: Variables Example to understand the types of variables: class A{ int data=50;//instance variable static int m=100; //static variable void method(){ int n=90; //local variable } } //end of class
- 36. Java: Variables Local variables Local variables are declared in methods. Local variables are created when the method is entered and the variable will be destroyed once it exits the method. Local variables are visible only within the declared method. There is no default value for local variables so local variables should be declared and an initial value should be assigned before the first use.
- 37. Java: Variables Local variables o Example: public class Test{ public void myAge(){ int age = 0; age = age + 7; System.out.println(“My age is : " + age); } public static void main(String args[]) { Test test = new Test(); test.myAge(); } } My age is: 7 public class Test{ public void myAge(){ int age ; age = age + 7; System.out.println(“My age is : " + age); } public static void main(String args[]) { Test test = new Test(); test.myAge(); } } Test.java:4:variable number might not have been initialized age = age + 7; ^ 1 error
- 38. Java: Variables Instance variables Instance variables are declared in a class, but outside a method. Instance variables are created when an object is created with the use of the keyword 'new' and destroyed when the object is destroyed. Instance variables can be declared in class level before or after use. The instance variables are visible for all methods in the class. Normally, it is recommended to make these variables private (access level).
- 39. Java: Variables Instance variables Instance variables have default values. Values can be assigned during the declaration or within the constructor. Instance variables can be accessed directly by calling the variable name inside the class. However within static methods and different class ( when instance variables are given accessibility) should be called using the fully qualified name . ObjectReference.VariableName.
- 40. Java: Variables Instance variables Example: public class Employee{ // this instance variable is visible for any child class. public String name; // salary variable is visible in Employee class only. private double salary; // The name variable is assigned in the constructor. public Employee (String empName){ name = empName; } // The salary variable is assigned a value. public void setSalary(double empSal){ salary = empSal; } // This method prints the employee details. public void printEmp(){ System.out.println("name : " + name ); System.out.println("salary :" + salary); } public static void main(String args[]){ Employee empOne = new Employee("Ransika"); empOne.setSalary(1000); empOne.printEmp(); } } name : Ransika salary :1000.0
- 41. Java: Variables Class/Static variables Class variables also known as static variables are declared with the static keyword in a class, but outside a method. There would only be one copy of each class variable per class, regardless of how many objects are created from it. Static variables are stored in static memory. It is rare to use static variables other than declared final and used as either public or private constants. Static variables are created when the program starts and destroyed when the program stops.
- 42. Java: Variables Class/Static variables Visibility is similar to instance variables. However, most static variables are declared public since they must be available for users of the class. Default values are same as instance variables. Static variables can be accessed by calling with the class name ClassName.VariableName. When declaring class variables as public static final, then variables names (constants) are all in upper case. If the static variables are not public and final, the naming syntax is the same as instance and local variables.
- 43. Java: Variables Class/Static variables Example: public class Employee{ // salary variable is a private static variable private static double salary; // DEPARTMENT is a constant public static final String DEPARTMENT = "Development "; public static void main(String args[]){ salary = 1000; System.out.println(DEPARTMENT+"average salary:"+salary); } } Development average salary:1000 Note: If the variables are access from an outside class the constant should be accessed as Employee.DEPARTMENT
- 44. Java : Operators Java provides a rich set of operators to manipulate variables: Arithmetic Operators Relational Operators Bitwise Operators Logical Operators Assignment Operators Conditional Operator
- 45. Java : Operators Arithmetic Operators: Arithmetic operators are used in mathematical expressions in the same way that they are used in algebra. Operator Description + Addition - Adds values on either side of the operator - Subtraction - Subtracts right hand operand from left hand operand * Multiplication - Multiplies values on either side of the operator / Division - Divides left hand operand by right hand operand % Modulus - Divides left hand operand by right hand operand and returns remainder ++ Increment - Increases the value of operand by 1 -- Decrement - Decreases the value of operand by 1
- 46. Java : Operators Relational Operators: There are following relational operators supported by Java language Operator Description == Checks if the values of two operands are equal or not, if yes then condition becomes true. != Checks if the values of two operands are equal or not, if values are not equal then condition becomes true. > Checks if the value of left operand is greater than the value of right operand, if yes then condition becomes true. < Checks if the value of left operand is less than the value of right operand, if yes then condition becomes true. >= Checks if the value of left operand is greater than or equal to the value of right operand, if yes then condition becomes true. <= Checks if the value of left operand is less than or equal to the value of right operand, if yes then condition becomes true.
- 47. Java : Operators The Bitwise Operators: Java defines several bitwise operators, which can be applied to the integer types, long, int, short, char, and byte. Bitwise operator works on bits and performs bit-by-bit operation. Assume if a = 60; and b = 13; now in binary format : a = 0011 1100 b = 0000 1101 a&b = 0000 1100 a|b = 0011 1101 a^b = 0011 0001 ~a = 1100 0011
- 48. Java : Operators Logical Operators: Operator Description && Called Logical AND operator. If both the operands are non-zero, then the condition becomes true. || Called Logical OR Operator. If any of the two operands are non-zero, then the condition becomes true. ! Called Logical NOT Operator. Use to reverses the logical state of its operand. If a condition is true then Logical NOT operator will make false.
- 49. Java : Operators The Assignment Operators: Operator Description = Simple assignment operator, Assigns values from right side operands to left side operand += Add AND assignment operator, It adds right operand to the left operand and assign the result to left operand -= Subtract AND assignment operator, It subtracts right operand from the left operand and assign the result to left operand *= Multiply AND assignment operator, It multiplies right operand with the left operand and assign the result to left operand /= Divide AND assignment operator, It divides left operand with the right operand and assign the result to left operand %= Modulus AND assignment operator, It takes modulus using two operands and assign the result to left operand
- 50. Java : Operators Conditional Operator ( ? : ) Conditional operator is also known as the ternary operator. The goal of the operator is to decide which value should be assigned to the variable. Syntax: variable x = (expression) ? value if true : value if false Example: int a , b; a = 10; b = (a == 1) ? 20: 30; System.out.println( "Value of b is : " + b ); b = (a == 10) ? 20: 30; System.out.println( "Value of b is : " + b ); Value of b is : 30 Value of b is : 20
- 51. Accessing Pre-Created Java Libraries It’s accomplished by placing an ‘import’ of the appropriate library at the top of your program. Syntax: import <Full library name>; Example: import java.util.Scanner; JAVA Scanner Class: Java Scanner class allows the user to take input from the console. It belongs to java.util package. It is used to read the input of primitive types like int, double, long, short, float, and byte. It is the easiest way to read input in Java program.
- 52. Syntax: Scanner sc=new Scanner(System.in); The above statement creates a constructor of the Scanner class having System.inM as an argument. It means it is going to read from the standard input stream of the program. The java.util package should be import while using Scanner class. It also converts the Bytes (from the input stream) into characters using the platform's default charset.
- 53. Getting Text Input You can use the pre-written methods (functions) in the Scanner class. General structure: import java.util.Scanner; main (String [] args) { Scanner <name of scanner> = new Scanner (System.in); <variable> = <name of scanner> .<method> (); } Creating a scanner object (something that can scan user input) Using the capability of the scanner object (actually getting user input)
- 54. Getting Text Input (2) The name of the online example: MyInput.java import java.util.Scanner; public class MyInput { public static void main (String [] args) { String str1; int num1; Scanner in = new Scanner (System.in); System.out.print ("Type in an integer: "); num1 = in.nextInt (); System.out.print ("Type in a line: "); in.nextLine (); str1 = in.nextLine (); System.out.println ("num1:" +num1 +"t str1:" + str1); } }
- 55. Useful Methods Of Class Scanner 1 Online documentation: http://java.sun.com/javase/6/docs/api/ Method Description int nextInt() It is used to scan the next token of the input as an integer. float nextFloat() It is used to scan the next token of the input as a float. double nextDouble() It is used to scan the next token of the input as a double. byte nextByte() It is used to scan the next token of the input as a byte. String nextLine() Advances this scanner past the current line. boolean nextBoolean() It is used to scan the next token of the input into a boolean value. long nextLong() It is used to scan the next token of the input as a long. short nextShort() It is used to scan the next token of the input as a Short.
- 56. Reading A Single Character Text menu driven programs may require this capability. Example: GAME OPTIONS (a)dd a new player (l)oad a saved game (s)ave game (q)uit game There’s different ways of handling this problem but one approach is to extract the first character from the string. Partial example: String s = "boo“; System.out.println(s.charAt(0));
- 57. Reading A Single Character Name of the (more complete example): MyInputChar.java import java.util.Scanner; public class MyInputChar { public static void main (String [] args) { final int FIRST = 0; String selection; Scanner in = new Scanner (System.in); System.out.println("GAME OPTIONS"); System.out.println("(a)dd a new player"); System.out.println("(l)oad a saved game"); System.out.println("(s)ave game"); System.out.println("(q)uit game"); System.out.print("Enter your selection: "); selection = in.nextLine (); System.out.println ("Selection: " + selection.charAt(FIRST)); } }
- 58. Decision Making In Java Java decision making constructs if if, else if, else-if switch
- 59. Decision Making: If Format: if (Boolean Expression) Body Example: if (x != y) System.out.println("X and Y are not equal"); if ((x > 0) && (y > 0)) { System.out.println("X and Y are positive"); } •Indenting the body of the branch is an important stylistic requirement of Java but unlike Python it is not enforced by the syntax of the language. •What distinguishes the body is either: 1.A semi colon (single statement branch) 2.Braces (a body that consists of multiple statements)
- 60. Decision Making: If, Else Format: if (Boolean expression) Body of if else Body of else Example: if (x < 0) System.out.println("X is negative"); else System.out.println("X is non-negative");
- 61. Example Program: If-Else Name of the online example: BranchingExample1.java import java.util.Scanner; public class BranchingExample1 { public static void main (String [] args) { Scanner in = new Scanner(System.in); final int WINNING_NUMBER = 131313; int playerNumber = -1; System.out.print("Enter ticket number: "); playerNumber = in.nextInt(); if (playerNumber == WINNING_NUMBER) System.out.println("You're a winner!"); else System.out.println("Try again."); } }
- 62. If, Else-If Format: if (Boolean expression) Body of if else if (Boolean expression) Body of first else-if : : : else if (Boolean expression) Body of last else-if else Body of else
- 63. If, Else-If (2) Name of the online example: BranchingExample.java import java.util.Scanner; public class BranchingExample2 { public static void main (String [] args) { Scanner in = new Scanner(System.in); int gpa = -1; System.out.print("Enter letter grade: "); gpa = in.nextInt(); if (gpa == 4) System.out.println("A"); else if (gpa == 3) System.out.println("B"); else if (gpa == 2) System.out.println("C"); else if (gpa == 1) System.out.println("D"); else if (gpa == 0) System.out.println("F"); else System.out.println("Invalid letter grade"); } }
- 64. Alternative To Multiple Else-If’s: Switch Format (character-based switch): switch (character variable name) { case '<character value>': Body break; case '<character value>': Body break; : default: Body } 1 The type of variable in the brackets can be a byte, char, short, int or long Important! The break is mandatory to separate Boolean expressions (must be used in all but the last)
- 65. Alternative To Multiple Else-If’s: Switch Format (integer based switch): switch (integer variable name) { case <integer value>: Body break; case <integer value>: Body break; default: Body } 1 The type of variable in the brackets can be a byte, char, short, int or long
- 66. Switch: When To Use/When Not To Use Benefit (when to use): It may produce simpler code than using an if-elseif (e.g., if there are multiple compound conditions)
- 67. Switch: When To Use/When Not To Use (2) Name of the online example: SwitchExample.java import java.util.Scanner; public class SwitchExample { public static void main (String [] args) { final int FIRST = 0; String line; char letter; int gpa; Scanner in = new Scanner (System.in); System.out.print("Enter letter grade: ");
- 68. Switch: When To Use/When Not To Use (3) line = in.nextLine (); letter = line.charAt(FIRST); switch (letter) { case 'A': case 'a': gpa = 4; break; case 'B': case 'b': gpa = 3; break; case 'C': case 'c': gpa = 2; break;
- 69. Switch: When To Use/When Not To Use (4) case 'D': case 'd': gpa = 1; break; case 'F': case 'f': gpa = 0; break; default: gpa = -1; } System.out.println("Letter grade: " + letter); System.out.println("Grade point: " + gpa); } }
- 70. Switch: When To Use/When Not To Use When a switch can’t be used: For data types other than characters or integers Boolean expressions that aren’t mutually exclusive: As shown a switch can replace an ‘if-elseif’ construct A switch cannot replace a series of ‘if’ branches). Example when not to use a switch: if (x > 0) System.out.print(“X coordinate right of the origin”); If (y > 0) System.out.print(“Y coordinate above the origin”); Example of when not to use a switch: String name = in.readLine() switch (name) { }
- 71. Loops Python loops • Pre-test loops: for, while Java Pre-test loops • For • While Java Post-test loop • Do-while
- 72. While Loops Format: while (Boolean expression) Body Example: int i = 1; while (i <= 4) { // Call function createNewPlayer(); i = i + 1; }
- 73. For Loops Format: for (initialization; Boolean expression; update control) Body Example: for (i = 1; i <= 4; i++) { // Call function createNewPlayer(); i = i + 1; }
- 74. Post-Test Loop: Do-While Recall: Post-test loops evaluate the Boolean expression after the body of the loop has executed. This means that post test loops will execute one or more times. Pre-test loops generally execute zero or more times.
- 75. Do-While Loops Format: do Body while (Boolean expression); Example: char ch = 'A'; do { System.out.println(ch); ch++; } while (ch <= 'K');
- 76. Contrasting Pre Vs. Post Test Loops Although slightly more work to implement the while loop is the most powerful type of loop. Program capabilities that are implemented with either a ‘for’ or ‘do- while’ loop can be implemented with a while loop. Implementing a post test loop requires that the loop control be primed correctly (set to a value such that the Boolean expression will evaluate to true the first it’s checked).
- 77. Example: Post-Test Implementation Name of the online example: PostTestExample.java public class PostTestExample { public static void main (String [] args) { final int FIRST = 0; Scanner in = new Scanner(System.in); char answer; String temp; do { System.out.println("JT's note: Pretend that we play our game"); System.out.print("Play again? Enter 'q' to quit: "); temp = in.nextLine(); answer = temp.charAt(FIRST); } while ((answer != 'q') && (answer != 'Q')); } }
- 78. Example: Pre-Test Implementation Name of the online example: PreTestExample.java public class PreTestExample { public static void main (String [] args) { final int FIRST = 0; Scanner in = new Scanner(System.in); char answer = ' '; String temp; while ((answer != 'q') && (answer != 'Q')) { System.out.println("JT's note: Pretend that we play our game"); System.out.print("Play again? Enter 'q' to quit: "); temp = in.nextLine(); answer = temp.charAt(FIRST); } } }
- 79. Now What Happens??? import java.util.Scanner; public class PreTestExample { public static void main (String [] args) { final int FIRST = 0; Scanner in = new Scanner(System.in); char answer = ' '; String temp; while ((answer != 'q') && (answer != 'Q')) System.out.println("JT's note: Pretend that we play our game"); System.out.print("Play again? Enter 'q' to quit: "); temp = in.nextLine(); answer = temp.charAt(FIRST); } }
- 80. Many Pre-Created Classes Have Been Created Rule of thumb: Before writing new program code to implement the features of your program you should check to see if a class has already been written with the features that you need. The Java API is Sun Microsystems's collection of pre-built Java classes: http://java.sun.com/javase/6/docs/api/
- 81. Java : Objects & Classes A Java program can be defined as a collection of objects that communicate via invoking each other's methods. Object o Objects have states and behaviors. o Example: A dog has states - color, name, breed as well as behaviors -wagging, barking, eating. o If you compare the software object with a real world object, they have very similar characteristics. o A software object's state is stored in fields and behavior is shown via methods. o An object is an instance of a class.
- 82. Java : Objects & Classes Class o A class can be defined as a template that describes the behaviors /states that object of its type support. o Anatomy of a Java Class: Public class MyClass { Class body: variables, methods } NO semi-colon Access modifier Keyword class Name of the class
- 83. Java : Objects & Classes Class o Example: public class Dog{ String breed; int age; String color; void barking(){ } void hungry(){ } void sleeping(){ } } methods variables
- 84. Java : Objects & Classes Class o All objects of a class have the same methods. o All objects of a class have the same attributes o (i.e., name, type, and number). o For different objects, each attribute can hold a different value. o The values of the attributes define the object state, which is what makes each object unique.
- 85. Java : Objects & Classes Class o A class definition implements the class model. o The class behaviors/services/actions/operations are implemented by class methods. o The class attributes (data items) are called fields or instance variables. o In Java, classes are defined in files with the “.java” extension. o The name of the file must match the name of the class defined within it. o e.g. class ‘Baker’ must be in Baker.java
- 86. Java : Objects & Classes Attributes o An attribute is basically a state. o Anatomy of an Attribute: <modifier> <type> <name> [ = <initial_value>]; o Examples: public class Foo { private int x; private float y = 10000.0F; private String name = "Bates Motel"; }
- 87. Java : Objects & Classes Methods o A method is basically a behavior. o A class can contain many methods. It is in methods where the logics are written, data is manipulated and all the actions are executed. o Methods operate on the internal state of an object. o Object-to-object communication is done via methods.
- 88. Java : Objects & Classes Method code: local variables and statements Methods o Anatomy of a Method: public double getSalary (String name) { } Access modifier Return type Name of the method Parameters
- 89. Java : Objects & Classes Methods o Examples: public class Dog { private int weight; public int getWeight() { return weight; } public void setWeight(int x) { weight = x; } }
- 90. Java : Objects & Classes Constructors o Every class has a constructor. o Each time a new object is created, at least one constructor will be invoked. o The main rule of constructors is that they should have the same name as the class. o A class can have more than one constructor.
- 91. Java : Objects & Classes Constructors o If we do not explicitly write a constructor for a class, the Java compiler builds a default constructor for that class. o The default constructor takes no arguments o The default constructor has no body o It Enables you to create object instances with new Xxx()without having to write a constructor.
- 92. Java : Objects & Classes Constructors o Example: public class Puppy{ public Puppy(){ } public Puppy(String name){ // This constructor has one parameter, name. } }
- 93. Creating an Object: o Basically, an object is created from a class. The 'new' keyword is used to create a new object. o There are three steps when creating an object from a class: o Declaration: To declare an object, you just declare a variable( its type and name) to refer to that object. o Instantiation: The ‘new’ operator instantiates a class by allocating memory for a new object of that type. o Initialization: The 'new' keyword is followed by a call to a constructor. This call initializes the new object. Java : Objects & Classes
- 94. Creating an Object: (more details) o Object Declaration: o To declare an object, you just declare a variable( its type and name) to refer to that object. o In Java, classes can be used as data types. So, type can be the name of a class. o Classes are reference types. o Declarations notify the compiler that you will use name to refer to a variable whose type is type. o Declarations do not create new objects. Java : Objects & Classes
- 95. Creating an Object: o Example: public class Dog{ Private String name; public Dog(String nameDog){ // This constructor has one parameter, name. name=nameDog; } public static void main(String[]args){ // Following statement would create an object myDog Dog myDog =new Dog("tommy"); } } Java : Objects & Classes
- 96. Accessing Instance Variables and Methods o Instance variables and methods are accessed via created objects. o The “dot” notation: <object>.<member> o This is used to access object members including attributes and methods. o Examples: d.setWeight(42); d.weight = 42; // only permissible : if weight is public Java : Objects & Classes
- 97. Accessing Instance Variables and Methods public class Puppy{ int puppyAge; public Puppy(String name){ // This constructor has one parameter, name. System.out.println("Name is :"+ name); } public void setAge(int age ){ puppyAge = age; } public int getAge(){ System.out.println(puppyAge ); return puppyAge; } public static void main(String[]args){ /* Object creation */ Puppy myPuppy =new Puppy("tommy"); /* Call class method to set puppy's age */ myPuppy.setAge(2); /* Call another class method to get puppy's age */ myPuppy.getAge(); /* You can access instance variable as follows as well */ System.out.println(myPuppy.puppyAge ); } } Java : Objects & Classes
- 98. Encapsulation: Information hiding o The problem: Client code has direct access to internal data: MyDate d = new MyDate(); d.day = 32; // invalid day d.month = 2; d.day = 30; // reasonable but wrong d.day = d.day + 1; // no check for wrap around Java : Objects & Classes MyDay day month year
- 99. Encapsulation: Information hiding o The Solution: Client code must use setters/getters to access internal data: MyDate d = new MyDate(); d.setDay(32); // invalid day, returns false d.setMonth(2); d.setDay(30); // plausible but wrong d.setDay(d.getDay() + 1); Java : Objects & Classes MyDay day month year setDay( : Integer) : Void setMonth( : Integer) : Void setYear( : Integer) : Void getDay() : Integer getMonth() : Integer getYear() : Integer Verify days in month
- 100. Encapsulation o Encapsulation is one of the four fundamental OOP concepts. o Encapsulation is the technique of making the fields in a class private and providing access to the fields via public methods. o If a field is declared private, it cannot be accessed by anyone outside the class, thereby hiding the fields within the class. o Encapsulation is also referred to as data hiding. Java : Objects & Classes
- 101. Encapsulation o Encapsulation can be described as a protective barrier that prevents the code and data being randomly accessed by other code defined outside the class. o Access to the data and code is tightly controlled by an interface. o Benefits of Encapsulation: o The fields of a class can be made read-only or write-only. o A class can have total control over what is stored in its fields. Encapsulation gives maintainability, flexibility and extensibility to our code. Java : Objects & Classes
- 102. Method Overloading Enables you to send different types of parameter to a method. In Java, it is possible to overload methods that have the same name, provided they have different signatures. A method signature is formed by its name, together with the number and types of its arguments. Method Overloading is used when objects are required to perform a similar task but by using a different input parameters. When a method is called in an object, Java matches up the method name first, and then the number and type of parameters to decide which to execute. This process is known as polymorphism. Polymorphic functions are functions that do not care about the variable types being passed to them. As in some cases, Java’s automatic type conversion plays an important role in overloaded resolution.
- 103. Method Overloading: Example public class Movie { double cost; void setCost () { cost = 3.5; } void setCost (double ncost) //Overloaded Method { cost = ncost; } public static void main (String[]args) { Movie m1 = new Movie (); m1.setCost (); m1.setCost (3.25); } }
- 104. The this REFERENCE All instance methods receive an implicit argument called this, which can be used inside any method to refer to the current object. The current object is the object on which the method was called. In the body of the method, the this reference can be used like any other object reference, to access the instance variables and instance methods of the object. However, the this reference cannot be modified. The main situations where only this reference is a solution are: When the name of an instance variable is hidden by a formal argument of an instance method. Here to access the instance variable, you must use This.instance_variable_name When you need to pass a reference to the current object as an argument to another method. When you need to call a constructor from another constructor. Here we use this() syntax. The argument of this() must match with those of the target constructor and this() must be the first line in the constructor.
- 105. this Reference: Example class Movie { String title; String rating; double cost; void setDetails (String title, String nrating, double ncost) { this.title=title; rating=nrating; cost=ncost; } } class test3 { public static void main (String[]args) { Movie m1 = new Movie (); m1.setDetails("Lost Paradise","pG", 7.6); } }
- 106. Using this() to invoke current class constructor // Java code for using this() to // invoke current class constructor class Test { int a; int b; //Default constructor Test() { this(10, 20); System.out.println("Inside default constructor n"); } //Parameterized constructor Test(int a, int b) { this.a = a; this.b = b; System.out.println("Inside parameterized constructor"); } public static void main(String[] args) { Test object = new Test(); } }
- 107. Using this to return current class instance //Java code for using 'this' keyword //to return the current class instance class Test { int a; int b; //Default constructor Test() { a = 10; b = 20; } //Method that returns current class instance Test get() { return this; } //Displaying value of variables a and b void display() { System.out.println("a = " + a + " b = " + b); } public static void main(String[] args) { Test object = new Test(); object.get().display(); } }
- 108. Using this keyword as Method Parameter // Java code for using 'this' // keyword as method parameter class Test { int a; int b; // Default constructor Test() { a = 10; b = 20; } // Method that receives 'this' keyword as parameter void display(Test obj) { System.out.println("a = " +obj.a + " b = " + obj.b); } // Method that returns current class instance void get() { display(this); } public static void main(String[] args) { Test object = new Test(); object.get(); } }
- 109. Call by value and Call by Reference In Java the method parameters can be primitive data types or object references. Both are passed as value only but small tricky explanation is here for object references. When primitive data types are passed as method parameters, they are passed by value (a copy of the value) but incase of object references, the reference is copied (of course, here also a copy only) and passed to the called method. That is, object reference is passed as a value. So, original reference and the parameter copy both will refer the same Java object. As both refer the same object, if the calling method changes the value of its reference (passed from calling method), the original object value itself changes. Note that object itself is not passed, but it’s references is passed. Finally to say, in Java, everyone is passed by value. But with object, the value of the reference is passed.
- 110. Call by value or Pass by value public class CallByValue { public void display(int y) { y = 20; } public static void main(String args[]) { CallByValue cbv = new CallByValue(); int x = 10; cbv.display(x); System.out.println(x); // prints 10 and not 20 } }
- 111. Call by reference or Pass by Reference public class CallByReference { public void display(StringBuffer sb2) { sb2.append("World"); System.out.println(sb2); // prints HelloWorld } public static void main(String args[]) { CallByReference cbr = new CallByReference(); StringBuffer sb1 = new StringBuffer("Hello"); cbr.display(sb1); System.out.println(sb1); // prints HelloWorld } }
- 112. 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. The class which inherits the properties of other is known as subclass (derived class, child class) and the class whose properties are inherited is known as superclass (base class, parent class).
- 113. A class in Java can only extend one other class, i.e., a class can only have one immediate superclass. This is sometimes called Linear Inheritance. Multiple inheritance, i.e. a subclass inheriting from more than one superclass is not supported in Java. Instead Java provides interfaces which are not only new type names but also permit Multiple Inheritance.
- 114. Defining Subclass The root class for all Java objects is java.lang.Object class. It sits at the top of the inheritance hierarchy. If a class does not specify an explicit superclass, then the class is deemed to extend directly from Object. For example, if we define class Movie {…………} Then the parent class of Movie class becomes Object. To explicitly define the parent-child class relationship, the extends keyword is used.
- 115. extends Keyword extends is the keyword used to inherit the properties of a class. Following is the syntax of extends keyword. Syntax: class Super { ..... ..... } class Sub extends Super { ..... ..... }
- 116. Single Inheritance: Example // Java program to illustrate the // concept of single inheritance import java.io.*; import java.lang.*; import java.util.*; class one { public void print_geek() { System.out.println("Geeks"); } } class two extends one { public void print_for() { System.out.println("for"); } } // Driver class public class Main { public static void main(String[] args) { two g = new two(); g.print_geek(); g.print_for(); g.print_geek(); } }
- 117. The super REFERENCE The super reference is useful only when a class has a parent class. A subclass inherits all of the superclass methods and variables as well as creates its own. The super keyword refers to the immediate parent class object as “this” refers to the current objects and is used to access members of the superclass. The super has two general forms: The first is called superclass constructor. The second is used to access a member of the superclass that has been hidden by a member of a subclass. super(parameter list); super.membername;
- 118. Calling superclass Constructor super keyword can also be used to access the parent class constructor. One more important thing is that, ‘’super’ can call both parametric as well as non parametric constructors depending upon the situation.
- 119. Example: /* superclass Person */ class Person { Person() { System.out.println("Person class Constructor"); } } /* subclass Student extending the Person class */ class Student extends Person { Student() { // invoke or call parent class constructor super(); System.out.println("Student class Constructor"); } } /* Driver program to test*/ class Test { public static void main(String[] args) { Student s = new Student(); } }
- 120. Use of super with Variables This scenario occurs when a derived class and base class has same data members. In that case there is a possibility of ambiguity for the JVM.
- 121. Example: /* Base class vehicle */ class Vehicle { int maxSpeed = 120; } /* sub class Car extending vehicle */ class Car extends Vehicle { int maxSpeed = 180; void display() { /* print maxSpeed of base class (vehicle) */ System.out.println("Maximum Speed: " + super.maxSpeed); } } /* Driver program to test */ class Test { public static void main(String[] args) { Car small = new Car(); small.display(); } } Output: Maximum Speed: 120
- 122. Use of super with methods This is used when we want to call parent class method. So whenever a parent and child class have same named methods then to resolve ambiguity we use super keyword.
- 123. Example: /* Base class Person */ class Person { void message() { System.out.println("This is person class"); } } /* Subclass Student */ class Student extends Person { void message() { System.out.println("This is student class"); } // Note that display() is only in Student class void display() { // will invoke or call current class message() method message(); // will invoke or call parent class message() method super.message(); } } /* Driver program to test */ class Test { public static void main(String args[]) { Student s = new Student(); // calling display() of Student s.display(); } }
- 124. Other Important Points: Call to super() must be first statement in Derived(Student) Class constructor. If a constructor does not explicitly invoke a superclass constructor, the Java compiler automatically inserts a call to the no-argument constructor of the superclass. If the superclass does not have a no-argument constructor, you will get a compile-time error. Object does have such a constructor, so if Object is the only superclass, there is no problem. If a subclass constructor invokes a constructor of its superclass, either explicitly or implicitly, you might think that a whole chain of constructors called, all the way back to the constructor of Object. This, in fact, is the case. It is called constructor chaining.
- 125. Constructor Chaining A class does not inherit constructors from its superclass. Objects of the subclass are always constructed from the top class down to bottom class, that is, from the Object class down to the class that is being instantiated using the new keyword. This ensures that a constructor in a base class can always rely on proper constructors of its superclass. In Java, constructor chaining is a sequence of invoking constructors upon initializing an object. It is used when we want to invoke a number of constructors, one after another by using only an instance. It occurs through inheritance. When we create an instance of a derived class, all the constructors of the inherited class (base class) are first invoked, after that the constructor of the calling class (derived class) is invoked.
- 126. We can achieve constructor chaining in two ways: Within the same class: If the constructors belong to the same class, we use this From the base class: If the constructor belongs to different classes (parent and child classes), we use the super keyword to call the constructor from the base class. In a class hierarchy, constructors are called in order of derivation, from superclass to subclass.
- 127. Example: class A { A() { System.out.println(“Inside A’s Constructor”); } } Class B extends A { B() { System.out.println(“Inside B’s Constructor”); } } class C extends B { C() { System.out.println(“Inside C’s Constructor”); } } class inherit6 { public static void main(String args[]) { C c1= new C(); } } Output: Inside A’s Constructor Inside B’s Constructor Inside C’s Constructor
- 128. Method Overriding If subclass (child class) has the same method as declared in the parent class, it is known as method overriding in Java. In other words, If a subclass provides the specific implementation of the method that has been declared by one of its parent class, it is known as method overriding. Method overriding is used to provide the specific implementation of a method which is already provided by its superclass. Method overriding is used for runtime polymorphism
- 129. Rules for Method Overriding The method must have the same name as in the parent class The method must have the same parameter as in the parent class. There must be an IS-A relationship (inheritance).
- 130. Example: //Java Program to illustrate the use of Java Method Overriding //Creating a parent class. class Vehicle{ //defining a method void run(){System.out.println("Vehicle is running");} } //Creating a child class class Bike2 extends Vehicle{ //defining the same method as in the parent class void run(){System.out.println("Bike is running safely");} public static void main(String args[]){ Bike2 obj = new Bike2();//creating object obj.run();//calling method } }
- 131. The Final Keyword The final keyword in java is used to restrict the user. The java final keyword can be used in many context. Final can be: 1. variable 2. method 3. class
- 132. final Variables • Specifying a variable as final prevents modification of its value. • This ensures that a value is consistent across all users of a class. To declare a variable as final, add the final keyword before the variable declaration. • A final variable is a constant and must be instantiated. • A final variable that is not initialized at the time of declaration is known as blank final variable. It can be initialized only in constructor. • Generally they have public access. • final double PI=3.14;
- 133. Final Methods All methods can be overridden by default in the subclass. To prevent the subclass from overriding the members of the superclass, we can declare them as final using the keyword final. final void disp() {…..} final method is inherited but you cannot override it. Final Class If you make any class as final, you cannot extend it. Eg. Final class bike {….}
- 134. Final Class When a class is declared with final keyword, it is called a final class. A final class cannot be extended(inherited). There are two uses of a final class : One is definitely to prevent inheritance, as final classes cannot be extended. The other use of final with classes is to create an immutable class like the predefined String class. You can not make a class immutable without making it final.
- 135. Handling Strings In Java, a string is a sequence of characters. But, unlike many other languages that implement strings as character arrays, Java implements strings as objects of type String. Implementing strings as built-in objects allows Java to provide a full complement of features that make string handling convenient. In Java, strings are objects of class String. The String class implements immutable character strings, which are read only, after the string has been created and initialized. Once a string object is created it cannot be changed. For example, Java has methods to compare two strings, search for a substring, concatenate two strings, and change the case of letters within a string. Also, String objects can be constructed a number of ways, making it easy to obtain a string when needed.
- 136. String Constructors The String class has several constructors defined. To create an empty string the default constructor is used. For example: String(): Creates a new, empty string. String s = new String(); It will create the instance of the string with no characters in it. String (String astring): constructs a new string that is a copy of the string astring. If we want to initialize the string with values we can use following constructor. String(char chars[]) For example: char chars[] = {‘h’, ‘e’, ‘l’, ‘l’, ‘o’}; String s = new String(chars);
- 137. String(char arrayOfChars[ ], int startingCharacter, int lengthOfSubarray): Constructs a new string in the same way as the previous constructor. The difference is that instead of copying the entire array, it just copies the length of subarray elements beginning with index startingCharacter. char chars[ ]={‘a’, ‘b’, ‘c’, ‘d’, ‘e’, ‘f’}; String str = new String(chars, 2, 3); The string gets initialized to the string “cde”. String(byte[ ] array): Constructs a new string from an array of byte values.
- 138. String Length To obtain the number of characters that a string contains use the length () method. String s = “Pramod”; int len = s.length();
- 139. String Concatenation Java uses + and += operators to indicate concatenation. String str1= “ABCD”; String str2= “LTD”; String str3= str1+ str2; //assign ABCDLTD String S = “Four: ” + 2 + 2;//assign Four:22 String S1 = “Four:” + (2+2); //assign Four:4 Method concat() can also be used. String s = “First”; String t = “Second”; s.concat(t);
- 140. String Conversion and toString() Every class in java is child of Object class either directly or indirectly. Object class contains toString() method. We can use toString() method to get string representation of an object. Whenever we try to print the Object reference then internally toString() method is invoked. If we did not define toString() method in your class then Object class toString() method is invoked otherwise our implemented/Overridden toString() method will be called.
- 141. // Java program to illustrate // working of toString() method class Best_Friend { String name; int age; String college; String course; String address; Best_Friend (String name, int age, String college, String course, String address) { this.name = name; this.age = age; this.college = college; this.course = course; this.address = address; } public String toString() { return name + " " + age + " " + college + " " + course + " " + address; } public static void main(String[] args) { Best_Friend b = new Best_Friend("Gulpreet Kaur", 21, "BIT MESRA", "M.TECH", "Kiriburu"); System.out.println(b); System.out.println(b.toString()); } }
- 142. Character Abstraction Methods charAt(): To extract a single character from a string, the method is char charAt(int where) Here, where is the index of the character. char ch; ch = “abc”. charAt(1); //assign ‘b’ to ch. In strings, the first character is at index 0, and the last one at index one less than the length of the string. If the index value is not valid, a StringIndexOutOfBoundsException is thrown.
- 143. getchars() getchars(): to extract more than one character at a time, the method is void getChars( int sourceStart, int sourceEnd, char target[ ], int targetStart) String S= “String class is a final class.”; int start = 7; int end = 23; char buf[ ] = new char [end-start]; S.getChars(start, end, buf, 0); System.Out.println(buf); Output: class is a final
- 144. toCharArray() It is used to convert all the characters in a string object into a character array. char[ ] toCharArray() char[ ] c = “Hello”.toCharArray(); This stores the characters of “Hello” string into character array c.
- 145. String Comprison methods equals() the String class overrides the equals() method from the Object class. It compares two strings for equality, i.e., the two objects have the same sequence of characters. boolean equals(Object str) Here, str is the object compared with the invoking string object. String S1= “Hello”; String S2 = “Hello”; System.out.println( S1 + “equals” + S2 + S1.equals(S2) ); Output: Hello Equals Hello true
- 146. equalsIgnoreCase() To compare two strings for equality, ignoring the case difference boolean equalsIgnoreCase(String str) Here, str is a string Object compared with the invoking string. String S1= “hello”; String S2 = “Hello”; System.out.println( S1 + “equals” + S2 + “>>” + S1.equalsIgnoreCase(S2) ); Output: Hello Equals Hello >> true
- 147. compareTo() The Java String compareTo() method is used for comparing two strings lexicographically. Each character of both the strings is converted into a Unicode value for comparison. If both the strings are equal then this method returns 0 else it returns positive or negative value. The result is positive if the first string is lexicographically greater than the second string else the result would be negative. int compareTo(String str) Example: int i= “abcd”.compareTo(“abbb”); //returns 1 int i= “abcd”.compareToIgnoreCase(“AbcD”); //returns 0
- 148. Searching and modifying Strings indexOf(): this method searches the first occurrence of a character or a string and return the index at which the character or string was found, or -1 on failure. int indexOf(int ch) Other overloaded forms are: int indexOf(int ch, int fromINdex) int indexOf(String str) int indexOf(String str, int fromIndex) Example: String S= “ABCDE LTD”; System.out.println(“indexOf(C)” + S.IndexOf(‘C’)); System.out.println(“indexOf(TD)” + S.IndexOf(‘TD’));
- 149. lastIndexOf() This method searches for the last occurrence of a character/string. int lastIndexOf(int ch) Example: String S =“UPTEC LTD”; System.out.println(“lastIndexOf(T)” + S.lastIndexOf(‘T’));
- 150. substring() The String class provides two overloaded methods to extract substring from a string. String substring(int startIndex): returns substring that begins with startIndex and runs to the end of the invoking string. String substring(int startIndex, int endIndex): Here, startIndex specifies the index at which the substring will begin and endIndex specifies the stopping point, excluding the characters at endIndex position. Example: String S=“HITEC LTD”; System.out.println(S.substring(6,8); Output: LT
- 151. replace() To replace all occurances of one character with another, the method used is replace(). String replace(char original, char replacement) Here, original specifies the character to be replaced by the character specified by replacement. String S= “Hello”.replace(‘l’, ‘w’); Here, “Hewwo” gets stored in the string object S.
- 152. trim() It returns a copy of the invoking string from which any leading and trailing whitespace has been removed. It takes the following general form: String trim() Example: String S= “Hello World “.trim(); The value “HelloWorld” gets stored into object S.
- 153. Changing Case of Characters The method toLowerCase( ) and toUpperCase( ) convert all the characters in a string from uppercase to lowercase and from lowercase to uppercase. Non-alphabetical character such as digits are unaffected. String toLowerCase( ) String toUpperCase( ) Example: String S = “This is a Test”; String upper = S.toUpperCase(); //THIS IS A TEST String lower = S.toLowerCase(); //this is a test
- 154. The StringBuffer Class StringBuffer represents growable and writeable character sequences. A StringBuffer is like the String data type, but it has methods for modifying the contents of the StringBuffer. String and StringBuffer classes both are two independent final classes, both directly extending the Object Class. Example: String message = “Hello World”; message = message + “!!”; When the Java compiler encounters code written above, it rewrites it as follows: message = new StringBuffer(message).append(“!!”).toString( )
- 155. Constructors StringBuffer defines the following three constructors: StringBuffer(): The default constructor reserves room for 16 characters. StringBuffer(int Size): explicitly sets the size of the buffer. StringBuffer(String str): sets the initial content of StringBuffer object and reserves room for 16 more characters. StringBuffer sb1 = new StringBuffer(“Java); //buffer size = 20 StringBuffer sb2 = new StringBuffer(10); //buffer size = 10 StringBuffer sb3 = new StringBuffer( ); //buffer size = 16
- 156. Methods of StringBuffer Class length( ): returns current length of the StringBuffer, i.e. the number of characters in the StringBuffer. Example: StringBuffer sb = new StringBuffer(“Hello”); System.out.println(“Length = “ + sb.length( ) ); Output: Length = 5 capacity( ): method finds out total allocated capacity for characters. System.out.println(“Capacity = “ + sb.capacity( ) ); Output: Capacity = 21
- 157. setLength( ) This method sets the length of the buffer. void setLength(int length) Here, len specifies the length of the buffer which must be greater than or equal to zero. Example: StringBuffer sb = new StringBuffer(“Hello”); sb.setLength(2); System.out.println(“sb = “ + sb ); Output: sb = He
- 158. Multithreading
- 159. What is Thread?
- 160. A thread is a single sequential flow of control within a program. Thread does not have its own address space but uses the memory and other resources of the process in which it executes. There may be several threads in one process The Java Virtual Machine (JVM) manages these and schedules them for execution.
- 161. What is Multithreading ?
- 162. Multithreading is a conceptual programming paradigm where a program (process) is divided into two or more subprograms (process), which can be implemented at the same time in parallel. For example, one subprogram can display an animation on the screen while another may build the next animation to be displayed. A program that contains multiple flow of control is known as multithreaded program.
- 163. Cont.. Since threads in java are subprograms of a main application program and share the same memory space, they are known as lightweight threads or lightweight processes. ‘threads running in parallel’ does not really mean that they actually run at the same time. Since all the threads are running on a single processor, the flow of execution is shared between the threads. The java interpreter handles the switching of control between the threads in such a way that it appears they are running concurrently.
- 164. Cont.. Multithreading enables programmers to do multiple things at one time. For ex, we can send tasks such as printing into the background and continue to perform some other task in the foreground. Threads are extensively used in java-enabled browser such as HotJava. These browsers can download a file to the local computer, display a web page in the window, output another web page to a printer and so on. The ability of a language to support multithreads is referred to as concurrency.
- 165. A Single Threaded Program class ABC { ………. ...…….. ………. ...…….. ………. ...…….. } Beginning Single-threaded Body of Execution End
- 166. A Multithreaded Program start start start switching switching Main Method Module
- 167. Thread Life Cycle During the life time of a thread, there are many states it can enter. They include: 1. Newborn state 2. Runnable State 3. Running State 4. Blocked State 5. Dead State
- 168. 1. Newborn State When we create a thread object, the thread is born and is said to be in newborn state. The thread is not yet scheduled for running. At this state, we can do only one of the following with it: Schedule it for running using start() method. Kill it using stop() method If scheduled, it moves to the runnable state. If we attempt to use any other method at this stage, an exception will be thrown.
- 169. Scheduling a Newborn Thread Newborn Runnable State Dead State start stop
- 170. 2. Runnable state (start()) The runnable state means that the thread is ready for execution and is waiting for the availability of the processor. That is, the thread has joined the queue of threads that are waiting for execution. If all threads have equal priority, then they are given time slots for execution in round robin fashion. i.e. first-come, first-serve manner.
- 171. Cont.. at the end and again waits for its turn. This process of assigning time to threads is known as time- slicing. If we want a thread to relinquish control to another thread of equal priority before its turn comes, we can do so by using the yield() method. The thread that relinquishes control joins the queue
- 172. Releasing Control Using yield() ……...... ……...... yield() Running Thread Runnable Thread
- 173. 3. Running State Running means that the processor has given its time to the thread for its execution. The thread runs until it relinquishes control on its own or it is preempted by a higher priority thread. A running thread may relinquish its control in one of the following situations:
- 174. 1. Suspend() and resume() Methods:- This approach is useful when we want to suspend a thread for some time due to certain reason, but do not want to kill it. Running Runnable Suspended suspended resume
- 175. 2. Sleep() Method :- This means that the thread is out of the queue during this time period. The thread re-enter the runnable state as soon as this time period is elapsed. Running Runnable Sleeping sleep(t)
- 176. 3. Wait() and notify() methods :- blocked until certain condition occurs Running Runnable Waiting wait notify
- 177. 4. Blocked State A thread is said to be blocked when it is prevented form entering into the runnable state and subsequently the running state. This happens when the thread is suspended, sleeping, or waiting in order to satisfy certain requirements. A blocked thread is considered “ not runnable” but not dead and therefore fully qualified to run again.
- 178. 5. Dead State A running thread ends its life when is has completed executing its run() method. It is a natural death. However, we can kill it by sending the stop message to it at any state thus causing a premature death to it. A thread can be killed as soon it is born, or while it is running, or even when it is in “not runnable” (blocked) condition.
- 179. State diagram of a thread yield Newborn start stop stop stop suspended sleep wait resume notify Blocked Dead Running Runnable Active Thread New Thread Idle Thread (Not Runnable) Killed Thread
- 180. Creating Threads Thread class in the java.lang package allows you to create and manage threads. Each thread is a separate instance of this class. A new thread can be created in two ways: 1. By extending a thread class 2. By implementing an interface
- 181. Extending the Thread class We can directly extend the Thread class class Threadx extends Thread { public void run() { //logic for the thread } } The class ThreadX extends Thread. The logic for the thread is contained in the run() method.
- 182. Implementing Runnable Interface Declare a class that implements the Runnable interface. This method declares only one method as shown here: public void run(); class RunnableY implements Runnable { Public vod run() { // logic for thread } }
- 183. Cont.. The application can start an instance of the thread by using the following code: RunnableY ry = new RunnableY(); ThreadY ty= new Thread(ry); Ty.start(); 1st line instantiate the RunnableY class. 2nd line instantiate the Thread class. A reference to the RunnableY object is provided as the argument to the constructor. Last line starts the thread.
- 184. Stopping a Thread Whenever we want to stop a thread form running further, we may do so by calling its stop() method like: ty.stop(); The stop() method may be used when the premature death of a thread is desired
- 185. Blocking a Thread A thread can also be temporarily suspended or blocked form entering into the runnable and subsequently running state by using either of the following thread methods: Sleep() – blocked for a specified time. Suspend() – blocked until further orders. Wait() – blocked until certain condition occurs.
- 186. Cont.. These methods cause the thread to go into the blocked state. The thread will return to the runnable state when the specified time is elapsed in the case of sleep(), the resume() method is invoked in the case of suspend(), and the notify() method is called in the case of wait().
- 187. CREATING THREADS EXAMPLE:- class A extends Thread { public void run() { for(int i=1;i<=5;i++) { System.out.println("From ThreadA : i = "+ i); } System.out.println("Exit from A"); } } class B extends Thread { public void run() { for(int j=1;j<=5;j++) { System.out.println("From ThreadB : j = "+ j); } System.out.println("Exit from B"); } } class C extends Thread { public void run() { for(int k=1;k<=5;k++) { System.out.println("From ThreadA : k = "+ k); } System.out.println("Exit from C"); } } public class threadtest { public static void main(String[] args) { new A().start(); new B().start(); new C().start(); } } OUTPUT:- From ThreadB : j = 1 From ThreadA : k = 1 From ThreadA : i = 1 From ThreadA : k = 2 From ThreadA : k = 3 From ThreadA : k = 4 From ThreadA : k = 5 Exit from C From ThreadB : j = 2 From ThreadB : j = 3 From ThreadB : j = 4 From ThreadB : j = 5 Exit from B From ThreadA : i = 2 From ThreadA : i = 3 From ThreadA : i = 4 From ThreadA : i = 5 Exit from A
- 188. USING THREAD METHODS:- class A1 extends Thread { public void run() { for(int i=1;i<=5;i++) { if(i==1) yield(); System.out.println("From ThreadA : i = "+ i); } System.out.println("Exit from A"); } } class B1 extends Thread { public void run() { for(int j=1;j<=5;j++) { System.out.println("From ThreadB : j = "+ j); if(j==3) stop(); } System.out.println("Exit from B"); } } class C1 extends Thread { public void run() { for(int k=1;k<=5;k++) { System.out.println("From ThreadA : k = "+ k); if(k==1) sleep(1000); } System.out.println("Exit from C"); } } OUTPUT:- Started thread A Started thread B Started thread C End of main thread From ThreadA : k = 1 From ThreadA : i = 1 From ThreadB : j = 1 From ThreadB : j = 2 From ThreadB : j = 3 From ThreadA : i = 2 From ThreadA : i = 3 From ThreadA : i = 4 From ThreadA : i = 5 Exit from A From ThreadA : k = 2 From ThreadA : k = 3 From ThreadA : k = 4 From ThreadA : k = 5 Exit from C public class thread2 { public static void main(String[] args) { A1 threadA = new A1(); B1 threadB = new B1(); C1 threadC = new C1(); System.out.println("Started thread A"); threadA.start(); System.out.println("Started thread B"); threadB.start(); System.out.println("Started thread C"); threadC.start(); System.out.println("End of main thread"); } }
- 189. Thank You..