OOPs With Java

Lecture 1
Introduction to JAVA

 JAVA was developed by Sun Microsystems Inc in 1991, later acquired

by Oracle Corporation. It was developed by James Gosling and Patrick
Naughton. It is a simple programming language. Writing, compiling
and debugging a program is easy in java. It helps to create modular
programs and reusable code.
 Why to learn JAVA (key Features)
 Object Oriented − In Java, everything is an Object. Java can be easily
extended since it is based on the Object model.
 Platform Independent − Unlike many other programming languages
including C and C++, when Java is compiled, it is not compiled into
platform specific machine, rather into platform independent byte code.
This byte code is distributed over the web and interpreted by the Virtual
Machine (JVM) on whichever platform it is being run on.
 Simple − Java is designed to be easy to learn. If you understand the
basic concept of OOP Java, it would be easy to master.
 Secure − With Java's secure feature it enables to develop virus-free,
tamper-free systems. Authentication techniques are based on public-key
encryption.
 Architecture-neutral − Java compiler generates an architecture-neutral
object file format, which makes the compiled code executable on many
processors, with the presence of Java runtime system.
 Portable − Being architecture-neutral and having no implementation dependent
aspects of the specification makes Java portable. Compiler in Java is written in ANSI
C with a clean portability boundary, which is a POSIX subset.
 Robust − Java makes an effort to eliminate error prone situations by emphasizing
mainly on compile time error checking and runtime checking.
 Multithreaded − With Java's multithreaded feature it is possible to write
programs that can perform many tasks simultaneously. This design feature allows
the developers to construct interactive applications that can run smoothly.
 Interpreted − Java byte code is translated on the fly to native machine
instructions and is not stored anywhere. The development process is more rapid
and analytical since the linking is an incremental and light-weight process.
 High Performance − With the use of Just-In-Time compilers, Java enables high
performance.
 Distributed − Java is designed for the distributed environment of the internet.
 Dynamic − Java is considered to be more dynamic than C or C++ since it is
designed to adapt to an evolving environment. Java programs can carry extensive
amount of run-time information that can be used to verify and resolve accesses to
objects on run-time.
 Types of Java Applications
There are mainly 4 types of applications that can be created using Java programming:

1) Standalone Application
Standalone applications are also known as desktop applications or window-based applications. These are
traditional software that we need to install on every machine. Examples of standalone application are Media
player, antivirus, etc. AWT and Swing are used in Java for creating standalone applications.

2) Web Application
An application that runs on the server side and creates a dynamic page is called a web application.
Currently, Servlet, JSP, Struts, Spring, Hibernate, JSF, etc. technologies are used for creating web
applications in Java.

3) Enterprise Application
An application that is distributed in nature, such as banking applications, etc. is called enterprise
application. It has advantages of the high-level security, load balancing, and clustering. In Java, EJB is used
for creating enterprise applications.

4) Mobile Application
An application which is created for mobile devices is called a mobile application. Currently, Android and Java
ME are used for creating mobile applications.
Java is an Object Oriented
language
Object oriented programming is a way of organizing programs as
collection of objects, each of which represents an instance of a class.
4 main concepts of Object Oriented programming are:

1. Abstraction
2. Encapsulation
3. Inheritance
4. Polymorphism
Object-Oriented Programming is a
methodology or paradigm to design a program
using classes and objects.
 Object means a real-world entity such as a pen, chair, table,
computer, watch, etc. An Object can be defined as an instance of a
class. An object contains an address and takes up some space in
memory. Objects can communicate without knowing the details of
each other's data or code.
 Class: Collection of objects is called class. It is a logical entity. A class can also be defined as a
blueprint from which you can create an individual object. Class doesn't consume any space.
 Inheritance: When one object acquires all the properties and behaviors of a parent object, it
is known as inheritance. It provides code reusability. It is used to achieve runtime
polymorphism.
 Polymorphism: If one task is performed in different ways, it is known as polymorphism. For
example: to convince the customer differently, to draw something, for example, shape,
triangle, rectangle, etc.
In Java, we use method overloading and method overriding to achieve polymorphism.

 Abstraction: Hiding internal details and showing functionality is known as abstraction. For
example phone call, we don't know the internal processing. In Java, we use abstract class and
interface to achieve abstraction.
 Encapsulation: Binding (or wrapping) code and data together into a single unit are known as
