Core Java

INTRODUCTION TO JAVA
=====================
IN 1991 JAMES GOSLING (PROJECT LEADER) WANTS TO DEVELOP A SOFTWARE WHICH IS USED IN
TV REMOTES, MICRO WOVENS, REFRIGIRATORS. THE MAIN TEAM MEMBERS ARE BILL JOY, MIKE
SHERADIN, PATRICK NAUGHTON. 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
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)".
MAIN SECURITY PROBLEMS ON INTERNET

====================================
1) EVES DROPPING :- READING OTHERS DATA ILLEGALLY. THIS IS THE MAJOR PROBLEM ON
INTERNET. TO AVOID THIS PROBLEM, JAVA USES ENCRYPTION / DECRYPTION.
ENCRYPTION :- CONVERTING THE ORIGINAL DATA INTO UNREADABLE FORMAT.
DECRYPTION :- GETTING BACK THE ORIGINAL DATA FROM THE ENCRYPTED FORMAT.
2) TAMPERING :- NOT ONLY READING OTHERS DATA AND ALSO MODIFYING THE DATA. TO AVOID
THIS PROBLEM ALSO, JAVA USES ENCRYPTION / DECRYPTION.
3) IMPERSONATION :- A PERSON ACTING AS ANOTHER PERSON ON INTERNET. TO AVOID THIS

PROBLEM ALSO, JAVA USES DIGITAL SIGNATURE.
DIGITAL SIGNATURE :- IT IS A FILE WITH PERSONAL INFORMATION IN ENCRYPTED FORMAT.
4) VIRUS :- IT S A COMPUTER PROGRAM THAT DAMAGES THE DATA, SOFTWARE AND HARDWARE OF
A COMPUTER SYSTEM.
THE FIRST PERSON WHO DEVELOPED THE VIRUS IS PAKISTANIS.
.EXE, .DOC, .GIF, .JPG, .MP3, .WAV, .MP4 FILES CAN SPREAD VIRUS.
A TEXT FILE (.TXT FILE OR NOTEPAD FILE) CAN NOT SPREAD VIRUS.
.CLASS FILES ARE SIMILAR TO .TXT FILES. SO THERE IS NO CHANCE OF VIRUS ATTACKING TO
THESE FILES. EVEN IF SOMEBODY INTENTIONALLY TRIES TO INCORPORATE THE VIRUS CODE
INTO .CLASS FILE, JVM CAN VERIFY ITS PRESENCE BEFORE RUNNING THE PROGRAM AND IF
FOUND, CAN ABORT THE .CLASS FILE'S EXECUTION.
THE ABOVE REASONS, JAVA IS SUITABLE FOR INTERNET. THE MAIN TWO REASONS ARE
1) IT IS SYSTEM INDEPENDENT.
2) IT ELIMINATES A LOT OF SECURITY PROBLEMS FOR DATA ON INTERNET.
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.
OBJECT :- REAL THINGS THAT WE CAN SEE AND TOUCH ARE CALLED OBJECTS. AN OBJECT IS
ANYTHING THAT EXISTS PHYSICALLY IN THE WORLD. AN OBJECT CAN PERFORM ACTIVITIES.
IN PROGRAMMING LANGUAGES, OBJECTS ARE INSTANCES (VARIABLES) OF CLASSES. AN OBJECT

CONTAINS PROPERTIES (VARIABLES) AND ACTIONS (METHODS).
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.
NATIVE METHODS :- METHODS WRITTEN IN OTHER LANGUAGE LIKE C AND C++.
CLASS :- A CLASS IS A MODEL OR BLUE PRINT FOR CREATING OBJECTS. A CLASS IS A GROUP
NAME GIVEN TO OBJECTS. IT SPECIFIES THE PROPERTIES AND ACTIONS OF OBJECTS.
IN PROGRAMMING LANGUAGES, A CLASS IS AN USER-DEFINED DATA TYPE. BY USING CLASS

CONCEPT WE CAN CREATE NEW DATA TYPES.
IN C++, WITHOUT USING CLASS WE CAN WRITE A PROGRAM. SO IT IS NOT A PURELY OBJECT
ORIENTED. IN JAVA, WE MUST WRITE ATLEAST ONE CLASS TO PERFORM ANYTHING.
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 FIREWALLS. FIREWALLS

STRICTLY CHECKS EVERYTHING BEFORE DOWNLOADING INTO OUR SYSTEM. JAVA ENABLES THE
CONSTRUCTION OF VIRUS FREE APPLICATIONS.
FIREWALL :- IT IS A SOFTWARE THAT ALLOWS ONLY AUTHORIZED PEOPLE TO ACCESS SYSTEM

RESOURCES.
ARCHITECURE NEUTRAL :- JAVA'S BYTE CODE IS NOT MACHINE DEPENDENT. IT CAN RUN ON ANY
MACHINE WITH ANY PROCESSOR AND ANY OPERATING SYSTEM.
PORTABLITY :- 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.
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.
COMMENTS :- COMMENTS ARE USED TO WRITE AIM OF THE PROGRAM. THESE ARE ALSO USED TO
WRITE REFERENCES. THE MAIN ADVANTAGE OF COMMENTS IS READABILITY (UNDERSTANDABLE).
THESE ARE NOT EXECUTABLE STATEMENTS. JAVA SUPPORTS THREE TYPES OF COMMENTS.
1) SINGLE LINE COMMENT :- WHICH STARTS WITH // AND NEED NOT TO END.
2) MULTI LINE COMMENT :- WHICH STARTS WITH /* AND ENDS WITH */
3) DOCUMENTATION COMMENT :- WHICH STARTS WITH /** AND ENDS WITH */. THESE COMMENTS
ARE USEFUL TO CONVERT A JAVA PROGRAM INTO A HTML DOCUMENT THAT CONTAINS DESCRIPTION
OF JAVA PROGRAM FEATURES. THAT CONVERTED HTML DOCUMENT IS CALLED API (APPLICATION
PROGRAM INTERFACE) DOCUMENT.
API DOCUMENT :- IT IS A HTML FILE THAT CONTAINS DESCRIPTION OF ALL THE FEATURES OF
A SOFTWARE.
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.
JAVAP (PROFILER COMPILER) :- IT IS USED TO CONVERT CLASS FILE INTO JAVA PROGRAM. IT
GIVES ONLY STRUCTURE OF THE JAVA PROGRAM. IF WE USE "JAD" UTILITY WE GET ENTIRE
JAVA PROGRAM FROM CLASS FILE.
JAVAH (HEADER FILE COMPILER) :- IT IS USED TO INCLUDE NATIVE METHODS, HEADER FILES
INTO JAVA PROGRAM.
JAVADOC (DOCUMENTATION COMPILER) :- IT IS USED TO CONVERT JAVA PROGRAM INTO HTML

DOCUMENT. THE GENERATED HTML DOCUMENT IS CALLED API DOCUMENT.
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 ETC) OR APPLETVIEWER TOOL.
BECAUSE THESE APPLICATIONS DON'T HAVE MAIN( ) METHOD.
A SAMPLE PROGRAM
===================
First.java
========
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".
STEPS TO PROGRAMMING
=======================
SETTING PATH
=============
1) OPEN C:\Program Files\Java\jdk1.6.0\bin THROUGH COMPUTER & COPY C:\Program

