Object Oriented Programming using JAVA

22CS33 / Course
Course Code IPCC Credits L-T-P 3 - 0- 1
22IS33 type
Hours/week: L-T-P 3 - 0 - 2 Total credits 4
Total Contact L = 40Hrs; T = 0Hrs; P = 20Hrs
CIE Marks 100
Hours Total = 60Hrs
Flipped Classes
10 Hours SEE Marks 100
content

Required Knowledge of: Procedure Oriented Programming Languages

 Course Learning Objectives
1. To understand the fundamentals of object-oriented programming
and String class in Java.
2. To demonstrate the object-oriented features such as
encapsulation, inheritance and polymorphism to design and
develop programs in Java.
3. To understand exception handling mechanism supported in Java.
4. To learn to use the data structures to organize data in the
program using the collections framework in Java.
5. To understand the concept of Packages, Interfaces and Lambda
expressions in Java.
 Course Outcome (COs)
Learning Levels:
Re - Remember; Un - Understand; Ap - Apply; An - Analysis; Ev - Evaluate; Cr - Create
Learning
At the end of the course, the student will be able to PO(s) PSO(s)
Level
Explain classes, objects, members of a class and 1,2,3,9,10,12 1,3
1. relationships among them needed for a specific Un
problem.
Apply OOP principles (encapsulation, inheritance, 1,2,3,5,9,10,12 1,2,3
2. polymorphism etc.) and proper program structure to Ap
write application programs.
Develop skills in writing programs using exception 1,2,3,5,9,10,12 1,2,3
3. Ap
handling techniques.
Make use of the type hierarchy in the Collections 1,3,9,10,12 1,3
4. Ap
Framework and Lambda expressions.
Experiment with the concept of packages and 1,3,9,10,12 1,3
5. Ap
interfaces.
Scheme of Continuous Internal Evaluation (CIE):
For integrated courses, a lab test also will be conducted at the end of the semester. The lab test COMPULSORY) will be part of the CIE. No
SEE for Lab.
THEORY (60 marks) LAB (40 marks)
IA test Assignment (OBA/Lab Project/ Industry Total
IA test 2 Conduction Lab test
1 assignment)
25 25 marks 10 marks 15 marks 25 marks
marks 100 marks

IA Test:
1. No objective part in IA question paper
2. All questions descriptive
Conduct of Lab:
1. Conducting the experiment and journal: 5 marks
2. Calculations, results, graph, conclusion and Outcome: 5 marks
3. Viva voce: 5 marks
Lab test: (Batchwise with 15 students/batch)
1. Test will be conducted at the end of the semester
2. Timetable, Batch details and examiners will be declared by Exam section
3. Conducting the experiment and writing report: 5 marks
4. Calculations, results, graph and conclusion: 10 marks
5. Viva voce: 10 marks
Eligibility for SEE:
1. 40% and above (24 marks and above) in theory component
2. 40% and above (16 marks and above) in lab component
3. Lab test is COMPULSORY
4. Not eligible in any one of the two components will make the student Not Eligible for SEE
Scheme of Semester End Examination (SEE):
1. It will be conducted for 100 marks of 3 hours duration
2. Minimum marks required in SEE to pass: 40 out of 100
3. Question paper contains two questions from each unit each
carrying 20 marks. Students have to answer one full question
from each unit.
Unit – I Contact Hours = 8 Hours
• OOP Paradigm: The key attributes of object-oriented programming.
• Java basics: The Java language, JDK, arrays, multidimensional arrays,
alternative array declaration, assigning array references, using the
length member, the for-each loop.
• Introducing classes and objects: Class fundamentals, how objects are
created, reference variables and assignment, String class
OOP Paradigm: The key attributes of object-oriented programming
• Encapsulation: Encapsulation is a programming mechanism that binds together both code and
data it manipulates. When code and data are linked together an object is created. The data is not
accessible to outside world and only those methods which are wrapped in class can access it.
• The meaning of Encapsulation, is to make sure that "sensitive" data is hidden from users.
To achieve this, you must:
•declare class variables/attributes as private
•provide public get and set methods to access and update the value of a private variable
Example:
• Inheritance : In Java, it is possible to inherit attributes and methods from one
class to another. We group the "inheritance concept" into two categories:
• subclass (child) - the class that inherits from another class
• superclass (parent) - the class being inherited from
• To inherit a class ,use the extend keyword.
• Information Hiding: Hide methods or data should not
be easily accessible or restricted access.

