Let's start with Java- Basic Concepts

 What is Java?
 Why Java?
 History of Java
 Versions of Java
 Features of Java
 Eclipse IDE
 First Java Program

 An Object Oriented Programming Language
 According to Sun, More Than 3 billion devices
run Java
 Applications use Java such as: Desktop
Applications like media players, web
applications like govt. websites, enterprise
applications like banking applications,
mobiles etc.
 Different Editions: J2SE, J2EE, J2ME etc.

CODING PROBLEM JAVA SOLUTION
Pointers References
Memory Management Garbage Collection
Error Handling Exception Handling
Complexity Reusable code in APIs
Platform dependent Portable code

 Developed by James Gosling and Sun
Microsystems in 1991
 Named as Oak language which was later
renamed as Java in 1995.
 Oak: Symbol of strength and name of
national tree of many countries.
 Java: Name of an island of Indonesia where
first coffee was produced (Java coffee)
 Now it’s subsidiary of Oracle.

1995
JDK Alpha &
Beta
1996
JDK 1.0
1997
JDK 1.1
1998
J2SE 1.2
2000
J2SE 1.3
2002
J2SE 1.4
2004
J2SE 5.0
2006
Java SE 6
2011
Java SE 7
2014
Java SE 8

Features of
Java
Simple
Object
Oriented
Platform
Independent
Portable
Secured
Robust
Architecture
Neutral
Interpreted
High
Performance
Multi-
Threaded

 An Integrated Development Environment
(IDE) for developing applications using Java,
C/C++, Python etc.
 Composed of plug-ins and designed to be
extensible using additional plug-ins.
 Developed in Java.
 Java Development Tools (JDT) provides a
plug-in that allows Eclipse to be used as a
Java IDE.

class MyFirstProgram
{
public static void main (String args[])
{
System.out.println(“I have just
started.”);
}
}
Compile: javac MyFirstProgram.java
Run/Execute: java MyFirstProgram

class MyFirstProgram //simple java program
{
/** @javadoc this would be documented in java
* @main this method is main method of class
*/
public static void main (String args[])
{
/*
This line won’t print on console because of multiline
comment block
*/
System.out.println(“I have just started.”);
}
}

 JVM, JRE and JDK
 Internal Architecture of JVM
 Naming Conventions
 Data Types
 Variables

 JVM:
 An abstract machine.
 Provides runtime environment in which java
byte code can be executed.
 JVM, JRE and JDK are platform dependent
because of the different configurations of
different OS
 But, Java is platform independent.
 Tasks Performed by JVM: Loads code, Verifies
code, Executes code

 JRE:
 An acronym for Java Runtime Environment.
 Contains set of libraries and other files that
JVM uses at runtime.

 JDK:
 An acronym for Java Development Kit.
 Contains JRE and development tools.

Loads class file
Per-class
structure
Runtime
data area Holds local variable
and partial results
Address of
instruction
currently being
executed
Native
methods used
in the
application

 Rule to follow as you decide what to name
your identifiers such as class, package,
variable, constant, method etc.
 Not forced to follow, that is why known as
convention not rule.
 Advantages:
 Make your code easier to read for yourself and
for other programmers.
 it takes less time to figure out what the code
does.

Identifier For Convention
Class / interface Should start with uppercase letter e.g. String,
Color, Math, MyFirstClass etc.
Method Should start with lowercase letter e.g.
actionPerformed(), setValue(), getParameter()
etc.
Variable Should start with lower case letter e.g.
orderNumber, productCode etc.
Package Should be in lowercase letter e.g. java, lang,
sql, etc.
Constants Should be in uppercase letter e.g. PI,
DEFAULT_VALUE, MAX etc.
NOTE: Java follows camel case syntax for naming convention. If name is
combined with two words, second word will start with uppercase letter
always.

Data types represent the different values to be stored in the variable.

Data Type Default Value Default Size
boolean False 1 bit
char ‘u0000’ 2 bytes
byte 0 1 byte
short 0 2 bytes
int 0 4 bytes
long 0L 8 bytes
float 0.0f 4 bytes
double 0.0d 8 bytes

 Name of reserved area allocation in memory.
 Combination of “vary” and “able” which
means its value can be changed
 Types:
 Local Variable
 Instance Variable
 Static Variable

 LOCAL VARIABLE:
 Variable declared inside a method
 INSTANCE VARIABLE:
 Variable declared inside a class but outside the
method. Represent object property.
 STATIC VARIABLE:
 Variable declared as static. Represents class
property.

 Unicode System
 Operators
 Command line arguments
 Control statements

 Universal International Standard Character
Encoding
 Capable of representing most of the world’s
written languages
 Other Coding Systems:
 ASCII
 ISO 8859-1
 Because of Unicode scheme Java uses 2 bytes
for char datatype.

 A symbol used to perform operations.