encapsulation. For example, a capsule, it is wrapped with different medicines. A java class is
the example of encapsulation. Java bean is the fully encapsulated class because all the data
members are private here.
What is the difference between an object-
oriented programming language and
object-based programming language?

 Object-based programming language follows

all the features of OOPs except Inheritance.
JavaScript and VBScript are examples of
object-based programming languages.
 C++ vs Java

Comparison Index C++ Java

Platform-independent C++ is platform-dependent. Java is platform-independent.

Mainly used for C++ is mainly used for system Java is mainly used for application programming. It is widely used in window,
programming. web-based, enterprise and mobile applications.

Design Goal C++ was designed for systems and Java was designed and created as an interpreter for printing systems but
applications programming. It was an later extended as a support network computing. It was designed with a goal
extension of of being easy to use and accessible to a broader audience.
C programming language.

Goto C++ supports the goto statement. Java doesn't support the goto statement.

Multiple inheritance C++ supports multiple inheritance. Java doesn't support multiple inheritance through class. It can be achieved
by interfaces in java.

Operator Overloading C++ supports operator overloading. Java doesn't support operator overloading.
Pointers C++ supports pointers. You can Java supports pointer internally. However, you can't write the pointer
write pointer program in C++. program in java. It means java has restricted pointer support in java.

Compiler and Interpreter C++ uses compiler only. C++ is Java uses compiler and interpreter both. Java source code is converted into
compiled and run using the compiler bytecode at compilation time. The interpreter executes this bytecode at
which converts source code into runtime and produces output. Java is interpreted that is why it is platform
machine code so, C++ is platform independent.
dependent.
Call by Value and Call by C++ supports both call by value and call by Java supports call by value only. There is no call
reference reference. by reference in java.
Structure and Union C++ supports structures and unions. Java doesn't support structures and unions.
Thread Support C++ doesn't have built-in support for threads. It Java has built-in thread support.
relies on third-party libraries for thread support.

Documentation comment C++ doesn't support documentation comment. Java supports documentation comment (/** ...
*/) to create documentation for java source
code.

Virtual Keyword C++ supports virtual keyword so that we can decide Java has no virtual keyword. We can override
whether or not override a function. all non-static methods by default. In other
words, non-static methods are virtual by
default.

unsigned right shift >>> C++ doesn't support >>> operator. Java supports unsigned right shift >>>
operator that fills zero at the top for the
negative numbers. For positive numbers, it
works same like >> operator.

Inheritance Tree C++ creates a new inheritance tree always. Java uses a single inheritance tree always
because all classes are the child of Object class
in java. The object class is the root of the
inheritance tree in java.

Hardware C++ is nearer to hardware. Java is not so interactive with hardware.

Object-oriented C++ is an object-oriented language. However, in C Java is also an object-oriented language.
language, single root hierarchy is not possible. However, everything (except fundamental
types) is an object in Java. It is a single root
hierarchy as everything gets derived from
java.lang.Object.
First Java Program

public class MyFirstJavaProgram {

/* This is my first java program.

* This will print 'Hello World' as the output
*/

public static void main(String []args) {

System.out.println("Hello World"); // prints Hello World
}
}
JAVA PROGRAM STRUCTURE
Basic Syntax

About Java programs, it is very important to keep in mind the following points.
 Case Sensitivity − Java is case sensitive, which means identifier Hello and hello would
have different meaning in Java.
 Class Names − For all class names the first letter should be in Upper Case. If several
words are used to form a name of the class, each inner word's first letter should be in
Upper Case. Example: class MyFirstJavaClass
 Method Names − All method names should start with a Lower Case letter. If several
words are used to form the name of the method, then each inner word's first letter should
be in Upper Case. Example: public void myMethodName()
 Program File Name − Name of the program file should exactly match the class name.
When saving the file, you should save it using the class name (Remember Java is case
sensitive) and append '.java' to the end of the name (if the file name and the class name
do not match, your program will not compile).
But please make a note that in case you do not have a public class present in the file then file name
can be different than class name. It is also not mandatory to have a public class in the file.
Example: Assume 'MyFirstJavaProgram' is the class name. Then the file should be saved
as 'MyFirstJavaProgram.java'
 public static void main(String args[]) − Java program processing starts from the