• Polymorphism: Polymorphism means "many forms", or one

Interface multiple methods, and it occurs when we have many classes
that are related to each other by inheritance. Inheritance lets us inherit
attributes and methods from another class. Polymorphism uses those
methods to perform different tasks. This allows us to perform a single
action in different ways.
 Java basics: The Java language
• The Java was chosen for two primary reasons:
1st it is one of the worlds most widely used computer language.
2nd its features are designed and implemented in such a way that makes it easy to
demonstrate the foundations of programming.

• The Origin of Java

• Java’s Contribution to the Internet
• Java Applets
• Security
• Portability
• Java’s Solution :The Bytecode
• The Evolution of Java.
 The Origin of Java
Year Development
1991 Java was conceived by James Gosling& others @ Sun Microsystems in 1991 . It was
initially called “oak’’ by James Gosling. ’’. Oak was renamed “Java”.
Gosling and others began to work on portable ,cross-platform language that could run
on variety of CPU’s under different platform. The WWW (World Wide Web) appeared
on internet due to which Java programs were portable.

1993 Web applets(tiny programs) using the new language that could run on all the types of
computer connected to Internet.
1994 The team developed a Web browser called “Hot Java” to locate & run applet program
on Internet.

1995 Oak was renamed “Java

Java is an island of Indonesia where first coffee was produced.
1996 JDK(Java Development Kit) 1.0 released in January 23,1996.
• Java’s Contribution to the Internet: Java innovated a new type of networked program called applet,
but it had issues with the Internet I,e. Portability and security.

• Java Applets: Applet is a special type of a program that is embedded in the webpage to generate a
dynamic content .It runs inside the browser and works at client side.
Drawbacks :Applets presented a serious challenges interms of Security and Portability.

• Security : Every time when you download the “normal program ‘’ it may contain virus like Torjan
Horse or some harmful code which may cause damage to the system.
 Java achieved this protection by confining an applet to the Java execution environment and not
allowing it to access to other parts of the computer.

• Portability: Portability is a major aspect of the Internet because many different types of computer
and operating system are connected to it. When ever a program is downloaded it must be able to
run on that system. Therefore some means of generating portable executable code was needed.
Same mechanism that ensures security also helps create portability.
 • Java’s Solution :The Bytecode

• As soon as a Java program is compiled bytecode is generated.

• Bytecodes are non-runnable codes that rely on the availability of an interpreter, this is where JVM comes into
play.
• Byte code is a machine-level language code that runs on the JVM.
• Bytecode adds portability to Java which resonates with the saying, “write once, read anywhere”.
• JVM, loads, verifies and executes Java bytecode. It is known as the interpreter or the core of Java programming
language because it executes Java programming.
• The Evolution of Java: Java is a programming language that was first
released in 1995 by Sun Microsystems (now owned by Oracle).
• Since its initial release, Java has undergone several updates and
changes, with the most recent version being Java 15, which was
released in September 2020.
• Some of the major updates and changes to Java over the years include:
• Java 1.1 (1997): Introduced the event-delegation model for event handling, inner classes, and JavaBeans.
• Java 2 (1998): Included the introduction of the Java Standard Edition (J2SE) and the Java Enterprise Edition (J2EE).
• Java 5 (2004): Introduced generics, annotations, and the for-each loop.
• Java 7 (2011): Introduced the try-with-resources statement and the diamond operator for generic types.
• Java 8 (2014): Included the introduction of lambda expressions and functional interfaces, as well as the Streams API.
• Java 9 (2017): Included the introduction of the Java Platform Module System (JPMS), as well as improvements to the Java
shell (JShell) and the HTTP client.
• Java 10 (2018): Introduced local-variable type inference and additional improvements to the JPMS.
• Java 11 (2018): Java 11 was the first Long-term support release with a new release cycle, where Oracle releases a new
version every six months, and supports each release for three years. This release introduced the removal of the JavaEE
and CORBA modules, and the introduction of the HTTP client.
• Java 12 (2019), Java 13 (2019), Java 14 (2020) and Java 15 (2020) : These releases have introduced new features and
improvements such as new switch expressions, text blocks, and pattern matching for instanceof.
JDK: The Java Development Kit.
• The JDK (Java Development Kit) is a software development kit that develops
applications in Java
• The JDK provides two primary programs.
• First is javac which is a Java compiler which is used to compile java programs, it takes
.java file as input and produces bytecode.
• Following is the syntax of this command .It converts your source code into bytecode.
javac sample.java
• Second The java command is used to execute the bytecode of java. It takes byte code as
input and runs it and produces the output. Following is the syntax of this command.
java sample