Files\Java\jdk1.6.0\bin IN ADDRESS BAR.
2) RIGHT CLICK ON COMPUTER ====> PROPERTIES ====> ADVANCED SYSTEM SETTINGS ====>
ENVIRONMENT VARIABLES ====> SELECT PATH ====> EDIT
3) TYPE ;PASTE;
4) CLICK ON OK, OK, OK
CREATE A FOLDER IN D:\JAVA LAB
1) START ====> TYPE cmd AND PRESS ENTER
2) C:\USERS\PC> cd\
3) d:
4) cd Java Lab
Notepad First.java
class First
{
public static void main(String args[])
{
System.out.print("This is my first java 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.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:\\windows");
}
}
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
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;
char :- 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.
EXAMPLE OF USING ALL DATA TYPES

==================================
class Third
{
{
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);
}
}
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.
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 FORMAT INTO SIMPLE
int FORMAT. parseInt( ) IS A STATIC METHOD IN Integer CLASS.
class Six
{
public static void main(String [ ]args)
{
int n,s;
n = Integer.parseInt(args[0]);
s = n * n;
}
}
javac Six.java
java Six 6
java Six 9
java Six 12
SUM OF TWO NUMBERS
======================
class Six
{
public static void main(String [ ]args)
{
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
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;
double 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;
byte d;
d = (byte) (a + b);
System.out.print("Sum : " + d);
}
}
class Six
{
{
byte a;
a = 200; (error)
a = (byte) (100 * 2);
}
}
WIDENING :- CONVERTING A LOWER DATA TYPE INTO HIGHER DATA TYPE.
Ex :-
byte a = 10;
float b = (float) a;
NARROWING :- CONVERTING A HIGHER DATA TYPE INTO LOWER DATA TYPE.
Ex :-
double a = 10.25;
int b = (int) a;
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 : SECOND GROUP
A : ADDITION : THIRD GROUP
S : SUBTRACTION : 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) ? TRUE PART : FALSE PART;
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.
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 int
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);
}
}
class Six
{
{
int x;
x = System.in.read( );
ps.print("Character : " + (char) x);
}
}
INPUT STRINGS AT RUNTIME

==========================
import java.io.*;
class Six
{
{
InputStreamReader isr = new InputStreadmReader(System.in);
BufferedReader br = new BufferedReader(isr);
String name;
ps.println("Enter Your Name");
name = br.readLine( );
ps.print("Your Name : " + name);
}
}
Working With Anonymous Objects

=============================
import java.io.*;
class Six
{
{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String name;
name = br.readLine( );
}
}
Sum of Two Numbers

===================
import java.io.*;
class Tenali
{
{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
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);
}
}
WORKING WITH DataInputStream CLASS

===================================
BY USING THIS CLASS WE CAN DIRECTLY CONNECT WITH KEYBOARD.
import java.io.*;
class Six
{
{
DataInputStream dis = new DataInputStream(System.in);
String name;
name = dis.readLine( );
}
}
import java.io.*;
class Tenali
{
{
DataInputStream dis = new DataInputStream(System.in);
int a,b,c;
a = Integer.parseInt(dis.readLine( ));
b = Integer.parseInt(dis.readLine( ));
c = a + b;
}
}
WORKING WITH Scanner CLASS [java.util]

==================================
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. 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( ); / 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;
ps.println("Enter Number");
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 1");
break;
case 2 :
break;
case 3 :
break;
case 4 :
break;
case 5 :
break;
default :
ps.print("You Entered Above 5 / Zero / Negative Number");
}
}
}
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.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;
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;
xxx :
for(i = 1; i <= 5; i++)
{
for(j = 1; j <= 5; j++)
{
if(j == 3)
{
continue xxx;
}
ps.print(j + "\t");
}
ps.println( );
}
}
}
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

===============
IT EXECUTES ONCE FOR A EACH ELEMENT IN A COLLECTION / GROUP. IT EXECUTES A GROUP OF

STATEMENTS FOR EACH ELEMENTS OF A COLLECTION / GROUP. THE COUNTER VARIABLE MUST BE
DECLARED IN FOR LOOP. FOR EACH LOOP IS ALSO CALLED ENHANCED FOR 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 loop 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( );
}
}
}
RAGGED ARRAYS / 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])
}
}
}
COPYING ARRAYS
=================
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};
int b[] = new int[5];
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)
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");
}
}
}
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);
ps.println("Array A Elements");
for(int i : a)
{
ps.print(i + "\t");
}
ps.println( );
int b[] = new int[10];
Arrays.fill(b,0,3,6); // N = EI - SI
Arrays.fill(b,3,7,3);
Arrays.fill(b,7,10,63);
ps.println("Array B Elements");
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.
get( ) : - THIS METHOD IS USED TO ACCESS AN ELEMENT FROM THE ARRAY LIST.
import java.util.ArrayList;
class Six
{
{
ArrayList al = new ArrayList( );
ps.println("Array List Size : " + al.size( ));
ps.println("Array List Elements : " + al);
al.add(10);
al.add(2.3);
al.add("Rama");
al.add(20);
al.add("Tata");
al.add(0,"Eeswar");
al.remove(3);
ps.println("Array List Elements");
for(int i = 0; i < al.size( ); i++)
{
ps.println(al.get(i));
}
}
}
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 AVIALABLE 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");
}
if(str1.equals(str3))
{
}
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( );
str2 = 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 st = " Rama Rao ";
String x = st.trim( );
ps.print("String : " + st);
ps.print("Hai");
ps.println( );
ps.print("String : " + x);
ps.print("Hai");
}
}
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);
}
}
}
NESTING OF 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.
WORKING WITH StringBuffer CLASS

==============================
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 Length : " + str1.length( ));
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( );
}
}
WE CAN'T INPUT DATA AT RUNTIME INTO STRINGBUFFER OBJECT. FIRST CREATE AN EMPTY
STRINGBUFFER OBJECT AND NEXT APPEND STRING TO STRINGBUFFER OBJECT.
class Six
{
{
String str;
StringBuffer strb = new StringBuffer( );
str = sc.nextLine( );
strb.append(str);
ps.println("String : " + strb);
}
}
WORKING WITH 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));
}
}
WORKING WITH 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);
}
}
round( ) :- THIS METHOD IS USED TO STORE A FLOAT VALUE INTO A INTEGER VARIABLE WITH
DATA LOSS.
class Six
{
public static void main(String args[]) throws InterruptedException
{
float a = 12.25F;
int b;
b = Math.round(a);
ps.println("B Value : " + b);
}
}
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); // 3000 : 3 THOUSAND MILLI SECONDS
// IT MEANS THREE SECONDS
}
}
}
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( );
Date d =new Date(95,11,29); Years : Starts From 1900, Month : Array : -1
ps.println("Current Date : " + d);
}
}
OUTPUT
========
Current Date : Mon Apr 19 16:05:50 IST 2010
FORMATTING DATES
===================
WORKING WITH 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.
WORKING WITH Calendar CLASS

