Core JAVA

JAVA
====
DIFFERENCE BETWEEN 'C', C++ AND JAVA

==================================
====
C, C++ ARE CALLED PLATFORM DEPENDENT LANGUAGES.

BECAUSE THESE LANGUAGES PRODUCES EXECUATABLE
FILES. THESE EXECUTABLE FILES EXECUTES ONLY ON
PARTICULAR PLAFORM (OPERATING SYSTEM). AFTER
COMPILING JAVA PRODUCES CLASS FILE WHICH CONTAINS
BYTE CODES. THESE BYTE CODES ARE INTERMEDIATE
CODE, WHICH IS NOT RELATED TO ANY OPERATING
SYSTEM. BUT EXECUTES ON ANY OPERATING SYSTEM
WITH THE HELP OF JVM (JAVA VIRTUAL MACHINE). JVM IS
THE INTERPRETER FOR BYTE CODES. JVM CONVERTS THE
BYTE CODES INTO APPROPRIATE OPERATING SYSTEM
INSTRUCTIONS. THE SLOGAN OF JAVA IS "WRITE ONCE,
RUN ANYWHERE (OS)".
INTRODUCTION TO JAVA
=====================
IN 1991 JAMES GOSLING (PROJECT LEADER) WANTS TO

DEVELOP A SOFTWARE WHICH IS USED IN TV REMOTES,
MICRO WOVENS, REFRIGIRATORS. JAMES GOSLING FIRST
SELECTED 'C++' LANGUAGE TO DEVELOP THAT
SOFTWARE. AFTER SOME DEVELOPMENT, HE FINDS SOME
PROBLEMS TO DEVELOP SOFTWARE IN 'C++'. THE
PROBLEMS ARE POINTERS AND OPERATOR
OVERLOADING. THE MAIN PROBLEM BY USING C++ IS
THAT IS SYSTEM DEPENDENT. THEN HE WANTS FIRST TO
DEVELOP A NEW LANGUAGE WHICH IS SIMILAR TO C++,
WHICH ELIMINATES POINTERS AND OPERATOR
OVERLOADING AND DIFFICULT TOPICS IN 'C++'
LANGUAGE AND WHICH IS SYSTEM INDEPENDENT. THEN
HE DEVELOPS NEW LANGUAGE CALLED "OAK" (TREE
NAME). BUT THE NAME IS ALREADY REGISTERED IN
SOFTWARE INDUSTRY. SO IT WAS RENAMED AS JAVA
(COFFE) IN 1995. AFTER SOME MODIFICATIONS FINALLY
JAVA WAS DEVELOPED BY SUN MICRO SYSTEMS OF USA.
VERSIONS OF JAVA
=================
JDK 1.0 ====> 1996 (JAVA DEVELOPMENT KIT)

JDK 1.1 ====> 1997
J2SE 2.0 ====> 1998 (JAVA 2 STANDARD EDITION)
J2SE 3.0 ====> 2000
J2SE 4.0 ====> 2002

J2SE 5.0 ====> 2004
J2SE 6.0 ====> 2006
J2SE 7.0 ====> 2008
J2SE 8.0 ====> 2010
EDITIONS OF JAVA
=================
SUN ORGANIZATION DIVIDES THE JAVA INTO 3 PARTS.
1) J2SE (JAVA 2 STANDARD EDITION)

2) J2EE (JAVA 2 ENTERPRISE EDITION)
3) J2ME (JAVA 2 MICRO / MOBILE EDITION)
J2SE :- IT DEALS WITH DEVELOPING STANDALONE

APPLICATIONS, FUNDAMENTAL APPLICATIONS FOR A
NETWORK.
J2EE :- IT DEALS WITH DEVELOPING BUSINESS SOLUTIONS

ON INTERNET.
J2ME :- IT DEALS WITH DEVELOPING EMBEDDED SYSTEMS

AND WIRELESS APPLICATIONS.
EMBEDDED SYSTEMS :- STORING PROGRAMS IN

HARDWARE OR CHIP. USING EMBEDDED SYSTEMS WE
CAN WRITE PROGRAMS DIRECTLY IN CHIPS.
FEATURES OF JAVA
==================
SIMPLE :- JAVA IS A SIMPLE PROGRAMMING LANGUAGE.

LEARNING JAVA IS EASY. BECAUSE ALMOST JAVA SYNTAX
IS SIMILAR TO 'C' AND 'C++'. DIFFICULT TOPICS ARE
ELIMINATED IN JAVA LIKE POINTERS AND OPERATOR
OVERLOADING. THE FOLLOWING TOPICS ARE ALSO
ELIMINATED FROM JAVA. (GOTO, TYPEDEF, SIZEOF,
UNSIGNED INTEGER, STRUCTURES, UNIONS, HEADER
FILES, MULTIPLE INHERITANCE).
OBJECT ORIENTED :- JAVA IS PURELY OBJECT ORIENTED

LANGUAGE. WHEREAS C++ IS NOT PURELY OBJECT
ORIENTED LANGUAGE. ANOTHER EXAMPLE FOR PURELY
OBJECT ORIENTED LANGUAGE IS SMALL TALK.
METHOD :- IT IS NOTHING BUT A FUNCTION. BUT

COMPARING WITH FUNCTION THE DIFFERENCE IS, IT
MUST BE WRITEN INSIDE A CLASS. WE DON'T HAVE
FUNCTIONS IN JAVA, ONLY METHODS ARE THERE.
DISTRIBUTED :- USING JAVA WE CAN DEVELOP NETWORK

APPLICATIONS. NETWORK APPLICATION IS USED BY ALL
SYSTEMS IN THAT NETWORK. DISTRIBUTED APPLICATION
MEANS, IT CAN ACCESS INFORMATION FROM MULTIPLE
SYSTEMS AT A TIME. USING JAVA, WE CAN DEVELOP
DISTRIBUTED APPLICATION.
ROBUST (STRONG / UNBREAKABLE) :- JAVA PROGRAMS

WILL NOT CRASH EASILY. BECAUSE OF ITS MEMORY
MANAGEMENT AND EXCEPTION HANDLING FEATURES, WE
CAN WRITE BREAK FREE PROGRAMS. GENERALLY
PROGRAMS ARE BREAK DUE TO MEMORY INSUFFICIENCE.
IN JAVA, MEMORY IS ALLOTED BY JVM'S CLASS LOADER
SUB SYSTEM AND DEALLOCATION IS DONE BY JVM'S
GARBAGE COLLECTOR.
GARBAGE COLLECTOR :- IT REMOVES UNUSED VARIABLES

& OBJECTS FROM THE MEMORY. THIS MEMORY CAN BE
USED BY ANOTHER VARIABLES OR OBJECTS.
SECURE :- JAVA IS A SECURE LANGUAGE BECAUSE JAVA

CONTAINS FILEWALLS. FILEWALLS STRICTLY CHECKS
EVERYTHING BEFORE DOWNLOADING INTO OUR SYSTEM.
JAVA ENABLES THE CONSTRUCTION OF VIRUS FREE
APPLICATIONS.
ARCHITECURE NEUTRAL :- JAVA'S BYTE CODE IS NOT

MACHINE DEPENDENT. IT CAN RUN ON ANY MACHINE
WITH ANY PROCESSOR AND ANY OPERATING SYSTEM.
PORTABILITY :- JAVA PROGRAMS GIVE SAME RESULTS ON

ALL MACHINES.
INTERPRETED :- JAVA PROGRAMS ARE COMPILED TO

GENERATED THE BYTE CODE. THIS BYTE CODE CAN BE
DOWNLOADED AND IS EXECUTED BY THE INTERPRETER.
BOTH COMPILER AND INTERPRETER PRESENT IN JAVA.
X.JAVA ====> COMPILER ====> X.CLASS ====>

JVM (INTERPRETER + JIT COMPILER)
HIGH PERFORMANCE :- ALONG WITH INTERPRETER,

THERE WILL BE A JIT (JUST IN TIME) COMPILER, WHICH
ENHANCES THE SPEED OF EXECUTION. SO THAT BOTH
COMPILER AND INTERPRETER RUN THE PROGRAM

SIMULTANEOUSLY.
NATIVE METHODS :- METHODS WRITTEN IN OTHER

LANGUAGE LIKE C AND C++.
MULTI THREADED :- THREAD MEANS PROCESS OR

EXECUTION. EXECUTING DIFFERENT PARTS OF A
PROGRAM SIMULTANEOUSLY IS CALLED MULTITHREADING.
THIS IS AN ESSENTIAL FEATURE TO DESIGN SERVER SIDE
PROGRAMS.
DYNAMIC :- WE CAN DEVELOP PROGRAMS IN JAVA WHICH

DYNAMICALLY INTERACT WITH THE USER ON INTERNET.
TOOLS OF JDK (JAVA DEVELOPMENT KIT)
==================================
====
JAVAC (COMPILER):- IT IS USED TO CONVERT JAVA

PROGRAM INTO CLASS FILE WHICH CONTAINS BYTE
CODES.
JAVA (INTERPRETER) :- IT IS USED TO EXECUTE CLASS

FILE MEANS BYTE CODES.
APPLETVIEWER :- IT IS USED TO EXECUTE APPLETS

(SMALL WEB PROGRAMS).
METHOD :- SET OF STATEMENTS.
CLASS :- SET OF METHODS.
PACKAGE :- SET OF CLASSES.
JSL (JAVA STANDARD LIBRARY) :- SET OF PACKAGES.
JRE (JAVA RUNTIME ENVIRONMENT) : JVM + JSL.
TYPES OF JAVA APPLICATIONS

===========================
1) STANDALONE APPLICATIONS
2) APPLETS
STANDALONE APPLICATIONS :- THESE ARE GENERAL

PROGRAMS WHICH ARE NOT RELATED TO INTERNET.
THESE APPLICATIONS ARE EXECUTED BY JAVA
INTERPRETER (JAVA TOOL). THESE APPLICATIONS
CONTAINS MAIN( ) METHOD. SO PROGRAM EXECUTION
STARTS FROM MAIN( ) METHOD.
APPLETS :- THESE ARE SMALL WEB PROGRAMS. APPLETS

ARE EXECUTED BY WEB BROWSER (INTERNET EXPLORER,
MOZILLA FIREFOX, GOOGLE CHROME) OR APPLETVIEWER
TOOL. BECAUSE THESE APPLICATIONS DON'T HAVE
MAIN( ) METHOD.
A SAMPLE PROGRAM
===================
class First
{
public static void main(String args[ ])
{
System.out.print("Welcome to Java Programming");
}
}
OUTPUT
========
Welcome to Java Programming
Note :- THE ABOVE PROGRAM MUST BE SAVED AS

"First.java". BECAUSE CLASS NAME AND FILE NAME MUST
BE SAME. IN JAVA ALL CLASS NAMES MUST START WITH
UPPER CASE ALPHABET.
IDE :- IT STANDS FOR INTEGRATED DEVELOPMENT

ENVIRONEMNT, WHICH ALLOWS TO WRITE, SAVE,
COMPILE, DEBUG AND EXECUTE A PROGRAM. UPTO JAVA
1.5 THERE IS NOT IDE AVAILABLE FOR JAVA. FROM JAVA
1.6 NET BEANS (IDE) IS AVAILABLE FOR JAVA. ECLIPSE IS
THE FAMOUS IDE FOR JAVA.
EDITOR :- WHICH IS USED TO ADD, MODIFY AND REMOVE

TEXT. THE FAMOUS EDITOR FOR MS-DOS IS "edit" AND
WINDOWS IS "notepad".
START ====> RUN (cmd / command)
C:\WINDOWS> cd\
C:\> cd program files
C:\PROGRAM FILES> cd java
C:\PROGRAM FILES\JAVA> dir
C:\PROGRAM FILES\JAVA> cd jdk1.6.0_02
C:\PROGRAM FILES\JAVA\JDK1.5.0> cd bin
C:\PROGRAM FILES\JAVA\JDK1.5.0\BIN>
edit First.java / Notepad First.java
WRITE PROGRAM
SAVE & EXIT
COMPILE PROGRAM : javac First.java
EXECUTE PROGRAM : java First
PRINT & PRINTLN METHODS
Second.java
class Second
{
{
System.out.println("One");
System.out.println("Two");
System.out.print("Three");
}
}
IMPORTING PACKAGES :- BEFORE USING ANY CLASS WE

MUST IMPORT THE APPROPRIATE PACKAGE IN THE
FOLLOWING MANNER.
import package_name.class_name;
Ex :-import java.lang.System;
import java.lang.String;
IF WE WRITE
import java.lang.*;
ALL CLASSES ARE IMPORTED FROM java.lang PACKAGE

INTO OUR PROGRAM.
java.lang :- IT CONTAINS PRIMARY CLASSES FOR JAVA
PROGRAMMING LIKE System, String ETC. THIS PACKAGE IS
IMPORTED BY DEFAULT INTO EVERY JAVA PROGRAM.
ESCAPE SEQUENCES :- WHICH ARE STARTED WITH

BACKSLASH. THESE ARE ALSO CALLED NON PRINTABLE
CHARACTERS / ACTION CHARACTERS. BECAUSE THESE
CHARACTERS NOT PRINT ON THE SCREEN. THESE
CHARACTERS PERFORMS SOME ACTION.
\n, \t, \b, \r, \', \", \\
b : backspace, r : carragie return (same line first column)
class Third
{
{
System.out.print("One\n");
System.out.println("Two");
System.out.print("1\t");
System.out.println("2");
System.out.print("Rama\b");
System.out.print("Babu\n");
System.out.println( ); // (Generates Empty Line);
System.out.print("Rama\r");
System.out.println("Sai");
System.out.println("This is Rama\'s Pen");.
System.out.println("This is \"rama\" Pen");
System.out.print("c:\\java\\jdk1.5.0\\bin");
}
NAMING CONVENTIONS IN JAVA

=============================
1) ALL PACKAGE NAMES IN JAVA ARE WRITTEN IN ALL

SMALL LETTERS.
Ex :-java.lang, java.awt, java.io, javax.swing
2) CLASS / INTERFACE NAME IN JAVA NAME SHOULD

START WITH CAPITAL LETTER. IF A CLASS OR INTERFACE
HAS MULTIPLE WORDS THEN EACH WORD OF CLASS OR
INTERFACE START WITH A CAPITAL LETTER. INITIAL CAPS.
Ex :- System, String, StringBuffer,DataInputStream
3) METHOD NAME SHOULD START WITH SMALL LETTER. IF

A METHOD HAS MULTIPLE WORDS THEN EACH WORD OF
METHOD START WITH A CAPITAL LETTER.
Ex :- print( ), getChars( ), setActionCommand( )
4) VARIABLE NAMES FOLLOWS SAME AS METHOD RULES.
Ex :-age, empName, avgMarks
5) CONSTANT (LITERALS) VARIABLES SHOULD BE

WRITTEN USING ALL CAPITAL LETTERS. USE UNDERSCORE
IF A CONSTANT HAS MULTIPLE WORDS.
Ex :-PI, MAX_VALUE, DAY_OF_WEEK
IMPORTANT PACKAGES OF JAVA

=============================
java.lang :- THE BASIC CLASSES THAT ARE USED IN JAVA

PROGRAM ARE PRESENT IN THIS PACKAGE. THIS PACKAGE
CONTAINS PRIMARY CLASSES AND INTERFACES. IT IS
ESSENTIAL FOR JAVA PROGRAM. IT CONTAINS WRAPPER
CLASSES, STRINGS, MULTITHREADING CLASSES ETC.
java.util (UTILITIES) :- THIS PACKAGE CONTAINS USEFUL

CLASSES AND INTERFACES LIKE STACK, LINKEDLIST,
DATE, ARRAYS ETC.
java.io :- THIS PACKAGE CONTAINS CLASSES WHICH

HANDLES INPUT AND OUTPUT OPERATIONS.
java.awt (ABSTRACT WINDOW TOOLKIT) :- THIS PACKAGE

HELPS TO DEVELOP GUI (GRAPHICAL USER INTERFACE)
APPLICATIONS.
javax.swing :- IT IS EXTENSION TO AWT PACKAGE. THIS

PACKAGE HELPS TO DEVELOP GUI APPLICATIONS LIKE
AWT. IT CONTAINS MORE GRAPHICS.
x :- STANDS FOR EXTENDED PACKAGE. IT MEANS IN FIRST

JAVA VERSION WE DON'T HAVE THESE PACKAGES.
java.net :- CLIENT-SERVER PROGRAMMING CAN BE DONE

USING THIS PACKAGE.
CLIENT :- CLIENT IS A MACHINE WHICH GETS

INFORMATION FROM THE SERVER.
SERVER :- SERVER IS A MACHINE WHICH SERVES

INFORMATION TO THE CLIENT. A SERVER CAN SERVE
INFORMATION TO ANY NUMBER OF CLIENTS AT A TIME.
java.applet :- APPLETS ARE SMALL INTELLIGENT

PROGRAMS WHICH TRAVEL FROM ONE PLACE TO
ANOTHER PLACE IN INTERNET. APPLET IS A PROGRAM
COMES FROM SERVER INTO CLIENT MACHINE AND
DISPLAYS THE RESULT IN CLIENT MACHINE. THIS PACKAGE
CONTAINS APPLET RELATED CLASSES.
java.sql (STRUCTURED QUERY LANGAUGE):- THIS

PACKAGE HELPS TO CONNECT THE DATABASES (MSACEESS, ORACLE, SYBASE, MYSQL) AND UTILIZE THEM IN
JAVA PROGRAM.
java.beans :- BEANS ARE SOFTWARE RELIABLE

COMPONENTS (PUSH BUTTON, CHECK BOX, DROP DOWN
LIST ETC). THEY CAN BE DEVELOPED USING THIS
PACKAGE. ONCE WE CREATE A COMPONENT THIS CAN BE
USED AGAIN AND AGAIN BY DIFFERENT PEOPLE IN
DIFFERENT PROGRAMS WITHOUT REDEVELOPING THEM.
javax.servlet :- SERVLETS ARE SERVER SIDE PROGRAMS

WHICH HANDLE CLIENTS. THIS PACKAGE IS USEFUL TO
DEVELOP SERVLETS.
WORKING WITH DATA
====================
VARIABLES :- A VARIABLE REPRESENTS MEMORY

LOACTION TO STORE VALUES.
DATA TYPE :- A DATA TYPE REPRESENT THE TYPE OF DATA

STORED INTO A VARIABLE.
BYTE : -128 TO +127
1 BYTE
SHORT : -32768 TO +32767
2 BYTES
INT : -2147483648 TO +2147483647
4 BYTES
LONG : -9223372036854775808 TO
+9223372036854775807
8 BYTES
THE DEFAULT PRIORITY IS SET TO "INT" IN INTEGER

FAMILY. LONG INTEGER CONSTANTS MUST BE POSTFIXED
WITH "L" / "l".
Ex :-long x = 100L;
FLOAT : -3.4e38 to +3.4e38
4 BYTES
DOUBLE : -1.7e308 to +1.7e308
8 BYTES
THE DEFAULT PRIORITY IS SET TO "DOUBLE" IN REAL

FAMILY. FLOAT CONSTANTS MUST BE POSTFIXED WITH
"F" / "f".
Ex :-float x = 12.34F;
WHEN WE TYPE THE CHARACTER ON KEYBOARD A

REVELANT INTEGER CODE IS GENERATED. THIS CODE IS
CALLED ASCII CODE. IN JAVA CHARACTER OCCUPIES 2
BYTES. BECUASE IT SUPPORTS UNICODE CHARACTER SET.
UNICODE IS A SPECIFICATION TO INCLUDE ALL
INTERNATIONAL LANGUAGES INTO THE CHARACTER SET
OF JAVA.
BOOLEAN :- IT CAN STORES EITHER TRUE OF FALSE. IT

