WelcomeTo

Programming in JAVA

By

Mr. A. Julias CeasorBosco Institute of Information

Technology

James Gosling

Java Basics:OOP and Java - Objects and Classes – Encapsulation - Inheritance - Polymorphism - Java Language - The Primaries - Character Set - Tokens - Constants - Variables - Operators and Expressions - Library Methods - Strings - I/O Streams - Formatting the Output values - Control Statements – If - Switch - While - Do-While-for.

After this unit will be over, you will be the Know-how of the followings:

Java Fundamentals & Basics for Programming

What is Java?Java is a programming language expressly designed for use in the distributed environment of the Internet. It was designed to have the "look and feel" of the C++ language, but it is simpler to use than C++ and enforces an object-oriented programming model.

Key Concept of Java:• Java Technology is:- Simple, Secure, Robust, Complete Object Oriented and Platform Independent High level Language.- It is portable and Multi-thread technology gives High performance.• It is based on concept called JVM.- Act as a translator between the language and the underlying Software and Hardware.

Objects

What is Object Oriented Programming?• This is a technique used to develop programs revolving around the real world entities. • In OOPs programming model, programs are developed around data rather than actions and logics.• In OOPs, every real life object has properties and behavior. • It contains properties (variables of some type) and behavior (methods). • OOPs provides a better flexibility and compatibility for developing large applications.

What is object?• Object is a real world entity.• the Real world Objects are: Building,Car, Fruit,… and etc.

An Object

Attributes:• Four Wheels• Engine• Seats• Steering• Speed• Disk Break• Etc.

Car

Functionalities (Methods):+Wheels for Rolling+ Engine for Moving+Seats for Sitting+Break for Control+Etc.

Programming Object:- It is combination of Data and Methods.

Data

Method

Method

Method

Method

Attributes of an object

(-) Functionalities of an Object

(+)

Object = Data + Methods

An Object

Pillars of OOPL:

O O P L

Inheritance Encapsulation PolymorphismDynamic Binding

Why the Java?• C, C++ and other programming languages are not flexible for complex problems.• Other languages are Structured and Object Oriented Programming language. Not Fully OOPL.• Others are not Platform Independent.

Evolution of Java• In 1990, the group of engineers developed a software for consumer electronics at Sun micro System of USA.• This group is headed by James Gosling.• In 1991, it is proved that it satisfy the concepts of OOPL like C++ and called as 'Oak' by James Gosling.• In 1992, the Green Project is started.• In 1993, the team developed small applet program for World Wide Web.• In 1994, the team came up with browser called HotJava.• In 1995, the 'Oak' renamed as 'Java'

Why is it named 'Oak'?When the 'Ever green' team was Developed Software for consumer Electronics, such as Set-Top-Boxes, and Other hand held devices, the Head of the team James Gosling saw a Oak tree in front of his office.The Oak tree is a ever green tree and never its leaves get dry. Due to this reason, the software named as 'Oak'.

Features of Java:• Java is:

simple easy to design easy to write and therefore easy to compile debug and learn than any other programming languages.

• Java is object-oriented, that is used to build modular programs and reusable code in other application.

• Java is platform-independent and flexible in nature.

• The most significant feature of Java is to run a program easily from one computer system to another. 

Continued…..

• Java works on distributed environment.

• Java is secure. The Java language, compiler, interpreter and runtime environment are  securable .

• Java is robust. Robust means reliability.

• Java  emphasis on  checking for possible errors.

• Java supports multithreaded. Multithreaded is the path of execution for a program to perform several tasks simultaneously within a program.

Java Platform:• Platform  is cross-combination of  hardware or software environment in which a program runs.

Hardware Platform

Java Platform

Software (OS) Platform

Operates and

Controls H/W

Environment for Java

Development

Java Platform:• Java Platform has Two Components.1. Java Virtual Machine (JVM)2. Java Application Programming Interface (API)

JVM API

JVM: The Java Virtual Machine is the root for the Java platform and is integrated into various hardware-based platforms.

API: The API is a vast collection of various software components that provide you many useful functionality to the application.It is grouped into logical collection  of related classes and interfaces; these logical collection  are known as packages.

How it Works:

•All source code is  written in  text files (Notepad Editor) save with the .java extension • The source files are compiled into .class files by the java

compiler. A .class file  contains byte codes • The java launcher tool  runs your application with an instance of

the Java Virtual Machine.

Execution of Program as Platform Independent

A simple Java Program:HelloWorld.java

import java.io.*;