===========================
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.
Calendar CLASS IS USED TO ACCESS DATE AND TIME PARTS INDIVIDUALLY. Calendar CLASS
IS AVAILABLE IN java.utilPACKAGE. Calendar CLASS IS AN ABSTRACT CLASS. IT MEANS WE
CAN'T CREATE ANOBJECT FROM IT. ONLY WE CAN CREATE REFERENCE. getInstace( ) 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_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
}
}
DISPLAYING DATE IN DIFFERENT FORMATS

========================================
class Six
{
{
int d,m,y;
d = cobj.get(Calendar.DATE);
m = cobj.get(Calendar.MONTH);
y= cobj.get(Calendar.YEAR);
ps.println("Date in Indian Format : " + d + "/" + (m + 1) + "/" + y);
ps.println("Date in American Format : " + (m + 1) + "-" + d + "-" + y);
ps.println("Date in Japan Format : " + y + "." + (m + 1) + "." + d);
}
}
DISPLAYING TIME IN DIFFERENT FORMATS

========================================
class Six
{
{
int h,m,s,r;
h = cobj.get(Calendar.HOUR);
m = cobj.get(Calendar.MINUTE);
s = cobj.get(Calendar.SECOND);
ps.println("Time in 12 Hours Format : " + h + ":" + m + ":" + s);
h = cobj.get(Calendar.HOUR_OF_DAY);
ps.println("Time in 24 Hours Format : " + h + ":" + m + ":" + s);
h = cobj.get(Calendar.HOUR);
r = cobj.get(Calendar.AM_PM);
ps.print("Current Time : " + h + ":" + m + ":" + s + " ");
if(r == 0)
{
ps.println("AM");
}
else
{
ps.println("PM");
}
}
}
WRAPPER CLASSES [java.lang]

=========================
A WRAPPER CLASS IS A CLASS WHOSE OBJECT WRAP (CONTAINS) PRIMITIVE DATA TYPE WITHIN
IT. 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 Byte
short Short
int Integer
long Long
float Float
double Double
char Character
boolean 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 OTHER 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. BUT THEY ARE OBJECT BASED LANGUAGES, WHERE AS C++ AND JAVA ARE OBJECT
ORIENTED LANGUAGES. C++ IS NOT PURE OOPS. IT IS CALLED PARTIAL OOPS. BECAUSE IT
DOES NOT SUPPORT 100% FEATURES OF OOPS. BUT JAVA IS PURE OOPS. IT SUPPORTS 100%
FEATURES OF OOPS. ANOTHER EXAMPLE FOR PURE OOPS IS SMALL TALK.
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.
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.
INHERITANCE :- PRODUCING NEW CLASSES FROM AN EXISTING CLASS ISCALLED 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.
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.
class Student
{
int studNo;
String studName;
double studAge;
void setData( )
{
studNo = 101;
studName = "Rama";
studAge = 17.8;
}
void showData( )
{
System.out.println("Student Number : " + studNo);
System.out.println("Student Name : " + studName);
System.out.println("Student Age : " + studAge);
}
};
class StudentDemo1
{
{
Student ob = new Student( );
ob.showData( );
ob.setData( );
System.out.println("Student Details");
ob.showData( );
}
}
DATA TYPE DEFAULT VALUE
========== ===============
byte 0
short 0
int 0
long 0
float 0.0
double 0.0
char ' ' (SPACE)
boolean FALSE
String / OBJECT NULL
FINALLY A CLASS IS A COLLECTION OF VARIABLES (DATA MEMBERS) AND FUNCTIONS

(METHODS). ONLY THOSE METHODS WHICH ARE WRITEN INSIDE THE CLASS, CAN ACCESS THE
DATA MEMBERS OF THE CLASS.
ONCE A CLASS IS DEFINED WE CAN CREATE ANY NUMBER OF OBJECTS FROM THAT CLASS.
class Student
{
int studNo;
String studName;
double studAge;
void setData( )
{
studNo = 101;
studName = "Rama";
studAge = 17.8;
}
void showData( )
{
}
};
class StudentDemo3
{
{
Student ob1 = new Student( );
ob1.setData( );
System.out.println("First Student Details");
ob1.showData( );
ob2.setData( );
System.out.println("Second Student Details");
ob2.showData( );
ob3.setData( );
System.out.println("Third Student Details");
ob3.showData( );
}
}
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 studNo;
String studName;
double studAge;
void setData(int pstudNo,String pstudName, double pstudAge)
{
studNo = pstudNo;
studName = pstudName;
studAge = pstudAge;
}
void showData( )
{
}
};
class Karishma
{
{
Student s1 = new Student( );
s1.setData(101,"Swetha",99.9);
s1.showData( );
s2.setData(102,"Pravallika",99.8);
s2.showData( );
s3.setData(103,"Chandana",99.7);
s3.showData( );
}
}
SQUARE OF A NUMBER
=====================
class Square
{
int n;
int s;
void set(int x)
{
n = x;
}
void process( )
{
s = n * n;
}
void show( )
{
}
};
class SquareDemo1
{
{
Square ob = new Square( );
ob.set(6);
ob.process( );
ob.show( );
}
}
SUM OF TWO NUMBERS