OCCUPIES ONE BIT.
STRING :- A STRING REPRESENTS A GROUP OF

CHARACTERS. ANY STRING IS AN OBJECT OF STRING
CLASS IN JAVA. ANY OBJECT IN JAVA IS CREATED WITH
NEW OPERATOR.
CREATING STRINGS
=================
String str = new String("RAMA");
OR
String str = "RAMA";
EXAMPLE OF USING ALL DATA TYPES

==================================
class Third
{
public static void main(String args[])
{
byte b;
short s;
int i;
long l;
float f;
double d;
char c;
boolean b1;
String s1;
b = 10;
s = 30000;
i = 999999;
l = 123456L;
f = 1.23F;
d = 123.456789;
c = 'K';
b1 = true;
s1 = "Rama";
System.out.println(b);
System.out.println("B Value : " + b);
System.out.println(b + " is B Value");
System.out.println("Ravana has " + b + " Heads");

// + ====> Concatenation / Joining Operator
System.out.println("S Value : " + s);
System.out.println("I Value : " + i);
System.out.println("L Value : " + l);
System.out.println("F Value : " + f);
System.out.println("D Value : " + d);
System.out.println("C Value : " + c);
System.out.println("B1 Value : " + b1);
System.out.println("S1 Value : " + s1);
}
}
SQUARE OF A NUMBER
====================
class Four
{
public static void main(String args[ ] )
{
int n,s;
n = 6;
s = n * n;
System.out.println("Square : " + s);
}
}
SUM OF TWO NUMBERS

======================
class Five
{
{
int a,b,c;
a = 10;
b = 20;
c = a + b;
System.out.println("Sum : " + c);
}
}
PRINTF
=======
class Six
{
{
int a;
byte b;
a = 10;
b = 20;
System.out.printf("A Value : %d\n",a);
System.out.printf("B Value : %d",b);
}
}
INTEGER FAMILY : BYTE, SHORT, INT, LONG : %d
REAL FAMILY : FLOAT, DOUBLE : %f
class Six
{
{
float f = 123.456F;
double d = 123.456789;
System.out.printf("F Value : %f\n",f);
System.out.printf("F Value : %.2f\n",f);
System.out.printf("D Value : %f\n",d);
System.out.printf("D Value : %.2f\n",d);
}
}
class Six
{
{
char x;
boolean y;
String z;
x = 'K';
y = true;
z = "Rama";
System.out.printf("X Value : %c\n",x);
System.out.printf("Y Value : %b\n",y);
System.out.printf("Z Value : %s",z);
}
}
SETTING PATH
==============
C:\> md Sample
C:\> cd Sample
C:\SAMPLE> notepad First.java
class First
{
{
System.out.print("This is my first java program");
}
}
SAVE & EXIT
C:\SAMPLE> javac First.java

C:\SAMPLE> java First
MY COMPUTER ====> RIGHT CLICK ====>

PROPERTIES ====> ADVANCED ====> ENVIRONMENT
VARIABLES ====> SELECT PATH ====> EDIT ====>
ADD ";C:\PROGRAM FILES\JAVA\JDK1.5.0\BIN;" TO
EXISTING PATH. (OK)
CLOSE COMMAND WINDOW AND RE-OPEN IT.
COMMAND LINE ARGUMENTS

============================
class Six
{
{
int n,s;
n = 6;
s = n * n;
}
}
WE RUN THE ABOVE ANY NUMBER OF TIMES, THE

PROGRAMS GIVES THE SAME OUTPUT. BECAUSE 'N' VALUE
IS FIXED. IF WE PASS THE 'N' VALUE AFTER RUNNING /
BEFORE RUNNING WE CAN PROVIDE DIFFERENT VALUES
AT EACH RUNTIME. SO THE ABOVE PROGRAM IS USELESS.
COMMAND LINE ARGUMENTS :- THESE ARGUMENTS ARE

PASSED BEFORE RUNNING THE PROGRAM FROM
COMMAND LINE. THESE ARGUMENTS ARE STORED IN THE
ARRAY NAMED ARGS OF TYPE STRING.
class Six
{
{
System.out.print(args[0]);
}
}
javac Six.java
java Six Rama

java Six 10
java Six 112.45
java Six (error)
PASSING NUMERIC TYPE ARGUMENTS

==================================
=
WRAPPER CLASSES
==================
THESE CLASSES ARE USED TO CONVERT PRIMITIVE DATA

TYPES / SIMPLE DATA TYPES (int, char, float, double,
boolean) INTO OBJECT DATA TYPES AND OBJECT DATA
TYPES INTO PRIMITIVE DATA TYPES. ADVANTAGE OF
CONVERTING FROM PRIMITIVE DATA TYPES INTO OBJECT
DATA TYPES IS, OBJECTS HAS METHODS TO OPERATE THE
DATA.
Ex :- Integer, Float, Double etc
parseInt( ) :- THIS METHOD IS USED TO CONVERT

NUMBER FROM STRING OBJECT FORMAT INTO SIMPLE
INTEGER FORMAT. parseInt( ) IS A STATIC METHOD IN
INTEGER CLASS.
class Six
{
public static void main(String [ ]args)
{
int x;
x = Integer.parseInt(args[0]);
System.out.print("X Value : " + x);
}
}
javac Six.java
java Six 10
class Six
{
{
int x,y,z;
x = Integer.parseInt(args[0]);
y = Integer.parseInt(args[1]);
z = x + y;
System.out.print("Sum : " + z);
}
}
javac Six.java
java Six 10 20
java Six 30 40
class Six
{
{
int n,s;
n = Integer.parseInt(args[0]);
s = n * n;
}
}
javac Six.java
java Six 6
java Six 9
java Six 12
Ex :-
byte k;
k = Byte.parseByte(args[0]);
short k;
k = Short.parseShort(args[0]);
long k;
k = Long.parseLong(args[0]);
String p;
p = args[0];
float x;
x = Float.parseFloat(args[0]);
double d;
d = Double.parseDouble(args[0]);
JAVA DOES NOT SUPPORTS GARBAGE VALUES. BEFORE

USING A VARIABLE WE MUST STORE SOME VALUE IN IT.
class Six
{
{
int a;
System.out.print("A Value : " + a); (error)
}
}
class Six
{

{
int a;
a = 10;
System.out.print("A Value : " + a);
}
}
INITIALIZATION :- IT IS THE PROCESS OF STORING SOME

VALUE INITIALLY (FIRST) INTO A VARIABLE AT THE TIME OF
IT'S DECLARATION. JAVA SUPPORTS TWO TYPES OF
INITIALIZATION.
1) STATIC / EARLY / COMPILE TIME INITIALIZATION
2) DYNAMIC / LATE / RUNTIME INITIALIZATION
STATIC INITIALIZATION :- IN THIS MODEL THE VARIABLE IS

INITIALIZED WITH A LITERAL (CONSTANT).
class Six
{

{
int a = 10;
}
}
DYNAMIC INITIALIZATION :- IN THIS MODEL THE VARIABLE

IS INITIALIZED WITH ANOTHER VARIABLE / RUNTIME
VALUE.
class Six
{
{
int a = Integer.parseInt(args[0]);
}
}
java Six 63
LITERALS / CONSTANTS :- THESE VARIABLES STORES

ONLY ONE VALUE. WE CAN'T CHANGE THESE VALUE.
GENERALLY KNOWN VALUES ARE DECLARED AS LITERALS.
GENERALLY WE MUST INITIALIZE LITERALS. LITERALS ARE
DECLARED BY USING "final" KEYWORD.
class Six
{
{
final int a = 10;
a = 20; (error)
}
}
FLEXIBLE DECLARATIONS :- IN JAVA WE CAN DECLARE

VARIABLES ANY WHERE IN THE PROGRAM, JUST BEFORE
USE.
class Six
{

{
int a,b;
a = 10;
b = 20;
int c;
c = a + b;
System.out.print("Sum : " + c);
}
}
A VARIABLE MAY INITIALIZE WITH A CONSTANT / VARIABLE

/ EXPRESSION / FUNCTION RETURN VALUE.
int c = a + b;
int b = Math.sqrt(64);
A VARIABLE MAY DECLARE IN FOR LOOP ALSO. BUT IT'S

SCOPE IS WITHIN FOR LOOP.
class Six
{
{
for(int i = 1; i <= 5; i++)
{
System.out.print(i + "\t");
}
System.out.print(i); (error)
}
}
SCOPE & LIFETIME

=================
class Six
{
{
for(int i = 1; i <= 3; i++)
{
int k = 10;
System.out.println("K Value : " + k);

k = k + 10;
}
}
}
TYPE CASTING
==============
IT IS THE CONCEPT OF STORING ONE TYPE OF DATA INTO

ANOTHER TYPE OF VARIABLE. THESE ARE TWO TYPES.
1) AUTOMATIC / IMPLICIT CONVERSION
2) MANUAL / EXPLICIT CASTING
AUTOMATIC CONVERSION IS DONE BY SYSTEM BY USING

ASSIGNMENT OPERATOR (=).
NOTE :- TO PERFORM AUTOMATIC CONVERSION, TARGET

VARIABLE MEMORY SIZE MUST BE GREATER THAN
SOURCE VARIABLE MEMORY SIZE.
class Six
{
{
int x;
// Compatability means adjustability
x = 'A';
System.out.println("X Value : " + x);
char y;
y = 65;
System.out.println("Y Value : " + y);
int i;
i = 10;
float f;
f = i;
f = 12.34F;
i = (int) f;
byte b;
b = 10;
i = b;
i = 20;
b = (byte) i;
}
}
IF AN INTEGER EXPRESSION CONTAINS BYTE VARIABLES

OR SHORT VARIABLES OR INT VARIABLES THEN THE
ENTIRE EXPRESSION IS CONVERTED INTO INT.
class Six
{
{
byte a,b;
int c;
a = 10;
b = 20;
c = a + b;
System.out.println("Sum : " + c);
byte d;
d = (byte) (a + b);
System.out.print("Sum : " + d);
}
}
class Six
{
{
byte a;
a = 200; (error)
a = (byte) (100 * 2);
}
}
OPERATORS
===========
AN OPERATOR IS A SPECIAL SYMBOL WHICH PERFORMS

SOME OPERATION. AN OPERATOR ACTS ON SOME
VARIABLES OR CONSTANTS WHICH ARE CALLED
OPERANDS. OPERATORS ARE CLASSIFIED INTO FOUR
CATEGORIES.
1) UNARY OPERATORS
2) BINARY OPERATORS
3) TERNARY / CONDITIONAL OPERATOR
4) SPECIAL / OTHER OPERATORS
UNARY OPERATORS :- WHICH WORKS ON SINGLE

OPERAND.
[ ++, --, - ]
class Six
{
{
int a,b;
a = 10;
b = -a;
System.out.println("A Value : " + a);
}
}
BINARY OPERATORS :- WHICH WORKS ON TWO

OPERANDS. THESE OPERATORS ARE CLASSIFIED INTO
THE FOLLOWING CATEGORIES.
1) ARITHMETICAL OPERATORS
2) ASSIGNMENT OPERATOR
(SHORTHAND OPERATORS)
3) RELATIONAL OPERATORS
4) LOGICAL OPERATORS
5) BOOLEAN OPERATORS
6) BITWISE OPERATORS
ARITHMETICAL OPERATORS :- THESE OPERATORS ARE

USED TO PERFORM ARITHMETICAL OPERATIONS LIKE
ADDITION, SUBTRACTION ETC.
[ +, -, *, /, % ]
% :- MODULES OPERATOR [REMAINDER]
MODULES OPERATOR MAY USE ON ANY NUMERIC DATA

TYPE.
.
EXPRESSION :- IF TWO OPERANDS OR CONSTANTS ARE

CONNECTED WITH AN ARITHMETICAL OPERATOR THEN IT
IS CALLED EXPRESSION.
Ex :-A + B, 10 - 5
ARITHMETICAL OPERATORS PRIORITY : PRDMAS
P : PARANTHESIS
: FIRST GROUP
R : REMAINDER
: SECOND GROUP
D : DIVISION
: SECOND GROUP
M : MULTIPLICATION
A : ADDITION
S : SUBTRACTION
: SECOND GROUP
: THIRD GROUP
: THRID GROUP
ASSIGNMENT OPERATOR (=) :- IT IS USED TO STORE

VALUES / DATA / CONSTANTS INTO A VARIABLE. IT
CONTAINS A SUB CATEGORY CALLED SHORTHAND
OPERATORS.
[ += ,-=, *=, /=, %= ]
Ex :A = A + 10; EXPANDED NOTATION
A += 10;
COMPACT NOTATION
RELATIONAL OPERATORS :- THESE OPERATORS ARE USED

TO CHECK RELATION BETWEEN TWO OPERANDS. THESE
OPERATORS ALWAYS RETURN BOOLEAN VALUE.
[ >, >=, <, <=, ==, != ]
CONDITION :- IF TWO OPERANDS OR CONSTANTS ARE

CONNECTED WITH A RELATIONAL OPERATOR THEN IT IS
CALLED CONDITION.
Ex :-A > B, 10 < 5
LOGICAL OPERATORS :- THESE OPERATORS ARE USED TO

JOIN MULTIPLE CONDITIONS. THE PURPOSE OF THESE
OPERATORS IS TO CHECK MORE THAN ONE CONDITION.
[ &&, ||, ! ]
| ====> PIPE
BOOLEAN OPERATORS :- THESE OPERATORS ONLY WORK

WITH BOOLEAN DATA TYPE VARIABLES.
[ &, |, ^, ! ]
& ====> BOOLEAN AND
| ====> BOOLEAN OR
^ (CARAT) ====> BOOLEAN XOR (EXCLUSIVE)

(BOTH OPERANDS CONTAINS DIFFERENT VALUES)
OPERAND 1 OPERAND 2 RESULT

========== ========== =======
TRUE
TRUE
FALSE
TRUE
FALSE
TRUE
FALSE
TRUE
TRUE
FALSE
FALSE
FALSE
! ====> BOOLEAN NOT
class Six
{
{
boolean x,y,res;
x = true;
y = false;
res = x & y;
System.out.println(res);
res = x | y;
res = x ^ y;
y = true;
res = x ^ y;
System.out.println(!x);
}
}
BITWISE OPERATORS :- THESE OPERATORS ARE USED TO

PERFORM OPERATIONS ON BITS. ADVANTAGE OF USING
THESE OPERATORS IS SPEED.
[ ~, &, |, ^, <<, >>, >>> ]
~ :- BITWISE ONE'S COMPLIMENT (TILDE)
& :- BITWISE AND

| :- BITWSE OR
^ :- BITWISE XOR (EXCLUSIVE) (CARAT)
<< :- LEFT SHIFT
>> :- RIGHT SHIFT
>>> :- ZERO FILL / UNSIGNED RIGHT SHIFT
class Six
{
{
int a,b;
a = 25;
System.out.println(a);
System.out.println(~a);
a = 15;
b = 25;
System.out.println(a & b);
System.out.println(a | b);
System.out.println(a ^ b);
a = 20;
System.out.println(a << 2);
System.out.println(a >> 2);
a = 24;
System.out.println(a >>> 2);
a = -24;
System.out.println(a >>> 2);
}
}
IN CASE OF POSITIVE VALUES, THERE IS NO DIFFERENCE

BETWEEN RIGHT SHIFT AND ZERO FILL RIGHT SHIFT
OPERATORS.
TERNARY OPERATOR :- IT IS THE ALTERNATIVE

CONSTRUCT TO SIMPLE IF ELSE STATEMENT. THIS
OPERATOR TAKES THREE EXPRESSIONS. THAT'S WHY IT IS
CALLED TERNARY OPERATOR. IT IS ALSO CALLED
CONDITIONAL OPERATOR.
SYNTAX
=======
(CONDITION) ? EXPRESSION 1 : EXPRESSION 2;
class Six
{
{
int a,b,c;
a = Integer.parseInt(args[0]);
b = Integer.parseInt(args[1]);
c = (a > b) ? a : b;
System.out.print("Big Number : " + c);
}
}
java Six 10 20
java Six 100 20
OTHER / SPECIAL OPERATORS
============================
DOT / PERIOD :- IT IS THE MOST COMMONLY USED
OPERATOR IN JAVA.
1) IT IS USED TO ACCESS A CLASS FROM A PACKAGE.
Ex :-java.lang.System, java.util.Arrays
2) IT IS USED TO ACCESS A METHOD FROM A CLASS /

OBJECT.
Ex :-Integer.parseInt( ), String.reverse( )
3) IT IS USED TO ACCESS A CONSTANT FROM A CLASS.
Ex :-Math.PI, Font.BOLD
INSTANCEOF :- IT CHECKS WHETHER AN OBJECT BELONGS