class HelloWorld{public static void main(String args[]){System.out.println("HelloWorld");}}

Output:HelloWorld

Procedure for developing java application1. Write a java source code as a text file (can create in notepad) using

any of the text editor.• Save the file with .java extension in your directory.• The filename should be the class name of the program.• Open the command prompt to run the application• Compile the code with command javac filename.java• Run the class file with the command java filename• The output will be displayed on your console.

Two ways of using Java

Java Source Code

Java Compiler

Java Enabled

Web Browser

Java Interpreter

Output Output

Applet Type Application Type

Java Technology:On full implementation of the Java platform gives you the following features:

JDK Tools: The JDK tools provide  compiling, Interpreter, running, monitoring, debugging, and documenting your applications.  The main tools used are the Javac compiler, the java launcher, and the javadoc documentation tool. Application Programming Interface (API): The API provides the core functionality of the Java programming language.

Deployment Technologies: The JDK software provides two type of deployment technology such as the Java Web Start software and Java Plug-In software for deploying your applications to end users. 

Graphical User Interface Toolkits: The Swing and Java 2D toolkits provide us the feature of  Graphical User Interfaces (GUIs).

Integrated Libraries: Integrated with various libraries such as the Java IDL API, JDBC API, Java Naming and Directory Interface TM ("J.N.D.I.") API, Java RMI, and Java Remote Method Invocation over Internet.

Structure of Java Program

Documentation Section

Package Statements

Import Statements

Interface Statements

Class Definitions

Main Method Class{Main method Definition}

A set of comment lines giving the name of the program, author and other details./**…….*/ or // or /*…..*/

Declare the package names and inform the compiler the class defined below belongs to this packages. e.g.: package student;

Instruct the interpreter to load the test class contained in Student package. E.g. import student.test;Includes a group of methods declarations.

Can have multiple class declarations.

Creates objects of various classes and establishes communication between them.

Java Virtual Machine:• All language compiler translate source code into machine code for specific computer.• Java compiler produces an intermediate code known as bytecode for a machine that does not exist.• This machine is called Java Virtual Machine (JVM)• It is simulated computer with in a computer does all major functions.• the bytecode is called as virtual machine code.• this is not machine specific.• Machine specific code is generated by Java Interpreter by acting as intermediary between the virtual machine and real machine.• Illustrated below.

Java Progra

m

Virtual Machin

eSource code

Bytecode

Java Compiler

Process of Compilation:

Java Interpreter

Virtual Machine

Real Machine

Bytecode

Process of Converting bytecode into machine code

Machine Code

Classes and Objects:Class:A class is a programming language construct that is used as a blueprint to create objects. This blueprint describes the state and behavior that the created objects all share.

E.g.: Bicycles

• There may be thousands of other bicycles in existence, all of the same make and model.

• Each bicycle was built from the same set of blueprints and therefore contains the same components.

• In object-oriented terms, we say that your bicycle is an instance of the class of objects known as bicycles.

• A class is the blueprint from which individual objects are created.

The following Bicycle class is one possible implementation of a bicycle:

class Bicycle {

int cadence = 0; int speed = 0; int gear = 1;

void changeCadence(int newValue) { cadence = newValue; }

void changeGear(int newValue) { gear = newValue; } void speedUp(int increment) { speed = speed + increment; } void applyBrakes(int decrement) { speed = speed - decrement; } void printStates() { System.out.println("cadence:"+cadence+" speed:"+speed+" gear:"+gear); }

}

• The fields cadence, speed, and gear represent the object's state, and the methods (changeCadence, changeGear, speedUp etc.) define its interaction with the outside world.

• It is just the blueprint for bicycles that might be used in an application

Here's a BicycleDemo class that creates two separate Bicycle objects and invokes their methods:

class BicycleDemo { public static void main(String[] args) {

// Create two different Bicycle objects Bicycle bike1 = new Bicycle(); Bicycle bike2 = new Bicycle();

// Invoke methods on those objects bike1.changeCadence(50); bike1.speedUp(10); bike1.changeGear(2); bike1.printStates();

bike2.changeCadence(40); bike2.speedUp(10);bike2.changeGear(3);bike2.printStates(); } }

The output of this test prints the ending pedal cadence, speed, and gear for the two bicycles:cadence:50 speed:10 gear:2 cadence:40 speed:20 gear:3

Object:Object is the basic entity of object oriented programming language. Class itself does nothing but the real functionality is achieved through their objects. Object is an instance of the class. It takes the properties (variables) and uses the behavior (methods) defined in the class. 