Operator Type Category Precedence
Unary Postfix expr++ expr--
Prefix ++expr –expr
Arithmetic Multiplicative * / %
Additive + -
Shift Shift << >> >>>
Relational Comparison < > <= >= instanceof
Equality == !=
Bitwise Bitwise AND &
Bitwise exclusive-OR ^
Bitwise inclusive-OR |

Operator Type Category Precedence
Logical Logical AND &&
Logical OR ||
Ternary Ternary ? :
Assignment Assignment = += -= *= /= %= &= ^=
|= <<= >>= >>>=

 If statement
 If-else statement
 Nested if statement
 If-else-if ladder statement
 Switch statement

 If statement:
if(condition)
{
// execute this block when condition is true
}
NOTE: Use where execution/output needed
only when condition meets.

 If-else statement:
if(condition)
{
// execute this block when condition is true
}
else
{
// execute this block when condition is false
}
NOTE: Use where execution/output must needed
irrespective of the condition.

 Nested-if statement:
if(condition1)
{
if(condition2)
{
// execute this block when condition1 and condition2 are true
}
else
{
// execute this block when condition1 is true
}
}
else
{
// execute when condition1 is false
}
NOTE: Use where nested conditions need to be checked to get the correct output.

 If-else-if ladder statement:
if(condition1)
{
}
else if(condition2)
{
}
else
{
// execute this block when conditions are false
}
NOTE: Use where multiple conditions need to be
checked in order to get the desired result.

 Switch statement:
switch(expression)
{
case value1:
// code to be executed
break; //optional
case value2:
break; //optional
…..
……
default:
}
NOTE: Use where code needs to be executed for one of the
possibilities from multiple possibilities.

 Loop statements
 Arrays
 OOPS Concepts

 There are three types of loop statements:
 For Loop
 While Loop
 Do-while Loop

 For Loop:
for(initialization; condition; increment/ decrement)
{
}
NOTE: Use this statement where number of
iterations are fixed/ known before.

 For Loop (enhanced):
for(Type var: array)
{
}
NOTE: Use this statement over arrays/
collections.

 For Loop (labelled):
labelname:
for(initialization; condition; increment/decrement)
{
}
NOTE: Use this statement where you have
nested loops and needs to break/continue
specific loop.

 While Loop:
while(condition)
{
}
iterations are not fixed/ known before.

 Do-While Loop:
do
{
} while(condition);
iterations are not fixed/ known before but
still you have to iterate at least once.

 Break statement in loops:
 Used to break loop or switch statement
 Breaks the current flow of the program at
specified condition.
 In case of inner loop, breaks only inner loop.
 Continue Statement in loops:
 Used to continue loop.
 Continues the current flow of the program and
skips the remaining code at specified position.
 In case of inner loop, continues only inner
loop.

 Collection of similar type of elements.
 Have contiguous memory location.
 Java array is an object, contains elements of
similar data type.
 Store only fixed set of elements.

 Pros:
 Code Optimization: retrieve or sort the data
easily.
 Random access: Get any data located at any
index position.
 Cons:
 Size Limit: Store only fixed no. of elements.
Doesn’t grow at runtime.

 Types of Arrays:
 Single Dimensional Array
 Multi-dimensional Array
 Single Dimensional Array:
 Declaration:
dataType[] array; or //preferred way
dataType []array; or
dataType array[];
 Instantiation:
array[]=new dataType[size];

 Multi-dimensional Array:
 Declaration:
dataType[][] array; or //preferred way
dataType [][]array; or
dataType array[][]; or
dataType []array[];
 Instantiation:
array[][]=new dataType[size][size];

 Object Oriented Programming is a paradigm
that provides many concepts like
polymorphism, encapsulation, inheritance
etc.
 Simula is considered as first Object-oriented
programming language.
 Smalltalk is considered as the first truly
Object-oriented programming language.

 Object Oriented Programming is a paradigm
to design program using objects and classes.
 Uses the following concepts:
 Object
 Class
 Inheritance
 Polymorphism
 Encapsulation
 Abstraction

 Object:
 Any entity that has state and behavior.
 For e.g. chair, pen, table, etc.
 Class:
 Collection of objects.
 Logical entity
 Inheritance:
 When one object acquires properties and behaviors of
parent object.
 Provides code reusability.
 Use to achieve runtime polymorphism.

 Polymorphism:
 When one task is performed by different ways.
 Two types: Compile-time and Run-time.
 Encapsulation:
 Binding (or wrapping) code and data together
into a single unit.
 Abstraction:
 Hiding internal details and showing functionality.

 Makes development and maintenance
easier.
 Provides data hiding.
 Provides ability to simulate real-world event