Java Identifiers
All Java components require names. Names used for classes, variables, and
methods are called identifiers.
In Java, there are several points to remember about identifiers. They are as
follows −
 All identifiers should begin with a letter (A to Z or a to z), currency
character ($) or an underscore (_).
 After the first character, identifiers can have any combination of characters.
 A key word cannot be used as an identifier.
 Most importantly, identifiers are case sensitive.
 Examples of legal identifiers: age, $salary, _value, __1_value.
 Examples of illegal identifiers: 123abc, -salary.
Java Modifiers

Like other languages, it is possible to modify classes, methods,

etc., by using modifiers. There are two categories of modifiers −
 Access Modifiers − default, public , protected, private
 Non-access Modifiers − final, abstract, strictfp
Java Keywords
abstract assert boolean break
byte case catch char
class const continue default

do double else enum

extends final finally float
for goto if implements

import instanceof int interface

long native new package

private protected public return

short static strictfp super

switch synchronized this throw

throws transient try void

volatile while
File compilation and execution

 Save this file as MyFirstJavaProgram.java


javac
To compile write command
MyFirstJavaProgram.java in command prompt.
 To execute this file write command java
MyFirstJavaProgram in command prompt.
Compilation and Execution flow
JAVA Architecture
Step 1: Create a java source code with .java extension

Step 2: Compile the source code using java compiler, which will
create bytecode file with .class extension

Step 3: Class loader reads both the user defined and library classes
into the memory for execution
 Step 4: Bytecode verifier validates all the bytecodes are valid and
do not violate java’s security restrictions.

 Step 5: JVM reads bytecodes and translates into machine code for
execution. While execution of the program the code will interact to
the operating system and hardware.
5 phases of java programs

 Edit
 Compile
 Loading
 Verify
 Execute
JVM Architecture
How JVM Works
 Class Loader: The class loader reads the .class file and save the byte code in the method
area.
 Method Area: There is only one method area in a JVM which is shared among all the
classes. This holds the class level information of each .class file.
 Heap: Heap is a part of JVM memory where objects are allocated. JVM creates a Class object
for each .class file.
 Stack: Stack is a also a part of JVM memory but unlike Heap, it is used for storing temporary
variables.
 PC Registers: This keeps the track of which instruction has been executed and which one is
going to be executed. Since instructions are executed by threads, each thread has a
separate PC register.
 Native Method stack: A native method can access the runtime data areas of the virtual
machine.
 Native Method interface: It enables java code to call or be called by native applications.
Native applications are programs that are specific to the hardware and OS of a system.
 Garbage collection: A class instance is explicitly created by the java code and after use it
is automatically destroyed by garbage collection for memory management.
JVM Vs JRE Vs JDK
 Comments in Java

 Java supports single-line and multi-line comments very similar to C and C++. All characters
available inside any comment are ignored by Java compiler.
Example
public class MyFirstJavaProgram {
/* This is my first java program.
* This will print 'Hello World' as the output
* This is an example of multi-line comments.
*/
public static void main(String []args) {
// This is an example of single line comment
/* This is also an example of single line comment. */
System.out.println("Hello World"); } }
Output
Hello World
 JAVA Datatypes
 There are two data types available in Java −
Primitive Data Types
Reference/Object Data Types
 Primitive Data Types
 Java variables
There are three kinds of variables in Java −
 Local variables: Local variables are declared in methods, constructors, or
blocks. Local variables are created when the method, constructor or block is
entered and the variable will be destroyed once it exits the method,
constructor, or block.

 Instance variables: Instance variables are declared in a class, but outside

a method, constructor or any block.

 Class/Static variables: Class variables also known as static variables are

declared with the static keyword in a class, but outside a method,
constructor or a block. There would only be one copy of each class variable
per class, regardless of how many objects are created from it.
 Variables in Java

 To declare a variable follow this syntax: data_type variable_name = value;

Ex: int num;
char ch = 'A';
int number = 100;
 Types of Variables in Java
There are three types of variables in Java.
1) Local variable 2) Static (or class) variable 3) Instance variable
 Variables naming convention in java
1) Variables naming cannot contain white spaces, for example: int num ber = 100;
is invalid because the variable name has space in it.
2) Variable name can begin with special characters such as $ and _
3) As per the java coding standards the variable name should begin with a lower
case letter, for example int number; For lengthy variables names that has more
than one words do it like this: int smallNumber; int bigNumber; (start the second
word with capital letter).
4) Variable names are case sensitive in Java.
JAVA Operators
 Java provides a rich set of operators to manipulate variables. We can