======================
class Sum
{
int a;
int b;
int c;
void set(int x, int y)
{
a = x;
b = y;
}
void process( )
{
c = a + b;
}
void show( )
{
}
};
class SumDemo1
{
{
Sum ob = new Sum( );
ob.set(6,3);
ob.process( );
ob.show( );
}
}
RUNTIME INPUT
===============
class Square
{
int n;
int s;
void input( )
{
n = sc.nextInt( );
}
void process( )
{
s = n * n;
}
void show( )
{
ps.println("Square : " + s);
}
};
class SquareDemo2
{
{
ob.input( );
ob.process( );
ob.show( );
}
}
RETURNABLE METHODS
======================
class Square
{
int n;
int s;
void input( )
{
n = sc.nextInt( );
}
int process( )
{
s = n * n;
return s;
}
};
class SquareDemo3
{
{
int k;
ob.input( );
k = ob.process( );
ps.println("Square : " + k);
}
}
TYPES 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;
int em;
int tm;
int hm;
int mm;
int scm;
int som;
int tot;
double avg;
String res;
void input( )
{
ps.println("Enter Student Number, Name");
sno = sc.nextInt( );
sname = sc.next( );
ps.println("Enter English, Telugu, Hindi Marks");
em = sc.nextInt( );
tm = sc.nextInt( );
hm = sc.nextInt( );
ps.println("Enter Maths, Science, Social Marks");
mm = sc.nextInt( );
scm = sc.nextInt( );
som = sc.nextInt( );
}
void process( )
{
tot = em + tm + hm + mm + scm + som;
avg = tot / 6.0;
if(em >= 35 && tm >= 35 && hm >= 35 && mm >= 35 && scm >= 35 && som >= 35)
{
if(avg >= 80)
{
res = "Distniction";
}
else
if(avg >= 60)
{
res = "First Class";
}
else
if(avg >= 50)
{
res = "Second Class";
}
else
if(avg >= 40)
{
res = "Third Class";
}
else
{
res = "Ordinary Pass";
}
}
else
{
res = "Fail";
}
}
void show( )
{
ps.println("Student Number : " + sno);
ps.println("Student Name : " + sname);
ps.println("Total Marks : " + tot);
ps.printf("Average Marks : %.2f\n",avg);
}
};
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].process( );
}
{
ob[i].show( );
}
/*
{
ob[i].input( );
ob[i].process( );
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.
OVERLOADING IS POSSIBLE WHEN METHODS SIGNATURE ARE DIFFERENT. SIGNATURE MEANS

METHOD HEADER / METHOD PROTOTYPE. METHOD SIGNATURE CONTAINS METHOD NAME, PARAMETERS
AND METHOD RETURN TYPE. TO OVERLOAD METHODS WE MUST FOLLOW ONE OF THE FOLLOWING TWO
RULES.
WRITING NUMBER OF METHODS WITH SAME NAME.
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) DYNAMIC INITIALIZATION OF CONSTRUCTORS
5) CONSTRUCTOR OVERLOADING
NON-PARAMETERIZED CONSTRUCTORS
==================================
A NON-PARAMETERIZED CONSTRUCTOR IS A CONSTRUCTOR, WHICH CONTAINS NO PARAMETERS.
class Student
{
int sno;
String sname;
double age;
Student( )
{
sno = 101;
sname = "Rama";
age = 12.6;
}
void show( )
{
ps.println("Student Age : " + age);
}
};
class ConsDemo1
{
{
Student ob = new Student( );
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( )
{
}
{
sno = vsno;
sname = vsname;
age = vage;
}
void input( )
{
ps.println("Enter Student Number, Name, Age");
sname = sc.next( );
age = sc.nextDouble( );
}
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( );
}
}
DYNAMIC INITIALIZATION OF CONSTRUCTORS

===========================================
class Student
{
int sno;
String sname;
double age;
{
sno = vsno;
sname = vsname;
age = vage;
}
void show( )
{
}
};
class ConsDemo4
{
{
int xsno;
String xsname;
double xage;
xsno = sc.nextInt( );
xsname = sc.next( );
xage = sc.nextDouble( );
Student ob = new Student(xsno,xsname,xage);
ob.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 ConsDemo5
{
{
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 KEYWORD REFERS TO CURRENT OBJECT. GENERALLY IT IS USED TO REMOVE NAMING

CONFLICTIONS AND RETURNING OBJECTS.
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( );
}
}
class Employee
{
int empNo;
String empName;
double sal;
void set(int vempNo, String vempName, double vsal)
{
empNo = vempNo;
empName = vempName;
sal = vsal;
}
Employee incrSal( )
{
sal = sal + sal * 0.1;
return this;
}
void show( )
{
ps.println("Employee Number : " + empNo);
ps.println("Employee Name : " + empName);
ps.println("Employee Salary : " + sal);
}
};
class ThisDemo2
{
{
Employee ob = new Employee( );
ob.set(101,"Rama",2500);
ps.println("Before Incrementing, Employee Details");
ob.show( );
ob = ob.incrSal( );
ps.println("After Incrementing, Employee Details");
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.
GENERALLY INSTANCE DATA MEMBERS ARE CREATED IN OBJECTS AND STATIC DATA MEMBERS ARE
CREATED IN CLASS.
JAVA PROVIDES A SPECIAL KEYWORD STATIC. USING THIS KEYWORD, WE CAN DEFINE STATIC
DATA MEMBERS, STATIC METHODS AND STATIC BLOCKS.
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( );
}
}
class Student
{
static int sno;
String sname;
double age;
Student( )
{
sno++;
}
void input( )
{
ps.println("Enter Student Name, Age");
sname = sc.next( );
}
void show( )
{
}
};
class StatDemo2
{
{
ob1.input( );
ob1.show( );
ob2.input( );
ob2.show( );
ob3.input( );
ob3.show( );
}
}
TYPES OF METHODS
===================
1) INSTANCE METHODS / NON STATIC METHODS
A) ACCESSOR METHODS
B) MUTATOR METHODS
2) STATIC METHODS
3) FACTORY METHODS
INSTANCE METHODS :- THESE METHODS ACT UPON INSTANCE VARIABLES OF A CLASS. THE
VARIABLES WHICH WILL PRESENT IN OBJECTS.
ACCESSOR METHODS :- THESE ARE THE METHODS WHICH ACCESS THE INSTANCE VARIABLES.
MUTATOR METHODS :- THESE ARE THE METHODS WHICH NOT ONLY ACCESS THE INSTANCE
VARIABLES AND ALSO MODIFY THEM.
GENERALLY IF WE WANT TO CALL A METHOD, FIRST WE MUST CREATE AN OBJECT FROM THAT
CLASS. WITHOUT CREATING AN OBJECT, WE CAN'T CALL THE METHOD OF A CLASS. IT THE
METHOD IS STATIC METHOD, THEN WE ARE ABLE TO CALL THAT METHOD, WITHOUT CREATING AN
OBJECT.
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 StatDemo3
{
{
Sample.show( );
}
}
class Sample
{
static void show1( )
{
System.out.println("Static Method");
}
void show2( )
{
System.out.println("Non Static Method");
}
};
class StatDemo4
{
{
Sample.show1( );
ob.show2( );
ob.show1( );
}
}
class Square
{
static int n;
static int s;
static void set(int x)
{
n = x;
}
static void process( )
{
s = n * n;
}
static void show( )
{
}
};
class StatDemo5
{
{
Square.set(6);
Square.process( );
Square.show( );
}
}
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 StatDemo6
{
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 StatDemo7
{
static int a = 10;
static
{
a = 20;
}
{
}
}
INNER CLASSES / NESTED CLASSES

==============================
A CLASS WITHIN ANOTHER CLASS IS CALLED INNER CLASS. GENERALLY IF WE WRITE A CLASS,
OTHER PROGRAMMER CAN CREATE OBJECT TO OUR CLASS. HE CAN USE OUR CLASS. SO THERE IS
NO SECURITY.
SECURITY :- RESTRICTING THE ACCESS. THAT IS ONLY SOME POPELE MAY ACCESS.
GENERALLY SECURITY FOR INSTANCE VARIABLES IS PROVIDED THROUGH PRIVATE KEYWORD. BUT
PRIVATE KEYWORD CAN'T BE USED BEFORE A CLASS. BUT WE CAN USE PRIVATE KEYWORD ONLY
FOR INNER CLASS. THAT IS OTHER PROGRAMMER CAN'T CREATE AN OBJECT TO THE INNER
CLASS. BUT WE CAN CREATE AN OBJECT TO THE CLASS AND USE IT.
INNER CLASS IS A SAFETY MECHANISM, WE CAN'T CREATE AN OBJECT FOR INNER CLASS IN ANY
OTHER CLASS, BUT ONLY IN OUTER CLASS. THE OBJECTS OF OUTER AND INNER CLASSES WILL
BE CREATED SEPERATELY IN MEMORY. INNER CLASS CAN ACCESS THE MEMBERS OF OUTER CLASS.
THE OBJECT OF INNER CLASS CONTAINS ANOTHER INVISIBLE FIELD CALLED "this$0" WHICH
CONTAINS THE HASHCODE OF OUTER CLASS OBJECT. AN OBJECT OF INNER CLASS CONTAINS
INVISIBLE FIELD "this$0" THAT REFERES THE OUTER CLASS OBJECT.
THE INNER CLASS DATA MEMBERS CAN BE REFERENCED AS
THIS.MEMBER;
THE OUTER CLASS DATA MEMBERS CAN BE REFERENCED AS
OUTERCLASS.THIS.MEMBER;
class Sample
{
void show( )
{
System.out.println("Outer Class");
Simple v = new Simple( );
v.display( );
}
private class Simple
{
void display( )
{
System.out.println("Inner Class");
}
};
};
class InnerDemo1
{
{
Sample k = new Sample( );
k.show( );
}
}
INHERITANCE
=============
INHERITANCE 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( );
}
}
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 SuperDemo1
{
{
ob.show( );
}
}
USING SUPER KEYWORD TO ACCESS SUPER CLASS 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 SuperDemo2
{
{
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");
}
};
{
Three( )
{
System.out.println("Class Three Constructor");
}
};
class SuperDemo3
{
{
Three ob = new Three( );
}
}
USING SUPER KEYWORD TO ACCESS SUPER CLASS 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 SuperDemo4
{
{
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)
FINAL VARIABLES
================
class FinalDemo1
{
{
final int a = 10;
a = 20; // error
}
}
FINAL METHODS
===============
class One
{
final void show( )
{
System.out.println("Show Method Called From Class One");
}
};
{
void show( ) // error
{
super.show( );
System.out.println("Show Method Called From Class Two");
}
};
class FinalDemo2
{
{
ob.show( );
}
}
FINAL CLASSES
==============
final class One

{
void show( )
{
}
};
class Two extends One // error
{
void show( )
{
super.show( );
}
};
class FinalDemo3
{
{
ob.show( );
}
}
A CLASS CANNOT BE DECLARED AS BOTH ABSTRACT AND FINAL.
DYNAMIC POLYMORPHISM
=======================
THE POLYMORPHISM EXHIBITED AT RUNTIME IS CALLED DYNAMIC POLYMORPHISM / LATE

BINDING. AT THE TIME OF COMPILATION, COMPILER DON'T KNOW THAT WHICH METHOD IS
CALLING, SO IT WILL KEEP QUITE UNTIL RUNTIME. AT RUNTIME JVM WILL CALL THE METHOD
WHICH WE ARE CALLING. WE CAN USE THE SAME METHOD CALL TO EXECUTE METHODS FROM
DIFFERENT CLASSES.
WORKING WITH ABSTRACT METHODS

=================================
CONCRETE METHOD :- IT IS A METHOD WITH BODY. WHEN ALL OBJECTS WANT TO PERFORM SAME
TASK, WE SHOULD WRITE A CONCRETE METHOD IN THE CLASS.
ABSTRACT METHOD :- IT IS A METHOD WITHOUT BODY. WHEN THE SAME METHOD SHOULD BE
IMPLEMENTED DIFFERENTLY FOR DIFFERENT OBJECTS. THEN WE SHOULD WRITE IT AS AN
ABSTRACT METHOD.
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.
AN ABSTRACT CLASS MAY HAVE INSTANCE VARIABLES AND CONCRETE METHODS IN ADDITION TO
ABSTRACT METHODS.
abstract class One

{
abstract void show( );
};
{
void show( )
{
}
};
class AbstDemo1
{
{
ob.show( );
}
}
SUB CLASSES MAY HAVE CONCRETE METHODS ALSO

==============================================
abstract class One

{
};
{
void show( )
{
}
void display( )
{
System.out.println("Display Method Called From Class Two");
}
};
class AbstDemo2
{
{
ob.show( );
ob.display( );
}
}
PARTIAL OVERRIDING
===================
abstract class One

{
abstract void display( );
};
abstract class Two extends One
{
void show( )
{
}
};
{
void display( )
{
System.out.println("Display Method Called From Class Three");
}
};
class AbstDemo3
{
{
Three ob = new Three( );
ob.show( );
ob.display( );
}
}
ABSTRACT CLASSES MAY HAVE CONCRETE METHODS ALSO

===================================================
abstract class One

{
void display( )
{
System.out.println("Display Method Called From Class One");
}
};
{
void show( )
{
}
};
class AbstDemo4
{
{
ob.show( );
ob.display( );
}
}
DYNAMIC METHOD DISPATCHING / RUNTIME POLYMORPHISM
=====================================================
WE CAN USE THE SAME METHOD CALL, TO EXEUCTE METHODS FROM DIFFERENT CLASSES.
A SUPER CLASS REFERENCE CAN POINT SUB CLASS OBJECT

===================================================
abstract class One

{
};
{
void show( )
{
}
};
class Three extends One
{
void show( )
{
System.out.println("Show Method Called From Class Three");
}
};
class Four extends One
{
void show( )
{
System.out.println("Show Method Called From Class Four");
}
};
class Five extends One
{
void show( )
{
System.out.println("Show Method Called From Class Five");
}
};
class AbstDemo5
{
{
One ref;
Two ob2 = new Two( );
Three ob3 = new Three( );
ref = ob5;
ref.show( );
ref = ob2;
ref.show( );
ref = ob4;
ref.show( );
ref = ob3;
ref.show( );
}
}
INTERFACES
===========
IT IS A SPECIFICATION OF METHOD PROTOTYPES. IT IS PURE ABSTRACT CLASS. IT IS

SIMILAR TO CLASS. BUT ALL THE METHODS ARE PUBLIC ABSTRACT AND VARIABLES ARE STATIC
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( )
{
}
};
class IntfaceDemo1
{
{
One OneOb = new One( );
OneOb.show( );
}
}
AN INTERFACE MAY BE IMPLEMENTED BY ANY NUMBER OF CLASSES

====================================================
interface Sample
{
void show( );
};
{
public void show( )
{
}
};
class Two implements Sample
{
public void show( )
{
}
};
class Three implements Sample
{
public void show( )
{
}
};
class IntfaceDemo2
{
{
OneOb.show( );
Two TwoOb = new Two( );
TwoOb.show( );
Three ThreeOb = new Three( );
ThreeOb.show( );
}
}
SUB CLASSES MAY HAVE CONCRETE METHODS ALSO

==============================================
interface Sample
{
void show( );
};
{
public void show( )
{
}
void display( )
{
System.out.println("Display Method Called From Class One");
}
};
class IntfaceDemo3
{
{
OneOb.show( );
OneOb.display( );
}
}
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 IntfaceDemo4
{
{
OneOb.show( );
}
}
DYNAMIC METHOD DISPATCHING / RUNTIME POLYMORPHISM

=====================================================
AN INTERFACE REFERENCE CAN POINT SUB CLASS OBJECT

==================================================
interface One
{
void show( );
};
class Two implements One
{
public void show( )
{
}
};
class Three implements One
{
public void show( )
{
}
};
class Four implements One
{
public void show( )
{
System.out.println("Show Method Called From Class Four");
}
};
class Five implements One
{
public void show( )
{
System.out.println("Show Method Called From Class Five");
}
};
class Gopi
{
{
One ref;
Two ob2 = new Two( );
Three ob3 = new Three( );
ref = ob5;
ref.show( );
ref = ob2;
ref.show( );
ref = ob4;
ref.show( );
ref = ob3;
ref.show( );
}
}
INTERFACE INHERITANCE
=======================
interface One
{
void show1( );
};
interface Two extends One
{
void show2( );
};
class Three implements Two
{
public void show1( )
{
System.out.println("Show1 Method Called From Class Three");
}
{
}
};
class IntfaceDemo6
{
{
Three t = new Three( );
t.show1( );
t.show2( );
}
}
AN INTERFACE CANNOT IMPLEMENT ANOTHER INTERFACE.
MULTIPLE INHERITANCE
======================
interface One
{
void show1( );
};
interface Two
{
void show2( );
};
class Three implements One, Two
{
{
}
{
}
};
class IntfaceDemo7
{
{
t.show1( );
t.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 One
{
void show1( )
{
System.out.println("Show1 Method Called From Class One");
}
};
interface Two
{
void show2( );
};
class Three extends One implements Two
{
{
}
};
class IntfaceDemo8
{
{
t.show1( );
t.show2( );
}
}
HYBRID INHERITANCE
====================
COMBINATION OF ANY TWO TYPES OF INHERITANCES. GENERALLY MULTILEVEL AND MULTIPLE

INHERITANCES ARE INVOLVED IN HYBRDID INHERITANCE.
class One
{
void show( )
{
System.out.println("show( ) method called from class One");
}
};
{
void show( )
{
super.show( );
System.out.println("show( ) method called from class Two");
}
};
interface Three
{
void show( );
};
class Four extends Two implements Three
{
public void show( )
{
super.show( );
System.out.println("show( ) method called from class Four");
}
};
class IntfaceDemo9
{
{
Four f = new Four( );
f.show( );
}
}
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 / BUGS :- WHICH ARE TRACED AT THE TIME OF DEBUGGING.
RUNTIME ERRORS / EXCEPTIONS :- 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.
Object
Throwable
Error Exception
TYPES OF EXCEPTIONS
====================
1) CHECKED EXCEPTIONS
2) UNCHECKED EXCEPTIONS
CHECKED EXCEPTIONS :- THESE ARE DETECTED BY JAVA COMPILER AT COMPILATION TIME.
UNCHECKED EXCEPTIONS :- THESE ARE DETECTED BY JVM AT RUN TIME.
Exception IS THE SUPER CLASS OF ALL THE EXCEPTIONS. Throwable IS A CLASS THAT
REPRESENTS ALL ERRORS AND EXCEPTIONS. IT MEANS IT IS THE SUPER OF Exception AND
Error CLASS.
try :- THIS BLOCK IS USED TO PUT PROBLEM RAISING STATEMENTS.
catch :- THIS BLOCK IS USED TO WRITE HANDLING STATEMENTS.
EVERY TRY BLOCK MUST HAVE CATCH BLOCK.
TYPES OF EXCEPTIONS
====================
1) BUILT-IN EXCEPTIONS
2) USER DEFINED EXCEPTIONS
BUILT-IN EXCEPTIONS
===================
1) ArithmeticException
2) ArrayIndexOutOfBoundsException
3) StringIndexOutOfBoundsException
4) NumberFormatException
5) IOException
6) FileNotFoundException
7) ClassNotFoundException
8) NoSuchMethodException
9) InterruptedException
10) NullPointerException
11) RuntimeException
12) ArrayStoreException
13) Exception
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");
}
}
}
Exception CLASS OBJECT'S CATCH BLOCK MUST WRITE AS LAST CATCH BLOCK.
WORKING WITH FINALLY BLOCK

=============================
THIS BLOCK STATEMENTS EXECUTES WHETHER AN EXCEPTION IS RAISED OR NOT RAISED.

GENERALLY FILE CLOSING, DATABASE CLOSING STATEMENTS ARE PLACED INSIDE THE FINALLY
BLOCK.
class Excep7
{
{
int a,b,c;
try
{
c = a / b;
}
{
}
finally
{
}
}
}
WORKING WITH THROWS CLAUSE

=============================
THIS CLAUSE IS USED TO ESCAPE FROM HANDLING AN EXCEPTION. IT IS USEFUL TO THROW AN

EXCEPTION OUT OF A METHOD WITHOUT HANDLING IT.
class Excep8
{
{
char x;
x = (char) System.in.read( );
ps.print("Character : " + x);
}
}
USER DEFINED EXCEPTIONS

==========================
THROW CLAUSE :- THIS STATEMENT IS USEFUL TO THROW AN EXCEPTION OBJECT AND ALSO
HANDLE IT. IT IS USEDFUL TO CREATE USER-DEFINED EXCEPTIONS AND HANDLE THEM.
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 Entry");
}
}
catch(InvalidMarks ob)
{
ps.println("Please enter between 0-100");
}
ps.print("Marks : " + m);
}
}
class InvalidMarks extends Exception
{
};
class Gopi
{
{
int m;
System.out.println("Enter Marks");
m = sc.nextInt( );
try
{
if(m > 100)
{
InvalidMarks ob = new InvalidMarks( );
throw ob;
}
System.out.println("Marks : " + m);
}
catch(InvalidMarks ex)
{
System.out.println("Invalid Marks, Please Enter Marks Between 0 - 100");
}
}
}
PACKAGES
==========
A PACKAGE IS A SUB DIRECTORY THAT STORES A GROUP OF CLASSES AND INTERFACES. PACKAGE
MEANS SET OF CLASSES AND INTERFACES. PACKAGE MEANS SIMPLY A FOLDER.
ADVANTAGES OF PACKAGES
=========================
1) PACKAGES PROTECT CLASSES AND INTERFACES. SO THAT ACCIDENTAL DELETION IS NOT

POSSIBLE.
2) PACKAGES PROVIDES REUSABILITY.
3) THE CLASSES OF ONE PACKAGE ARE ISOLATED FROM THE CLASSES OF ANOTHER PACKAGE. SO,
SAME NAMES CAN BE USED IN TWO DIFFERENT PACKAGES.
4) USING PACKAGE CONCEPT WE CAN ALSO CREATE OUR OWN PACKAGES AND EXTEND ALREADY
AVAILABLE PACKAGES.
package amar;
public class SampleMsg
{
public void show( )
{
System.out.println("Show Method Called From SampleMsg Class Of amar Package");
}
}
javac -d . SampleMsg.java
-d : DEFINE / CREATE SUB DIRECTORY (DESTINATION DIRECTORY / FOLDER).
. : CURRENT DIRECTORY.
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
{
{
ob.show();
}
}
import amar.*;
class UseSampleMsg1
{
{
ob.show();
}
}
WHEN WE WRITE import amar.*; WE MUST COPY SampleMsg.java INTO amar FODLER / ANY
OTHER FOLDER.
SUB PACKAGES
==============
package one.two.three;
public class SimpleMsg
{
public void show( )
{
System.out.println("Show Method Called From SimpleMsg Class Of one.two.three
Package");
}
}
javac -d . SimpleMsg.java
import one.two.three.SimpleMsg;
class UseSimpleMsg
{
{
SimpleMsg ob = new SimpleMsg( );
ob.show();
}
}
ACCESS SPECIFIERS : private, default, protected, public
private : INSIDE THE CLASS. CLASS LEVEL.
default / friendly : INSIDE THE PACAKGE. PACKAGE LEVEL.
protected : INSIDE THE PACAKGE. PACKAGE LEVEL + ANOTHER PACKAGE SUB CLASS.
public : ANY PACAKGE, ANY CLASS. UNLIMITED ACCESS.
MULTI THREADING
=================
EXECUTION OF STATEMENTS IN JAVA IS TWO TYPES.
1) SINGLE TASKING
2) MULTI TASKING
SINGLE TASKING :- EXECUTING ONLY ONE TASK AT A TIME BY THE MIRCO PROCESSOR. MUCH OF
THE PROCESSOR TIME IS WASTED IN SINGLE TASKING.
MULTI TASKING :- EXECUTING MULTIPLE TASKS AT A TIME BY THE MIRCO PROCESSOR. MUCH OF
THE PROCESSOR TIME IS SAVED IN MUTLI TASKING. ADVANTAGE OF USING MUTLI TASKING IS
HERE PROCESSOR TIME IS NOT WASTED. THE PROCESSOR TIME IS UTILIZED IN OPTIMUM
(BETTER) WAY.
TIME SLICE :- IT REPRESENTS A UNIT OF TIME ALLOTED FOR A TASK.
ROUND ROBIN :- EXECUTING THE FIRST TASK AFTER THE LAST TASK IN CYCLIC MANNER IS
CALLED ROUND ROBIN METHOD.
WAYS OF MULTI TASKING

======================
1) PROCESS BASED MULTI TASKING
2) THREAD BASED MULTI TASKING
PROCESS BASED MULTI TASKING :- IN THIS MODEL MULTIPLE PROCESSES / PROGRAMS ARE
EXECUTED BY THE PROCESSOR AT A TIME.
THREAD BASED MULTI TASKING :- IN THIS MODEL SEVERAL PARTS (METHODS) OF THE SAME
PROGRAM ARE EXECUTED BY THE PROCESSOR AT A TIME USING THREADS.
USES OF THREADS
================
1) THREADS ARE USED IN SERVER SIDE PROGRAMS TO PROVIDE SERVICES TO SEVERAL CLIENTS
AT A TIME.
2) THREADS ARE USED IN ANIMATIONS AND GAMES.
1) MUTLI TASKING
2) MUTLI PROGRAMMING
3) MUTLI THREADING
A THREAD REPRESENTS A PROCESS / EXECUTON OF GROUP OF STATEMENTS. 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) (DEFAULT)
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. main( ) THREAD IS THE DEFAULT THREAD THAT EXECUTES
THE STATEMENTS IN A JAVA PROGRAM.
PRINTING main( ) THREAD DETAILS

==============================
class ThreadDemo1
{
{
Thread ob = Thread.currentThread( );
ps.println("Main thread details");
System.out.println(ob);
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 Gopi extends Thread

{
public void run( )
{
System.out.println("Three");
System.out.println("Four");
System.out.println("Five");
System.out.println("Six");
}
};
class Thread1a
{
{
Gopi ob = new Gopi( );
ob.start( );
System.out.println("Seven");
System.out.println("Eight");
System.out.println("Nine");
System.out.println("Ten");
System.out.println("Eleven");
System.out.println("Twelve");
}
}
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);
}
}
}

{
String name;
Sample(String st)
{
super(st);
name = st;
start( );
}
public void run( )
{
for(int i = 1; i <= 10; i++)
{
System.out.println(name + " : " + i);
}
}
};
class ThreadDemo3
{
{
Sample ob = new Sample("Sample Thread");
for(int i = 1; i <= 10; i++)
{
}
}
}
CREATING THREAD BY IMPLEMENTING Runnable INTERFACE

====================================================
class Gopi implements Runnable

{
public void run( )
{
System.out.println("Three");
System.out.println("Four");
System.out.println("Five");
System.out.println("Six");
}
};
class Thread1b
{
{
Gopi ob = new Gopi( );
Thread t = new Thread(ob);
t.start( );
System.out.println("Seven");
System.out.println("Eight");
System.out.println("Nine");
System.out.println("Ten");
System.out.println("Eleven");
System.out.println("Twelve");
}
}
class Sample implements Runnable

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

{
Thread t;
String name;
Sample(String st)
{
name = st;
t = new Thread(this,st);
t.start( );
}
public void run( )
{
for(int i = 1; i <= 10; i++)
{
}
}
};
class ThreadDemo5
{
{
for(int i = 1; i <= 10; i++)
{
}
}
}
CREATING MULTIPLE THREADS

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

{
String name;
One(String st)
{
super(st);
name = st;
start( );
}
public void run( )
{
for(int i = 1; i <= 10; i++)
{
}
}
};
class Two extends Thread
{
String name;
Two(String st)
{
super(st);
name = st;
start( );
}
public void run( )
{
for(int i = 1; i <= 10; i++)
{
}
}
};
class Three extends Thread
{
String name;
Three(String st)
{
super(st);
name = st;
start( );
}
public void run( )
{
for(int i = 1; i <= 10; i++)
{
}
}
};
class ThreadDemo7
{
{
One ob1 = new One("One Thread");
Two ob2 = new Two("Two Thread");
Three ob3 = new Three("Three Thread");
for(int i = 1; i <= 10; i++)
{
}
}
}
SETTING PRIORITIES TO THREADS

===============================

{
String name;
One(String st)
{
super(st);
name = st;
}
public void run( )
{
for(int i = 1; i <= 10; i++)
{
}
}
};
{
String name;
Two(String st)
{
super(st);
name = st;
}
public void run( )
{
for(int i = 1; i <= 10; i++)
{
}
}
};
{
String name;
Three(String st)
{
super(st);
name = st;
}
public void run( )
{
for(int i = 1; i <= 10; i++)
{
}
}
};
class ThreadDemo8
{
{
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 InterruptedException.

{
String name;
Sample(String st)
{
super(st);
name = st;
start( );
}
public void run( )
{
for(int i = 1; i <= 10; i++)
{
try
{
Thread.sleep(1000); // 1000 : Milli Seconds = 1 Second
}
catch(InterruptedException ex)
{
}
}
}
};
class ThreadDemo9
{
{
for(int i = 1; i <= 10; i++)
{
try
{
}
{
}
}
}
}

{
String name;
One(String st)
{
super(st);
name = st;
start( );
}
public void run( )
{
for(int i = 1; i <= 10; i++)
{
try
{
}
{
}
}
}
};
{
String name;
Two(String st)
{
super(st);
name = st;
start( );
}
public void run( )
{
for(int i = 1; i <= 10; i++)
{
try
{
}
{
}
}
}
};
{
String name;
Three(String st)
{
super(st);
name = st;
start( );
}
public void run( )
{
for(int i = 1; i <= 10; i++)
{
try
{
}
{
}
}
}
};
class ThreadDemo10
{
{
for(int i = 1; i <= 10; i++)
{
try
{
}
{
}
}
}
}
suspend( ) :-THIS METHOD IS USED TO SUSPEND A THREAD BASED ON CONDITION.
resume( ) :- THIS METHOD IS USED TO CONTINUE THE SUSPENDED THREAD.

{
String name;
Sample(String st)
{
super(st);
name = st;
start( );
}
public void run( )
{
for(int i = 1; i <= 10; i++)
{
}
}
};
class ThreadDemo11
{
{
Sample ob = new Sample("Sample Thread" );
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.

{
String name;
Sample(String st)
{
super(st);
name = st;
start( );
}
public void run( )
{
for(int i = 1; i <= 10; i++)
{
}
}
};
class ThreadDemo12
{
{
Sample ob = new Sample("Sample Thread" );
for(int i = 1; i <= 10; i++)
{
if(i == 5)
ob.stop( );
}
}
}
SYNCHRONIZATION (LOCKING)
===========================
Without SYNCHRONIZATION SOMETIMES WE GET UNRELIABLE RESULTS.
synchronization :- WHEN A THREAD ACTS ON AN OBJECT, ANY OTHER THREADS ARE NOT
ALLOWED TO ACT UPON THE SAME OBJECT SIMULTENOUSLY. THE OBJECT ON WHICH THE THREADS
ARE SYNCHRONIZED IS CALLED MUTEX (MUTUALLY EXCLUSIVE LOCK).
TYPES OF SYNCHRONIZATION
==========================
1) BLOCK SYNCHRONIZATION
2) THREAD SYNCHRONIZATION
BLOCK SYNCHRONIZATION :- IT IS USEFUL TO SYNCHRONIZE A BLOCK STATEMENTS.
THREAD SYNCHRONIZATION :- IT IS USEFUL TO SYNCHRONIZE AN ENTIRE METOD.
DEADLOCK :- WHEN A THREAD WANTS TO ACT UPON AN OBJECT WHICH IS LOCKED BY ANOTHER
THREAD, AND THE SECOND THREAD WANTS TO ACT UPON THE OBEJCT WHICH IS ALREADY LOCKED
BY FIRST THREAD, BOTH THE THREADS WILL CONTINUE IN WAITING STATE FOREVER. WHEN
DEADLOCK OCCURS FURTHER PROCESSING OF THE PROGRAM IS HALTED. THERE IS NO SOLUTION
FOR DEADLOCK. THE PROGRAMMER SHOULD DESIGN THE LOGIC IN SUCH A WAY THAT IT WILL NOT
INVOLVE THE DEADLOCK.
class Tata
{
synchronized static void show(String str)
{
System.out.print("\n(" + str);
try
{
Thread.sleep(1000);
}
catch(InterruptedException ie)
{
}
System.out.print(")");
}
};
{
Thread t;
String st;
Sample(String k)
{
st = k;
t = new Thread(this);
t.start( );
}
public void run( )
{
Tata.show(st);
}
};
class ThreadDemo13
{
{
Sample ob1 = new Sample("This is India");
Sample ob2 = new Sample("I am Indian");
Sample ob3 = new Sample("I love my India");
}
}
FILES
=====
FILES ARE USED TO STORE DATA PERMANENTLY. A FILE IS A ORGANIZED COLLECTION OF DATA
AND STORE PERMANENTLY IN THE HARD DISK OR FLOPPY DISK OR COMPACT DISK.
ADVANTAGES OF FILES
====================
1) DATA STORE PERMANENTLY IN THE SECONDARY MEMORY.
2) SAME FILE DATA CAN BE SHARED BY DIFFERENT PROGRAMS.
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
{
public static void main(String args[]) throws 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 fos = new 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 fos = new 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 fos = new 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( );
}
}
READING CONTINUOUS TEXT FROM ANY FILE

========================================
import java.io.*;
class File7
{
public static void main(String args[ ]) throws FileNotFoundException, IOException
{
String fname;
System.out.println("Enter File Name");
fname = sc.next( );
FileReader fr = new FileReader(fname);
int ch;
while(true)
{
ch = fr.read( );
if(ch == -1)
break;
System.out.print((char)ch);
}
fr.close( );
}
}
JAVA IDE'S : ECLIPSE, NET BEANS

Core Java

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Core Java

Uploaded by

Copyright:

Available Formats

INTRODUCTION TO JAVA

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

DIFFERENCE BETWEEN 'C', C++ AND JAVA

MAIN SECURITY PROBLEMS ON INTERNET

ENCRYPTION :- CONVERTING THE ORIGINAL DATA INTO UNREADABLE FORMAT.

3) IMPERSONATION :- A PERSON ACTING AS ANOTHER PERSON ON INTERNET. TO AVOID THIS

DIGITAL SIGNATURE :- IT IS A FILE WITH PERSONAL INFORMATION IN ENCRYPTED FORMAT.

THE FIRST PERSON WHO DEVELOPED THE VIRUS IS PAKISTANIS.

2) IT ELIMINATES A LOT OF SECURITY PROBLEMS FOR DATA ON INTERNET.

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

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

SIMPLE :- JAVA IS A SIMPLE PROGRAMMING LANGUAGE. LEARNING JAVA IS EASY. BECAUSE

IN PROGRAMMING LANGUAGES, OBJECTS ARE INSTANCES (VARIABLES) OF CLASSES. AN OBJECT

NATIVE METHODS :- METHODS WRITTEN IN OTHER LANGUAGE LIKE C AND C++.

IN PROGRAMMING LANGUAGES, A CLASS IS AN USER-DEFINED DATA TYPE. BY USING CLASS

DISTRIBUTED :- USING JAVA WE CAN DEVELOP NETWORK APPLICATIONS. NETWORK APPLICATION

SECURE :- JAVA IS A SECURE LANGUAGE BECAUSE JAVA CONTAINS FIREWALLS. FIREWALLS

FIREWALL :- IT IS A SOFTWARE THAT ALLOWS ONLY AUTHORIZED PEOPLE TO ACCESS SYSTEM

PORTABLITY :- JAVA PROGRAMS GIVE SAME RESULTS ON ALL MACHINES.

MULTI THREADED :- THREAD MEANS PROCESS OR EXECUTION. EXECUTING DIFFERENT PARTS OF A

2) MULTI LINE COMMENT :- WHICH STARTS WITH /* AND ENDS WITH */