E.g.: Bicycle

• Real-world objects share two characteristics: They all have state and behavior.

• Dogs have state (name, color, breed, hungry) and behavior (barking, fetching, wagging tail).

• Bicycles also have state (current gear, current pedal cadence, current speed) and behavior (changing gear, changing pedal cadence, applying brakes).

• Identifying the state and behavior for real-world objects is a great way to begin thinking in terms of object-oriented programming.

• Ask yourself: "What possible states can this object be in?" and "What possible behavior can this object perform?". Make sure to write down your observations.

• An object stores its state in fields (variables in some programming languages)

• And exposes its behavior through methods (functions in some programming languages).

Data Encapsulation: Hiding internal state and requiring all interaction to be performed through an object's methods is known as data encapsulation — a fundamental principle of object-oriented programming.

A Software Object

Bundling code into individual software objects provides a number of benefits, including:

Modularity:The source code for an object can be written and maintained independently of the source code for other objects. Information-hiding:By interacting only with an object's methods, the details of its internal implementation remain hidden from the outside world. Code re-use:If an object already exists (perhaps written by another software developer), you can use that object in your program.Pluggability and debugging ease:If a particular object turns out to be problematic, you can simply remove it from your application and plug in a different object as its replacement.

Main Pillars of OOP:Encapsulation:• Abstraction: Hiding the information (Complexities) to the end users. E.g.: User Driving a Car.• Encapsulation is the process of binding together the methods and

data variables as a  single entity. • It keeps both the  data and functionality code safe  from the

outside world. • It hides the data within the class and makes it available only

through  the methods. • Java provides different accessibility scopes (public, protected,

private ,default) to hide the data from outside.

Example:Here we create a class "Check" which has a variable "amount" to store the current amount. To manipulate  this variable we create a methods and to set the value of amount we create setAmount() method and to get the value of amount we create getAmount() method .

class Check{  private int amount=0;  public int getAmount(){     return amount;  }  public void setAmount(int amt){     amount=amt;  } } public class Mainclass{  public static void main(String[] args){     int amt=0;     Check obj= new Check();     obj.setAmount(200);     amt=obj.getAmount();      System.out.println("Your current amount is :"+amt);     }}

Here the data variable "amount" and methods setAmount() and  getAmount() are enclosed together with in a single entity called the "Check" class.

Inheritance: • Inheritance allows a class (subclass) to acquire the properties and behavior of another class (superclass). • In java, a class can inherit only one class (superclass) at a time

but a class can have any number of subclasses. • It helps to reuse, customize and enhance the existing code. • So it helps to write a code accurately and reduce the

development time. Java uses extends keyword to extend a class.

Class A

Class B

Fun 1

Fun 2

Extends

Class B inherits the property of

class A