TO A CLASS.
class Six
{
{
String str = "Rama";
boolean b;
b = str instanceof String;
System.out.print(b);
}
NEW OPERATOR :- IT IS THE MOST COMMONLY USED

OPERATOR IN JAVA. IT IS USED TO CREATE OBJECTS. JVM
WILL ALLOT MEMORY FOR OBJECTS IN HEAP AREA.
PrintStream :- THIS CLASS IS USED TO PRINT

INFORMATION ON THE SCREEN. IT IS AN ALTERNATIVE
CLASS TO SYSTEM CLASS.
System.out :- IT REFERS TO MONITOR.
import java.io.PrintStream;
class Six
{
{
PrintStream ps = new PrintStream(System.out);
int a = 10;
ps.println("Program Started");
ps.println("Welcome to Print Stream Class");
ps.printf("A Value : %d\n",a);
ps.print("Program Ended");
}
}
INPUT DATA AT RUNTIME

========================
System.in :- IT REFERS TO KEYBOARD.
INPUT CHARACTER DATA AT RUNTIME

==================================
=
read( ) :- THIS METHOD INPUTS SINGLE CHARACTER. THIS

METHOD READS DATA IN INTEGER FORMAT. SO NEED
TYPE CASTING. THIS METHOD THROWS IOEXCEPTION. SO
WE HAVE TO TYPE "throws IOException" ALONG WITH
MAIN METHOD.
import java.io.IOException;
class Six
{
public static void main(String args[ ]) throws IOException
{
char x;
ps.println("Enter Character");
x = (char) System.in.read( );
ps.print("Character : " + x);
}
}
import java.io.*;
class Six
{
{
InputStreamReader isr = new
InputStreamReader(System.in);
BufferedReader br = new BufferedReader(isr);
char x;
x = (char) br.read( );
}
}
INPUT STRINGS AT RUNTIME
==========================
import java.io.*;
class Six
{
{
BufferedReader br = new BufferedReader(new
InputStreamReader(System.in));
String name;
ps.println("Enter Your Name");
name = br.readLine( );
ps.print("Your Name : " + name);
}
}
INPUT NUMERIC DATA AT RUNTIME
================================
import java.io.*;
class Six
{
{
String temp;
int n;
ps.println("Enter Integer");
temp = br.readLine( );
n = Integer.parseInt(temp);
ps.print("Integer : " + n);
}
import java.io.*;
class Six
{
{
String temp;
float n;
ps.println("Enter Float");
temp = br.readLine( );
n = Float.parseFloat(temp);
ps.print("Float : " + n);
}
}
Byte.parseByte( ), Short.parseShort( ), Long.parseLong( ),

Double.parseDouble( )
SQUARE OF A NUMBER
=====================
import java.io.*;
class Six
{
{
int n,s;
ps.println("Enter Number");
n = Integer.parseInt(br.readLine( ));
s = n * n;
ps.print("Square : " + s);
}
}
SUM OF TWO NUMBERS
=====================
import java.io.*;
class Six
{
{
int a,b,c;
ps.println("Enter Two Numbers");
a = Integer.parseInt(br.readLine( ));
b = Integer.parseInt(br.readLine( ));
c = a + b;
ps.print("Sum : " + c);
}
}
USING DATAINPUTSTREAM TO INPUT DATA
==================================
=====
BY USING THIS CLASS WE CAN DIRECTLY CONNECT WITH

KEYBOARD.
import java.io.*;
class Six
{
{
DataInputStream dis = new DataInputStream(System.in);
char x;
x = (char) dis.read( );
}
}
import java.io.*;
class Six
{
{
DataInputStream dis = new DataInputStream(System.in);
int a,b,c;
a = Integer.parseInt(dis.readLine( ));
b = Integer.parseInt(dis.readLine( ));
c = a + b;
}
}
USING SCANNER CLASS TO INPUT DATA

==================================
==
BY USING THIS CLASS WE CAN DIRECTLY CONNECT WITH

KEYBOARD. THE MAIN ADVANTAGE OF USING THIS CLASS
IS TO READ NUMERIC TYPES OF DATA WITHOUT

CONVERTING IT. THIS CLASS CAN'T THROWS
IOEXCEPTION. IT IS AVAILABLE IN java.util PACKAGE. THIS
CLASS CONTAINS THE FOLLOWING METHODS.
next( ), nextLine( ), nextByte( ), nextShort( ), nextInt( ),

nextLong( ), nextFloat( ), nextDouble( )
import java.util.Scanner;
class Six
{
{
Scanner sc = new Scanner(System.in);
String st;
ps.println("Enter String");
st = sc.next( );
ps.println("String : " + st);
}
class Six
{
{
String st;
st = sc.nextLine( );
ps.println("String : " + st);
}
}
SUM OF TWO NUMBERS

======================
class Six
{
{
int a,b,c;
a = sc.nextInt( );
b = sc.nextInt( );
c = a + b;
}
}
CONTROL FLOW STATEMENTS

============================
FLOW OF EXECUTION :- THE WAY THE PROGRAM IS

EXECUTED. GENERALLY PROGRAMS ARE EXECUTED IN
TWO TYPES OF FLOW OF EXECUTIONS.
1) SEQUENTIAL EXECUTION
2) RANDOM EXECUTION
SEQUENTIAL EXECUTION :- IN THIS MODEL, ALL

STATEMENTS ARE EXECUTED ONE BY ONE (TIME WASTE).
RANDOM EXECUTION :- IN THIS MODEL, WE CAN

DIRECTLY EXECUTE THE REQUIRED STATEMENT (TIME
SAVE). TO APPLY RANDOM EXECUTION WE NEED
CONTROL FLOW STATEMENTS.
CONTROL FLOW STATEMENTS :- THESE ARE THE

STATEMENTS TO CHANGE FLOW OF EXECUTION. THESE
STATEMENTS ARE USED TO TAKE DECISIONS AND TO
ITERATE (LOOP) SET OF STATEMENTS.
1) BRANCHING STATEMENTS : IF STATEMENT, SWITCH
STATEMENT
2) ITERATING / LOOPING STATEMENTS : FOR, WHILE, DO

WHILE
3) JUMPING STATEMENTS : BREAK, CONTINUE, RETURN
IF STATEMENT :- THIS STATEMENT IS USED TO TAKE

DECISIONS. IT IS USED TO CHECK CONDITIONS AND
COMPARE VALUES. IF STATEMENT HAVE THE FOLLOWING
MODELS.
1) SIMPLE IF STATEMENT
2) IF ELSE STATEMENT
3) ELSE IF STATEMENT
4) NESTED IF STATEMENT
SIMPLE IF STATEMENT
=====================
class Six
{
{
int n,s;
n = sc.nextInt( );
if(n > 0)
{
s = (int) Math.sqrt(n);
ps.print("Square Root : " + s);
}
}
}
IF ELSE STATEMENT
===================
class Six
{
{
int m;
ps.println("Enter Marks");
m = sc.nextInt( );
if(m >= 35)
{
ps.print("Result : Pass");
}
else
{
ps.print("Result : Fail");
}
}
ELSE IF STATEMENT
===================
class Six
{
{
int n;
n = sc.nextInt( );
if(n > 0)
{
ps.print("It is Positive Number");
}
else
if(n < 0)
{
ps.print("It is Negative Number");
}
else
{
ps.print("It is Zero");
}
}
}
NESTED IF STATEMENT
=====================
class Six
{
{

int n;
n = sc.nextInt( );
if(n != 0)
{
if(n > 0)
{
ps.print("It is Positive Number");
}
else
{
ps.print("It is Negative Number");
}
}
else
{
ps.print("It is Zero");
}
}
}
SWITCH STATEMENT
===================
IF STATEMENT IS USED TO CHECK CONDITIONS AND

COMPARE VALUES. SWITCH STATEMENT IS USED FOR
COMPARISION PURPOSE. BY USING SWITCH STATEMENT
WE CAN SELECT AN OPTION RANDOMLY, WHICH IS NOT
POSSIBLE THROUGH IF STATEMENT. GENERALLY SWITCH
STATEMENTS ARE USED IN MENU DRIVEN PROGRAMS.
THROUGH SWITCH STATEMENT WE CAN COMPARE ONLY
INTEGERS AND CHARACTERS.
class Six
{
{
int n;
ps.println("Enter Number [1 - 5]");
n = sc.nextInt( );
switch(n)
{
case 1 :
ps.print("You Entered One");
break;
case 2 :
ps.print("You Entered Two");
break;
case 3 :
ps.print("You Entered Three");
break;
case 4 :
ps.print("You Entered Four");
break;
case 5 :
ps.print("You Entered Five");
break;
default :
ps.print("You Entered Above Five / Below One");
}
}
}
FOR LOOP
=========
class Six
{
{
int n,i;
ps.println("Enter Choice");
n = sc.nextInt( );
for(i = 1; i <= n; i++) // for(int i = 1; i <= n; i++)
{
ps.print(i + "\t");
}
}
}
WHILE LOOP
============
class Six
{
{
int n,i;
n = sc.nextInt( );
i = 1;
while(i <= n)
{
ps.print(i + "\t");
i++;
}
}
}
DO WHILE LOOP
===============
class Six
{
{
int n,i;
n = sc.nextInt( );
i = 1;
do
{
ps.print(i + "\t");
i++;
} while(i <= n);
}
}
INFINITE LOOPS
===============
class Six
{
{
int n,r;
ps.println("Enter Numbers, 0 to Stop");
while(true) // for(; ;)
{
n = sc.nextInt( );
if(n == 0)
{
break;
}
if(n % 2 == 0)
{
ps.println("Even Number");
}
else
{
ps.println("Odd Number");
}
}
}
}
NESTED LOOPS
==============
class Six
{
{
int i,j;
for(i = 1; i <= 5; i++)
{
for(j = 1; j <= 5; j++)
{
ps.print(i + "\t");
}
ps.println( );
}
}
}
class Six
{
{
int i,j;
for(i = 1; i <= 5; i++)
{
ps.print("J = ");
for(j = 1; j <= 5; j++)
{
ps.print(j + "\t");
}
ps.println( );
}
}
}
BREAK STATEMENT
==================
class Six
{

{
int i;
for(i = 1; i <= 10; i++)
{
ps.print(i + "\t");
if(i == 5)
{
break;
}
}
ps.print(i);
}
}
CONTINUE STATEMENT
=====================
class Six
{
{
int i;
for(i = 1; i <= 10; i++)
{
if(i == 5)
{
continue;
}
ps.print(i + "\t");
}
ps.print(i);
}
}
LABELLED LOOPS
================
class Six
{
{
int i,j;
for(i = 1; i <= 5; i++)
{
for(j = 1; j <= 5; j++)
{
ps.print(j + "\t");
if(j == 3)
{
break;
}
}
ps.println( );
}
}
}
class Six
{
{
int i,j;
xxx :
for(i = 1; i <= 5; i++)
{
for(j = 1; j <= 5; j++)
{
ps.print(j + "\t");
if(j == 3)
{
break xxx;
}
}
ps.println( );
}
}
}
class Six
{
{
int i,j;
for(i = 1; i <= 5; i++)
{
for(j = 1; j <= 5; j++)
{
if(j == 3)
{
continue;
}
ps.print(j + "\t");
}
ps.println( );
}
}
}
class Six
{
{
int i,j;
xxx :
for(i = 1; i <= 5; i++)
{
ps.println( );
ps.print("J = ");
for(j = 1; j <= 5; j++)
{
ps.print(j + "\t");
if(j == 3)
{
continue xxx;
}
}
}
}
}
ARRAYS
========
AN ARRAY IS A GROUP OF ITEMS OF SIMILAR DATA TYPE.

EACH ITEM IS CALLED AN ELEMENT. EACH ELEMENT HAS
AN UNIQUE INDEX. ARRAY INDEX ALWAYS STARTS FROM
ZERO. SO AN ARRAY IS ALWAYS CREATED WITH N-1. IN
JAVA ARRAYS ARE CALLED AS OBJECTS. THE MAIN
ADVANTAGE OF OBJECTS IS, OBJECTS CONTAINS
METHODS WHICH OPERATES THE DATA. AN OBJECT IS
ALWAYS CREATES WITH THE HELP OF NEW OPERATOR. AN
OBJECT IS DESTROYED BY ASSIGNING NULL KEYWORD.
IN JAVA ARRAY CREATION HAS TWO STEPS.
1) ARRAY VARIABLE DECLARATION
Ex :-INT A[ ]; / INT [ ]A;
2) ALLOCATING MEMORY TO ARRAY
Ex:- A = NEW INT[5];
WE CAN WRITE BOTH ABOVE TWO STEPS AS FOLLOWS.
Ex :-INT A[ ] = NEW INT[5];
IN JAVA, ARRAYS HAS A SPECIAL PROPERTY CALLED

LENGTH, WHICH RETURNS SIZE OF THE ARRAY.
class Six
{
{
int a[ ];
a = new int[5];
a[0] = 10;
a[1] = 20;
a[2] = 30;
a[3] = 40;
a[4] = 50;
ps.println("Array Elements");
for(int i = 0; i < a.length; i++)
{
ps.print(a[i] + "\t");
}
}
}
FOR EACH LOOP

===============
class Six
{
{

int a[ ];
a = new int[5];
a[0] = 10;
a[1] = 20;
a[2] = 30;
a[3] = 40;
a[4] = 50;
for(int i : a)
{
ps.print(i + "\t"); (i ====> a[i])
}
}
}
NOTE :- FOR EACH CAN ACCESS ONLY VALUE FROM THE

ARRAY. IT IS UNABLE TO PERFORM ANY OTHER
OPERATION ON THE ARRAY.
INITIALIZING ARRAYS
====================
AT THE TIME OF INITIALIZATION WE CAN'T USE NEW

KEYWORD.
class Six
{
{
int a[ ] = {10,20,30,40,50,60};
for(int i : a)
{
ps.print(i + "\t");
}
}
}
INPUT DATA INTO ARRAYS AT RUNTIME
==================================
==
class Six
{
{
int n;
ps.println("Enter Size of the Array");
n = sc.nextInt( );
int a[ ] = new int[n];
ps.println("Enter " + n + " Elements");
for(int i = 0; i < n; i++)
{
a[i] = sc.nextInt( );
}
for(int i : a)
{
ps.print(i + "\t");
}
}
}
2-D ARRAYS
===========
class Six
{
{
int a[][];
or int [ ][ ]a; or int [ ]a[ ];
a = new int[3][5];
a[0][0] = 10;
a[0][1] = 20;
a[0][2] = 30;
a[0][3] = 40;
a[0][4] = 50;
a[1][0] = 60;
a[1][1] = 70;
a[1][2] = 80;
a[1][3] = 90;
a[1][4] = 100;
a[2][0] = 110;
a[2][1] = 120;
a[2][2] = 130;
a[2][3] = 140;
a[2][4] = 150;
{
for(int j = 0; j < a[i].length; j++)
{
ps.print(a[i][j] + "\t");
}
ps.println( );
}
}
}
INITIALIZING 2-D ARRAYS

=======================
class Six
{
{
int a[][] = {
{10,20,30,40,50},
{60,70,80,90,100},
{110,120,130,140,150}
};
{

{
}
ps.println( );
}
}
}
INPUT DATA INTO 2-D ARRAYS AT RUNTIME

==================================
======
class Six
{
{

int r,c;
ps.println("Enter Rows, Columns");
r = sc.nextInt( );
c = sc.nextInt( );
int a[][] = new int[r][c];
ps.println("Enter " + (r * c) + " Elements");
for(int i = 0; i < r; i++)
{
for(int j = 0; j < c; j++)
{
a[i][j] = sc.nextInt( );
}
}
{
{
}
ps.println( );
}
}
}
JAGGED ARRAYS / VARIABLE SIZE ARRAYS / ARRAYS OF

ARRAYS
==================================
================
class Six
{
{
int a[][] = new int[3][];
a[0] = new int[5];
a[1] = new int[3];
a[2] = new int[6];
a[0][0] = 10;
a[0][1] = 20;
a[0][2] = 30;
a[0][3] = 40;
a[0][4] = 50;
a[1][0] = 60;
a[1][1] = 70;
a[1][2] = 80;
a[2][0] = 90;
a[2][1] = 100;
a[2][2] = 110;
a[2][3] = 120;
a[2][4] = 130;
a[2][5] = 140;
{
{
}
ps.println( );
}
}
}
STRING ARRAYS
===============
class Six
{
{
String names[ ] = new String[5];
ps.println("Enter Five Names");
for(int i = 0; i < names.length; i++)
{
names[i] = sc.nextLine( );
}
ps.print("Names : ");
for(String i : names)
{
ps.print(i + "\t"); (i ====> names[i])
}
}
}
ASSIGNING ARRAYS
==================
hashCode( ) :- THIS METHOD RETURNS MEMORY

LOCATION WHICH IS POINTED BY AN OBJECT. UNIQUE ID
NUMBER GIVEN TO EVERY OBJECT BY JVM. IT IS ALSO
CALLED REFERENCE NUMBER.
class Six
{
{
int a[] = {10,20,30,40,50};
int b[] = a;
ps.println("Array A Elements");
for(int i : a)
{
ps.print(i + "\t");
}
ps.println( );
ps.println("Array B Elements");
for(int i : b)
{
ps.print(i + "\t");
}
ps.println( );
ps.println("A Points to : " + a.hashCode( ) );
ps.println("B Points to : " + b.hashCode( ) );
}
}
NOTE :- IN THE ABOVE PROGRAM ARRAYS A & B ARE

POINTS TO SAME LOCATION.
COPYING ARRAYS
=================
class Six
{
{
int a[] = {10,20,30,40,50};
int b[] = new int[5];
{
b[i] = a[i];
}
for(int i : a)
{
ps.print(i + "\t");
}
ps.println( );
for(int i : b)
{
ps.print(i + "\t");
}
ps.println( );
ps.println("A Points to : " + a.hashCode( ) );
ps.println("B Points to : " + b.hashCode( ) );
}
}
NOTE :- IN THE ABOVE PROGRAM ARRAYS A & B ARE

POINTS TO DIFFERENT LOCATIONS.
arraycopy( ) :- THIS METHOD IS USED TO COPY AN ARRAY.

THIS METHOD IS A STATIC METHOD IN SYSTEM CLASS.
class Six
{
{
int a[] = {10,20,30,40,50};
System.arraycopy(a,0,b,0,5);
// arrarycopy(Source Array, Source Array Starting Index,
// Target Array, Target Array Starting Index, Number of
Elements To Be // copied)
for(int i : a)
{
ps.print(i + "\t");
}
ps.println( );
for(int i : b)
{
ps.print(i + "\t");
}
}
}
METHODS OF ARRAYS CLASS [JAVA.UTIL]

==================================
=====
NOTE :- ALL METHODS IN THE ARRAYS CLASS ARE STATIC

METHODS.
COMPARING ARRAYS
===================
class Six
{
{
int a[] = {10,20,30,40,50};
int b[] = {10,20,30,40,50};

if(a == b)
{
ps.print("Both are equal Arrays");
}
else
{
ps.print("Both are not equal Arrays");
}
}
}
NOTE :- COMPARISION OPERATOR (==) CHECKS MEMORY

LOCATIONS NOT CONTENTS.
equals( ) :- THIS METHOD IS USED TO COMPARE TWO

ARRAYS. IF BOTH ARE EQUAL THEN IT RETURNS TRUE
OTHERWISE RETURNS FALSE.
import java.util.Arrays;
class Six
{
{
int a[] = {10,20,30,40,50};
int b[] = {10,20,30,40,50};
if(Arrays.equals(a,b))
{
ps.print("Both are equal Arrays");
}
else
{
ps.print("Both are not equal Arrays");
}
}
}
FILLING ARRAYS
================
fill( ) :- THIS METHOD IS USED TO FILL AN ENTIRE ARRAY /

A RANGE (PARTIAL ARRAY) WITH A SPECIFIC VALUE.
class Six
{
{
int a[] = new int[10];
Arrays.fill(a,6);
for(int i : a)
{
ps.print(i + "\t");
}
ps.println( );
Arrays.fill(b,0,3,6);
// N = EI - SI
for(int i : b)
{
ps.print(i + "\t");
}
}
}
SORTING ARRAYS
================
sort( ) :- THIS METHOD IS USED TO SORT (ARRANGE DATA

IN ASCENDING ORDER) AN ENTIRE ARRAY / A RANGE
(PARTIAL ARRAY).
class Six
{
{
int a[] = {30,60,50,10,40,20};
ps.println("Before Sorting, Array A Elements");
for(int i : a)
{
ps.print(i + "\t");
}
ps.println( );
Arrays.sort(a);
ps.println("After Sorting, Array A Elements");
for(int i : a)
{
ps.print(i + "\t");
}
ps.println( );
int b[] = {30,60,50,10,40,20};
ps.println("Before Sorting, Array B Elements");
for(int i : b)
{
ps.print(i + "\t");
}
ps.println( );
Arrays.sort(b,0,4);
ps.println("After Sorting, Array B Elements");
for(int i : b)
{
ps.print(i + "\t");
}
}
}
NOTE :- SORT METHOD OF ARRAYS CLASS CAN APPLY ON

ANY DATA TYPE, EVEN STRINGS ALSO.
class Six
{
{

String names[ ] =
{"Rama","Siva","Divya","Krishna","Tata"};
ps.println("Names Before Sorting");
{
ps.print(i + "\t");
}
ps.println( );
Arrays.sort(names);
ps.println("Names After Sorting");
{
ps.print(i + "\t");
}
ps.println( );
}
}
SEARCHING
===========
binarySearch( ) :- THIS METHOD IS USED TO SEARCH FOR

AN ELEMENT IN THE ARRAY. IF SEARCH ELEMENT FOUNDS
RETURNS INDEX OF THE SEARCH ELEMENT OTHERWISE
RETURNS NEGATIVE VALUE. BEFORE USING BINARY
SEARCH METHOD YOU MUST USE SORT METHOD ON THAT
ARRAY.
class Six
{
{
int a[] = {40,50,60,20,30,10};
int se,pos;
ps.println("Enter Search Element");
se = sc.nextInt( );
Arrays.sort(a);
pos = Arrays.binarySearch(a,se);
if(pos < 0)
{
ps.print("Element Not Found");
}
else
{
ps.print("Element Found at Position : " + (pos+1));
}
}
}
DYNAMIC ARRAYS
=================
FIXED ARRAY :- FIXED ARRAY IS AN ARRAY WHOSE SIZE

CAN'T BE CHANGED AFTER CREATION AND WE CAN'T
REMOVE ELEMENTS FROM IT.
DYNAMIC ARRAY :- DYNAMIC ARRAY IS AN ARRAY WHOSE