much more effectively.
NOTE: There is a difference between Object-
based language and Object-oriented
language. Object-based doesn’t follow all
the concepts of OOPS such as inheritance.

 Object & Classes
 Constructors

 Object:
 Physical as well as logical entity.
 Has state and behavior e.g. chair, table, pen etc.
 Main characteristics:
 State: represents data (value) of an object.
 Behavior: represents the behavior (functionality) of
an object such as play() etc.
 Identity: Implemented via a unique ID that is used by
JVM only. (not visible to external user)
 It is an instance of a class.
 Class acts as template or blueprint from which
objects are created.

 Object Definitions:
 A real world entity.
 A run time entity.
 An instance of a class.
 An entity which has state and behavior.

 Class:
 A group of objects which has common
properties.
 A template or blueprint from which objects are
created.
 Logical entity, not physical.
 A class in java can contain:
 Fields
 Methods
 Constructors
 Nested class and interface
 blocks

 Instance Variables:
 Variables which are created inside class but
outside the method.
 Don’t get the memory at compile time.
 Get memory at run time when object
(instance) is created.
 Methods:
 Methods are like functions i.e. used to expose
behavior of an object.
 Helps in code optimization and reusability.

 new Keyword:
 Use to allocate memory at run time.
 All objects get memory in Heap memory area.
 Methods:
 Methods are like functions i.e. used to expose
behavior of an object.
 Helps in code optimization and reusability.

 Examples:
class Customer{
int customerId; //field or data member or instance variable
String customerName;
public static void main(String args[]){
Customer customer=new Customer(); //creating an object of Customer
System.out.println(customer.customerId);
//accessing member through reference variable
System.out.println(customer.customerName);
}
}
Customer.java

 Examples:
class Customer{
int customerId; //field or data member or instance variable
String customerName;
}
class CustomerExample{
Customer customer=new Customer();
System.out.println(customer.customerId);
System.out.println(customer.customerName);
}
}
CustomerExample.java

 Initialization of object:
 By reference variable
 By method
 By constructor

 By reference variable:
class Student{
int studentId;
String studentName;
}
class StudentExample{
Student student=new Student();
student.studentId=1001;
student.studentName=“Ashu";
System.out.println(student.studentId+" "+student.studentName);
}
}

 By Method:
class Student{
int studentId;
String studentName;
void createRecord(int id, String name){
studentId=id; studentName=name;}
void displayRecord(){
System.out.println(student.studentId+" "+student.studentName);
}}
class StudentExample{
student.createRecord(2001,”Aakash”);
student.displayRecord();
}}

 By Constructor:
 Special type of method use in java to initialize the
objects.
 Invoked at the time of object creation.
 Rules for constructor:
 Constructor name must be same as its class name
 Constructor must have no explicit return type
 Types of constructor:
 Default Constructor
 Parameterized Constructor

 Default Constructor:
 Constructor that have no parameter. E.g.:
class Student{
Student(){System.out.println(" Student is created");}
}
}
NOTE: If there is no constructor explicitly defined in the
class, compiler automatically creates a default
constructor.

 Default Constructor:
class Student{
int id;
String name;
void display(){System.out.println(id+" "+name);}
Student student1=new Student();
Student student2=new Student();
student1.display();
student2.display();
}
}

 Parameterized Constructor:
 A constructor that have parameters.
class Student{
int studentId;
String studentName;
Student(int id,String name){
studentId = id;
studentName = name;
}
void display(){System.out.println(studentId+" "+studentName);}
Student student1=new Student(1001,”Ashu”);
Student student2=new Student(1002,”Aman”);
student1.display();
student2.display();
}
}

 Object and Class: Constructor
 Inheritance
 Aggregation
 Keywords: this, static, final, super

 Constructor Overloading:
 A class have number of constructors that differ in
parameter lists.
 Compiler differentiates them by taking into
account the number of parameters in the list and
their type.

 Constructor Overloading:
class Student{
int studentId; String studentName; int studentAge;
Student(int id, String name){
studentId = id; studentName = name;
}
Student(int id, String name, int age){
studentId = id; studentName = name; studentAge=age;
}
void display(){System.out.println(studentId+" "+(studentName+"
"+(studentAge);}
Student student1 = new Student(111,"Ashu");
Student student2 = new Student(222,"Aman",25);
student1.display(); student2.display();
} }

 Constructor v/s Method:
Constructor Method
Use to initialize the state of an
object.
Use to expose behavior of an
object.
Must not have return type. Must have return type.
Invoked implicitly. Invoked explicitly.
Java compiler provides a default
constructor if class don’t have any.
Not provided by compiler in any
case.
Name must be same as the class
name.
May or may not be same as class
name.

 Copy constructor:
class Student{
int studentId; String studentName;
Student(int id, String name){
studentId = id; studentName = name;
}
Student(Student student){
studentId = student .id; studentName = student .name;
}
void display(){System.out.println(studentId+" "+(studentName+"
"+(studentAge);}
Student student1 = new Student(111,"Ashu");
Student student2 = new Student(student1);
student1.display(); student2.display();
} }

 A mechanism in which one object acquires
properties and behaviors of parent
object.
 Represents IS-A relationship, also known
as parent-child relationship.
 Use for code reusability.

class subclass-name extends superclass-name
{
Methods and fields
}
 Extends keyword indicates that newly
defined class has been derived from an
existing class.
 “Extends” means “To increase the
functionality”.
 Class which is inherited called as parent or
super class
 Class which inherits called as child or sub
class.

 Class having an entity reference, known
as aggregation.
 Represents HAS-A relationship.
 Use for code reusability.

 this:
 Refers to the current object.
class Student{
int rollno; String name; float fee;
Student(int rollno,String name,float fee){
this.rollno=rollno; this.name=name; this.fee=fee;
}
void display(){System.out.println(rollno+" "+name+" "+fee);}
}
class ThisExample{
Student student1=new Student(1111,"ankit",9000f);
Student student2=new Student(1112,"sumit",8000f);
student1.display();
student2.display();
}}

 static:
 Used for memory management only.
 Can be applied on variables, methods,
blocks, and nested class.
 Static variable
 Can be used to refer the common properties of
all objects.
 Gets memory only once in class area at the
time of class loading.

 static:
 Static variable
class Student{
int rollno; String name; static float fee=5000f;
Student(int rollno,String name){
this.rollno=rollno;
this.name=name; }
}
class StaticExample{
Student student1=new Student(1111,"ankit”);
student1.display();
}}

 static:
 Static method
 Belongs to class rather than object of a class.
 Can be invoked without the need for creating an
instance of a class.
 Can access static data member and can change
the value of it.
 Can not use non-static data members or call non-
static method directly.
 this and super can not be used in static context.

 static:
 Static method
class Student{
int rollno; String name; static float fee=5000f;
Student(int rollno,String name){
this.rollno=rollno;
this.name=name; }
static void changeFee(){fee=9000f;}
}
class StaticExample{
Student student1=new Student(1111,"ankit”); student1.display();
Student.changeFee();
Student student2=new Student(1121,“Rajat”); student2.display();
}}

 static:
 Static block
 Use to initialize the static data member.
 Execute before main method at the time of class
loading.
class StaticBlockExample{
static{System.out.println("static block is invoked");}
System.out.println("Hello main");
}
}

 final:
 Use to restrict the user.
 Can be used on variable, method, and class.
NOTE:
 Constructor can not be final.
 Final methods can be inherited but can not be
overridden.
 Can declare blank final variable but that will be
initialized only by constructor.
JAVA FINAL KEYWORD
Stop value change
Stop method overriding
Stop inheritance

 super:
 Use to refer immediate parent class object.
 Can be used to refer immediate parent class instance
variables.
 Can be used to invoke immediate parent class method.
 Can be used to invoke immediate parent class
constructor.

 super:
class Animal{
String color="white"; }
class Dog extends Animal{
String color="black";
void printColor(){
System.out.println(color);//prints color of Dog class
System.out.println(super.color);//prints color of Animal class
}}
class SuperExample{
Dog d=new Dog();
d.printColor();
}}

 Polymorphism
 Abstraction
 Interfaces
 Abstract class v/s Interfaces

 Polymorphism
 “Poly+Morphs” Many+ Forms
 Ability of an object to take on many forms.
 A single action can be performed by many ways.
 Two Types:
 Compile Time Polymorphism or Method overloading
 Run Time Polymorphism or Method overriding

 Compile Time Polymorphism or Method overloading:
 A class having multiple methods having same name but
different in parameters.
 If you have to perform only one operation, having same
name of the methods increases the readability of the
program.
class Adder{
static int add(int a, int b){return a+b;}
static int add(int a, int b, int c){return a+b+c;}
}
class TestOverloading{
public static void main(String[] args){
System.out.println(Adder.add(11,11));
System.out.println(Adder.add(11,11,11));
}}

 Run Time Polymorphism or Method overriding:
 Subclass (child class) having the same method as declared in
the super class.
 In other words, subclass provides specific implementation of
the method that has been provided by one of its super class.
class Vehicle{
void run(){System.out.println("Vehicle is running");}
}
class Bike extends Vehicle{
void run(){System.out.println("Bike is running safely");}
Bike bike = new Bike();
bike.run();
}}

 Method Overloading v/s Method Overriding:
Method Overloading Method Overriding
Used to increase the readability of
the program.
Used to provide the specific
implementation of the method
that is already provided by parent
class.
Performed within class. Occurs in two classes having IS-A
(inheritance) relationship.
Parameters must be different. Parameters must be same.
Known as Compile-time
polymorphism
Known as run-time polymorphism.

 A process of hiding the implementation details and
showing only functionality to the user.
 It shows only the important things to the user and hides