class A{  public void fun1(int x){     System.out.println("Int in A is :" + x);  }} class B extends A{  public void fun2(int x,int y){     fun1(6);  // prints "int in A"      System.out.println("Int in B is :" + x+" and "+y);    }}public class inherit{  public static void main(String[] args){     B obj= new B();     obj.fun2(2,6);      }}

In the above example,  class B extends class A and so acquires properties and behavior of class A. So we can call method of A in class B.

Polymorphism :• Polymorphism allows one interface to be used for a set of actions i.e. one name may refer to different functionality. • Polymorphism allows a object to accept different requests of a

client (it then properly interprets the request like choosing appropriate method) and responds  according to the current state of the runtime system, all without bothering the user. 

There are two types of polymorphism :1.Compile-time polymorphism (Method Overloading)2.Runtime Polymorphism (Method Overriding)

Method Overloading:• In compiletime Polymorphism, method to be invoked is determined at the compile time. • Compile time polymorphism is supported through the method overloading concept in java.• Method overloading means having multiple methods with same name but with different signature (number, type and order of parameters).

class A{  public void fun1(int x){    System.out.println("The value of class A is : " + x);  }  public void fun1(int x,int y){    System.out.println("The value of class B is : " + x + " and " + y);  }}public class polyone{  public static void main(String[] args){    A obj=new A();// Here compiler decides that fun1(int) is to be called and "int" will be printed.    obj.fun1(2);   // Here compiler decides that fun1(int,int)is to be called and "int and int" will be printed.       obj.fun1(2,3);         }}

Method Overloading (Compile-time polymorphism)

Method Overriding:• In Run-time polymorphism, the method to be invoked is

determined at the run time. • The example of run time polymorphism is method overriding.

When a subclass contains a method with the same name and signature as in the super class then it is called as method overriding.

class A{  public void fun1(int x){     System.out.println("int in Class A is : "+ x);  }}

class B extends A{  public void fun1(int x){     System.out.println("int in Class B is : "+ x);  }}

public class polytwo{  public static void main(String[] args){     A obj;          obj= new A(); // line 1     obj.fun1(2);  // line 2 (prints "int in Class A is : 2")          obj=new B();  // line 3     obj.fun1(5);  // line 4 (prints ""int in Class B is : 5")  }}

Method Overriding (Run-time Polymorphism)

Character Set in Java:• The smallest units of java languages are Characters used to

write Java Tokens.• These characters are defined by Unicode Character set.• The Unicode is a 16-bit character coding system.• It supports more than 34,000 characters in worldwide.• ASCII characters are subset of UNICODE Character set.

lower-case <= a|b|c|d|e|f|g|h|i|j|k|l|m|n|o|p|q|r|s|t|u|v|w|x|y|zupper-case <= A|B|C|D|E|F|G|H|I|J|K|L|M|N|O|P|Q|R|S|T|U|V|W|X|Y|Zalphabetic <= lower-case | upper-casenumeric     <= 0|1|2|3|4|5|6|7|8|9alphanumeric <= alphabetic | numericspecial       <= !|%|^|&|*|(|)|-|+|=|{|}|||~|[|]|\|;|'|:|"|<|>|?|,|.|/|#|@|`|_graphic     <= alphanumeric | special

Java Tokens:•Smallest individual units in a program are known as tokens.•The compiler recognizes them for building up expressions and statements.•Java language includes Five types of tokens. They are:•Reserved Keywords•Identifiers•Literals•Operators•Separators

Keywords:•Keyword are an essential part of a language definition.•Java has 50 keywords listed below.•Keywords have specific meaning in Java.•We cannot use them as names for variables, classes, methods and so on.• All keywords are to be written in lower-case letters.•It is good practice avoiding usage of key words as identifiers.•keywords are case-sensitive.

abstract continue goto package switch

assert default if private this

boolean do implements protected throw

break double import public throws

byte Else Instanceof Return Transient

Case Extends Int Short Try

Catch Final Interface Static Void

Char Finally Long Strictfp Volatile

Class Float Native Super While

Const For New Synchronized enum

List of Keywords in Java

Identifiers:•Identifiers are programmer-designed tokens. They are used for naming classes, methods, variables, objects, labels, packages and interfaces in a program.•Rules for Identifiers:

1. They can have alphabets, digits, underscore and dollar sign characters.

• They must not begin with digit.• Uppercase and lowercase letters are distinct.• They can be of any length.

Literals:Literals in Java are a sequence of characters (digits, letters, and other characters) that represent constant values to be stored in variables.

Java specifies Five major types of literals. They are:

1.Integer Literals E.g.: 123• Floating-point Literals E.g.: 123.45• Character Literals E.g.: 'X' or 'x'• String Literals E.g.: "Hello"• Boolean Literals E.g.: true or false

Operators:An operator is a symbol that takes one or more arguments and operates on them to produce a result.

Separators:Separators are symbols used to indicate where groups of code are divided and arranged.

separators

Note that the first three separators are tokens that separate/punctuate other tokens. The last six separators (3-pairs of 2 each) are also known as delimiters.For example the Java code Math.max(count,limit); contains nine tokens. 1. An identifier (math), followed by • A separator (a period), followed by • Another identifier (max), followed by • A separator (the left parenthesis delimiter), followed by • An identfier (count), followed by • A separator (a comma), followed by • Another identifier(limit), followed by • A separator (the right parenthesis delimiter), followed by • A separator (a semicolon)

; , . ( ) { } [ ]

Java Statements

Selection Statements

Iteration Statements

Jump Statements

Expression Statements

Labeled Statements

Synchronize Statements

Guarding Statements

return

break

continueIf-

else

switch

if

while do for

Control St.

Constants:Definition:Constants in Java refer to fixed values that do not change during the execution of a program.

Java Constants

Java Constants Java Constants

Integer Constants

Real Constants

String Constants

Character Constants

Decimal : 123Octal : 037Hexadecimal: 0X9F

Fractional : 0.0065,-0.75Exponential : 1.5e+5

E.g.: '5' 'X' ';'

E.g.:"Hello" "1223"

Integer Constants:An integer constant refers to a sequence of digits.Real Constant:A constant which has fractional part is called Real constant.Character Constant:A single character constant (or simply character constant) contains a single character enclosed within a pair of single quote marks. String Constant:A string constant is a sequence of characters enclosed between double quotes.Backslash Character Constants:'\b', '\f', '\n', '\r', '\t', '\"', '\"', '\\'

Variables:A variable is an identifier that denotes a storage location used to store a data value. Unlike constants that remain unchanged during the execution of a program.Rules for variable names:1. They must not begin with a digit.• Uppercase and lowercase are distinct.• It shou8ld not be a keyword.• White space is not allowed.• Variable names can be of any length.

Declaration of variables:Variables are the names of storage locations. After designing suitable variable names, we must declare them to the compiler.

type variable1, variable2, …………, variableN;Declaration does :1. Tell the compiler what the variable name is.• Specify what type of data the variable will hold.• Decides the scope of variable (depends on the place it is declared).

Scope of Variables:The area of the program where the variable is accessible is called its scope.It is classified into three kinds:• Instance variable• Class variable• Local variable

Instance:Instance variable is declared inside the class. It is created when the objects are instantiated and therefore they are associated with the objects. They take different values for different object.Class:It is also declared inside the class and it is global variable to a class and belong to the entire set of objects that creates. Only one memory location is created for each class.Local:Variables declared and used inside methods are called local variables. And it also can be declared inside the block of codes that defined between { and }.

Data Types in Java:• Data types specify the size and type of values that can be stored.• Variety of data types available allow the programmer to select the

type appropriate to the needs of the application.

Primitive (Intrinsic

)

Non-Primitive (Derived)

Numeric Non-Numeric

IntegerFloating-Point

CharacterBoolean

Classes Arrays

Interface

DATA TYPES IN JAVA

Integer Type:• Can hold whole numbers such as 123, -234.• It has Four types of Integer Types:

o Byteo Shorto Into Long

Floating Point Types:• Can hold numbers containing fractional parts such as 57.78 and -

45.78.• It has two types of values:

o Single Precisiono Double precision

Character Type:• To store character constant in memory the data type Char is

used.• It assumes a size of 2 bytes and holds a single character.

Boolean type:this type of data type is used to hold the values of Boolean such as ‘true’ or ‘false’.Symbolic Constants:Storing of some Constant value (which is needed frequently in the program) to a symbol is called Symbolic Constant.final type symbolic-name = value;E.g.: final int STRENGTH = 100;Type Casting:The process of Converting one data type to another is called casting.type variable1 = (type) variable2;

Operators:Operators are used in programs to manipulate data and variables.The list of Operators:1. Arithmetic operators• Relational operators• Logical operators• Assignment operators• Increment and decrement operators• Conditional operators• Bitwise operators• Special operators

Operator Meaning

+ Addition or unary plus

- Subtraction or unary minus

* Multiplication

/ Division

% Modulo division

Arithmetic Operators

Operator Meaning

< Is less than

<= Is less than or equal to

> Is greater than

>= Is greater than or equal to

== Is equal to

!= Is not equal toRelational Operators

Logical Operators

Assignment Operator

Increment and decrement Operators

Operator Meaning

&& Logical AND

|| Logical OR

! Logical NOT

Operator Meaning

= Store value

Operator Meaning

++ Incrementing value

-- Decrementing value

Conditional Operator

Exp1 ? Exp2 : exp3

Bitwise Operators

Special Operators

Operator Meaning

& Bitwise AND

| Bitwise OR

^ Bitwise exclusive OR

~ One's complement

<< Shift left

>> Shift right

>>> Shift right with zero fill

Instanceof Operator:E.g.: person instanceof student

Dot Operator:E.g.: person.age

postfix [] . () expr++ expr–

unary ++expr –expr +expr -expr ! ~

creation/caste new (type)expr

multiplicative * / %

additive + -

shift >> >>>

relational < <= > >= instanceof

equality == !=

bitwise AND &

bitwise exclusive OR ^

bitwise inclusive OR |

logical AND &&

logical OR ||

ternary ?:

assignment = “op=”

Operator Precedence

Control Statements:There are two types of control statements. They are:1. Decision making and Branching Statements• Decision making and Looping statements

Decision making and Branching:•when a program breaks the sequential flow and jumps to another part of the code, it is called branching. •When the branching is based on a particular condition, it is known as conditional branching. •If branching takes place without any decision, it is known as unconditional branching.They are:1. If statement• Switch statement• Conditional operator statement

If Statement:The four forms of If statement:1. Simple if• If….else• Nested if…else• Else if ladder

Simple if:General form:if (test expression){statement-block;}statement-X;

Next statements

Statements X

Statements block

Test?

Entry

true

False

If…Else statement:General form:if (test expression){True-block statement;}else{False-block statement;}statement-X;

Conditional Operator:

General form:

Conditional expression ? Expression-1 : Expression-2

Next statements

Statements X

Statements block

Test?

Entry

true

FalseStatements block

False

Nested If…Else statement:General form:if (test expression){if (test expression){True-block statement;}else{False-block statement;}}else{False-block statement;}statement-X;

Test?

Entry

true

FalseStatements block

False

Statements

Test?

trueFalse

Statements

Statements X

Else…If Ladder:General form:if (test expression)else if (test expression)Statement-1;else if (test expression)Statement-2;elseDefault St;Statement-X;

Test?

Entry

true

FalseStatements block

False

Test?

trueFalse

Statements

Default

Test?

true

False

Statements

Statements X

Switch Statement:General form:Switch (expression){case value-1:blockt-1;break;case value-1:blockt-1;break;default:default-block;break;} Statement-X;

Loop Controls:There are three types of looping statements:1. While construct2. Do construct3. For construct

A looping process, in general, would include the following four steps:1. Setting and initialization of a counter• Execution of the statements in the loop• Test for a specified condition for execution of the loop• Incrementing the counter

Loop control structures:

Entry

true

FalseTest

?

Body of the loop

Entry

true

False

Test?

Body of the loop

Exit controlEntry control

The While Statement:Entry Controlled Loop.General Form:Initialization;While (test-condition){Body of the loop;}

The do Statement:

Exit Controlled Loop.General Form:Initialization;do{Body of the loop;}While (test-condition);

The for Statement:Another entry Controlled Loop.General Form:for (initialization; test-condition; increment){Body of the loop;}

Nesting of for Loops:

General Form:for (initialization; test-condition; increment){for (initialization; test-condition; increment){Body of the loop;}}

Jump in Loops:Java permits a jump from one statement to the end or beginning of a loop as well as out of loop.Jumping Out of Loop:General Form:Initialization;While (test-condition){ ………….………….if (condition)break;Body of the loop;}……………..……………..

Exit from loop

Skipping a Part of a Loop:During the loop operations, it may be necessary to skip a part of the body of the loop under certain conditions.the continue statement causes the loop to be continued with the next iteration after skipping.General Form:Initialization;While (test-condition){ ………….………….if (condition)continue;Body of the loop;}……………..……………..

Skip the iteration

Labeled Loops:General Form:Outer: While (test-condition){ ………….………….if (condition)Body of the loop;continue Outer;}……………..……………..

Transferring Control

Java Library Methods:Strings:In Java string is a sequence of characters. Java implements strings as objects of type String.String Constructors:

String(char chars[])String(char chars[], int startindex, int numChars)String(String strObj)Strin(byte asciiChars[])String(byte asciiChars[], int startIndex, int numChars)Where: startIndex • specify the subrange begins and numChars • specify the number of characters to use.Declaration: E.g.: String S = new String();

Methods in String Description

int length() Return the length of the string

String toString() Converts data into string representation

Char charAt(int where) Returns a character at index specified

Void getChars(int sourceStart, int sourceEnd, char target[], int targetStart)

Extract the specified characters from one string to another

char[] toCharArray() Returns an array of characters

boolean equals(Object str) Returns boolean value

Boolean startsWith(String str) Returns boolean value

Boolean endsWith(String str) Returns boolean value

int compareTo(String str) If value is: < 0 • Invoking String is less than str> 0 • Invoking String is greater than str== 0 • Invoking String equal to str

String substring(int startIndex,int endIndex)

Separate the substring from main string

String concat(String str) Concatenation of two strings

String replace(char original, char replace)

Replace the string

String trim() Remove the white space in a string.

Methods in String Description

Static String value(double num)

Converts data into human readable format

String toLowerCase() Converts letters to lower case

String to UpperCase() Converts letters to Uppercase

Char charAt(int where) Return a character

Void setCharAt(int where, char ch)

Set the character at its position

StringBuffer delete(int start, int end) and StringBuffer deleteCharAt(int where)

Delete the content at specified position.

StringBuffer replace(int start, int end, String str)

Replace the string at specified positions

'+' is a Concatenation operator of Strings or any Data types.

It just join the strings or data