SIZE CAN'T BE SPECIFIED AT THE TIME OF CREATION. SO
WE CAN STORE ANY NUMBER OF ELEMENTS IN IT. WE

CAN ALSO REMOVE ELEMENTS FROM IT.
ARRAYLIST :- ARRAYLIST OBJECT IS CALLED DYNAMIC

ARRAY. ARRAYLIST CAN STORE ONLY OBJECTS & SIMPLE
DATA TYPES. IT CAN'T STORE PRIMITIVE TYPES LIKE INT,
CHAR, FLOAT ETC.THE ARRAYLIST CLASS IS AVAILABLE IN
JAVA.UTIL PACKAGE. IT CONTAINS THE FOLLOWING
METHODS.
size( ) :- THIS METHOD RETURNS NUMBER OF ELEMENTS

IN THE ARRAY.
add( ) :- THIS METHODS ADDS ELEMENTS TO THE ARRAY

LIST. BY DEFAULT ADDS AT LAST POSITION. IF WE SPECIFY
INDEX THEN ADDS THE ELEMENT AT SPECIFIED POSITION.
remove( ) :- THIS METHOD REMOVES AN ELEMENT FROM

THE ARRAY LIST. WE CAN REMOVE ELEMENT BASED ON
ELEMENT AND BASED ON POSITION.
import java.util.ArrayList;
class Six
{
{
ArrayList al = new ArrayList( );
ps.println("Number of Elements : " + al.size( ));
ps.println("Elements : " + al);
Integer e1 = new Integer(10);
al.add(e1);
al.add(e2);
al.add(e3);
al.add(e4);
al.add(new Integer(50)); // Anonymous Object (Unnamed

Object)
al.add(2,new Integer(25)); // Adds 25 at 2nd index.
al.remove(new Integer(30));
al.remove(2); // removes index 2 element.
}
}
import java.util.ArrayList;
class Six
{

{
ArrayList ob = new ArrayList( );
ps.println("Array List Size : " + ob.size( ));
ps.println("Array List Elements : " + ob);
ob.add("Teja");
ob.add(39);
ob.add(12.3);
ob.add("Dragon");
ob.add("Good Girl");
ob.add("Devil");
ob.remove(4);
}
}
VECTORS
========
SAME AS ARRAY LIST. IT INCREASES SIZE BY DOUBLE.

THROUGH VECTORS WE CAN ACCESS INDIVIDUAL
ELEMENTS OF THE VECTOR.
import java.util.Vector;
class Six
{
{
Vector ob = new Vector( ); // Default size is 10
//Vector ob = new Vector(5);
//Vector ob = new Vector(5,3);
ps.println("Vector Size : " + ob.capacity( ));
ps.println("Vector Size : " + ob.size( ));
ps.println("Vector Elements : " + ob);

ob.add(10);
ob.add("Divya");
ob.add(12.34);
ps.println("Vector Elements");
for(int i = 0; i < ob.size( ); i++)
{
ps.println(ob.elementAt(i));
}
ob.remove(1);
ps.println("Vector Elements");
for(int i = 0; i < ob.size( ); i++)
{
ps.println(ob.elementAt(i));
}
}
}
STRINGS
========
A STRING REPRESENTS A GROUP OF CHARACTERS.

UNLIKE C, STRING IS NOT AN CHARACTER ARRAY IN JAVA
AND IT IS NOT TERMINATED WITH NULL CHARACTER (\0).
IN JAVA ANY STRING IS AN OBJECT OF STRING CLASS. WE
CAN DIRECTLY ASSIGN A STRING CONSTANT TO A STRING
OBJECT. STRING CLASS IS AVIABLE IN JAVA.LANG
PACKAGE.
CREATING STRINGS :- THERE ARE THREE WAYS TO

CREATE STRINGS.
FIRST WAY : BY USING ASSIGNMENT OPERATOR.
class Six
{
{
String str = "Rama";
ps.print("String : " + str);
}
}
SECOND WAY : BY USING NEW OPERATOR.
class Six
{
{
String str = new String("Rama");
}
}
THIRD WAY : WE CAN CREATE A STRING BY CONVERTING

CHARACTER ARRAY INTO STRING OBJECT.
class Six
{
{
char ar[] = {'T','E','N','A','L','I'};
String str = new String(ar);
}
}
NOTE :- WE CAN ALSO CREATE A STRING WITH SOME

CHARACTERS FROM A CHARACTER ARRAY.
class Six
{

{
char ar[] = {'T','E','N','A','L','I'};
String str = new String(ar,2,3);
}
}
+ :- THIS OPERATOR IS CALLED CONCATENATION /

JOINING OPERATOR. THIS OPERATORS CONCATS TWO OR
MORE STRINGS.
class Six
{
{
String str1 = "Rama";
String str2 = "Krishna";
String str3;
str3 = str1 + str2;
ps.print("String : " + str3);
}
}
class Six
{
{
String str3;
str3 = str1 + " " + str2;
}
}
METHODS OF STRING CLASS
==========================
concat( ) :- THIS METHOD IS USED TO CONCAT TWO

STRINGS.
class Six
{
{
String str3,str4;
str3 = str1.concat(str2);
str4 = str2.concat(str1);
ps.println("String : " + str3);
}
}
NOTE :- CONCATENATION OPERATOR CONCATS ANY TYPE

OF DATA. BUT CONCAT( ) METHOD CONCATS ONLY
STRING TYPE OF DATA.
class Six
{
{
int n = 10;
String str2;
str2 = str1 + n;
}
}
class Six
{

{
int n = 10;
String str2;
str2 = str1.concat(n); (error)
}
}
NOTE :- CONCATENATION OPERATORS CONCATS ANY

NUMBER OF STRINGS. BUT CONCAT( ) METHOD CONCATS
ONLY TWO STRINGS.
class Six
{
{
String str1 = "Raja ";

String str2 = "Ram ";
String str3 = "Mohan ";
String str4 = "Roy";
String str5;
str5 = str1 + str2 + str3 + str4;
}
}
THE ABOVE CONCATENATION IS NOT POSSIBLE THROUGH

CONCAT( ) METHOD.
length( ) :- THIS MEHOD IS USED TO FIND LENGTH OF

STRING. LENGTH MEANS HOW MANY CHARACTERS IN A
STRING.
class Six
{
{
String str = "Rama Rao";
int n;
n = str.length( );
ps.print("String Length : " + n);
}
}
class Six
{
{
String str;
int n;
str = sc.nextLine( );
n = str.length( );
}
}
CHARACTER EXTRACTION
=========================
charAt( ):- THIS METHOD IS USED TO EXTRACT (ACCESS /

GET) A CHARACTER FROM A STRING.
class Six
{
{
String str = "Rama Krishna";
char x;
x = str.charAt(5);
ps.print("Extracted Character : " + x);

}
}
class Six
{
{
String str = "Rama Krishna";
ps.println("String : " + str);
ps.print("String : ");
for(int i = 0; i < str.length( ); i++)
{
ps.print(str.charAt(i) + " ");
}
}
}
getChars( ) :- THIS METHOD IS USED TO EXTRACT

MULTIPLE CHARACTER FROM A STRING INTO A
CHARACTER ARRAY.
class Six
{
{
String str = "Raja Ram Mohan Roy";
char x[] = new char[3];
str.getChars(5,8,x,0);
// getChars(Source String Starting Index, Source String
Ending // Index, Target Array, Target Array Starting Index)
ps.print("Extracted String : ");
for(int i = 0; i < x.length; i++)
{
ps.print(x[i]);
}
}
}
COMPARING STRINGS
====================
class Six
{
{
String str1 = new String("Rama");
if(str1 == str2)
{
ps.print("Both are equal Strings");
}
else
{
ps.print("Both are not equal Strings");
}
}
}
NOTE :- COMPARISION OPERATOR (==) CHECKS MEMORY

LOCATIONS NOT CONTENTS.
equals( ) :- THIS METHOD IS USED TO COMPARE TWO

STRINGS. IF BOTH ARE EQUAL THEN IT RETURNS TRUE
OTHERWISE RETURNS FALSE.
equalsIgnoreCase( ) :- THIS METHOD IS USED TO

COMPARE TWO STRINGS WITHOUT CASE SENSITIVE.
class Six
{
{
String str3 = new String("RAMA");

if(str1.equals(str2))
{
ps.println("String1 and String2 are equal Strings");
}
else
{
ps.println("String1 and String2 are not equal Strings");
}
{
}
else
{
}
if(str1.equalsIgnoreCase(str3))
{
}
else
{
}
}
}
compareTo( ) :- THIS METHOD IS USED TO COMPARE TWO

STRINGS. IT RETURNS THE FOLLOWING VALUES.
BOTH ARE EQUAL STRINGS : ZERO
FIRST STRING IS BIG
: POSITIVE VALUE
SECOND STRING IS BIG : NEGATIVE VALUE
compareToIgnoreCase( ) :- THIS METHOD IS USED TO

COMPARE TWO STRINGS WITHOUT CASE SENSITIVE.
class Six
{
{
String str1;
String str2;
int res;
ps.println("Enter Two Strings");
str1 = sc.nextLine( );
res = str1.compareTo(str2);
ps.println("Result : " + res);
if(res == 0)
{
ps.println("Both are equal Strings");
}
else
if(res > 0)
{
ps.println("First String is Big");

}
else
{
ps.println("Second String is Big");
}
}
}
regionMatches( ) :- THIS METHOD IS USED TO COMPARE A

PART OF TWO STRINGS.
class Six
{
{
String str1 = "Raja Ram Mohan Roy";
String str2 = "Seeta Rama Raju";
String str3 = "Seeta RAMA Raju";
if(str1.regionMatches(5,str2,6,3))
// regionMatches(first string starting index, second string,
second // string starting index, number of characters to
be compared);
{
}
else
{
ps.println("Both are not equal Strings");
}
if(str1.regionMatches(5,str3,6,3))
{
}
else
{
}
if(str1.regionMatches(true,5,str3,6,3))
// regionMatches(true,first string starting index, second

string, // second string starting index, number of
characters to be // compared);
// true :- WITHOUT CASE SENSITIVE.
{
}
else
{
}
}
}
startsWith( ) :- THIS METHOD IS USED TO CHECK A

STRING STARTS WITH PARTICULAR STRING OR NOT.
class Six
{
{
String str = "Ramesh";
if(str.startsWith("Ram"))
{
ps.println("Yes");
}
else
{
ps.println("No");
}
}
}
endsWith( ) :- THIS METHOD IS USED TO CHECK A STRING
ENDS WITH PARTICULAR STRING OR NOT.
class Six
{
{
String str = "Ramesh";
if(str.endsWith("esh"))
{
ps.println("Yes");
}
else
{
ps.println("No");
}
}
}
SEARCHING STRINGS
====================
indexOf( ) :- THIS METHOD IS USED TO FIND FIRST

OCCURANCE OF A SUB STRING IN A STRING. IF THE SUB
STRING IS NOT FOUND THEN IT RETURNS -1. BY DEFAULT
IT STARTS SEARCHING FROM ZERO POSITION. WE CAN
SPECIFY THE STARTING POSITION IF WE NEED.
class Six
{
{
String str = "This is a book";
int p;
p = str.indexOf("is");
if(p == -1)
{
ps.println("Sub String Not Found");
}
else
{
ps.println("Position : " + (p + 1));
}
p = str.indexOf("was");
if(p == -1)
{

}
else
{
}
p = str.indexOf("is",3);
if(p == -1)
{
}
else
{
}
}
}
lastIndexOf( ) :- THIS METHOD IS USED TO FIND
LASTOCCURANCE OF A SUB STRING IN A STRING. IF THE
SUB STRING IS NOT FOUND THEN IT RETURNS -1. BY
DEFAULT IT CONTINUES SEARCHING UPTO END OF THE
STRING. . WE CAN SPECIFY THE LAST POSITION TO BE

SEARCH, IF WE NEED.
class Six
{
{
String str = "This is a book";
int p;
p = str.lastIndexOf("is");
if(p == -1)
{
}
else
{
}
p = str.lastIndexOf("was");
if(p == -1)
{
}
else
{
}
p = str.lastIndexOf("is",3);
if(p == -1)
{
}
else
{
}
}
}
CONVERTING STRINGS
=====================
toLowerCase( ) :- THIS METHOD IS USED TO CONVERT A

STRING INTO LOWER CASE.
class Six
{
{
String str = "RAMA";
ps.println("Converted String : " + str.toLowerCase( ));
}
}
toUpperCase( ) :- THIS METHOD IS USED TO CONVERT A

STRING INTO UPPER CASE.
class Six
{
{
String str = "rama";
ps.println("Converted String : " + str.toUpperCase( ));
}
}
MODIFYING STRINGS
====================
substring( ) :- THIS METHOD IS USED TO GET SUB STRING

FROM MAIN STRING.
class Six
{
{
String str = "Raja Ram Mohan Roy";
ps.println("Sub String : " + str.substring(5,8));
ps.println("Sub String : " + str.substring(5));
}
}
replace( ) :- THIS METHOD IS USED TO REPLACE A

CHARACTER / SUB STRING WITH ANOTHER CHARACTER /
SUB STRING.
class Six
{
{
String str1 = "Raja Ram Mohan Roy Siva Ram Krishna";
String str2,str3;
str2 = str1.replace('a','*');
str3 = str1.replace("Ram","Tata");
ps.println("Replaced String : " + str2);
ps.println("Replaced String : " + str3);
}
}
trim( ) :- THIS METHOD IS USED TO REMOVE ALL LEADING
(BEFORE) AND TRAILING (AFTER) SPACES .
class Six
{
{
String str1 = "
Raja Ram
String str2;
str2 = str1.trim( );
";
ps.println("Trimmed String : " + str2);

}
}
split( ) :- THIS METHOD IS USED TO DIVIDE MAIN STRING

INTO SOME SUB STRINGS.
class Six
{
{
String str1 = "Raja Ram Mohan Roy Siva Rama Krishna";
String str2[ ] = str1.split(" ");
ps.println("Splitted Strings");
for(String i : str2)
{
ps.println(i);
}
String str3[] = str1.split(" ",5);

ps.println("Splitted Strings");
for(String i : str3)
{
ps.println(i);
}
}
}
NESTINGOF METHODS
=====================
class Six
{
{
String str1 = " Raja Ram ";
int n;
n = str1.length( );
ps.println("String Length : " + n);

n = str1.trim( ).length( );
ps.println("String Length : " + n);
}
}
class Six
{
{
String str1 = "Raja ";
String str2 = "Ram ";
String str3 = "Mohan ";
String str4 = "Roy";
String str5;
str5 = str1.concat(str2).concat(str3).concat(str4);
}
}
class Six
{
{
String str1 = "RAJA RAM MOHAN ROY";
ps.println("Sub String : " +
str1.substring(5,8).toLowerCase( ));
5 : STARTING INDEX, 8 : ENDING INDEX
N : ENDING INDEX - STARTING INDEX
}
}
TYPES OF OBJECTS
==================
1) IMMUTABLE OBJECTS
2) MUTABLE OBJECTS
IMMUTABLE OBJECT :- AN IMMUTABLE OBJECT WHOSE

CONTENTS CAN'T BE MODIFIED.
Ex :- STRING CLASS OBJECTS
MUTABLE OBJECT :- A MUTABLE OBJECT WHOSE

CONTENTS CAN BE MODIFIED.
Ex :- STRINGBUFFER CLASS OBJECTS
FIXED STRINGS :- STRING CLASS OBJECTS ARE

IMMUTABLE OBJECTS / FIXED STRINGS. THESE OBJECTS
SIZE CAN'T BE INCREASED / DECREASED AND WE CAN'T
MAKE ANY MODIFICTIONS IN STRING OBJECTS.
class Six
{
{

String str2;
ps.println("String 1 : " + str1);
str2 = str1.toUpperCase( );
ps.println("String 1 : " + str1.toLowerCase( ));
}
}
DYNAMIC STRINGS :- STRINGBUFFER CLASS OBJECTS ARE

MUTABLE OBJECTS / DYNAMIC STRINGS. THESE OBJECTS
SIZE CAN BE INCREASED / DECREASED AND WE CAN
MAKE ANY MODIFICTIONS IN STRINGBUFFER OBJECTS. BY
DEFAULT STRINGBUFFER OBJECT HAS 16 BYTES EXTRA
SPACE TO PERFORM MODIFICATIONS. STRINGBUFFER
CLASS IS AVIABLE IN JAVA.LANG PACKAGE.
CERATING STRING BUFFER OBJECTS

==================================
capacity( ) :- THIS METHOD IS USED TO FIND MAXIMUM

NUMBER OF CHARACTERS TO BE STORED BY A
STRINGBUFFER OBJECT.
class Six
{
{
StringBuffer str1 = new StringBuffer( );
StringBuffer str2 = new StringBuffer(10);
StringBuffer str3 = new StringBuffer("Rama");
ps.println("String 1 Capacity : " + str1.capacity( ));
}
}
METHODS OF STRINGBUFFER CLASS

=================================
length( ) :- THIS MEHOD IS USED TO FIND LENGTH OF

STRINGBUFFER OBJECT. LENGTH MEANS HOW MANY
CHARACTERS IN A STRINGBUFFER OBJECT.
class Six
{
{
StringBuffer str = new StringBuffer("Rama");
int n;
n = str.length( );
}
}
WE CAN'T ASSIGN CONTENTS TO STRINGBUFFER CLASS.

BUT WE CAN APPEND CONTENTS TO STRINGBUFFER
CLASS.
append( ) :- THIS METHOD IS USED TO ADD CONTENTS AT

END TO THE EXISTING OBJECT.
class Six
{
{
StringBuffer str1 = new StringBuffer( );
str1 = "Rama"; (error)
str1.append("Rama");
}
}
insert( ) :- THIS METHOD IS USED TO ADD CONTENTS AT

SPECIFIED POSITION TO THE EXISTING OBJECT.
class Six
{
{
StringBuffer str1 = new StringBuffer("Rama is Boy");
str1.insert(8,"Good ");
}
}
setCharAt( ) :- THIS METHOD IS USED TO SET A

CHARACTER AT SPECIFIED POSITION.
class Six
{
{
StringBuffer str = new StringBuffer("Ramesh");
str.setCharAt(2,'j');
}
}
replace( ) :- THIS METHOD IS USED TO REPLACE A

CHARACTER / SUB STRING WITH ANOTHER CHARACTER /
SUB STRING.
class Six
{
{
StringBuffer str = new StringBuffer("Siva Rama Krishna");

str.replace(5,9,"Radha");
}
}
deleteCharAt( ) :- THIS METHOD IS USED TO DELETE A