the internal details.
 Lets you focus on what the object does instead of how it
does it.
 Two ways:
 Abstract Class (0%-100%)
 Interface (100%)

 Abstract class:
 A class declared with abstract keyword.
 It can have abstract and non-abstract methods.
 It needs to be extended and its methods need to be
implemented.
 If subclass is not implementing the abstract methods
of super class then it must be declared as abstract.
 It can not be instantiated.

 Abstract class:
abstract class Bike{
abstract void run();
}
class Honda extends Bike{
void run(){System.out.println("running safely..");}
Bike bike = new Honda();
bike.run();
}
}

 Abstract class:
abstract class Shape{ abstract void draw(); }
//In real scenario, implementation is provided by others i.e. unknown by end user
class Rectangle extends Shape{
void draw(){System.out.println("drawing rectangle");} }
class Circle extends Shape{
void draw(){System.out.println("drawing circle");} }
//In real scenario, method is called by programmer or user
class AbstractionExample{
Shape s=new Circle();
//In real scenario, object is provided through method e.g. getShape() method
s.draw(); s=new Rectangle();
s.draw();} }

 A mechanism to achieve abstraction.
 It is a blueprint of a class.
 It has static constants and abstract methods.
 Also represents IS-A relationship.
 Can be used to achieve multiple inheritance.
 Used to achieve loose coupling.

//Interface declaration: by first user
interface Drawable{
void draw(); }
//Implementation: by second user
class Rectangle implements Drawable{
public void draw(){System.out.println("drawing rectangle");} }
class Circle implements Drawable{
public void draw(){System.out.println("drawing circle");} }
//Using interface: by third user
class TestInterface{
Drawable drawShape=new Circle();
//In real scenario, object is provided by method e.g. getDrawable()
drawShape.draw();
}}

interface Drawable{
void draw();
static int cube(int x){return x*x*x;}
}
class Rectangle implements Drawable{
public void draw(){System.out.println("drawing
rectangle");}
}
class TestInterface{
Drawable drawShape=new Rectangle();
drawShape.draw();
System.out.println(Drawable.cube(3));
}}

Abstract class Interface
Can have abstract and non-abstract
methods.
Interface can have only abstract
methods. Since Java 8, it can have
default and static methods.
Doesn’t support multiple
inheritance.
Supports multiple inheritance.
Can have final, non-final, static
and non-static variables.
Can have only static and final
variables.
Can provide the implementation of
interfaces.
Can’t provide the implementation
of abstract class.
abstract keyword is used to
declare abstract class.
interface keyword is used to
declare interface.
Subclass uses extends keyword. Subclass uses implements
keyword.

 Packages
 Java modifiers

 A group of similar types of classes,
interfaces, and sub-packages.
 Used to categorize the classes and interfaces
so that they can be easily maintained.
 Provides access protection.
 Removes Naming collision.
 Can be categorized into two forms:
 Built-in package
 User-defined package

 User-defined package:
 package keyword is used to create a package in
java.
package mypack;
public class Simple{
System.out.println("Welcome to package");
}
}

 User-defined package:
 If you are not using IDE, follow the syntax below
to compile the package:
 javac –d directory javafilename
 javac –d . Simple.java
 -d swtich specifies the destination where to put
the generated class file.
 Use any directory name like /home etc.
 If you want to keep the package within the same
directory, you can use .(dot).
 To run the class, you have to use full qualified
name:
 java mypack.Simple

 Access package from another package:
 Three ways to access the package from outside
the package:
 import package.*;
 import package.classname;
 Fully qualified name.

 Using import package.* :
//save by Course.java
package university;
public class Course{
public void message(){System.out.println("Hello");} }
//save by Student.java
package college;
import university.*;
class Student{
Course course= new Course();
course.message();
} }

 Using import package.classname :
package university;
package college;
import university.Course;
class Student{
Course course= new Course();
course.message();
} }

 Using Fully qualified name:
package university;
package college;
class Student{
university.Course course= new university.Course();
course.message();
} }

 Subpackages:
 Package inside a package is called the
subpackage.
package com.learning.simple;
class Simple{
System.out.println("Hello subpackage");
}
}
Compile: javac –d . Simple.java
Run: java com.learning.simple.Simple

 Specifies accessibility (scope) of a data
member, method, constructor or class.
 Types:
 private
 default
 protected
 public

 Private Modifier:
 Accessible only within the class.
class Student{
private int id=40;
private void printMessage (){
System.out.println("Hello java");}
}
public class PrivateExample{
System.out.println(student.id);//Compile Time Error
student.printMessage();//Compile Time Error
}
} NOTE: A class can not be private or protected except nested
class.

 Default Modifier:
 Accessible only within the class.
package university;
class Course{
public void message(){ System.out.println("Hello");} }
package college;
class Student{
university.Course course= new university.Course(); //error
course.message(); //error
} }

 Protected Modifier:
 Accessible within package and outside the package through