TOOLS OF JDK (JAVA DEVELOPMENT KIT)

JAVA (INTERPRETER) :- IT IS USED TO EXECUTE CLASS FILE MEANS BYTE CODES.

JAVADOC (DOCUMENTATION COMPILER) :- IT IS USED TO CONVERT JAVA PROGRAM INTO HTML

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

IDE :- IT STANDS FOR INTEGRATED DEVELOPMENT ENVIRONEMNT, WHICH ALLOWS TO WRITE,

1) OPEN C:\Program Files\Java\jdk1.6.0\bin THROUGH COMPUTER & COPY C:\Program

4) CLICK ON OK, OK, OK

CREATE A FOLDER IN D:\JAVA LAB

1) START ====> TYPE cmd AND PRESS ENTER

SAVE & EXIT

COMPILE PROGRAM : javac First.java

EXECUTE PROGRAM : java First

print( ) & println( ) METHODS

\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 SMALL LETTERS.

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

Ex :- System, String, StringBuffer,DataInputStream

Ex :- print( ), getChars( ), setActionCommand( )

4) VARIABLE NAMES FOLLOWS SAME AS METHOD RULES.

Ex :- age, empName, avgMarks

Ex :- PI, MAX_VALUE, DAY_OF_WEEK

WORKING WITH DATA

VARIABLES :- A VARIABLE REPRESENTS MEMORY LOACTION TO STORE VALUES.

byte : -128 TO +127 1 BYTE

short : -32768 TO +32767 2 BYTES

int : -2147483648 TO +2147483647 4 BYTES

long : -9223372036854775808 TO +9223372036854775807 8 BYTES

float : -3.4e38 to +3.4e38 4 BYTES