divide all the Java operators into the following groups −
 Unary Operator,
 Arithmetic Operator,
 Shift Operator,
 Relational Operator,
 Bitwise Operator,
 Logical Operator,
 Ternary Operator and
 Assignment Operator.
Java Operator Precedence

Operator Type Category Precedence

Unary postfix expr++ expr--

prefix ++expr --expr +expr -expr ~ !

Arithmetic multiplicative */%

additive +-
Shift shift << >> >>>
Relational comparison < > <= >= instanceof

equality == !=
Bitwise bitwise AND &
bitwise exclusive OR ^

bitwise inclusive OR |

Logical logical AND &&

logical OR ||
Ternary ternary ?:
Assignment assignment = += -= *= /= %= &= ^= |= <<=
>>= >>>=
Operator examples
class OperatorExample{
public static void main(String args[]){
int a=10;
int b=10;
System.out.println(a++ + ++a);
System.out.println(b++ + b++);

}
}

Output: 22
21
class OperatorExample{
public static void main(String args[]){
int a=10;
int b=-10;
boolean c=true;
boolean d=false;
System.out.println(~a);
System.out.println(~b);
System.out.println(!c);
System.out.println(!d);
}}

Output:-11 (minus of total positive value which starts from 0)

9 (positive of total minus, positive starts from 0)
false (opposite of boolean value)
true
Arithmetic operator

class OperatorExample{
public static void main(String args[]){
System.out.println(10*10/5+3-1*4/2);
}}

Output: 21
Type Casting in Java
 Type casting is used to convert an object or variable of one type into
another.
 Syntax: dataType variableName = (dataType)
variableToConvert;
 There are two casting directions: narrowing (larger to smaller type)
and widening (smaller to larger type). Widening can be done
automatically (for example, int to double), but narrowing must be
done explicitly (like double to int).
 Widening or Automatic Type Conversion: Widening conversion
takes place when two data types are automatically converted. This
happens when:
1. The two data types are compatible.
2. When we assign value of a smaller data type to a
bigger data type.
 Example:
class Test
{
public static void main(String[] args)
{
int i = 100;
//automatic type conversion
long l = i;
//automatic type conversion
float f = l;
System.out.println("Int value "+i);
System.out.println("Long value "+l);
System.out.println("Float value "+f); } }
Output: Int value 100
Long value 100
Float value 100.0
 Narrowing or Explicit Conversion

 If we want to assign a value of larger data type to a smaller data type we perform
explicit type casting or narrowing.

 This is useful for incompatible data types where automatic conversion cannot be
done.
 Here, target-type specifies the desired type to convert the specified value to.
Example:
//Java program to illustrate incompatible data
// type for explicit type conversion
public class Test
{
public static void main(String[] argv)
{
char ch = 'c';
int num = 88;
ch = num;
}
}
Output:error: incompatible types: possible lossy conversion from int to
char
ch = num;
^
1 error
Explicit Conversion
//Java program to illustrate explicit type conversion
class Test
{ public static void main(String[] args)
{ double d = 100.04;
//explicit type casting
long l = (long)d;
//explicit type casting
int i = (int)l;
System.out.println("Double value "+d);
//fractional part lost
System.out.println("Long value "+l);
//fractional part lost
System.out.println("Int value "+i); } }

Output: Double value 100.04

Long value 100
Int value 100
 Control Statement
 If Statement:
//Java Program to demonstate the use of if statement.
public class IfExample {
public static void main(String[] args) {
//defining an 'age' variable
int age=20;
//checking the age
if(age>18){
System.out.print("Age is greater than 18");
} } }
Output: Age is greater than 18
 If-else statement
public class LeapYearExample {
public static void main(String[] args) {
int year=2020;
if(((year % 4 ==0) && (year % 100 !=0)) || (year % 400==0)){
System.out.println("LEAP YEAR");
}
else{
System.out.println("COMMON YEAR");
} } }

Output: LEAP YEAR

 If else-if Statement