inheritance only.
package university;
protected void message(){ System.out.println("Hello");} }
package college;
class Student extends Course{
Student student= new Student();
student.message();
} }

 Public Modifier:
 Accessible everywhere.
 It has widest scope among all.
package university;
protected void message(){ System.out.println("Hello");} }
package college;
class Student{
Course course=new Course();
course.message();
} }

 Process of wrapping code and data together
into a single unit.
 You can create a fully encapsulated class in
java by making all the data members of the
class private.
 Use setter and getter to set and get the data
in it.
 Java bean is an example
 Provides control over data

package com.college;
public class Student{
private String name;
public String getName(){
return name; }
public void setName(String name){
this.name=name ;
} }
package com.college;
class EncapsulationTest{
public static void main(String[] args){
student.setName("vijay");
System.out.println(student.getName());
} }

 In java, String is basically an object.
 Represents sequence of char values.
 Java String class provides a lot of methods to
perform operations on strings.
 Such as: length(), concat(), equals(), etc.
 The java.lang.String class implements
following interfaces:

 CharSequence interface is used to represent
sequence of characters.
 It is implemented by following classes to create
strings:
 The Java String is immutable i.e. it can not be
changed.
 Whenever we change any string, a new instance
is created.

 For mutable strings, use StringBuffer or
StringBuilder class.
 Two ways to create String object:
 By string literal
 By new keyword
 String Literal:
 String literal is created by using double quotes.
String example=“welcome”;

 String Literal:
 Each time you create a single literal, JVM checks
the string constant pool first.
 If the string already exist in the pool, a reference
to the pooled instance is returned.
 If string doesn’t exist in the pool, a new string
instance is created and placed in the pool.
String example1=“welcome”;
String example2=“welcome”;// will not create new instance

 By new Keyword:
 JVM will create a new string object in normal
(non pool) heap memory.
 The literal “welcome” will be placed in the string
constant pool.
 The variable example will refer to the object in
heap (non pool).
String example=new String(“welcome”);

 Immutable String:
 Immutable simply means unchangeable or
unmodifiable.
 Once string object is created, its state and data can’t
be changed but a new object is created.
class TestImmutableString{
String str="Sachin";
str.concat(" Tendulkar"); //concat() method appends the string at the end
System.out.println(str); //will print Sachin because strings are immutable
objects
}
}

 Immutable Strings:
 Why string objects are immutable?
 Java uses the concept of string literals
 Suppose there are 3 reference variables, all refer to
one object “Sachin”
 If one reference variable modifies the value of the
object, it will be affected to all the reference
variables.

 String Comparison:
 Strings can be compared on the basis of content
and reference.
 Three ways to compare string:
 Used for authentication (by equals() method)
 Used for sorting (by compareTo() method)
 Used for reference matching (by == operator)

 By equals() method:
 Compares the original content of the string.
 Compares values of string for equality.
 String class provides two methods:
 public boolean equals(Object object)
 Compares this string to the specified object.
 public boolean equalsIgnoreCase(String object)
 Compares this String to another string, ignoring
case.

 By equals() method:
class StringComparison{
String string1="Sachin";
String string2="SACHIN";
System.out.println(string1.equals(string2));//false
System.out.println(string1.equalsIgnoreCase(string2));
//true
}
}

 By compareTo() method:
 Compares values lexicographically and returns an
integer value that describes if first string is less,
equals or greater than second string.
 Suppose string1 and string2 are two string
variables, if:
 string1==string2 : 0
 string1<string2 : negative value
 string1>string2 : positive value

 By compareTo() method:
String string3="Ratan";
System.out.println(string1.compareTo(string2));//0
System.out.println(string1.compareTo(string3));
//1(because s1>s3)
System.out.println(string3.compareTo(string1));
//-1(because s3 < s1 )
}
}

 By == operator:
 It compares references not values.
String string3=new String("Sachin");;
System.out.println(string1==string2);//true
System.out.println(string1==string3); //false
}
}

 String concatenation:
 Concatenation forms a new string that is the
combination of multiple strings.
 Two ways to concatenate a string:
 By + operator
 By concat() method

 By + operator:
class StringConcatenation{
String str="Sachin"+" Tendulkar";
System.out.println(str);//Sachin Tendulkar
}}
 The java compiler transforms above code to this:
String str=(new StringBuilder()).append("Sachin").append(" Te
ndulkar).toString();
 String concatenation is implemented through the
StringBuilder (or StringBuffer) class and its append
method.

 By + operator:
String str=50+30+"Sachin"+40+40;
System.out.println(str);//80Sachin4040
}}
NOTE: After a string literal, all the + will be treated as string
concatenation operator.

 By concat() method:
 Concatenates the specified string to the end of