CHARACTER AT SPECIFIED POSITION.
class Six
{
{
StringBuffer str = new StringBuffer("Raxma");
str.deleteCharAt(2);
2:x

}
delete( ) :- THIS METHOD IS USED TO DELETE A SUB

STRING FROM MAIN STRING.
class Six
{
{
StringBuffer str = new StringBuffer("Siva Rama Krishna");
str.delete(5,10);
}
}
reverse( ) :- THIS METHOD IS USED TO REVERSE A

STRING.
class Six
{
{
str.reverse( );
}
}
WRITE A PROGRAM TO INPUT A STRING FIND IT IS

PALINDROME OR NOT.
WE CAN'T INPUT DATA AT RUNTIME INTO STRINGBUFFER

OBJECT.
class Six
{
{
String str1,str2;
StringBuffer strb = new StringBuffer( );
strb.append(str1);
strb.reverse( );
str2 = new String(strb);
{
ps.println("It is Palindrome");
}
else
{
ps.println("It is Not Palindrome");
}
}
}
METHODS OF CHARACTER CLASS

===============================
NOTE :- ALL METHODS IN THE CHARACTER CLASS ARE

STATIC METHODS. CHARACTER CLASS IS AVIALABLE IN
JAVA.LANG PACKAGE.
isLetterOrDigit( ) :- THIS METHOD IS USED TO CHECK

WHETHER A CHARACTER IS ALPHABET / DIGIT OR NOT.
class Six
{
public static void main(String args[]) throws IOException
{
char ch;
ch = (char) System.in.read( );
if(Character.isLetterOrDigit(ch))
{
ps.println("It is Alphabet / Digit");
}
else
{
ps.println("It is Not Alphabet / Digit");
}
}
}
isLetter( ) :- THIS METHOD IS USED TO CHECK WHETHER

A CHARACTER IS ALPHABET OR NOT.
class Six
{
{
char ch;
if(Character.isLetter(ch))
{
ps.println("It is Alphabet");
}
else
{
ps.println("It is Not Alphabet");
}
}
}
isDigit( ) :- THIS METHOD IS USED TO CHECK WHETHER A

CHARACTER IS DIGIT OR NOT.
class Six
{
{
char ch;
if(Character.isDigit(ch))
{
ps.println("It is Digit");
}
else
{
ps.println("It is Not Digit");
}
}
}
isSpaceChar( ) :- THIS METHOD IS USED TO CHECK

WHETHER A CHARACTER IS SPACE OR NOT.
class Six
{
{
char ch;
if(Character.isSpaceChar(ch))
{
ps.println("It is Space");
}
else
{
ps.println("It is Not Space");
}
}
}
isWhitespace( ) :- THIS METHOD IS USED TO CHECK

WHETHER A CHARACTER IS TAB / SPACE / ENTER OR NOT.
class Six
{
{
char ch;
if(Character.isWhitespace(ch))
{
ps.println("It is Tab / Space / Enter");
}
else
{
ps.println("It is Not Tab / Space / Enter");
}
}
}
isLowerCase( ) :- THIS METHOD IS USED TO CHECK

WHETHER AN ALPHABET IS IN LOWER CASE OR NOT.
class Six
{
{
char ch;
ps.println("Enter Alphabet");
if(Character.isLowerCase(ch))
{
ps.println("It is Lower Case Alphabet");
}
else
{
ps.println("It is Not Lower Case Alphabet");
}
}
}
isUpperCase( ) :- THIS METHOD IS USED TO CHECK

WHETHER AN ALPHABET IS IN UPPER CASE OR NOT.
class Six
{
{
char ch;
ps.println("Enter Alphabet");
if(Character.isUpperCase(ch))
{
ps.println("It is Upper Case Alphabet");
}
else
{
ps.println("It is Not Upper Case Alphabet");
}
}
}
toLowerCase( ) :- THIS METHOD IS USED TO CONVERT A

CHARACTER INTO LOWER CASE.
class Six
{
{
char ch;
ps.println("Enter Upper Case Alphabet");

ps.println("Entered Alphabet : " + ch);
ps.println("Converted Alphabet : " +
Character.toLowerCase(ch));
}
}
toUpperCase( ) :- THIS METHOD IS USED TO CONVERT A

CHARACTER INTO UPPER CASE.
class Six
{
{
char ch;
ps.println("Enter Lower Case Alphabet");
ps.println("Entered Alphabet : " + ch);

ps.println("Converted Alphabet : " +
Character.toUpperCase(ch));
}
}
METHODS OF MATH CLASS

=========================
NOTE :- ALL METHODS IN THE MATH CLASS ARE STATIC

METHODS. ALMOST ALL METHODS IN MATH CLASS TAKE
DOUBLE TYPE PARAMETERS. MATH CLASS IS AVIALABLE IN
JAVA.LANG PACKAGE.
sqrt( ) :- THIS METHOD IS USED TO FIND SQUARE ROOT

OF A NUMBER.
class Six
{
{
double n,s;
n = sc.nextDouble( );
s = Math.sqrt(n);
ps.println("Square Root : " + s);
}
}
pow( ) :- THIS METHOD IS USED TO FIND POWER OF A

NUMBER.
class Six
{
{

double b,p,res;
ps.println("Enter Base, Power");
b = sc.nextDouble( );
p = sc.nextDouble( );
res = Math.pow(b,p);
}
}
sin( ) :- THIS METHOD IS USED TO FIND SIN TETA.
ALL TRIGONOMETRY METHODS TAKES ARGUMENTS AS

RADIANS. SO, WE HAVE TO CONVERT RADIANS INTO
DEGREES.
class Six
{
{
double d,r,res;
ps.println("Enter Degrees");
r = sc.nextDouble( );
d = r * Math.PI / 180;
res = Math.sin(d);
//
res = 1 / Math.sin(d);
//
res = Math.cos(d);
//
res = 1 / Math.cos(d);
//
res = Math.tan(d);
//
res = 1 / Math.tan(d);

}
}
ceil( ) :- THIS METHOD IS USED TO ROUND NUMBER TO

THE NEXT INTEGER.
floor( ) :- THIS METHOD IS USED TO ROUND NUMBER TO

THE PREVIOUS INTEGER.
rint( ) :- THIS METHOD TO ROUND AUTOMATICALLY BASED

ON FRACTIONAL PART.
class Six
{
{
double n,res;
n = 12.3;
res = Math.ceil(n);
n = 12.9;
res = Math.floor(n);
n = 12.7;
res = Math.rint(n);

n = 12.3;
res = Math.rint(n);
n = 12.5;
res = Math.rint(n);
}
}
abs( ) :- THIS METHOD IS USED TO FIND ABSOLUTE VALUE

(ALWAYS POSITIVE VALUE / A VALUE WITHOUT SIGN) OF A
NUMBER.
class Six
{
{
double n,res;
n = 12;
res = Math.abs(n);
n = -12;
res = Math.abs(n);
}
}
class Six
{
{
double n,s;
n = sc.nextDouble( );
s = Math.sqrt(Math.abs(n));
ps.println("Square Root : " + s);

}
}
max( ) :- THIS METHOD IS USED TO FIND MAXIMUM

NUMBER OF TWO NUMBERS.
min( ) :- THIS METHOD IS USED TO FIND MINIMUM

NUMBER OF TWO NUMBERS.
class Six
{
{
double a,b,res;
a = sc.nextDouble( );
b = sc.nextDouble( );
res = Math.max(a,b);
ps.println("Maximum Number : " + res);
res = Math.min(a,b);
ps.println("Minimum Number : " + res);
}
}
random( ) :- THIS METHOD IS USED TO GENERATE

RANDOM NUMBERS BETWEEN 0 AND SPECIFIED NUMBER.
sleep( ) :- THIS METHOD IS USED TO STAY PROCESSING AT

SPECIFIED TIME. THIS IS THE STATIC METHOD IN THREAD
CLASS, WHICH IS AVIALABLE IN JAVA.LANG PACKAGE.
class Six
{
public static void main(String args[]) throws
InterruptedException
{
double n;
int r;
while(true)
{
n = Math.random( ) * 10;
r = (int) n;
ps.print(r + "\t");
if(r == 0)
{
break;
}
Thread.sleep(3000);
SECONDS
//
// 3000 : 3 THOUSAND MILLI
IT MEANS THREE SECONDS
}
}
}
FORMATTING NUMBERS
======================
AREA OF CIRCLE
================
class Six
{
{
int rds;
double area;
ps.println("Enter Radius");
rds = sc.nextInt( );
area = Math.PI * rds * rds;
ps.println("Area of Circle : " + area);
}
}
FACTORY METHODS
===================
SOME TIMES OBECTS TO THE CLASSES MAY NOT BE

CREATED BY JVM. SO WE UNABLE TO USE NEW
OPERATOR. FOR SOME CLASSES IN JAVA, WE CAN'T
CREATE AN OBJECT TO THAT CLASSES BY USING NEW
OPERATOR. FOR EXAMPLE WE CAN'T CREATE OBJECT TO
SYSTEM CLASS. BECAUSE SYSTEM CLASS DEPENDS ON
OPERATING SYSTEM INTERNALLY. IN THIS SITUATIONS WE
CAN CREATE OBJECTS WITH FACTORY METHODS.
FACTORY METHOD :- A FACTORY METHOD IS A METHOD

THAT RETURNS AN OBJECT OF CLASS TO WHICH IT
BELONGS. ALL FACTORY METHODS ARE STATIC METHODS.
NUMBERFORMAT CLASS IS USED TO FORMAT NUMBERS.

NUMBERFORMAT CLASS IS AVAILABLE IN JAVA.TEXT
PACKAGE. NUMBERFORMAT CLASS IS AN ABSTRACT
CLASS. IT MEANS WE CAN'T CREATE OBJECT FROM IT.
ONLY WE CAN CREATE REFERENCE. GETINSTANCE( ) IS
THE FACTORY METHOD OF NUMBERFORMAT CLASS.
import java.text.NumberFormat;
class Six
{
{
NumberFormat nf =
NumberFormat.getNumberInstance( );
String str;
int rds;
double area;
nf.setMinimumIntegerDigits(6);
nf.setMaximumFractionDigits(2);
str = nf.format(area);
ps.println("Area of Circle : " + area);
ps.println("Area of Circle : " + str);
}
USING PRINTF( ) METHOD TO FORMAT NUMBERS

==================================
===========
class Six
{
{
int rds;
double area;
ps.printf("Area of Circle : %.2f",area);
}
}
WORKING WITH DATES
======================
JAVA PROVIDES SEVERAL CLASSES TO HANDLE DATES.

THE MOST COMMONLY USED CLASS IS DATE OF JAVA.UTIL
PAKCAGE. THIS CLASS IS USED TO GET CURRENT SYSTEM
DATE AND TIME.
import java.util.Date;
class Six
{
{
Date d = new Date( );
ps.println("Current Date : " + d);
}
OUTPUT
========
Current Date : Mon Apr 19 16:05:50 IST 2010
FORMATTING DATES
===================
USING SIMPLEDATEFORMAT CLASS

=================================
THIS CLASS IS USED TO FORMAT DATES. IT IS THE MOST

COMMONLY USED DATE FORMAT CLASS. THIS CLASS IS
AVAILABLE IN JAVA.TEXT PACKAGE.
DISPLAYING DATE AND TIME IN DIFFERENT FORMATS

==================================
===============
import java.util.Date;
import java.text.SimpleDateFormat;
class Six
{
{
Date d = new Date( );
String str;
SimpleDateFormat sdf = new
SimpleDateFormat("dd/MM/yyyy");
// MM = MONTH, mm = MINUTE
str = sdf.format(d);
ps.println("Date in Indian Format : " + str);
sdf = new SimpleDateFormat("MM-dd-yyyy");
ps.println("Date in American Format : " + str);
sdf = new SimpleDateFormat("yyyy.MM.dd");
ps.println("Date in Japan Format : " + str);
sdf = new SimpleDateFormat("hh:mm:ss");
// hh : 12 HOURS FORMAT, HH : 24 HOURS FORMAT

ps.println("Current Time in 12 Hours Format : " + str);
sdf = new SimpleDateFormat("HH:mm:ss");
ps.println("Current Time in 24 Hours Format : " + str);
}
}
dd, MM, yyyy, hh, HH, mm, ss ARE CALLED DATE AND
TIME FORMAT CODES. DATE AND TIME FORMAT CODES
HAS CASE SENSITIVE.
CALENDAR CLASS
=================
CALENDAR CLASS IS USED TO ACCESS DATE AND TIME

PARTS INDIVIDUALLY. CALENDAR CLASS IS AVAILABLE IN
JAVA.UTIL PACKAGE. CALENDAR CLASS IS AN ABSTRACT
CLASS. IT MEANS WE CAN'T CREATE ANOBJECT FROM IT.
ONLY WE CAN CREATE REFERENCE. GETINSTANCE( ) IS
THE FACTORY METHOD OF CALENDAR CLASS. THIS CLASS
PROVIDES GET( ) AND SET( ) METHODS TO ACEESS AND
MODIFY DATE AND TIME.
CALENDAR CLASS PROVIDES THE FOLLOWING

CONSTANTS TO GET AND SET INDIVIDUAL PARTS OF DATE
AND TIME. ALL CONSTANTS RETURNS INTEGER.
DATE, MONTH, YEAR, HOUR, HOUR_OF_DAY, MINUTE,
SECOND, MILLISECOND, DAY_OF_WEEK,
DAY_OF_WEEK_IN_MONTH, DAY_OF_MONTH,
DAY_OF_YEAR, WEEK_OF_MONTH, WEEK_OF_YEAR,
AM_PM.
import java.util.Calendar;
class Six
{
{
Calendar cobj = Calendar.getInstance( );
int res;
ps.println("Current Date : " + cobj);
res = cobj.get(Calendar.DATE);
ps.println("Day : " + res);
res = cobj.get(Calendar.DAY_OF_WEEK);
ps.println("Day of Week : " + res);
res = cobj.get(Calendar.DAY_OF_WEEK_IN_MONTH);
ps.println("Day of Week in Month : " + res);
res = cobj.get(Calendar.DAY_OF_MONTH);
ps.println("Day of Month : " + res);
res = cobj.get(Calendar.DAY_OF_YEAR);
ps.println("Day of Year : " + res);
res = cobj.get(Calendar.WEEK_OF_MONTH);
ps.println("Week of Month : " + res);
res = cobj.get(Calendar.WEEK_OF_YEAR);
ps.println("Week of Year : " + res);
res = cobj.get(Calendar.MONTH);
// MONTH CONSTANT STARTS FROM ZERO.
ps.println("Month : " + (res+1) );
res = cobj.get(Calendar.YEAR);
ps.println("Year : " + res );
res = cobj.get(Calendar.HOUR);
ps.println("Hours (12 Hours Format) : " + res );
res = cobj.get(Calendar.HOUR_OF_DAY);
ps.println("Hours (24 Hours Format) : " + res );
res = cobj.get(Calendar.MINUTE);
ps.println("Minutes : " + res );
res = cobj.get(Calendar.SECOND);
ps.println("Seconds : " + res );
res = cobj.get(Calendar.MILLISECOND);
ps.println("Milli Seconds : " + res );
res = cobj.get(Calendar.AM_PM);
ps.println("AM / PM : " + res );
// RETURNS ZERO FOR AM AND ONE FOR PM
}
}
WRAPPER CLASSES
==================
THESE CLASSES ARE USED TO CONVERT PRIMITIVE DATA

TYPES INTO OBJECTS AND OBJECTS INTO PRIMITIVE DATA
TYPES. EVERY PRIMITIVE DATA TYPE HAS RELATED
WRAPPER CLASS.
PRIMITIVE DATA TYPE WRAPPER CLASS
=====================
================
byte
short
Byte
Short
int
Integer
long
Long
float
Float
double
char
boolean
Double
Character
Boolean
CONVERTING PRIMITIVE DATA TYPES INTO OBJECTS
==================================
==============
class Six
{
{
int n = 10;
Integer ob = new Integer(n);
ps.println("N Value : " + n);
ps.println("Object Value : " + ob);
}
}
byte n = 10;
Byte ob = new Byte(n);
short n = 10;
Short ob = new Short(n);
long n = 10L;
Long ob = new Long(n);
float n = 10.25F;
Float ob = new Float(n);
double n = 10.25;
Double ob = new Double(n);
char n = 'k';
Character ob = new Character(n);
boolean n = true;
Boolean ob = new Boolean(n);
CONVERTING OBJECTS INTO PRIMITIVE DATA TYPES

==================================
==============
xxxValue( ) :- THIS METHOD IS USED TO ACCESS VALUE

FROM AN OBJECT AND STORES INTO A PRIMITIVE DATA
TYPE. HERE xxx MEANS DATA TYPE.
class Six
{
{
Integer ob = new Integer(10);
int n = ob.intValue( );
ps.println("Object Value : " + ob);
}
}
Byte ob = new Byte((byte)10);
byte n = ob.byteValue( );
Short ob = new Short((short)10);
short n = ob.shortValue( );
Long ob = new Long(10L);

long n = ob.longValue( );
Float ob = new Float(10.25F);

float n = ob.floatValue( );
Double ob = new Double(10.25);

double n = ob.doubleValue( );
Character ob = new Character('K');

char n = ob.charValue( );
Boolean ob = new Boolean(true);

boolean n = ob.booleanValue( );
CONVERTING NUMERIC OBJECTS INTO STRING OBJECTS

==================================
=========
toString( ) :- THIS METHOD IS USED TO CONVERT ANY

TYPE OF OBJECT INTO STRING TYPE OBJECT.
class Six
{
{
Integer iob = new Integer(10);
String sob = iob.toString( );
ps.println("Integer Object Value : " + iob);
ps.println("String Object Value : " + sob);
}
}
Byte bob = new Byte((byte)10);

String sob = bob.toString( );
Short sob = new Short((short)10);

String stob = sob.toString( );
Long lob = new Long(10L);

String sob = lob.toString( );
Flaot fob = new Float(10.25F);

String sob = fob.toString( );
Double dob = new Double(10.25);

String sob = dob.toString( );
Character cob = new Character('K');

String sob = cob.toString( );
Boolean bob = new Boolean(true);

String sob = bob.toString( );
CONVERTING STRING OBJECTS INTO NUMERIC DATA TYPE

OBJECTS
==================================
=========
valueOf( ) :- EVERY NUMERIC CLASS HAS A STATIC

METHOD CALLED valueOf( ). THIS METHOD IS USED TO
CONVERT STRING TYPE OBJECT INTO NUMERIC OBJECT.
class Six
{
{
String sob = "10";
Integer iob = Integer.valueOf(sob);
ps.println("String Object Value : " + sob);
ps.println("Integer Object Value : " + iob);
}
}
String sob = "10";

Byte bob = Byte.valueOf(sob);
String stob = "10";
Short sob = Short.valueOf(stob);
String sob = "10";

Long lob = Long.valueOf(sob);
String sob = "10.25";

Float fob = Float.valueOf(sob);
String sob = "10.25";

Double dob = Double.valueOf(sob);
String sob = "true";

Boolean bob = Boolean.valueOf(sob);
CONVERTING PRIMITIVE DATA TYPES INTO STRING

OBJECTS
==================================
==============
toString( ) :- EVERY NUMERIC CLASS HAS A STATIC

METHOD CALLED toString( ). THIS METHOD IS USED TO
CONVERT ANY TYPE OF OBECT INTO STRING TYPE OBJECT.
class Six
{
{
int n = 10;
String ob = Integer.toString(n);
ps.println("String Object Value : " + ob);
}
}
byte n = 10;
String ob = Byte.toString(n);
short n = 10;
String ob = Short.toString(n);
long n = 10L;
String ob = Long.toString(n);
float n = 10.25F;
String ob = Float.toString(n);
double n = 10.25;
String ob = Double.toString(n);
char n = 'K';
String ob = Character.toString(n);
boolean n = true;
String ob = Boolean.toString(n);
CONVERTING STRING OBJECTS INTO PRIMITIVE DATA

TYPES
==================================
==============
parseXxx( ) :- EVERY NUMERIC CLASS HAS A STATIC

METHOD CALLED parseXxx( ). THIS METHOD IS USED TO
ACCESS VALUE FROM AN STRING OBJECT AND STORES
INTO A PRIMITIVE NUMERIC DATA TYPE. HERE xxx MEANS

DATA TYPE.
class Six
{
{
String ob = "10";
int n = Integer.parseInt(ob);
ps.println("String Object Value : " + ob);
}
}
String ob = "10";
byte n = Byte.parseByte(ob);
String ob = "10";
short n = Short.parseShort(ob);
String ob = "10";
long n = Long.parseLong(ob);
String ob = "10.25";
float n = Float.parseFloat(ob);
String ob = "10.25";
double n = Double.parseDouble(ob);
String ob = "true";
boolean n = Boolean.parseBoolean(ob);
OOPS (OBJECT ORIENTED PROGRAMMING SYSTEM)

==================================
=============
ONCE WE CREATE THE SOFTWARE, IT IS DIFFICULT TO

WRITE AGAIN & AGAIN THE SOLUTIONS FOR THE
PROBLEM GIVE BY CLIENT. THIS IS MAIN PROBLEM IN
PROCEDURAL LANGUAGES LIKE C, C++. FOR EXAMPLE IF
SOFTWARE IS EMPLOYEE PAY ROLE ONLY, CLIENT WILL
COME AGAIN AND AGAIN THAT YOUR SOFTWARE IS NOT

CALCULATING PF, BANK REPORTS ETC. SO PROGRAMMER
HAS TO WRITE THE SOLUTIONS AGAIN AND AGAIN FOR
PARTICULAR PROBLEM.
DRAWBACKS OF PROCEDUREAL LANGUAGES

==================================
========
IN PROCEDURAL APPROACH, CONCENTRAION IS WHAT IS

THE PROBLEM AND HOW TO SOLVE THE PROBLEM. IT
DOES NOT STUDY THE BEHAVIOUR OF THE ENTIRE
SYSTEM.
PROCEDURAL APPROACH IS NOT SUITABLE FOR

DEVELOPING COMPLEX PROGRAMS WHICH HAS
THOUSANDS OF LINES. BECAUSE PROGRAMMER MAY
LOOSE THEIR CONTROL ON THE PROGRAM.
IN PROCEDURAL LANGUAGE, PROGRAMMER LOOSE

CONTROL ON THE PROGRAM AT A PARTICULAR STATE
WHEN THE PROGRAM SIZE EXCEEDS BETWEEN TEN
THOUSAND AND LAKH LINES OF CODE. SO PROCEDURAL
APPROACH IS NOT SUITABLE FOR CREATIVE BIGGER AND
COMPLEX SOFTWARES.
IN PROCEDURAL APPROACH PROGRAMMING WILL NOT

REFELECT THE HUMAN LIFE.
OOPS :- OOPS HELPFUL TO CREATE VERY COMPLEX

PROGRAMS. OOPS REFLECT HUMAN LIFE. C++ AND JAVA
COME UNDER OOPS. SMALL TALK, SIMULA-67 ARE
INSIPIRATION BEHIND JAVA DEVELOPMENT.
FEATURES OF OOPS
==================
OBJECT / CLASS :- OOPS DEVELOPED FROM THE ROOT

CONCEPT IS CALLED OBJECT. AN OBJECT IS SOMETHING
THAT IS EXISTING IN THE REAL WORLD. AN OBJECT HAVE
PROPERTIES AND ACTIONS. FOR EXAMPLE IF MAN IS AN
OBJECT THEN NAME, COLOR, HEIGHT, WEIGHT ARE
CALLED PROPERTIES AND WALK, EAT, SLEEP ARE CALLED
ACTIONS. IN PROGRAMMING LANGAUGES PROPERTIES
ARE CALLED VARIABLES AND ACTIONS ARE CALLED
METHODS.
A CLASS IS AN ABSTRACT IDEA, NOT REAL. BUT AN

OBJECT IS REAL. CLASS DOES NOT EXIST PHYSICALLY,
BUT OBJECT EXIST PHYSICALLY. AN OBJECT DOES NOT
EXIST WITHOUT A CLASS, BUT A CLASS CAN EXIST

WIITHOUT AN OBJECT. CLASS IS ALSO A DATA TYPE. A
CLASS IS A GROUP NAME THAT SPECIFIES PROPERTIES
AND ACTIONS OF OBJECT. A CLASS IS A MODEL / BLUE
PRINT FOR CREATING OBJECTS. IN JAVA MEMORY IS
ALLOTED TO OBJECTS NOT FOR CLASSES. A CLASS / AN
OBJECT CONTAINS VARIABLES AND METHODS.
ENCAPSULATION :- BINDING UP OF DATA AND METHODS

IN THE SAME MEMORY. CLASS IS AN EXAMPLE FOR
ENCAPSULATION. VARIABLES AND METHODS ARE CALLED
MEMBERS OF CLASS. THE MEMBERS OF EACH CLASS ARE
SEPERATED FROM THE MEMBERS OF OTHER CLASSES.
THE MAIN ADVANTAGE OF ENCAPSULATION IS, DATA
REQUIRED TO METHODS IS AVAILABLE IN THE SAME
MEMORY, SO SPEEDER EXECUTION IS POSSIBLE.
ABSTRACTION :- HIDING UNNECESSARY DATA FROM THE

USER IS CALLED ABSTRACTION. SOME DATA IS NOT
DISPLAYED TO THE USER. USER HAS NO LIGHT TO SEE IT.
FOR EXAMPLE ENGINE IN THE CAR IS HIDDEN. TO
PROVIDE ABSTRACTION, A PROGRAMMER USES
KEYWORDS LIKE PRIVATE, PROTECTED, DEFAULT, PUBLIC
ETC.
PRIVATE KEYWORD IS USED TO HIDE COMPLETLY.
PROTECTED KEYWORD IS USED TO HIDE PARTIALLY.
DEFAULT KEYWORD IS USED TO HIDE PARTIALLY.
PUBLIC KEYWORD IS USED TO SHOW COMPLETLY.
INHERITANCE :- PRODUCING NEW CLASSES FROM AN

EXISTING CLASS IS CALLED INHERITANCE. WE CAN
CREATE NEW CLASSES FROM OLD EXISTING CLASS
WITHOUT REWRITING THE CODE. IT MEANS WE ARE
REUSING THE EXISTING CODE. THE MAIN ADVANTAGE OF
INHERITANCE IS REUSABILITY.
POLYMORPHISM :- IF SOMETHING EXIST IN MANY FORMS.

THE ABILITY TO EXIST IN DIFFERENT FORMS. SAME
METHOD PERFORMING DIFFERENT TASKS BASED ON
SITUATION IS CALLED POLYMORPHISM.
MESSAGE PASSING :- CALLING A METHOD IS CALLED

MESSAGE PASSING.
A CLASS IS A MODEL TO CREATE THE OBJECT. AN OBJECT

IS AN INSTANCE (VARIABLE) OF CLASS. WHATEVER WE
WRITE IN THE OBJECT WILL BE THERE IN THE CLASS.
JAVA IS A COMPLETE OOPS. IN OOPS WE CAN'T DO

ANYTHING WITHOUT OBJECT. THE WHOLE OOPS CONCEPT
IS IMPLEMENTED THROUGH OBJECT. OBJECT IS THE
VEHICLE TO IMPLEMENT ALL THE FEATURES OF THE
OOPS.
OBJECT :- IT IS AN INSTANCE (VARIABLE) OF A CLASS.
CLASS :- IT IS A COLLECTION OF DATA MEMBERS AND

METHODS. ONCE CLASS IS CREATED WE CAN CREATE ANY
NUMBER OF OBJECT FROM THAT CLASS.
THE FOLLOWING PROGRAM MUST BE SAVE IN

StudentDemo.java NOT IN Student.java. BECAUSE MAIN( )
IS WRITEN IN StudentDemo CLASS.
Designing Student Class

===================
class Student
{
int sno;
String sname;
double age;
void set( )
{
sno = 101;
sname = "Rama";
age = 12.6;
}
void show( )
{
System.out.println("Student Number : " + sno);
System.out.println("Student Name
: " + sname);
System.out.println("Student Age
: " + age);
}
};
class StudentDemo
{
{
Student ob = new Student( );
ob.show( );
ob.set( );
ob.show( );
}
}
DATA TYPE
DEFAULT VALUE
==========
BYTE
SHORT
INT
LONG
FLOAT
0.0
DOUBLE
0.0
CHAR
' ' (SPACE)
===============
BOOLEAN
FALSE
STRING / OBJECT NULL
Designing Sum Class

================
class Sum
{
int a;
int b;
int c;
void set( )
{
a = 10;
b = 20;
}
void calc( )
{
c = a + b;
}
void display( )
{
System.out.printf("Sum : %d",c);
}
};
class SumDemo
{
{
Sum s = new Sum( );
s.set( );
s.calc( );
s.display( );
}
}
THE ABOVE TWO PROGRAMS ARE LOGICALLY CORRECT,

BUT AS PER OOPS RULES NOT CORRCT. IN THE ABOVE
PROGRAM SNAME IS ACCESSED BY NON METHOD OF
STUDENT CLASS (MAIN METHOD). WE HAVE NO
CONTROLLING ON DATA. BY DEFAULT DATA IS AVAILABLE
TO ALL METHODS EVEN NON METHODS ALSO. WE CAN

CONTROL DATA THROUGH ACCESS SPECIFIERS.
ACCESS SPECIFIER :- IT IS A KEYWORD THAT REPRESENTS

HOW TO ACCESS THE MEMBERS OF A CLASS. JAVA
PROVIDES FOUR TYPES OF ACCESS SPECIFIERS.
1) PRIVATE
2) PUBLIC
3) PROTECTED
4) DEFAULT
PRIVATE :- IF A MEMBER IS DECLARED AS PRIVATE, THEN

THE MEMBER IS NOT AVAILABLE ANYWHERE OUTSIDE THE
CLASS. IT CAN ACCESS ONLY INSIDE THE CLASS.
PUBLIC :- IF A MEMBER IS DECLARED AS PUBLIC, THEN

THE MEMBER IS AVAILABLE ANYWHERE OUTSIDE THE
CLASS.
PROTECTED :- THIS IS SIMILAR TO PUBLIC. BUT SOME

DIFFERNCE IS THERE. THIS KEYWORD IS DISCUSSED IN
INHERITANCE CONCEPT.
DEFAULT :- IT IS THE DEFAULT ACCESS SPECIFIER. FOR

EXAMPLE IF WE WRITE int sno; THEN COMPILER PLACES
DEFAULT TO int sno; AND CHANGES THE STATEMENT INTO
default int sno; THIS IS SIMILAR TO PUBLIC. BUT SOME

DIFFERNCE IS THERE. THIS KEYWORD IS DISCUSSED IN
PACKAGES CONCEPT.
GENERALLY THE VARIABLES OF A CLASS ARE DECLARED

AS PRIVATE AND THE METHODS OF A CLASS ARE
DECLARED AS PUBLIC.
class Student
{
private int sno;
private String sname;
private double age;
void set( )
{
sno = 101;
sname = "Rama";
age = 12.6;
}
void show( )
{

: " + sname);
: " + age);
}
};
class StudentDemo2
{
{
ob.set( );
ob.sname = "King"; (error)
/* BECAUSE PRIVATE MEMBERS ARE NOT ACCESSED
OUTSIDE THE CLASS. SO THERE IS HIGH SECURITY
FOR
DATA IN OOPS CONCEPT THROUGH PRIVATE
ACCESS
SPECIFIER
*/
System.out.println("Student Details");
ob.show( );
}
}
ONCE A CLASS IS DEFINED WE CAN CREATE ANY NUMBER

OF OBJECTS FROM THAT CLASS.
class Student
{
private int sno;
private String sname;
private double age;
void set( )
{
sno = 101;
sname = "Rama";
age = 12.6;
}
void show( )
{
: " + sname);
: " + age);
};
class StudentDemoOops3
{
{
Student ob1 = new Student( );
ob1.set( );
System.out.println("First Student Details");
ob1.show( );
ob2.set( );
System.out.println("Second Student Details");
ob2.show( );
ob3.set( );
System.out.println("Third Student Details");
ob3.show( );
}
}
THE ABOVE PROGRAM IS LOGICALLY NOT CORRECT,

BECAUSE ALL OBJECTS HAVE SAME DATA. THE SOLUTION
FOR ABOVE PROBLEM IS PARAMETERIZED METHODS. A
PARAMETERIZED METHOD IS METHOD WHICH HAVE SOME
PARAMETERS.
Parameterized Methods
===================
class Student
{
int sno;
String sname;
double age;
void set(int vsno,String vsname,double vage)
{
sno = vsno;
sname = vsname;
age = vage;
}
void show( )
{

: " + sname);
: " + age);
}
};
class StudentDemo4
{
{
ob1.set(101,"Rama",12.6);
System.out.println("First Student Details");
ob1.show( );
ob2.set(102,"King",15.3);
System.out.println("Second Student Details");
ob2.show( );
ob3.set(103,"Tata",21.6);
System.out.println("Third Student Details");
ob3.show( );
}
}
Runtime Input
============
class Student
{
int studNo;
String studName;
int cLangMarks;
int cppLangMarks;
int javaLangMarks;
int totMarks;
double avgMarks;
void inputData( )
{
ps.println("Enter Student Number, Name");

studNo = sc.nextInt( );
studName = sc.next( );
ps.println("Enter C, Cpp, Java Marks");
cLangMarks = sc.nextInt( );
cppLangMarks = sc.nextInt( );
javaLangMarks = sc.nextInt( );
}
void calcData( )
{
totMarks = cLangMarks + cppLangMarks +
javaLangMarks;
avgMarks = totMarks / 3.0;
}
void showData( )
{
ps.println("Student Number : " + studNo);
ps.println("Student Name
: " + studName);
ps.println("C Langauge Marks : " + cLangMarks);

ps.println("Cpp Langauge Marks : " + cppLangMarks);
ps.println("Java Langauge Marks : " + javaLangMarks);
ps.println("Total Marks : " + totMarks);

ps.printf("Average Marks : %.2f",avgMarks);
}
};
class StudentDemo5
{
{
Student s = new Student( );
s.inputData( );
s.calcData( );
s.showData( );
}
}
Returnable Methods
================
class Sum
{
int a;
int b;
int c;
void input( )
{
a = sc.nextInt( );
b = sc.nextInt( );
}
int process( )
{
c = a + b;
return c;
}
};
class SumDemo
{
{
Sum ob = new Sum( );
int k;
ob.input( );
k = ob.process( );
ps.println("Sum : " + k);
}
}
Creating References to Objects

=========================
A REFERENCE IS A VARIABLE WHICH STORES OBJECT

HASHCODE. A HASHCODE IS NOTHING BUT MEMORY
LOCATION WHICH IS POINTED BY AN OBJECT. UNIQUE ID
NUMBER GIVEN TO EVERY OBJECT BY JVM. IT IS ALSO
CALLED REFERENCE NUMBER. MEMORY IS ACTUALLY
ALLOTED TO OBJECT NOT TO REFERENCE.
class Student
{
int sno;
String sname;
double age;
void set(int vsno,String vsname,double vage)
{
sno = vsno;
sname = vsname;
age = vage;
}
void show( )
{
: " + sname);
: " + age);
}
};
class StudentDemo6
{
{
ob.set(101,"Rama",12.6);
Student ref;
ob.show( );
ref = ob;
ref.show( );
ps.println("Object Points to : " + ob.hashCode( ));
ps.println("Reference Points to : " + ref.hashCode( ));
/*ref = null; (DELETING LINK)
ref.show( );
*/
}
}
Types of Passing Arguments / Calling of Passing

Arguments / Calling Function
==================================
====================
1) Call / Pass By Value : Not Effect
2) Call / Pass By Reference : Effect
PRIMITIVE DATA TYPES ARE AUTOMATICALLY PASSED BY

VALUE AND OBJECT TYPES ARE AUTOMATICALLY PASSED
BY REFERENCE.
Pass / Call By Value
===============
class Sample
{
void change(int x)
{
x = 20;
}
};
class PassByValDemo
{
{
Sample ob = new Sample( );

int n = 10;
ps.println("Before Calling Function, N Value : " + n);
ob.change(n);
ps.println("After Calling Function, N Value : " + n);
}
}
Pass / Call By Reference

===================
class Sample
{
void change(StringBuffer x)
{
x.reverse( );
}
};
class PassByRefDemo
{

{
ps.println("Before Calling Function, String : " + str);
ob.change(str);
ps.println("After Calling Function, String : " + str);
}
}
Object Arrays
===========
class Student
{
int sno;
String sname;
double age;
void input( )
{
ps.println("Enter Student Number, Name, Age");
sno = sc.nextInt( );
sname = sc.next( );
age = sc.nextDouble( );
}
void show( )
{
: " + sname);
: " + age);
}
};
class ObjArysDemo
{
{
Student ob[ ] = new Student[5];
int i;
for(i = 0; i < ob.length; i++)
{
ob[i] = new Student( );
}
{
ob[i].input( );
}
{
ob[i].show( );
}
}
}
Polymorphism
============
IT IS DERIVED FROM TWO GREEK WORDS CALLED "POLY"

AND "MORPHIC". POLY MEANS MANY AND MORPHIC
MEANS FORMS. POLYMORPHISM MEANS ONE METHOD
DIFFERENT FORMS OR IF SOMETHING EXIST IN MANY
FORMS. IT MEANS SAME METHOD PERFORMING
DIFFERENT TASKS BASED ON SITUATION. IT MEANS THE

ABILITY TO EXIST IN DIFFERENT FORMS. JAVA SUPPORTS
TWO TYPES OF POLYMORPHISM.
1) STATIC POLYMORPHISM
2) DYNAMIC POLYMORPHISM
STATIC POLYMORPHISM :- WHICH IS DONE AT COMPILE