public class PositiveNegativeExample {
public static void main(String[] args) {
int number=-13;
if(number>0){
System.out.println("POSITIVE");
}else if(number<0){
System.out.println("NEGATIVE");
}else{
System.out.println("ZERO");
}
}
}
Output: NEGATIVE
Switch statement
public class SwitchExample {
public static void main(String[] args) {
//Declaring a variable for switch expression
int number=20;
//Switch expression
switch(number){
//Case statements
case 10: System.out.println("10");
break;
case 20: System.out.println("20");
break;
case 30: System.out.println("30");
break;
//Default case statement
default:System.out.println("Not in 10, 20 or 30"); } } }
Output: 20
Java Break Statement

 When a break statement is encountered inside a loop, the loop is

immediately terminated and the program control resumes at the next
statement following the loop.

 The Java break is used to break loop or switch statement. It breaks

the current flow of the program at specified condition. In case of inner
loop, it breaks only inner loop.
For Loops

class ForLoopExample {
public static void main(String args[]){
for(int i=10; i>1; i--){
System.out.println("The value of i is: "+i);
}
}
}
Output: The value of i is: 10
The value of i is: 9
The value of i is: 8
The value of i is: 7
The value of i is: 6
The value of i is: 5
The value of i is: 4
The value of i is: 3
The value of i is: 2
For loop example to iterate an array:

Here we are iterating and displaying array elements using the for loop.

class ForLoopExample3 {
public static void main(String args[]){
int arr[]={2,11,45,9};
//i starts with 0 as array index starts with 0 too
for(int i=0; i<arr.length; i++){
System.out.println(arr[i]);
}
}
} Output: 2
11
45
9
 Enhanced For loop
 Enhanced for loop is useful when you want to iterate
Array/Collections, it is easy to write and understand.
class ForLoopExample3 {
public static void main(String args[]){
int arr[]={2,11,45,9};
for (int num : arr) {
System.out.println(num);
}
}
Output
} :2
11
45
9
Practice for loop

 Write a Java Program to find sum of natural numbers using for loop.
 Write a Java Program to find factorial of a number using loops.
 Write a Java Program to print Fibonacci Series using for loop.
 While Loop
class WhileLoopExample {
public static void main(String args[]){
int i=10;
while(i>1){
System.out.println(i);
i--;
} } }
Output:10

5
Practice while loop

 Write a Java Program to display Fibonacci Series using while loop.

 Write a Java Program to find factorial using while loop.
 Do-while statement
class DoWhileLoopExample {
public static void main(String args[]){
int i=10;
do{
System.out.println(i);
i--;
Output :10
}while(i>1); 9
} 8
7
} 6
5
4
3
2
 Continue Statement
 Continue statement is mostly used inside loops. Whenever it is
encountered inside a loop, control directly jumps to the beginning of the
loop for next iteration, skipping the execution of statements inside loop’s
body for the current iteration. This is particularly useful when you want to
continue the loop but do not want the rest of the statements(after
continue statement) in loop body to execute for that particular iteration.
public class ContinueExample {
public static void main(String args[]){
for (int j=0; j<=6; j++) {
if (j==4)
{
continue;
}
System.out.print(j+" "); } } }
Output: 0 1 2 3 5 6
Arrays

 An array is a collection of similar type of elements which have a

contiguous memory location.
 Java array is an object which contains elements of a similar data
type. Additionally, The elements of an array are stored in a
contiguous memory location. It is a data structure where we store
similar elements. We can store only a fixed set of elements in a Java
array.
 There are two types of array.

1. Single Dimensional Array

2. Multidimensional Array
Creating an array
 Creation of an array involves three steps:
1. Declaring the array.
2. Creating memory locations.
3. Putting values into the memory locations.
1. Syntax for declaring an one dimensional array
type var-name[];
OR
type[] var-name;
2. Creating memory locations.
Java allows us to create array using new operator only.
arrayname=new type[size];
The above statement does two things −
It creates an array using new type[Size].
It assigns the reference of the newly created array to the variable arrayname
Putting values into memory locations:
Type[] arrayname = {value0, value1, ..., valuek};
Example of array
/Java Program to illustrate how to declare, instantiate, initialize
//and traverse the Java array.
class Testarray{
public static void main(String args[]){
int a[]=new int[5];//declaration and instantiation
a[0]=10;//initialization
a[1]=20;
a[2]=70;
a[3]=40;
a[4]=50;
//traversing array
for(int i=0;i<a.length;i++)//length is the property of array Output:10
20
System.out.println(a[i]); 70
}} 40
50
Multidimensional Arrays

 Multidimensional arrays are arrays of arrays with each element of the