current string.
 public String concat(String object)
String string1="Sachin ";
String string2="Tendulkar";
String string3=string1.concat(string2);
System.out.println(string3);//Sachin Tendulkar
}
}

 Substring in Java:
 A part of string is called as substring.
 In other words, it is a subset of another string.
 In case of substring, startIndex is inclusive and
endIndex is exclusive.
 Methods:
 public String substring (int beginIndex)
 Returns substring of the given string from specified
beginIndex (inclusive)
 public String substring (int beginIndex, int endIndex)
 Returns substring of the given string from specified
beginIndex to endIndex (exclusive)

 Substring in Java:
public class TestSubstring{
String string1="SachinTendulkar";
System.out.println(string1.substring(6));//Tendulkar
System.out.println(string1.substring(0,6));//Sachin
}
}

 Commonly used string methods:
 toUpperCase():
 Converts the string into uppercase letters.
 toLowerCase():
 Converts the string into lowercase letters.
 trim():
 Eliminates white spaces before and after string.
 startsWith():
 Returns true if string starts with specified string.
 endsWith():
 Returns true if string ends with specified string.
 chartAt(int index):
 Returns a character at specified index.
 length():
 Returns the length of a string.

 StringBuffer class:
 Used to create mutable (changeable) string.
 Same as String class except it is mutable.
 Important Constructors:
 StringBuffer():
 Creates an empty string buffer with the initial
capacity of 16.
 StringBuffer(String str):
 Creates a string buffer with the specified string.
 StringBuffer(int capacity):
 Creates an empty string buffer with the specified
capacity as length.

 StringBuffer class-Commonly used methods:

 StringBuilder class:
 Used to create mutable (changeable) string.
 Same as StringBuffer class except it is non-synchronized.
 Important Constructors:
 StringBuilder():
 Creates an empty string builder with the initial
capacity of 16.
 StringBuilder(String str):
 Creates a string builder with the specified string.
 StringBuilder(int length):
 Creates an empty string builder with the specified
capacity as length.

 StringBuilder class-Methods:

 String v/s StringBuffer:
String StringBuffer
Immutable Mutable
Slow and consumes more memory
when you concat too many strings
because every time it creates new
instance
Fast and consumes less memory
Overrides equals() method of
Object class to compare the
content of two strings.
Doesn’t override the equals()
method of Object class.

 StringBuffer v/s StringBuilder:
StringBuffer StringBuilder
Synchronized i.e. thread safe. (two
threads can’t call the methods of
StringBuffer simultaneously)
Non-Synchronized i.e. not thread
safe. (two threads can call the
methods of StringBuilder
simultaneously)
Less efficient than StringBuilder More efficient than StringBuffer

 toString() method:
 When you want to represent any object as a
string, this method comes into existence.
 Returns the string representation of the object.
 If you print any object, compiler internally
invokes this method on the object.
 For desired output, you can override this
method.
 By overriding this method, you can return values
of an object, so don’t need to write much code.

class Student{
int rollno; String name; String city;
Student(int rollno, String name, String city){
this.rollno=rollno;
this.name=name;
this.city=city;
}
Student student=new Student(101,"Rajat","Delhi");
System.out.println(student);
//compiler writes here student.toString()
}
}

class Student{
int rollno; String name; String city;
Student(int rollno, String name, String city){
this.rollno=rollno; this.name=name; this.city=city; }
public String toString(){//overriding the toString()
method
return rollno+" "+name+" "+city;
}
Student student=new Student(101,"Rajat","Delhi");
System.out.println(student);
//compiler writes here student.toString()
}}

 Strings
 Exception Handling

 StringTokenizer class:
 java.util.StringTokenizer class allows you to
break strings into tokens.
 Constructors:

 StringTokenizer class-Methods:
NOTE: This class has been deprecated now.
Use split() method of String class or regular
expression.

 It is a mechanism to handle the run time errors
to maintain the normal flow of the application.
 Exception: an abnormal condition.
 In Java, It is an event that disrupts the normal
flow of the program.
 It is an object which is thrown at runtime.

 Possibilities of exception to occur in scenarios
like:
 A user has entered an invalid data.
 A file that needs to be opened can’t be found.
 A network connection has been lost in the middle
of communications or the JVM run out of
memory.
 Exceptions may be caused by user error,
others by programming error, and others by
physical resources that have failed in some
manner.

 Types of Exception:
 Checked Exception
 An exception that occurs at compile time.
 Can’t be simply ignored at the time of compilation.
 Programmer should take care of (handle) these.
import java.io.File;
import java.io.FileReader;
public class FilenotFoundDemo {
public static void main(String args[]) {
File file = new File("E://file.txt");
FileReader fr = new FileReader(file);
}
}

 Unchecked Exception
 An exception that occurs at execution time.
 Known as Runtime exception.
 Includes logical errors or improper use of an API.