TIME.
Ex :- METHOD OVERLOADING
DYNAMIC POLYMORPHISM :- WHICH IS DONE AT RUN TIME.
Ex :- METHOD OVERRIDING [ INHERITANCE ]
METHOD OVERLOADING
======================
IN 'C' LANGAUGE WE CAN USE UNIQUE NAME FOR
METHODS (FUNCTIONS) . IT MEANS WE CAN'T PUT THE

SAME NAME FOR TWO METHODS (FUNCTIONS). METHOD
OVERLOADING MEANS WE CAN USE THE SAME NAME FOR
SEVERAL METHODS. IT MEANS WE CAN USE SINGLE
METHOD FOR SEVERAL PURPOSES. TO OVERLOAD
METHODS WE MUST FOLLOW ONE OF THE FOLLOWING
TWO RULES.
1) DIFFERENT PARAMETER DATA TYPES
2) DIFFERENT NUMBER OF PARAMETERS
Overloading Methods Based On First Rule

=================================
class Sum
{
void sum(int x, int y)
{
int k;
k = x + y;
ps.println("Integer Sum : " + k);
}
void sum(long x, long y)
{
long k;
k = x + y;
ps.println("Long Sum : " + k);
}
void sum(float x, float y)
{
float k;
k = x + y;
ps.println("Float Sum : " + k);
}
void sum(double x, double y)
{
double k;
k = x + y;
ps.println("Double Sum : " + k);
}
};
class MethOvrLodDemo1
{
{
ob.sum(6,3);
ob.sum(63L,36L);
ob.sum(12.34F,56.78F);
ob.sum(98.76,54.32);
}
}
Overloading Methods Based On Second Rule

==================================
=
class Sum
{

void sum(int x, int y)
{
int k;
k = x + y;
ps.println("Two Parameters Sum : " + k);
}
void sum(int x, int y, int z)
{
int k;
k = x + y + z;
ps.println("Three Parameters Sum : " + k);
}
void sum(int x, int y, int z, int t)
{
int k;
k = x + y + z + t;
ps.println("Four Parameters Sum : " + k);
}
};
class MethOvrLodDemo2
{
{
ob.sum(6,3);
ob.sum(10,20,30);
ob.sum(100,200,300,400);
}
}
Constructors
==========
A CONSTRUCTOR IS ALSO ONE OF THE METHOD OF A

CLASS. BUT THE SPECIALITY OF THE CONSTRUCTOR IS
WHICH CONTAINS SAME CLASS NAME. CONSTRUCTORS
ARE USED TO INITIALIZE AN OBJECT. THE TASK OF
CONSTRUCTOR IS TO INITIALIZE THE DATA MEMBERS. WE
MUST FOLLOW THE RULES IN CONSTRUCTORS.
1) SAME CLASS NAME
2) IT HAS NO RETURN TYPE