• Note: The JDK runs in the command prompt environment and uses command line tools.
It is not a windowed application, It is also not an integrated development
environment(IDE).
A First Example
 A First Example:
 Every application begins with a class name and that class name must match the file name.
 Let us first create a Java file as Example.java that prints "Hello, World!" to the console:
public class Example {
public static void main(String[] args) {
System.out.println("Hello, World!");
}
}
 Every line of the code must be included inside the class.
 Java is case sensitive. i.e Example and example are different.
 The class begins with opening { and closing }braces. The elements between the two braces are members of
class.
 public static void main(String[] args) {
 The line starts with the public keyword which indicates access modifier.
 If class is private ,which prevents the members from being used by code defined outside of its class.
 The main method is the entry point of the program. It is where the program starts executing
 Main method has one parameter i.e String[] args, which declares the parameter named args. This is an array
of objects of type String. i.e args receives any command line arguments present when the program is
executed.
 System.out.println("Hello, World!");
The line outputs the string “Hello , World!” followed by new line on the
screen.
 System – is a predefined class that provides access to the system
 out– is an output stream that is connected to the console.
 println—displays the string.
Converting Gallons to Liters

Explanation:The program begins by declaring a variable gallons and assigning a value of 5 to it .

• The program then performs the conversion by multiplying the number of gallons by the conversion
factor (3.78541) and storing the result in the variable liters..
• Finally, the program prints the result of the conversion to the console using the System.out.println
method .
Here is a program in Java that converts gallons to liters using scanner class.
Explanation:
• The program begins by importing the Scanner
class from the java.util package, which is used to
read input from the user.
• In the main method, a Scanner object is created
and assigned to the variable sc.
• The program then prompts the user to enter the
number of gallons using the System.out.print
method.
• The nextDouble method of the Scanner class is
used to read the user's input and store it in the
variable gallons.
• The program then performs the conversion by
multiplying the number of gallons by the
conversion factor (3.78541) and storing the
result in the variable liters.
• Finally, the program prints the result of the
conversion to the console using the
System.out.println method.
.

WAP in Java to find the largest of 3 numbers

• The program begins by declaring three variables
num1, num2, num3 and assigning values 10, 20,
30 to them respectively.

• The program then declares a variable largest and

assigns the value of num1 to it.

• The program then uses an if-else statement to

check if num2 is greater than largest. If it is, then
the value of num2 is assigned to largest

• The program then uses another if-else

statement to check if num3 is greater than largest. If
it is, then the value of num3 is assigned to largest.

• Finally, the program prints the largest number using

the System.out.println method.

• When you run this program, it will display the largest

number among num1, num2 and num3 which are
assigned in the program.
Find the largest of 3 numbers using scanner class

In this program, we are

using a scanner object to
take input from the user for
three numbers. Then using
if-else statement to find the
largest of three numbers
and print the largest
number.
 Arrays
• In Java, an array is an object which is a collection of elements of the same data
type. The elements of an array are stored in contiguous memory locations, and
each element can be accessed by its index.
• Additionally, It is a data structure where we store similar elements. We can store
only a fixed set of elements in a Java array.
• Array in Java is index-based, the first element of the array is stored at the 0th index,
2nd element is stored on 1st index and so on.
• We can store primitive values or objects in an array in Java. Like C/C++, we can
also create single-dimensional or multidimensional arrays in Java.
Advantages
•Code Optimization: It makes the code optimized, we can
retrieve or sort the data efficiently.
•Random access: We can get any data located at an index
position.

Disadvantages
•Size Limit: We can store only the fixed size of elements in the
array. It doesn't grow its size at runtime. To solve this problem,
a collection framework is used in Java which grows
automatically.
One Dimensional Array
Syntax to Declare an Array in Java
datatype arrayName[] = new datatype[size];
dataType[] arr; (or)
dataType []arr; (or)
dataType arr[];
• datatype: is the type of the elements that we want to enter in
the array, like int, float, double, etc.
• arrayName: is an identifier.
• new: is a keyword that creates an instance in the memory.
• size: is the length of the array.
// Declaring an array example
int[] myArray;
Instantiation of an Array in Java
arrayRefVar=new datatype[size];
// Initializing an array
myArray = new int[5];
Example of Java 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
• System.out.println(a[i]);
• }}
//Let's create a program that takes a single-dimensional array as input
import java.util.Scanner;
public class scanne1 {
public static void main(String[] args) {
int n;
Scanner sc= new Scanner(System.in);
System.out.println("Enter how many elements you want to store");
n=sc.nextInt(); //The nextInt() method scans the next token of the input data as an “int”.
int[] array =new int[10];
System.out.println("Enter the elements of array");
for(int i=0;i<n;i++){
array[i]= sc.nextInt();
}
System.out.println("Array elements are");
for(int i=0;i<n;i++)
{
System.out.println(array[i]);
}
}
}
 Find the minimum and maximum value in an array