array holding the reference of other array. These are also known as
Jagged Arrays. A multidimensional array is created by appending one
set of square brackets ([]) per dimension. Examples:

 int[][] intArray = new int[10][20]; //a 2D array or matrix

 int[][][] intArray = new int[10][20][10]; //a 3D array
 class multiDimensional {
public static void main(String args[]) {
// declaring and initializing 2D array
int arr[][] = { {2,7,9},{3,6,1},{7,4,2} };
// printing 2D array
for (int i=0; i< 3 ; i++) {
for (int j=0; j < 3 ; j++)
System.out.print(arr[i][j] + " ");
System.out.println();
} }}
Output:

279
361
742
Passing Arrays to Methods
class Test {
// Driver method
public static void main(String args[])
{
int arr[] = {3, 1, 2, 5, 4};
// passing array to method m1
sum(arr); }
public static void sum(int[] arr) {
// getting sum of array values
int sum = 0;
for (int i = 0; i < arr.length; i++) Output: sum of array values : 15
sum+=arr[i];
System.out.println("sum of array values : " + sum); } }
 Returning Arrays from Methods
class Test {
// Driver method
public static void main(String args[])
{
int arr[] = m1();
for (int i = 0; i < arr.length; i++)
System.out.print(arr[i]+" "); }
public static int[] m1()
{ // returning array
return new int[]{1,2,3}; Output: 1 2 3

} }
Some methods use in Array

 length
 copyOf(original array, length)
 sort(array)
 reverse(array)
 copyOfRange(original array, from, to)
 equals(array1, array 2)
 fill(array , value)
 toString(array)
String

 string is basically an object that represents sequence of char values.

An array of characters works same as Java string. For example:
char[] ch={'j','a','v','a','t','p','o','i','n','t'};
String s=new String(ch);
is same as:
String s="javatpoint
There are two ways to create String object:
By string literal: String s="welcome";
By new keyword: String s=new String("Welcome")
 Example
public class StringExample{
public static void main(String args[]){
String s1="java";//creating string by java string literal
char ch[]={'s','t','r','i','n','g','s'};
String s2=new String(ch);//converting char array to string
String s3=new String("example");//creating java string by new keyword
System.out.println(s1);
System.out.println(s2);
System.out.println(s3);
Output: java
}}
strings
example
No. Method Description

1 char charAt(int index) returns char value for the particular index
2 int length() returns string length
3 static String format(String format, Object... args) returns a formatted string.

4 static String format(Locale l, String format, Object... args) returns formatted string with given locale.

5 String substring(int beginIndex) returns substring for given begin index.

6 String substring(int beginIndex, int endIndex) returns substring for given begin index and end index.

7 boolean contains(CharSequence s) returns true or false after matching the sequence of

char value.

8 static String join(CharSequence delimiter, CharSequence... elements) returns a joined string.

9 static String join(CharSequence delimiter, Iterable<? extends CharSequence> elements) returns a joined string.

10 boolean equals(Object another) checks the equality of string with the given object.

11 boolean isEmpty() checks if string is empty.

12 String concat(String str) concatenates the specified string.
13 String replace(char old, char new) replaces all occurrences of the specified char value.

14 String replace(CharSequence old, CharSequence new) replaces all occurrences of the specified
CharSequence.

15 static String equalsIgnoreCase(String another) compares another string. It doesn't check case.

16 String[] split(String regex) returns a split string matching regex.

17 String[] split(String regex, int limit) returns a split string matching regex and limit.

18 String intern() returns an interned string.

19 int indexOf(int ch) returns the specified char value index.

20 int indexOf(int ch, int fromIndex) returns the specified char value index starting with given index.

21 int indexOf(String substring) returns the specified substring index.

22 int indexOf(String substring, int fromIndex) returns the specified substring index starting with given index.

23 String toLowerCase() returns a string in lowercase.

24 String toLowerCase(Locale l) returns a string in lowercase using specified locale.

25 String toUpperCase() returns a string in uppercase.

26 String toUpperCase(Locale l) returns a string in uppercase using specified locale.

27 String trim() removes beginning and ending spaces of this string.

28 static String valueOf(int value) converts given type into string. It is an overloaded method.