OOPDP MODULE II
Control Statements, Methods and Arrays
Basic selection statements, Iterative constructs,
Relative and Logical operators, break, continue,
Module II- Methods, static methods, parameter passing,
argument promotion and casting, scopes, method
Syllabus overloading. Arrays and ArrayList in Java,
Enhanced for statement, Passing arrays to
methods, Multidimensional arrays, Using command
line arguments.
JAVA CONTROL STATEMENTS
The Java if statement is used to test the condition.
It checks boolean condition: true or false.
There are various types of if statement in Java.
Java If-else if statement
if-else statement
Statement if-else-if ladder
nested if statement
The Java switch statement executes one statement
from multiple conditions.
It is like if-else-if ladder statement.
The switch statement works with byte, short, int, long,
enum types,
String and some wrapper types like Byte, Short, Int, and
Java Long.
Switch Since Java 7, you can use strings in the switch
statement.
Statement In other words, the switch statement tests the equality of
a variable against multiple values.
public class SwitchStringExample {
public static void main(String[] args) {
String levelString="Expert";
int level=0;
switch(levelString){
//Using String Literal in Switch case
case "Beginner": level=1;
break;
case "Intermediate": level=2;
Example break;
case "Expert": level=3;
break;
default: level=0;
break;
}
System.out.println("Your Level is: "+level);
}
}
Output
Your Level is: 3
In programming languages, loops are used to execute
a set of instructions/functions repeatedly when some
conditions become true.
There are three types of loops in Java.
Java Loops 1. for loop
2. while loop
3. do-while loop
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.
Loop Java Continue Statement
Control The continue statement is used in loop control structure
Statements when you need to jump to the next iteration of the loop
immediately.
Static Methods in Java
When a method is static, it is really part of the class
and not part of the individual objects in the class.
It means that static methods exist even before
creating any objects.
The best example of a static method is
the main() method.
Properties of Static Function
• It can access only static members.
• It can be called without an instance.
• It is not associated with the object.
• Non-static data members cannot be accessed by the static
function.
class Demo
{
//non-static function
void display()
{
System.out.println("A non-static function is called.");
}
Example1 //static function
static void show()
{
System.out.println("The static function is called.");
}
}
public class Main
{
public static void main(String args[])
{
//creating an object of the class A
Demo obj = new Demo();
obj.display();
Demo.show();
}
}
Output:
A non-static function is called.
The static function is called.
public class Test
{ //instance var
public int instanceVariable = 10;
public static void main(String args[])
//static method
{
Example2
Test test = new Test();
System.out.println(test.instanceVariable);
}
}
Output
10
Method Overloading
If a class has multiple methods having
same name but different in
parameters, it is known as Method
Overloading.
There are two ways to overload the
method in java
By changing number By changing the
of arguments data type
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;}
}
Example: class TestOverloading1{
Changing public static void main(String[] args){
no. of System.out.println(Adder.add(11,11));
arguments System.out.println(Adder.add(11,11,11));
}}
Output:
22
33
class Adder{
static int add(int a, int b)
{return a+b;}
static double add(double a, double b)
{return a+b;}
}
Example: class TestOverloading2{
Changing public static void main(String[] args){
Data Type System.out.println(Adder.add(11,11));
System.out.println(Adder.add(12.3,12.6));
}}
Output:
22
24.9
Parameter Passing Techniques in Java
Important methods of Parameter Passing
Pass by Value
Any modifications to the formal parameter variable inside the called
function or method affect only the separate storage location and will not
be reflected in the actual parameter in the calling environment.
Pass by reference
Any changes to the formal parameter are reflected in the actual
parameter in the calling environment as formal parameter receives a
reference (or address) to the actual data.
class CallByValue {
// Function to change the value
// of the parameters
public void Example(int x, int y)
Pass by
{
x++;
Value y++;
}
}
public class Main {
public static void main(String[] args)
{
int a = 10;
int b = 20;
CallByValue object = new CallByValue();
System.out.println("Value of a: " + a + " & b: " + b);
object.Example(a, b);
System.out.println("Value of a: "+ a + " & b: " + b);
}
}
Output:
Value of a: 10 & b: 20
Value of a: 10 & b: 20
class CallByReference {
int a, b;
CallByReference(int x, int y)
{
a = x;
b = y;
}
Call by void ChangeValue(CallByReference obj)
Reference {
obj.a += 10;
obj.b += 20;
}
}
public class Main {
public static void main(String[] args)
{
CallByReference object = new CallByReference(10, 20);
System.out.println("Value of a: " +object.a + " & b: "+
object.b);
object.ChangeValue(object);
System.out.println("Value of a: "+ object.a + " & b: "+
object.b);
}
}
Output
Value of a: 10 & b: 20
Value of a: 20 & b: 40
Argument Promotion and Casting
An important feature of method calls in java is argument
promotion.
Converting an argument's value to the type that the
method expects to receive in its corresponding
parameter.
Argument
For example, a program can call Math method sqrt with
promotion an integer argument even though the method expects
to receive a double argument (but, as we will soon see,
not vice versa).
Attempting these conversions may lead to compilation
errors if Java's promotion rules are not satisfied.
Promotions
allowed for
primitive types
In cases where information may be lost due to
conversion, the Java compiler requires the programmer
to use a cast operator (introduced in ) to explicitly force
the conversion to occur ,otherwise a compilation error
occurs.
This enables the programmer to "take control" from the
Casting compiler.
The programmer essentially says, "I know this conversion
might cause loss of information, but for my purposes
here, that's fine."
public class Main
{
void display(double a)
{
System.out.println(a);
}
void show(int b)
{
System.out.println(b);
Example }
public static void main(String[] args) {
Main ob=new Main();
ob.display(4); //promotion
ob.show((int)5.0); //casting
}
}
Output
4.0
5
Scope of Variables In Java
Scope of a variable is the part of the program where the
variable is accessible.
ava programs are organized in the form of classes. Every
class is part of some package.
Java scope rules can be covered under following
categories.
Class Level
Method Level
Block Level
We can declare class variables anywhere in class, but
outside methods.
Access specified of member variables doesn’t affect
scope of them within a class.
The scope of Member variables can be defined using
Class Level the available access modifiers
Scope
Public
Private
Protected
Default
Understanding
Java Access
Modifiers
Variables declared inside a method have method level
scope and can’t be accessed outside the method.
public class Test
{
void method1()
Method {
Level Scope // Local variable (Method level scope)
int x;
}
}
A variable declared inside pair of brackets “{” and “}” in
a method has scope within the brackets only.
Block Scope
public class Main
{
public static void main(String[] args) {
System.out.println("Start");
{
int x=10;
System.out.println(x);
Example
}
//System.out.println(x);generate error if removes
comment
System.out.println("End");
}
}
Output
Start
10
End
Arrays and Array List in Java
An array is a group of like-typed variables that are
referred to by a common name.
Arrays in Java work differently than they do in C/C++.
Following are some important points about Java arrays.
Since arrays are objects in Java, we can find their length
using the object property length.
Array A Java array variable can also be declared like other
variables with [] after the data type.
The variables in the array are ordered and each have an
index beginning from 0.
Java array can be also be used as a static field, a local
variable or a method parameter.
The size of an array must be specified by an int or short
value and not long.
An array declaration has two components: the type
and the name.
int intArray[];
or int[] intArray;
Declaration Although the first declaration above establishes the fact
that intArray is an array variable, no actual array exists.
It merely tells the compiler that this variable (intArray)
will hold an array of the integer type.
When an array is declared, only a reference of array is
created.
To actually give memory to array, you create an array
like this:
The general form of new as it applies to one-dimensional
arrays appears as follows:
var-name = new type [size];
Instantiation int intArray[]; //declaring array
intArray = new int[20]; // allocating memory to
array
Or
int[] intArray = new int[20]; // combining both
statements in one
public class Main
{
public static void main(String[] args) {
int[] intArray = new int[]{ 1,2,3,4,5,6,7,8,9,10 };
String[] cars = {"Volvo", "BMW", "Ford", "Mazda"};
System.out.println(intArray[2]);
System.out.println(cars[2]);
Example
}
}
Output
3
Ford
Multidimensional A multidimensional array is an array of arrays.
Arrays Each element of a multidimensional array is an array
itself.
For example,
int[][] a = new int[3][4];
int[][] a = new int[3][4];
Memory Layout view
Here is how we can initialize a 2-dimensional array in
Java.
int[][] a = {
{1, 2, 3},
{4, 5, 6, 9},
{7},
Initializing };
2D Array As we can see, each element of the multidimensional
array is an array itself.
And also, unlike C/C++, each row of the
multidimensional array in Java can be of different
lengths.
class MultidimensionalArray {
public static void main(String[] args) {
// create a 2d array
int[][] a = {
{1, 2, 3},
{4, 5, 6, 9},
{7},
};
Example
// calculate the length of each row
System.out.println("Length of row 1: " + a[0].length);
System.out.println("Length of row 2: " + a[1].length);
System.out.println("Length of row 3: " + a[2].length);
}
}
Output:
Length of row 1: 3
Length of row 2: 4
Length of row 3: 1
public class Main
{
public static void main(String[] args) {
int a[]={33,3,4,5};
for(int i=0;i<a.length;i++)
System.out.println(a[i]);
}
Array and }
For Loop Output
33
3
4
5
public class Main {
public static void main(String[] args) {
int[][] myNumbers = { {1, 2, 3, 4}, {5, 6, 7} };
for (int i = 0; i < myNumbers.length; ++i) {
for(int j = 0; j < myNumbers[i].length; ++j) {
System.out.println(myNumbers[i][j]);
2D Array }
and For }
Loop }
}
Output
1
2
3
4
5
6
7
import java.util.Scanner;
public class ArrayInputExample1
{
public static void main(String[] args)
{
int n;
Scanner sc=new Scanner(System.in);
System.out.print("Enter the number of elements you want to store: ");
n=sc.nextInt();
int[] array = new int[n];
System.out.println("Enter the elements of the array: ");
Input from for(int i=0; i<n; i++)
{
Keyboard array[i]=sc.nextInt();
}
System.out.println("Array elements are: ");
for (int i=0; i<n; i++)
{
System.out.println(array[i]);
}
}
}
Output
Enter the number of elements you want to store:
5
Enter the elements of the array:
12345
Array elements are:
1
2
3
4
5
You can pass arrays to a method just like normal
variables.
When we pass an array to a method as an argument,
actually the address of the array in the memory is
Passing passed (reference).
Arrays to Therefore, any changes to this array in the method will
affect the array.
Methods
import java.util.Scanner;
class Example{
void Change(int[] a,int size)
{
for(int i=0;i<size;i++)
Example {
a[i]=a[i]+10;
}
}
}
public class Main
{
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("Enter the size of the array that is to be created::");
int size = sc.nextInt();
int[] myArray = new int[size];
System.out.println("Enter the elements of the array ::");
for(int i=0; i<size; i++)
myArray[i] = sc.nextInt();
System.out.println("Array before function call");
for(int i=0; i<size; i++)
System.out.println(myArray[i]);
Example ob=new Example();
ob.Change(myArray,size);
System.out.println("Array after function call");
for(int i=0; i<size; i++)
System.out.println(myArray[i]);
}
}
Output
Enter the size of the array that is to be created::
5
Enter the elements of the array ::
12345
Array before function call
1
2
3
4
5
Array after function call
11
12
13
14
15
public class Main{
public static void main(String[] args) {
int[][] a = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } };
acceptIt(a); // pass it to the method
}
public static void acceptIt(int[][] a) {
System.out.println("Elements are :");
Passing 2D
for (int i = 0; i< a.length; i++) {
Array to for (int j = 0; j < a[i].length; j++) {
Method System.out.print(a[i][j] + "\t");
}
System.out.println("");
}
}
}
Output
Elements are :
1 2 3
4 5 6
7 8 9
ArrayList is a part of collection framework and is present
in java.util package.
Java ArrayList class uses a dynamic array for storing the
elements.
Array List It is like an array, but there is no size limit.
We can add or remove elements anytime.
So, it is much more flexible than the traditional array.
The important points about Java ArrayList class are:
Java ArrayList class can contain duplicate elements.
Java ArrayList class maintains insertion order.
Java ArrayList class is non synchronized.
Java ArrayList allows random access because array
works at the index basis.
In ArrayList, manipulation is little bit slower than the
LinkedList in Java because a lot of shifting needs to
occur if any element is removed from the array list.
Constructor Description
ArrayList() It is used to build an empty
array list.
ArrayList(Collection<? It is used to build an array
extends E> c) list that is initialized with the
Constructors elements of the collection
of ArrayList c.
ArrayList(int capacity) It is used to build an array
list that has the specified
initial capacity.
import java.util.ArrayList;
Creating ArrayList<String> cars = new ArrayList<String>();
ArrayList
import java.util.ArrayList;
public class Main {
public static void main(String[] args) {
ArrayList<String> cars = new ArrayList<String>();
cars.add("Volvo");
cars.add("BMW");
cars.add("Ford");
Adding cars.add("Mazda");
elements System.out.println(cars);
}
}
Output
[Volvo, BMW, Ford, Mazda]
Access an Item
To access an element in the ArrayList, use
the get() method and refer to the index number:
Example
cars.get(0);
Change an Item
Other To modify an element, use the set() method and refer
Operations to the index number:
Example
cars.set(0, "Opel");
Remove an Item
To remove an element, use the remove() method and
refer to the index number:
Example
cars.remove(0);
To remove all the elements in the ArrayList, use
the clear() method:
Example
cars.clear();
ArrayList Size
To find out how many elements an ArrayList have, use
the size method:
Example
cars.size();
Elements in an ArrayList are actually objects.
In the examples above, we created elements (objects)
of type "String".
Remember that a String in Java is an object (not a
primitive type).
Other To use other types, such as int, you must specify an
Types equivalent wrapper class: Integer.
For other primitive types, use: Boolean for
boolean, Character for char, Double for double, etc:
import java.util.ArrayList;
public class Main {
public static void main(String[] args) {
ArrayList<Integer> myNumbers = new ArrayList<Integer>();
myNumbers.add(10);
myNumbers.add(15);
myNumbers.add(20);
Example myNumbers.add(25);
System.out.println(myNumbers);
}
}
Output
[10, 15, 20, 25]
public class Main {
public static void main(String[] args) {
ArrayList<String> cars = new ArrayList<String>();
cars.add("Volvo");
cars.add("BMW");
cars.add("Ford");
cars.add("Mazda");
for (int i = 0; i < cars.size(); i++) {
System.out.println(cars.get(i));
}
Loop }
Through an }
ArrayList
Output
Volvo
BMW
Ford
Mazda
In Java, the for-each loop is used to iterate through
elements of arrays and collections (like ArrayList).
It is also known as the enhanced for loop.
The advantage of the for-each loop is that it eliminates
the possibility of bugs and makes the code more
readable.
It is known as the for-each loop because it traverses
Enhanced each element one by one.
for The drawback of the enhanced for loop is that it cannot
traverse the elements in reverse order.
Statement Here, you do not have the option to skip any element
because it does not work on an index basis.
The syntax of Java for-each loop consists of data_type
with the variable followed by a colon (:), then array or
collection.
for(data_type variable : array | collection)
{
//body of for-each loop
}
//An example of Java for-each loop
class Example1{
public static void main(String args[]){
int arr[]={12,13,14,44};
for(int i:arr){
Example1 System.out.println(i);
}
}
}
Output:
12
13
14
44
Class Example2{
public static void main(String args[]){
int arr[]={12,13,14,44};
int total=0;
for(int i:arr){
total=total+i;
Example2 }
System.out.println("Total: "+total);
}
}
Output:
Total: 83
import java.util.*;
class Example3{
public static void main(String args[]){
//Creating a list of elements
ArrayList<String> list=new ArrayList<String>();
list.add("vimal");
list.add("sonoo");
list.add("ratan");
Example3 //traversing the list of elements using for-each loop
for(String s:list){
System.out.println(s);
}
}
}
Output:
vimal
sonoo
ratan
Commandline Arguments in Java
The java command-line argument is an argument i.e.
passed at the time of running the java program.
The arguments passed from the console can be
Java received in the java program and it can be used as an
input.
Command
Line
arguments
class Example{
public static void main(String args[]){
System.out.println("Your first argument is: "+args[0]);
Example1 }
}
Compile by > javac Example.java
Run by > java Example hai
Output:
Your first argument is: hai
class A{
public static void main(String args[]){
for(int i=0;i<args.length;i++)
System.out.println(args[i]);
Example2
}
}
compile by > javac A.java
run by > java A sonoo jaiswal 1 3 abc
Output:
sonoo
jaiswal
1
3
abc
class Main {
public static void main(String[] args) {
for(String str: args) {
// convert into integer type
int argument = Integer.parseInt(str);
Numeric
System.out.println(argument);
Command-
}
Line
Arguments }
}
// compile the code
javac Main.java
// run the code
java Main 11 23
Output
11
23
Java Packages
A java package is a group of similar types of classes,
interfaces and sub-packages.
Package in java can be categorized in two form, built-in
package and user-defined package.
Java There are many built-in packages such as java, lang,
Package awt, javax, swing, net, io, util, sql etc.
Advantage of Java Package
Java package is used to categorize the classes and
interfaces so that they can be easily maintained.
Java package provides access protection.
Java package removes naming collision.
Part of Java Package Hierarchy
package mypack;
public class Simple{
public static void main(String args[]){
System.out.println("Welcome to package");
User }
defined }
Output
Package
Welcome to package
//save by A.java
package pack;
public class A{
Importing public void msg(){System.out.println("Hello");}
Package in }
Java
//save by B.java
package mypack;
import pack.*;
class B{
public static void main(String args[]){
A obj = new A();
obj.msg();
}
}
Output
Hello
Sample Questions
State the significance of access modifiers
in Java
Write a program to find the first repeating
element in an array of
integers? Input: input [] = {10, 5, 3, 4, 3, 5,
6} Output: 5 [5 is the first element that
repeats]
Explain the concept of compile time
polymorphism in java using an example
Illustrate the significance of ArrayList in java
Explain the significance of static methods
in Java using example