import java.util.Scanner;
public class MinMax { min=max=nums[0];
public static void main (String[] args) { for (int i=1;i<n;i++) {
if(nums[i]<min)
int[] nums=new int[10];
min=nums[i];
int min , max , n; if(nums[i]>max)
Scanner sc = new Scanner(System.in); max=nums[i]; }
System.out.println("Min And
System.out.println("Enter the number of elements you want Max=" + min + " " + max); } }
to store: ");
n= sc.nextInt();
System.out.println("Enter the elements of the array: ");
for(int i=0;i<n ; i++)
nums[i]=sc.nextInt();
System.out.println("Array elements are: ");
for(int i=0 ; i<n ; i++) {
System.out.println(nums[i]); }
Find minimum and maximum to from array without using scanner function.
• Array boundaries are strictly enforced in Java.
• It is run time error to over run or under run an array.
• For example demonstration of ARRAY OVERRUN
class ArrayErr{
public static void main(String[] args) {
int[] sample =new int[10];
int i;
// generate an array over run
for(i=0;i<100;i++)
sample[i]= i; }
}
As soon as i reaches 10, an ArrayIndexOutOfBoundsException is generated
and the program is terminated.
Sorting an Array using Bubble sort.
 public static int binarySearch(int[] arr, int target) {
public static void main(String[] args) {
int left = 0;
int[] myArray = {1, 2, 3, 4, 5, 6, 7, 8, 9}; int right = arr.length - 1;
int target = 6; while (left <= right) {
int mid = left + (right - left) / 2;
int result = binarySearch(myArray, target);
if (arr[mid] == target) {
if (result == -1) { return mid;
System.out.println("Element not found"); }
} else if (arr[mid] < target) {
left = mid + 1;
{ } else {
System.out.println("Element found at right = mid - 1;
index: " + result); }
} }
return -1;
}
}
}
Multidimensional Array
• In Java, a multidimensional array is an array of arrays. It can be used to
represent a table with rows and columns, or a matrix, or a grid.

• Example of how to declare and initialize a two-dimensional array in Java

int[][] myArray = new int[3][3];
• This creates a 2-dimensional array with 3 rows and 3 columns. Each
element of the array is initialized with the default value for the int data
type, which is 0.
Syntax to Declare and Initialize a two-dimensional array :
int[][] myArray = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
• In this example, the array named "myArray" is being declared as a 2-
dimensional array of integers, and it is being initialized with the values 1, 2,
3, 4, 5, 6, 7, 8, 9.
Assigning array references
• In Java, arrays are objects that store multiple values of the same data type. You can
create an array by specifying the type of data it will hold, followed by square
brackets and the name of the array. For example, to create an array of integers
called "numbers", you would use the following syntax:
• int[] numbers;

• You can also initialize an array when you create it by specifying its size and the
values it will hold. For example:
• int[] numbers = {1, 2, 3, 4, 5};

• Once you have an array, you can access its elements by using the array name
followed by the index of the element in square brackets. For example:
• System.out.println(numbers[0]); // prints 1
 • You can also assign new values to specific elements of an array using
the same syntax:
• numbers[0] = 10;
• You can also create a reference to an array using the same syntax.
• int[] numbers = {1, 2, 3, 4, 5};
• int[] copy = numbers;

.
Using the length member
length is an instance variable that contains the size of array.
int myArray = [1, 2, 3, 4, 5];
console.log(myArray.length); // Output: 5
// console.log() is a function in JavaScript that is used to print or output data to the
console.
Example:
int[ ] a={10,20,30,40,50};
int len = a.length //get the size of array.
system.out.println(len); //outputs 5
for-each loop
• In Java, the for loop and the for-each loop (also known as the enhanced for loop) are both used to
iterate over the elements of an array or any other iterable object. However, they work slightly
differently and have different use cases.
• A traditional for loop uses an index variable to iterate over the elements of an array. Here is an
example of a for loop that iterates over the elements of an int array
• The syntax for a for each loop (also known as a "for each" loop) is as follows:

for (type variable : collection) {

// code to be executed
}

•‘type’ is the data type of the items in the collection.

•‘variable’ is the variable that will be assigned the value of each item in the collection, one at a
time.
•‘collection ‘ is the collection of items over which the loop will iterate. This could be an array, a
list, a set, or any other type of collection.
• For example, the following for each loop iterates over an array of integers and
prints each value:
• int[ ] numbers = {1, 2, 3, 4, 5};
• for (int num : numbers) {
• System.out.println(num); }

• //The output would be

• 1
• 2
• 3
• 4
• 5
• It's important to note that the for-each loop is used for only iterating over elements
of an array or collections, it can't be used to iterate over the range of integers or
anything like that.
Q. Write a program to add sum of array using for-each loop.

public class ForEach {

public static void main(String[] args) {
int [] nums={1,2,3,4,5,6,7,8,9,10};
int sum=0;
//use for each loop to display and sum the value.
for(int x:nums){
System.out.println(x);
sum=sum+x;
}
System.out.println("Summation =" +sum);
}
}
• Write a Java program display a pattern as shown below using a looping
structure.
1
22
333
4444
55555
• Define the process of building and running Java program. And write a
Java program to accept a number and check whether it is prime or
not.
 Introducing classes and objects
[access modifier] class ClassName {
// declare instance variables
type var1;
type var2;
//……
// declare methods
type method1(parameters) {
//body of method }
type method2(parameters) {
//body of method2 }
}
‘access modifier’: Specifies the accessibility of the class, such as public, private, or protected. If no access
modifier is specified, the class is given default access (accessible within the same package).
‘class’: The keyword used to declare a class in Java.
‘ClassName’: The name of the class, which should begin with a capital letter and follow camel case naming
conventions.
‘{ }’: The curly braces that enclose the class body, where fields and methods are defined.
class Vehicle{
int passengers;
int fulecap;
int mpg;
}
//to create an object
Vehicle minivan=new Vehicle(); // create an Vehicle object called minivan
The general form of the dot operator is
Object.member
Ex: minivan.fulecap=16;
/*program that uses the vehicle class*/
class Vehicle{
int passengers;
int fulecap;
int mpg;
}
Class VehicleDemo{
public static void main(String[] args){
Vehicle minivan= new Vehicle();
int range;
minivan.passangers=7;
minivan.fulecap=16;
minivan.mpg=21;
//compute the range assuming full tank of gas
range= minivan.fulecap*minivan.mpg;
System.out.println(“Minivan can carry”+minivan.passangers+ ”with a range of “+range);
 How objects are created,
In Java, objects are created using the new keyword, followed by the constructor of the class.
The general syntax for creating an object is as follows:
ClassName objectName = new ClassName(parameters);

• ‘className’ is the name of the class.

• ‘objectName’ is the name of the object (variable) that refers to the created object.
• ‘new ClassName(parameters)’ is a call to the constructor of the class, passing in any necessary parameters.

For example, using the Student class that I provided in the previous response, we can create an object of the class
as follows:

Student student1 = new Student("John",20,"Computer Science");

Once an object is created, we can call its methods or access its fields using the dot (.) operator.

The general form of the dot operator is

Object.member

For example,
System.out.println(student1.getName());
Reference variables and assignment
• In Java, when a variable is assigned the value of an object, it is actually assigned a
reference to that object. This means that the variable holds a memory address that
points to the location of the object in memory.

• Vehicle car1= new Vehicle();

• Vehicle car2=car1; //However, since both “car1" and “car2" are reference variables, they both
hold the same memory address, which points to the same object in memory.
car1.mpg=26;
System.out.println(car1.mpg);
System.out.println(car2.mpg);
Both display the same value 26.

For example:
Vehicle car1=new vehicle();
Vehicle car2=car1;
Vehicle car3=new vehicle();
Car2=car3;// now car2 and car3 refer to the same object, but object referred by car1 is unchanged
Methods
• Methods are the subroutines that manipulates the data defined by the class and in many cases
control access to that data.
• main() is reserved for the method that begins execution of the program.
• The general form is as shown here:
return-type name(parameter list)
{
//body of method
}
 STRINGS
• In Java, strings are objects of the String class, which is part of the Java standard library. They are used to
represent text and are commonly used in Java programs.
Constructing Strings: by using new keyword and calling a string constructor
For example:
String str1 = "Hello World";
String str2 = new String("Hello World");
char[] charArray = {'H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd'};
String str3 = new String(charArray);

• Once a String object is created, you can perform various operations on it such as:
• Concatenation using the "+" operator or the concat() method
• Comparison using the equals() method or the "==" operator
• Finding the length of a string using the length() method
• Extracting a substring using the substring() method
• Replacing part of a string using the replace() method
• Converting to lowercase or uppercase using the toLowerCase() or toUpperCase() method
• etc.
• Few examples are:
String str1 = "Hello";
String str2 = "World";
String str3 = str1 + " " + str2; // "Hello World"
System.out.println(str1.length()); // 5
System.out.println(str3.substring(0, 5)); // "Hello"
System.out.println(str3.toUpperCase()); // "HELLO WORLD"
No. Method Description
1 char charAt(int index) It returns char value for the particular index

2 int length() It returns string length

3 boolean equals(str) It checks the equality of string with the given string.
4 boolean isEmpty() It checks if string is empty.
5 String concat(String str) It concatenates the specified string.

7 int compare To(str) Returns less than 0 if the invoking string is less than str, greater than zero if the
invoking string is greater than str, and zero if the string are equal.
8 int indexOf(str) Searches the invoking string for the substring specified by str. Returns the index of
the first match or -1 on failure.
 Program on String Operations
public class StrOps {
public static void main(String[] args) {
String str1="when it comes to web programming ,java
if(result== 0)
is 1"; System.out.println("string1
String str2 =new String(str1); and 3 are equal");
String str3="Java strings are powerfull";
else if(result<0)
System.out.println("string1
int result,idx;
is less than string3");
char ch;
else
System.out.println("length of str1 " + str1.length()); System.out.println("string1
//display str1 , one character at a time is greater than string3");
for(int i=0;i<str1.length();i++) //assign a new string to str2
System.out.print(str1.charAt(i)); str2="One Two Three One";
System.out.println(); idx=str2.indexOf("one");
System.out.println("Index of
if(str1.equals(str2))
first occurance of One:" +idx);
System.out.println("str1 equals str2");
idx=str2.lastIndexOf("one");
else System.out.println("Index of
System.out.println("str1 does not equals str2"); first occurance of One:" +idx);
if(str1.equals(str3)) }
System.out.println("string1 equals string3"); }
 Output:

• Length of str1: 45
• when it comes to web programming ,java is 1
• str1 equals str2
• string1 does not equals string3
• string1 is greater than string3
• Index of first occurance of One: 0
• Index of first occurance of One: 14
Arrays Of Strings
• Like any other data type strings can be assembled into arrays.
For example:
• public class StringArrays {
• public static void main(String[] args) {
OutPut:
• String[] strs={"This" , "is" , "a" , "test."};
• System.out.println("Original array"); Original array
• for (String s:strs) This is a test.
• System.out.print(s + " ");
• System.out.println("\n"); Modified array:
• //change a string in the array This was a test,too !
• strs[1]="was";
• strs[3]="test,too !";
• System.out.println("Modified array:");
• for (String s:strs)
• System.out.print(s + " "); } }
Strings are Immutable
• Java, strings are immutable, meaning their value cannot be changed
once they are created.
• This means that any operations that appear to change the value of a
string, such as concatenation or replacement, will actually create a
new string object with the modified value.
• This can have an impact on performance and memory usage, as
multiple copies of the same string may exist in memory.
• However, it also provides a level of security and consistency, as the
original string remains unchanged and any changes can be tracked
and controlled.
Using a string to control a switch statement
• A string can be used to control a switch statement in Java by using the string as the
expression in the switch statement. For example, here is a sample switch statement
that uses a string variable called "input" to control the flow of the program:

• Here the string contained in input

and it is tested against the case
constants.
• When a match is found the code
sequence associated with that string
is executed.
• Explain the following terms with respect to string in JAVA.
charAt()
indexOf()
compareTo()
toCharArray()
toLowerCase()
• What is the difference between a class and an object? How is class
defined in JAVA? Write a Java program to define a class called
myTriangle to model a triangle geometrical object with three sides.
Include functions to:
• Initialize the three sides of triangle.
• Compute and return the area of the triangle.
• Define constructor. And demonstrate the concept of constructor
overloading with an example