3) WE NEED NOT TO CALL CONSTRUCTOR, IT
AUTOMATICALLY CALLS WHENEVER AN OBJECT IS
CREATED.
TYPES OF CONSTRUCTORS
=======================
1) NON-PARAMETERIZED / NO ARGUMENT
CONSTRUCTORS
2) PARAMETERIZED CONSTRUCTORS
3) DEFAULT CONSTRUCTORS
4) CONSTRUCTOR OVERLOADING
NON-PARAMETERIZED CONSTRUCTORS
==================================
==
A NON-PARAMETERIZED CONSTRUCTOR IS A
CONSTRUCTOR, WHICH CONTAINS NO PARAMETERS.
class Teja
{
Teja( )
{
System.out.println("Welcome to Constructors");
}
};
class Six
{
{
Teja ob = new Teja( );
}
}
class Student
{
int sno;
String sname;
double age;
Student( )
{
sno = 101;
sname = "Rama";
age = 25;
}
void show( )
{
ps.println("Student Number : " + sno);
ps.println("Student Name : " + sname);
ps.println("Student Age : " + age);
}
};
class ConsDemo1
{
{
ps.println("Student Details");
ob.show( );
}
}
PARAMETERIZED CONSTRUCTORS
================================
A PARAMETERIZED CONSTRUCTOR IS A CONSTRUCTOR,

WHICH CONTAINS SOME PARAMETERS. THE MAIN
ADVANTAGE OF USING PARAMETERIZED CONSTRUCTOR
IS, WE CAN INITIALIZE EACH OBJECT WITH DIFFERENT
DATA.
class Student
{
int sno;
String sname;
double age;
Student(int vsno, String vsname, double vage)
{
sno = vsno;
sname = vsname;
age = vage;
}
void show( )
{
}
};
class ConsDemo2
{
{
Student ob1 = new Student(101,"Rama",12.6);

ps.println("First Student Details");
ob1.show( );
Student ob2 = new Student(102,"King",15.3);
ps.println("Second Student Details");
ob2.show( );
Student ob3 = new Student(103,"Siva",6.3);
ps.println("Third Student Details");
ob3.show( );
}
}
DEFAULT CONSTRUCTORS
========================
AN OBJECT ALWAYS CREATES WITH THE HELP OF

CONSTRUCTOR. IF YOUR CLASS CAN'T CONTAIN ANY
CONSTRUCTOR, THEN JAVA COMPILER AUTOMATICALLY
WRITES AND PLACES A DEFAULT CONSTRUCTOR IN YOUR
CLASS. IF YOUR PROGRAM CONTAINS ANY
CONSTRUCTOR, JAVA COMPILER CAN'T WRITE AND PLACE
A DEFAULT CONSTRUCTOR IN YOUR CLASS. THEN IT IS
PROGRAMMER'S RESPONSIBILITY TO WRITE DEFAULT

CONSTRUCTOR.
SYNTAX OF DEFAULT CONSTRUCTOR

==================================
class_name( )
{
}
Ex :Student( )
{
}
THE MAIN ADVANTAGE OF DEFAULT CONSTRUCTOR IS TO

CREATE AN OBJECT SUCCESSFULLY WHEN OUR PROGRAM
HAS OTHER CONSTRUCTORS.
class Student
{
int sno;
String sname;
double age;
Student( )
{
}
Student(int vsno, String vsname, double vage)
{
sno = vsno;
sname = vsname;
age = vage;
}
void input( )
{
sname = sc.next( );
}
void show( )
{
}
};
class ConsDemo3
{
{
Student ob1 = new Student(101,"Rama",12.6);
ob2.input( );
ps.println("First Student Details");
ob1.show( );
ps.println("Second Student Details");
ob2.show( );
}
}
CONSTRUCTOR OVERLOADING
============================
LIKE METHODS, WE CAN ALSO OVERLOAD

CONSTRUCTORS. THE MAIN ADVANTAGE OF
OVERLOADING CONSTRUCTORS IS WE CAN CREATE
VARIETY OF OBJECTS. IT MEANS FLEXIBLE OBJECTS.
THROUGH CONSTRUCTOR OVERLOADING, USER CAN
CREATE OBJECTS AS PER HIS REQUIREMENTS.
class Student
{
int sno;
String sname;
String addr;
Student( )
{
}
Student(int vsno)
{
sno = vsno;
sname = "Smith";
addr = "Tenali";
}
Student(int vsno, String vsname)
{
sno = vsno;
sname = vsname;
addr = "Guntur";
}
Student(int vsno, String vsname, String vaddr)
{
sno = vsno;
sname = vsname;
addr = vaddr;
}
void input( )
{
ps.println("Enter Student Number, Name, Address");
sname = sc.next( );
addr = sc.next( );
}
void show( )
{
ps.println("Student Address : " + addr);
}
};
class ConsDemo4
{
{
ob1.input( );
ob1.show( );
Student ob2 = new Student(101);

ob2.show( );
Student ob3 = new Student(102,"Tata");
ob3.show( );
Student ob4 = new Student(103,"King","Chennai");
ob4.show( );
}
}
THIS KEYWORD
===============
THIS REFERS TO CURRENT OBJECT. GENERALLY IT IS USED

TO REMOVE NAMING CONFLICTIONS.
class Student
{
int sno;
String sname;
double age;
Student(int sno, String sname, double age)
{
this.sno = sno;
this.sname = sname;
this.age = age;
}
void show( )
{
}
};
class ThisDemo1
{
{
Student ob = new Student(101,"Rama",12.6);
ob.show( );
}
TYPES OF VARIABLES
====================
1) LOCAL VARIABLES : BELONGS TO METHODS.
2) INSTANCE VARIABLES : BELONGS TO OBJECTS.
3) STATIC VARIABLES : BELONGS TO CLASSES.
INSTANCE VARIABLE :- AN INSTANCE VARIABLE IS A

VARIABLE, WHOSE SEPERATE COPY IS AVAILABLE TO
EACH OBJECT. INSTANCE VARIABLES ARE CREATED ON
HEAP AREA. IF THE INSTNACE VARIABLE VALUE IS
MODIFIED IN AN OBJECT, IT WILL NOT EFFECT IN OTHER
OBJECTS.
STATIC VARIABLE :- A STATIC VARIABLE IS A VARIABLE,

WHOSE SINGLE COPY IS SHARED BY ALL OBJECTS OF THE
CLASS. STATIC VARIABLES ARE CREATED ON METHOD
AREA.
STATIC DATA MEMBERS

======================
THE SPECIALITY OF STATIC DATA MEMBERS IS, IT CAN'T

CREATED IN THE OBJECT, IT CREATED IN CLASS. SO, IT
CAN BE USED BY EACH AND EVERY OBJECT CREATED
FROM THAT CLASS. IT MEANS ALL OBJECTS CREATED
FROM THAT CLASS CAN SHARE THESE DATA MEMBERS.
THROUGH STATIC DATA MEMBERS, WE CAN SAVE
MEMORY AND PROVIDE COMMON DATA (EX :- COLLEGE
NAME, BATCH CODE) TO ALL OBJECTS. WE CAN ALSO
REDUCE INVALID ENTRY RISK.
A STATIC VARIABLE IS A VARIABLE WHOSE SINGLE COPY

IS SHARED BY ALL THE OBJECTS OF THE CLASS. ONLY
ONE COPY OF THAT VARIABLE IN MEMORY AND IT IS
SHARED BY ALL OBJECTS OF CLASS IS CALLED STATIC
VARIABLE.
class Student
{

int sno;
String sname;
double age;
static String cname = "VSR";
void input( )
{
sname = sc.next( );
}
void show( )
{
ps.println("College Name : " + cname);
}
};
class StatDemo1
{
{
ob1.input( );
ob2.input( );
ob3.input( );
ob1.show( );
ob2.show( );
ob3.show( );
}
}
TYPES OF METHODS
===================
STATIC METHOD :- THESE METHODS ACT UPON STATIC

VARIABLES OF A CLASS. THESE METHODS HANDLES ONLY
STATIC DATA MEMBERS. NON-STATIC METHODS ARE

OBJECT LEVEL METHODS AND STATIC METHODS ARE
CLASS LEVEL METHODS.
class Sample
{
static void show( )
{
System.out.println("Welcome to Static Methods");
}
}
class StatDemo2
{
{
Sample.show( );
}
}
class Sum
{
static int a;
static int b;
static int c;
static void set(int x, int y)
{
a = x;
b = y;
}
static int process( )
{
c = a + b;
return c;
}
};
class StatDemo3
{
{
Sum.set(6,3);
int k;
k = Sum.process( );
System.out.println("Sum : " + k);
System.out.println("Sum : " + Sum.process( ));
}
}
FACTORY METHOD :- A FACTORY METHOD IS A METHOD

THAT RETURNS AN OBJECT OF CLASS TO WHICH IT
BELONGS. ALL FACTORY METHODS ARE STATIC METHODS.
STATIC BLOCKS
==============
BLOCK :- SET OF STATEMENTS WHICH ARE PLACED INSIDE

THE BRACES.
A STATIC BLOCK IS A BLOCK WHICH IS PREFIXED WITH

THE KEYWORD "static". THE SPECIALITY OF STATIC BLOCK
IT EXECUTES BEFORE THE MAIN( ).
class StatDemo4
{
static
{
System.out.println("Static Block");
}
{
System.out.println("Static Method");
}
}
WE ARE USING STATIC KEYWORD IN THE FOLLOWING

THREE FORMS.
1) STATIC DATA MEMBER
2) STATIC METHOD
3) STATIC BLOCK
THE PRIORITY OF ABOVE THREE FORMS IS AS FOLLOWS.
1) STATIC DATA MEMBER
2) STATIC BLOCK
3) STATIC METHOD
class StatDemo5
{
static int a = 10;
static
{
a = 20;
{
}
}
INHERITANCE
=============
IT IS THE TECHNIQUE OF EXTENSION OF ALREADY

EXISTING CLASS. IT MEANS WE CAN PRODUCE NEW
CLASS FROM EXSTING CLASS WITHOUT DISTRUBING
EXISTING CLASS. IN THIS PROCESS, EXISTING CLASS IS
CALLED AS SUPER CLASS / BASE CLASS / OLD CLASS AND
THE EXTENDED CLASS IS CALLED AS SUB CLASS /
DERIVED CLASS / NEW CLASS. SUB CLASS IS POWERFUL
THAN SUPER CLASS, BECAUSE SUB CLASS HAVE ALL THE
FEATURES OF SUPER CLASS AND ADDITIONAL FEATURES
OF ITSELF. THE MAIN ADVANTAGE OF INHERITANCE IS
REUSABILITY OF CODE. IF WE CREATE AN OBJECT TO SUB
CLASS IT CONTAINS A COPY OF SUPER CLASS OBJECT.
THAT IS THE REASON WHY SUPER CLASS MEMBERS ARE
AVAILABLE TO SUB CLASS. GENERALLY WE DON'T CREATE
AN OBJECT TO SUPER CLASS IN INHERITANCE. SO BETTER
WAY IS CREATE OBJECT TO SUB CLASS NOT TO SUPER
CLASS.
TYPES OF INHERITANCE
======================
1) SINGLE INHERITANCE
2) MULTI LEVEL INHERITANCE
3) HIERARCHICAL INHERITANCE
4) MULTIPLE INHERITANCE
5) MULTI PATH INHERITANCE
6) HYBRID INHERITANCE
JAVA'S RULE IS THAT A CLASS CAN HAVE ONLY ONE SUPER

CLASS. SO JAVA DOES NOT SUPPORT MULTIPLE, MULTI
PATH AND HYBRID INHERITANCES DIRECTLY. BUT
SUPPORTS INDIRECTLY IN THE FORM OF INTERFACES. AN
INTERFACE IS SIMILAR TO CLASS BUT MINOR
DIFFERENCES.
A SUB CLASS ALWAYS CONTAINS A COPY OF SUPER

CLASS.
SINGLE INHERITANCE
====================
DERIVING NEW CLASS FROM SINGLE CLASS.
class One
{
void show1( )
{
ps.println("show1 method called from class One");
}
}
class Two extends One
{
void show2( )
{
ps.println("show2 method called from class Two");
}
}
class InhDemo1
{
{
Two ob = new Two( );

ob.show1( );
ob.show2( );
}
}
IN THE ABOVE PROGRAM TWO CLASSES HAVE DIFFERENT

METHOD NAMES CALLED SHOW1( ) AND SHOW2( ).
THERE IS POSSIBILITY TO ASSIGN SAME NAME FOR TWO
METHODS IN TWO CLASSES. THIS CONCEPT IS CALLED
METHOD OVERRIDING.
METHOD OVERRIDING :- WRITING TWO OR MORE

METHODS WITH SAME NAME AND SAME SIGNATURE IS
CALLED METHOD OVERRIDING. THE SUB CLASS METHOD
OVERRIDES THE SUPER CLASS METHOD.
SUPER KEYWORD :- IT IS USED TO ACCESS SUPER CLASS

METHODS & DATA MEMBERS.
class One
{

void show( )
{
ps.println("show method called from class One");
}
}
{
void show( )
{
super.show( );
ps.println("show method called from class Two");
}
}
class InhDemo2
{
{
ob.show( );
}
MULTILEVEL INHERITANCE
==========================
DERIVING NEW CLASS FROM ANOTHER DERIVED CLASS.
class One
{
void show( )
{
}
};
{
void show( )
{
super.show( );

}
};
class Three extends Two
{
void show( )
{
super.show( );
ps.println("show method called from class Three");
}
};
class Four extends Three
{
void show( )
{
super.show( );
ps.println("show method called from class Four");
}
};
class InhDemo3
{

{
Four ob = new Four( );
ob.show( );
}
}
TYPES OF SUPER CLASSES

========================
1) DIRECT SUPER CLASSES
2) INDIRECT SUPER CLASSES
IN THE ABOVE PROGRAM CLASS THREE IS THE DIRECT

SUPER CLASS TO CLASS FOUR AND CLASS TWO, ONE ARE
THE INDIRECT SUPER CLASSES TO CLASS FOUR.
TYPES OF SUB CLASSES

=====================
1) DIRECT SUB CLASSES
2) INDIRECT SUB CLASSES
IN THE ABOVE PROGRAM CLASS FOUR IS THE DIRECT SUB

CLASS TO CLASS THREE AND INDIRECT SUB CLASS TO
CLASS TWO AND CLASS ONE.
HIERARCHICAL INHERITANCE
============================
THIS TYPE OF INHERITANCE IS SIMILAR TO A TREE. IN

THIS MODEL EACH SUPER CLASS HAS MINIMUM TWO SUB
CLASSES. GENERALLY IN THIS MODEL OBJECTS ARE
CREATED FROM LEAF NODE (LAST SUB) CLASSES.
class One
{
void show( )
{

}
};
{
void show( )
{
super.show( );
}
};
class Three extends One
{
void show( )
{
super.show( );
ps.println("show method called from class Three");
}
};
class Four extends Two
{
void show( )
{
super.show( );
ps.println("show method called from class Four");
}
};
class Five extends Two
{
void show( )
{
super.show( );
ps.println("show method called from class Five");
}
};
class Six extends Three
{
void show( )
{
super.show( );
ps.println("show method called from class Six");
}
};
class Seven extends Three
{
void show( )
{
super.show( );
ps.println("show method called from class Seven");
}
};
class InhDemo4
{
{
Four ob1 = new Four( );
Five ob2 = new Five( );
Six ob3 = new Six( );
Seven ob4 = new Seven( );
ps.println("Class Four Methods");
ob1.show( );
ps.println("Class Five Methods");
ob2.show( );
ps.println("Class Six Methods");
ob3.show( );
ps.println("Class Seven Methods");
ob4.show( );
}
}
SUPER KEYWORD
=================
SUPER KEYWORD HAVE THREE FORMS.
1) TO ACCESS SUPER CLASS METHODS.
2) TO ACCESS SUPER CLASS DATA MEMBERS.
3) TO CALL SUPER CLASS CONSTRUCTORS.
USING SUPER KEYWORD TO ACCESS SUPER CLASS

METHOD
==================================
============
class One
{
void show( )
{
}
};
{
void show( )
{
super.show( );
}
};
class InhDemo12
{
{
ob.show( );
}
}

DATA MEMBERS
==================================
===========================
class One
{
int a;
};
{
int a;
void set(int x,int y)

{
super.a = x;
a = y;
}
void show( )
{
ps.println("Super Class A Value : " + super.a);
ps.println("Sub Class A Value : " + a);
}
};
class InhDemo13
{
{
ob.set(6,3);
ob.show( );
}
}
WHEN CONSTRUCTORS ARE CALLED
==================================
class One
{
One( )
{
System.out.println("Class One Constructor");
}
};
{
Two( )
{
System.out.println("Class Two Constructor");
}
};
class Three extends Two
{
Three( )
{
System.out.println("Class Three Constructor");
}
};
class InhDemo14
{
{
Three ob = new Three( );
}
}

CONSTRUCTORS
==================================
===========================
class One
{

int a;
int b;
One(int x,int y)
{
a = x;
b = y;
}
void show( )
{
ps.println("A Value : " + a);
ps.println("B Value : " + b);
}
};
{
int c;
int d;
Two(int x,int y,int m,int n)
{
super(x,y);
c = m;
d = n;
}
void show( )
{
super.show( );
ps.println("C Value : " + c);
ps.println("D Value : " + d);
}
};
class InhDemo15
{
{
Two ob = new Two(10,20,30,40);
ob.show( );
}
}
FINAL KEYWORD
================
FINAL KEYWORD HAS THREE FORMS. FINAL KEYWORD