public class UncheckedDemo {
public static void main(String args[]) {
int num[] = {1, 2, 3, 4};
System.out.println(num[5]);
}
}

 Error
 Not exception at all, but problems that arise beyond
the control of the user or programmer.
 Typically ignored in code because one can rarely do
anything about an error.
 For example, if a stack overflow occurs, an error will
arise.

 Keywords used in Exception Handling:
 try
 Catch
 finally
 throw
 throws

 Keywords used in Exception Handling:
 try
 try-block is used to enclose the code that might throw
an exception.
 Must be followed by either catch or finally block.
 catch
 Used to handle the exception
 Must be used after try block.
 Multiple catch blocks can be used with a single try
block

 Problem Without exception handling:
public class WithoutExceptionHandling{
int data=50/0;// throw exception
System.out.println("rest of the code...");
} }
 Solution by exception handling:
public class WithExceptionHandling{
try{
int data=50/0;
}catch(ArithmeticException e){System.out.println(e);}
}}

 Using multiple try-catch block:
try{
int a[]=new int[5]; a[5]=30/0;
}
catch(ArithmeticException e){System.out.println("task1 is
completed");}
catch(ArrayIndexOutOfBoundsException
e){System.out.println("task 2 completed");}
catch(Exception e){System.out.println("common task
completed");}
} }

 Using nested try block:
try{
try{
System.out.println("going to divide");
int b =39/0;
}catch(ArithmeticException e){System.out.println(e);}
try{
int a[]=new int[5];
a[5]=4;
}catch(ArrayIndexOutOfBoundsException e){System.out.println(e);}
System.out.println("other statement);
}catch(Exception e){System.out.println("handeled");}
System.out.println("normal flow..");
}}

 Keyword used in Exception Handling:
 finally:
 finally-block is used to execute important code such as
closing connection, stream etc.
 Always executed despite of the exception handled or
not.
 Follows try-catch block.
public class WithoutExceptionHandling{
try{
int data=25/0;
System.out.println(data); }
catch(ArithmeticException e){System.out.println(e);}
finally{System.out.println("finally block is always executed");}
} }

 throw:
 This keyword is used to explicitly throw an exception.
 Can throw either checked or unchecked exceptions.
 Mainly used to throw custom exception.
public class ExceptionHandling{
static void validate(int age){
if(age<18)
throw new ArithmeticException("not valid");
else
System.out.println("welcome to vote");
}
validate(13);
} }

 throws:
 Used to declare an exception.
 Gives an information to the programmer that an
exception may occur.
 It is better for the programmer to provide the
exception handling code to maintain the normal flow.
public class ExceptionHandling{
public static void main(String[] args) throws IOException{
FileWriter file = new FileWriter(“d:Data1.txt");
file.write("This is exception handling using throws keyword");
file.close();
}}

 Throw custom exception:
import java.io.*;
public class InsufficientFundsException extends
Exception {
private double amount;
public InsufficientFundsException(double amount) {
this.amount = amount; }
public double getAmount() {
return amount;
}}

import java.io.*;
public class CheckingAccount {
private double balance; private int number;
public CheckingAccount(int number)
{ this.number = number; }
public void deposit(double amount) { balance += amount; }
public void withdraw(double amount) throws
InsufficientFundsException {
if(amount <= balance) {balance -= amount; }
else { double needs = amount - balance;
throw new InsufficientFundsException(needs); }}
public double getBalance() { return balance; }
public int getNumber() { return number;}}

public class BankDemo {
public static void main(String [] args) {
CheckingAccount c = new CheckingAccount(101);
System.out.println("Depositing $500...");
c.deposit(500.00);
try {
System.out.println("nWithdrawing $100...");
c.withdraw(100.00);
System.out.println("nWithdrawing $600...");
c.withdraw(600.00);
}catch(InsufficientFundsException e) {
System.out.println("Sorry, but you are short $" +
e.getAmount());
e.printStackTrace();
}
}}

 throw v/s throws:
throw throws
This keyword is used to explicitly
throw an exception.
This keyword is used to declare an
exception.
Checked exception can not be
propagated using throw only.
Checked exception can be
propagated with throws.
Followed by an instance. Followed by class.
Used within the method. Used with the method signature.
Can’t throw multiple exceptions. Can declare multiple exceptions
e.g.
void pull() throws
NullPointerException, IOException

 Exception handling in case of method overriding:
 If the super class doesn’t declare an exception, sub class
overridden method can declare unchecked exception but can’t
declare checked exception.
 If the super class method declares an exception, sub class
overridden method can declare same, sub class exception or
no exception but can’t declare parent exception.

Let's start with Java- Basic Concepts

More Related Content

What's hot (20)

Similar to Let's start with Java- Basic Concepts (20)

Recently uploaded (20)

Let's start with Java- Basic Concepts