CAN BE USED TO DECLARE
1) FINAL VARIABLES (CONSTANTS / LITERALS)
2) FINAL METHODS (MUST NOT OVERRIDDEN)
3) FINAL CLASSES (MUST NOT INHERITED)
class FinalDemo1
{
{
final int a = 10;
a = 20;
}
}
//
FINAL METHODS
class One
{
final void show( )
{
System.out.println("Show Method Called From Class
One");
}
};
{
void show( ) // Error
{
super.show( );
Two");
}
};
class FinalDemo2
{

{
ob.show( );
}
}
//
FINAL CLASSES
final class One

{
void show( )
{
One");
}
};
class Two extends One // error
{
void show( )
{
super.show( );

Two");
}
};
class FinalDemo3
{
{
ob.show( );
}
}
ABSTRACT METHODS
===================
AN ABSTRACT METHOD IS A METHOD, WHICH HAVE NO

BODY. SUB CLASS MUST OVERRIDE ABSTRACT METHOD. IF
A CLASS CONTAINS ATLEAST ONE ABSTRACT METHOD,
THEN THE CLASS MUST BE DECLARED AS ABSTRACT
CLASS. WE CAN'T CREATE OBJECT FROM THE ABSTRACT
CLASS. BUT WE CAN CREATE REFERENCE FROM THE
ABSTRACT CLASS.
abstract class One

{
abstract void show( );
}
{
void show( )
{
Two");
}
}
class AbstDemo1
{
{
ob.show( );
}
}
DYNAMIC METHOD DISPATCHING / RUNTIME

POLYMORPHISM
==================================
==============
A SUPER CLASS REFERENCE CAN POINT SUB CLASS

OBJECT
abstract class One

{
abstract void show( );
};
{
void show( )
{
Two");
}
};
class Three extends One
{
void show( )
{
Three");
}
};
class Four extends One
{
void show( )
{
Four");
}
};
class AbstDemo5
{
{
One ref;
Two ob2 = new Two( );
Three ob3 = new Three( );

Four ob4 = new Four( );
ref = ob3;
ref.show( );
ref = ob2;
ref.show( );
ref = ob4;
ref.show( );
}
}
INTERFACES
==========
A PURE ABSTRACT CLASS. IT IS SIMILAR TO CLASS. BUT

ALL THE METHODS ARE ABSTRACT AND VARIABLES ARE
FINAL. ALL INTERFACE METHODS MUST BE OVERRIDEN BY
SUB CLASS. AT THE TIME OF INTERFACE DECLARACTION
NO NEED TO USE "ABSTRACT" KEYWORD BEFORE
METHODS AND MUST USE "FINAL" KEYWORD BEFORE
VARIABLES. AT THE TIME OF OVERRIDEN WE MUST ADD
"PUBLIC" KEYWORD BEFORE METHODS. WE CAN'T
CREATE AN OBJECT FROM THE INTERFACE. WE CAN ONLY

CREATE REFERENCE FROM THE INTERFACE.
interface Sample
{
void show( );
}
class One implements Sample
{
public void show( )
{
One");
}
}
class IntFaceDemo1
{
{
One OneOb = new One( );
OneOb.show( );
}
}
INTERFACES CAN HAVE FINAL VARIABLES

==================================
=====
interface Sample
{
final int a = 10;
static final int b = 20;
}
{
void show( )
{
System.out.println("A Value : " +a);
System.out.println("B Value : " + Sample.b);
}
}
class IntFaceDemo2
{
{
OneOb.show( );
}
}
DYNAMIC METHOD DISPATCHING / RUNTIME

POLYMORPHISM
==================================
==============
AN INTERFACE REFERENCE CAN POINT SUB CLASS OBJECT
interface Sample
{
void show( );
}
{
public void show( )
{
One");
}
}
class Two implements Sample
{
public void show( )
{
Two");
}
}
class Three implements Sample
{
public void show( )
{
Three");
}
}
class Four implements Sample
{
public void show( )
{
Four");
}
}
class IntFaceDemo3
{
{
Sample ref;
One obOne = new One( );
Two obTwo = new Two( );
Three obThree = new Three( );
Four obFour = new Four( );
ref = obOne;
ref.show( );
ref = obTwo;
ref.show( );
ref = obThree;
ref.show( );
ref = obFour;
ref.show( );
}
}
INTERFACE INHERITANCE
====================
interface Sample
{
void show1( );
}
interface Simple extends Sample
{
void show2( );
}
class One implements Simple
{
public void show1( )
{
System.out.println("Show1 Method Called From Class
One");
}
{
One");
}
}
class IntFaceDemo4
{
{
OneOb.show1( );
OneOb.show2( );
}
}
MULTIPLE INHERITANCE
====================
interface Sample
{
void show1( );
}
interface Simple
{
void show2( );
}
class One implements Sample,Simple
{
{
One");
}
{

One");
}
}
class IntFaceDemo5
{
{
OneOb.show1( );
OneOb.show2( );
}
}
A SUB CLASS CAN HAVE ONLY ONE SUPER CLASS AND

ANY NUMBER OF INTERFACES. IN THIS SITUTATION, WE
MUST FIRST EXTEND SUPER CLASS AND THEN
IMPLEMENTS INTERFACES.
class Smile
{
void show1( )
{
Smile");
}
}
interface Sample
{
void show2( );
}
interface Simple
{
void show3( );
}
class One extends Smile implements Sample,Simple
{
{
One");
}
{
One");
}
};
class IntFaceDemo6
{
{
OneOb.show1( );
OneOb.show2( );
OneOb.show3( );
}
}
EXCEPTION HANDLING
=====================
TYPES OF ERRORS
=================
1) SYNTAX ERRORS
2) LOGICAL ERRORS
3) RUNTIME ERRORS
SYNTAX ERRORS :- WHICH ARE TRACED AT THE TIME OF

COMPILATION.
LOGICAL ERRORS :- WHICH ARE TRACED AT THE TIME OF

DEBUGGING.
RUNTIME ERRORS :- THESE ARE ALSO CALLED AS

EXCEPTIONS. THESE ARE VERY DANGEROUS ERRORS.
WHEN AN EXCEPTION IS ENCOUNTERED, IT WILL EFFECT
ON ENTIRE PROJECT. THESE RUNTIME ERRORS ARE
MANAGED BY EXCEPTION HANDLING TECHNIQUE.
EXCEPTION UNHANDLED PROGRAM
=================================
class Excep1
{
{
int a,b,c;
ps.println("Module 1");
c = a / b;
ps.println("Quotient : " + c);
}
}
EXCEPTION HANDLED PROGRAM

==============================
class Excep2
{
{
int a,b,c;
try
{
c = a / b;
}
catch(ArithmeticException ob)
{
ob.printStackTrace( );
ps.println(ob);
ps.println(ob.getMessage( ));
ps.println("Second value not be zero");
}
}
}
class Excep3
{
{
int a,b,c;
try
{
c = a / b;
}
{
}
}
}
class Excep4
{
{
int a,b,c;
try
{
c = a / b;
}
catch(ArrayIndexOutOfBoundsException ob)
{
ps.println("Please enter 2 numbers");
}
}
}
class Excep5
{
{
int a,b,c;
try
{
c = a / b;
}
catch(NumberFormatException ob)
{
ps.println("Please enter 2 integers");
}
}
}
A TRY BLOCK CAN HAVE ANY NUMBER OF CATCH

BLOCKS
==================================
====================
class Excep6
{
{
int a,b,c;
try
{
c = a / b;
}
catch(ArrayIndexOutOfBoundsException ob)
{
ps.println("Please enter 2 numbers");
}
catch(NumberFormatException ob)
{
ps.println("Please enter 2 integers");
}
{
}
catch(Exception ob)
{
ps.println("Some error occured");
}
}
}
FINALLY BLOCK :- The finallykeyword is designed to

address this contingency.finally creates a block of code
that will be executed after a try/catch block hascompleted
and before the code following the try/catch block. The
finally block will execute
whether or not an exception is thrown. If an exception is
thrown, the finallyblock will execute even if no catch
statement matches the exception.
class Excep7
{
{
int a,b,c;
try
{
c = a / b;
}
{
}
finally
{
}
}
}
THROW CLAUSE :- THIS CLAUSE IS USED TO ESCAPE

FROM HANDLING AN EXCEPTION.It is possible for your
program to throw an exception explicitly,using the throw
statement. The general form of throw is shown here:
throw ThrowableInstance;
class Excep8
{
{
char x;
x = (char) System.in.read( );
}
}
USER DEFINED EXCEPTIONS
==========================
class InvalidMarks extends Exception
{
InvalidMarks(String k)
{
System.out.println(k);
}
}
class Excep9
{
{
int m;
m = Integer.parseInt(args[0]);
try
{
if(m > 100)
{
throw new InvalidMarks("Invalid Marks");

}
}
catch(InvalidMarks ob)
{
ps.println("Please enter between 0-100");
}
ps.print("Marks : " + m);
}
}
class InvalidMarks extends Exception
{
};
class Excep10
{
{
int m;
m = Integer.parseInt(args[0]);
try
{
if(m > 100)
{
throw new InvalidMarks( );
}
}
catch(InvalidMarks ob)
{
ps.println("Please enter between 0-100");
}
ps.print("Marks : " + m);
}
}
PACKAGES
==========
PACKAGE MEANS SET OF CLASSES AND INTERFACES.

PACKAGE MEANS SIMPLY A FOLDER. THE MAIN
ADVANTAGE OF PACKAGES IS REUSABILITY.
package amar;
public class SampleMsg
{
public void show( )
{
System.out.println("Show Method Called From SampleMsg
Class Of Amar Package");
}
}
javac -d . SampleMsg.java
import amar.SampleMsg;
class UseSampleMsg
{
{
SampleMsg ob = new SampleMsg( );

ob.show();
}
}
ONCE A CLASS IS PLACED IN A PACKAGE, WE CAN USE IT

IN ANY NUMBER OF PROGRAMS.
import amar.SampleMsg;
class UseSampleMsg1
{
{
SampleMsg ob = new SampleMsg( );
ob.show();
}
}
MULTITHREADING
=================
A THREAD IS NOTHING BUT A METHOD. BY USING

MULTITHREADING CONCEPT WE CAN EXECUTE MULTIPLE
THREADS SIMULTANEOUSLY. BY USING THIS CONCEPT WE
CAN SAVE TIME. EVERY THREAD HAVE THE FOLLOWING
THREE PROPERTIES.
1) THREAD GROUP
2) THREAD NAME
3) THREAD PRIORITY
a) MIN_PRIORITY (1)
b) NORM_PRIORITY (5)
c) MAX_PRIORITY (10)
RUN( ) METHOD IS THE HEART AND SOUL OF THREAD

CLASS. THE CODE WILL BE PLACED INSIDE THE RUN( )
METHOD. WHEN WE CALL START( ) METHOD OF THREAD
OBJECT, THEN IT CALLS RUN( ) METHOD OF THREAD
CLASS.
PRINTING MAIN( ) THREAD DETAILS

================================
class ThreadDemo1
{
{
Thread ob = Thread.currentThread( );
ps.println("Main thread details");
System.out.println(t);
ps.println("Thread Group : " + ob.getThreadGroup( ) );
ps.println("Thread Name : " + ob.getName( ) );
ps.println("Thread Priority : " + ob.getPriority( ) );
ob.setName("Sample");
ob.setPriority(10);
ps.println("Thread Name : " + ob.getName( ) );
ps.println("Thread Priority : " + ob.getPriority( ) );
}
}
CREATING THREAD BY EXTENDING THREAD CLASS
==================================
=============
class Sample extends Thread

{
public void run( )
{
for(int i = 1; i <= 10; i++)
{
System.out.println("Sample Thread : " + i);
}
}
};
class ThreadDemo2
{
{
ob.start( );
for(int i = 1; i <= 10; i++)
{
System.out.println("Main Thread : " + i);

}
}
}
CREATING THREAD BY IMPLEMENTING RUNNABLE

INTERFACE
==================================
========================
class Sample implements Runnable

{
public void run( )
{
for(int i = 1; i <= 10; i++)
{
System.out.println("Sample Thread : " + i);
}
}
};
class ThreadDemo3
{
{
Thread t = new Thread(ob);
t.start( );
for(int i = 1; i <= 10; i++)
{
}
}
}
CREATING MULTIPLE THREADS

=============================
class One extends Thread

{
String name;
One( )
{
start( );
}
public void run( )
{
for(int i = 1; i <= 10; i++)
{
System.out.println(name + " : " + i);
}
}
};
class Two extends Thread
{
String name;
Two( )
{
start( );
}
public void run( )
{
for(int i = 1; i <= 10; i++)
{

}
}
};
class Three extends Thread
{
String name;
Three( )
{
start( );
}
public void run( )
{
for(int i = 1; i <= 10; i++)
{
}
}
};
class ThreadDemo4
{

{
One ob1 = new One( );
for(int i = 1; i <= 10; i++)
{
}
}
}
SETTING PRIORITIES TO THREADS

===============================
class One extends Thread

{
public void run( )
{
for(int i = 1; i <= 10; i++)
{
}
}
};
class Two extends Thread
{
public void run( )
{
for(int i = 1; i <= 10; i++)
{
}
}
};
class Three extends Thread
{
public void run( )
{
for(int i = 1; i <= 10; i++)
{

}
}
};
class ThreadDemo5
{
{
One ob1 = new One( );
ob1.setPriority(Thread.MIN_PRIORITY);
ob2.setPriority(ob1.getPriority( ) + 2);
ob3.setPriority(Thread.MAX_PRIORITY);
ob1.start( );
ob2.start( );
ob3.start( );
for(int i = 1; i <= 10; i++)
{
}
}
}
SLEEP( ) :- THIS METHOD IS USED TO PAUSE A THREAD AT

PARTICULAR TIME. THIS METHOD THROWS INTERRUPTED
EXCEPTION.

{
public void run( )
{
for(int i = 1; i <= 10; i++)
{
try
{
Thread.sleep(1000); // 1000 : Milli Seconds = 1 Second
}
catch(InterruptedException ex)
{
}
}
}
};
class ThreadDemo6
{
{
for(int i = 1; i <= 10; i++)
{
try
{
Thread.sleep(1000); // 1000 : Milli Seconds = 1 Second
}
catch(InterruptedException ex)
{
}
}
}
}
SUSPEND( ) :-THIS METHOD IS USED TO SUSPEND A

THREAD BASED ON CONDITION.
RESUME( ) :- THIS METHOD IS USED TO CONTINUE THE

SUSPENDED THREAD.

{
public void run( )
{
for(int i = 1; i <= 10; i++)
{
}
}
};
class ThreadDemo7
{
{
Sample ob = new Sample();

for(int i = 1; i <= 10; i++)
{
if(i == 5)
ob.suspend( );
if(i == 9)
ob.resume( );
}
}
}
STOP( ) :- THIS METHOD IS USED TO KILL A THREAD.

{
public void run( )
{
for(int i = 1; i <= 10; i++)
{
}
}
};
class ThreadDemo11
{
{
for(int i = 1; i <= 10; i++)
{
if(i == 5)
ob.stop( );
}
}
}
FILES
=====
FILES ARE USED TO STORE DATA PERMANENTLY. TO

PERFORM FILE OPERATIONS WE NEED THE FOLLOWING
STREAMS.
1) FILEOUTPUTSTREAM / FILEWRITER
2) FILEINPUTSTREAM / FILEREADER
BOTH ABOVE STREAMS ARE AVAILABLE IN JAVA.IO

PACKAGE. BOTH ABOVE STREAMS THROW
FILENOTFOUNDEXCEPTION.
BOTH READ( ) AND WRITE( ) METHODS THROW

IOEXCEPTION.
STORING DATA INTO A FILE

==========================
import java.io.*;
class File1
{
FileNotFoundException, IOException
{
FileOutputStream fos = new
FileOutputStream("Sample.txt");
fos.write('K');
fos.close( );
}
}
APPENDING / ADDING DATA TO EXISTING FILE

==================================
========
import java.io.*;
class File2
{
{
FileOutputStream("Sample.txt",true);
fos.write('V');
fos.close( );
}
}
READING DATA FROM EXISTING FILE
==================================
=============
import java.io.*;
class File3
{
{
FileInputStream fis = new FileInputStream("Sample.txt");
int t;
t = fis.read( );
System.out.print((char)t);
t = fis.read( );
fis.close( );
}
}
STORING CONTINUOUS TEXT INTO A FILE
==================================
================
import java.io.*;
class File4
{
{
FileOutputStream("Simple.txt");
char t;
System.out.println("Enter text, ends with *");
while(true)
{
t = (char) System.in.read( );
if(t == '*')
break;
fos.write(t);
}
fos.close( );
}
}
APPENDING / ADDING CONTINUOUS TEXT INTO A FILE

==================================
===============
import java.io.*;
class File5
{
{
FileOutputStream("Simple.txt",true);
char t;
System.out.println("Enter text, ends with *");

while(true)
{
t = (char) System.in.read( );
if(t == '*')
break;
fos.write(t);
}
fos.close( );
}
}
READING CONTINUOUS TEXT FROM A FILE
==================================
=====
import java.io.*;
class File6
{

{
FileInputStream fis = new FileInputStream("Simple.txt");
int t;
System.out.println("Data from simple.txt");
while(true)
{
t = fis.read( );
if(t == -1)
// -1 : End of File
break;
}
fis.close( );
}
}
IDES

Core JAVA

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Core JAVA

Transféré par

Droits d'auteur :

Formats disponibles

JAVA

DIFFERENCE BETWEEN 'C', C++ AND JAVA

C, C++ ARE CALLED PLATFORM DEPENDENT LANGUAGES.

IN 1991 JAMES GOSLING (PROJECT LEADER) WANTS TO

JDK 1.0 ====> 1996 (JAVA DEVELOPMENT KIT)

J2SE 4.0 ====> 2002

SUN ORGANIZATION DIVIDES THE JAVA INTO 3 PARTS.

1) J2SE (JAVA 2 STANDARD EDITION)

J2SE :- IT DEALS WITH DEVELOPING STANDALONE

J2EE :- IT DEALS WITH DEVELOPING BUSINESS SOLUTIONS

J2ME :- IT DEALS WITH DEVELOPING EMBEDDED SYSTEMS

EMBEDDED SYSTEMS :- STORING PROGRAMS IN

SIMPLE :- JAVA IS A SIMPLE PROGRAMMING LANGUAGE.

OBJECT ORIENTED :- JAVA IS PURELY OBJECT ORIENTED

METHOD :- IT IS NOTHING BUT A FUNCTION. BUT

DISTRIBUTED :- USING JAVA WE CAN DEVELOP NETWORK

ROBUST (STRONG / UNBREAKABLE) :- JAVA PROGRAMS

GARBAGE COLLECTOR :- IT REMOVES UNUSED VARIABLES

SECURE :- JAVA IS A SECURE LANGUAGE BECAUSE JAVA

ARCHITECURE NEUTRAL :- JAVA'S BYTE CODE IS NOT

PORTABILITY :- JAVA PROGRAMS GIVE SAME RESULTS ON

INTERPRETED :- JAVA PROGRAMS ARE COMPILED TO

X.JAVA ====> COMPILER ====> X.CLASS ====>

HIGH PERFORMANCE :- ALONG WITH INTERPRETER,

COMPILER AND INTERPRETER RUN THE PROGRAM

NATIVE METHODS :- METHODS WRITTEN IN OTHER

MULTI THREADED :- THREAD MEANS PROCESS OR

DYNAMIC :- WE CAN DEVELOP PROGRAMS IN JAVA WHICH

JAVAC (COMPILER):- IT IS USED TO CONVERT JAVA

JAVA (INTERPRETER) :- IT IS USED TO EXECUTE CLASS

APPLETVIEWER :- IT IS USED TO EXECUTE APPLETS

METHOD :- SET OF STATEMENTS.

CLASS :- SET OF METHODS.

PACKAGE :- SET OF CLASSES.

JSL (JAVA STANDARD LIBRARY) :- SET OF PACKAGES.

JRE (JAVA RUNTIME ENVIRONMENT) : JVM + JSL.

TYPES OF JAVA APPLICATIONS

STANDALONE APPLICATIONS :- THESE ARE GENERAL

APPLETS :- THESE ARE SMALL WEB PROGRAMS. APPLETS

Note :- THE ABOVE PROGRAM MUST BE SAVED AS

IDE :- IT STANDS FOR INTEGRATED DEVELOPMENT

EDITOR :- WHICH IS USED TO ADD, MODIFY AND REMOVE

START ====> RUN (cmd / command)

C:\> cd program files

C:\PROGRAM FILES> cd java

C:\PROGRAM FILES\JAVA> dir

C:\PROGRAM FILES\JAVA> cd jdk1.6.0_02

C:\PROGRAM FILES\JAVA\JDK1.5.0> cd bin

edit First.java / Notepad First.java

SAVE & EXIT

COMPILE PROGRAM : javac First.java

EXECUTE PROGRAM : java First

PRINT & PRINTLN METHODS

IMPORTING PACKAGES :- BEFORE USING ANY CLASS WE

ALL CLASSES ARE IMPORTED FROM java.lang PACKAGE

ESCAPE SEQUENCES :- WHICH ARE STARTED WITH

\n, \t, \b, \r, \', \", \\

b : backspace, r : carragie return (same line first column)

NAMING CONVENTIONS IN JAVA

1) ALL PACKAGE NAMES IN JAVA ARE WRITTEN IN ALL

Ex :-java.lang, java.awt, java.io, javax.swing

2) CLASS / INTERFACE NAME IN JAVA NAME SHOULD

Ex :- System, String, StringBuffer,DataInputStream