Contents

 Java Methods
 Command Line Arguments
 Constructors
 this Keyword
 super Keyword
 static Keyword
 final Keyword
 finally
 Java Methods
 A java method is a set of statements that are used to perform some task.
 Naming Convention –
 Method name should start with lowercase letter.
 If the method name contains multiple words, start it with a lowercase letter followed by an uppercase
letter such as getData().
 Creating Method –
 First you write return type of method then method name.
void show() {
// Statements;
}
 Method Calling – There are two ways in which method is called in java:
 With return a value
 With no return value
 Java Methods
With Return a Value With No Return a Value
class Test { class Test {
public static void main(String args []) { public static void main(String args []) {
int c = show(); Test t = new Test();
System.out.println(c); t.show();
} }
int show() { void show() {
int z = 10 + 20; int z = 10 + 20;
return z; System.out.println(z);
} }
} }
Output - 30 Output - 30
 Java Methods
Passing parameters by value:

 Passing Parameters by Value means calling a method with a parameter.

 The order of passing value in calling and called method should be same.
Passing Parameters by Value
class Test {
public static void main(String args []) {
int x = 10, y = 20;
Test t = new Test();
t.show(x, y);
}
void show(int x, int y) {
int z = x + y;
System.out.println(z);
}
}
Output - 30
 Java Methods
Method Overloading:

 If a class has more than one method with same name but different parameters is known as Method
Overloading.
 Passing Parameters by Value means calling a method with a parameter.
 There are ways to overload the method in java

 By changing the number of arguments

 By changing the data type
 Java Methods
By changing number of arguments By changing the data type
class Test { class Test {
void show(int x, int y) { void show(int x, int y) {
int z = x + y; int z = x + y;
System.out.println("z = "+z); System.out.println("z = "+z);
} }
void show(int x, int y, int a) { void show(int x, int y, double a) {
int c = x + y + a; double c = x + y + a;
System.out.println("c = "+c); System.out.println("c = "+c);
} }
public static void main(String args []) { public static void main(String args []) {
int x = 10, y = 20, a = 30; int x = 10, y = 20; double a = 30.5;
Test t = new Test(); Test t = new Test();
t.show(x, y); t.show(x, y);
t.show(x, y, a); t.show(x, y, a);
} }
} }
Output – z = 30 Output – z = 30
c = 60 c = 60.5
 Command Line arguments
 At runtime, when you will want to pass any information into a program then this is accomplished by passing
command-Line arguments to main().
 They are stored as strings in the String array passed to main( ).
Command-Line Arguments
public class Test {
public static void main(String args[]) {
int x = Integer.parseInt(args[0]);
int y = Integer.parseInt(args[1]);
int sum = x+y;
System.out.println("sum: " + sum);
}
}

Execution Steps –
javac Test.java
java Test 10 20
Output – sum = 30
 Constructors
 I java, Constructor is a special type of method. It is called at the time of object creation. Memory of the
object is allocated at the time calling constructor.
 Every class must have a constructor. If there is no constructor in class then java compiler automatically
creates a default constructor.

class Test { Compiler class Test {

} Test() { }
}

 It is used to initialize the object

 Constructor has no return type except current class instance.
 A constructor cannot be declared as final, static or synchronized.
 A class can have more than one constructor i.e., constructor can be overloaded.
 Constructor has the same name as class name.
 Constructors
 The default constructor is used to provide the default values to the object like zero (0), null, etc., depending
on the data type.
class Test{
int id;
String name;
void display(){
System.out.println(id+" "+name);
}
public static void main(String args[]){
Test s1=new Test();
Test s2=new Test();

s1.display();
s2.display();
}
}

Output – 0 null
0 null
 Constructors
 In java, there are three types of constructor:
 Parameterized Constructor
 Non – Parametrized Constructor
 Default Constructor

Parameterized and Non-Parameterized Constructor

A constructor has a specific parameter is called Parameterized Constructor. A constructor with no parameter is
called Non-Parameterized Constructor.
 Constructors
Parameterized Constructor Non-Parameterized Constructor

class Test{ class Test{

int id; int id;
String name; String name;
Test(int i, String n){ Test(){
id = i; id = 101;
name = n; name = “Manish”;
} }
void show(){ void show(){
System.out.println("Id = "+id+"\t"+"Name = "+name); System.out.println("Id = "+id);
} System.out.println("Name = "+name);
public static void main(String args[]){ }
Test t1=new Test(101, "Manish"); public static void main(String args[]){
t1.show(); Test t1=new Test();
} t1.show();
} }
}
Output – Id = 101 Name = Manish
Output – Id = 101
Name = Manish
 Constructors
 In java, there are three types of constructor:
 Parameterized Constructor
 Non – Parametrized Constructor
 Default Constructor

Parameterized and Non-Parameterized Constructor

A constructor has a specific parameter is called Parameterized Constructor. A constructor with no parameter is
called Non-Parameterized Constructor.

Default Constructor

Constructor generated by compiler if there is no constructor in program, that constructor is known as Default
Constructor.
 Constructors
Constructor Overloading

Constructor Overloading means that a class having more than one constructor with different parameter.
void show(){
Constructor Overloading
System.out.println("Id = "+id+"\t"+"Name = "+name);
class Demo{
}
int id, salary;
void show1(){
String name;
System.out.println("Id = "+id+"\t"+"Name = "+name+"\tSalary = "+salary);
Demo(int i, String n){
}
id = i;
public static void main(String args[]){
name = n;
Demo t=new Demo(101, "Manish");
}
Demo t1=new Demo(102, "Manish", 2000);
Demo(int i, String n, int sal){
t.show(); t1.show1();
id = i;
}}
name = n; salary = sal;
Output – Id = 101 Name = Manish
}
Id = 102 Name = Manish Salary = 2000
 Constructors
Constructor Vs. Method
Java Constructor
A constructor is used to initialize the
state of an object.
A constructor must not have a return
type.
The constructor is invoked implicitly.
The Java compiler provides a default
constructor if you don't have any
constructor in a class.
The constructor name must be same
as the class name.
Java Method
A method is used to expose the behavior
of an object.
A method must have a return type.
The method is invoked explicitly.
The method is not provided by the
compiler in any case.
The method name may or may not be same
as the class name.
 this Keywords
 In java, this is a reference variable that refers to the current class object.
 this keyword is used to differentiate local and instance variable when both the variable name is same.

this (Reference Variable) object

 this() must be first statement in constructor.

 To reuse the constructor from constructor is known as Constructor Chaining.

Uses of this keyword

 this keyword is used to call current class method.

 this () is used to invoke current class constructor.
 this can be passed as an argument in method and constructor call.
 this Keywords
this keyword Used to call current class method

class Demo { class Demo {

int id; void show() {
String name; System.out.println("Hello Show Method");
Demo(int id, String name) { this.display(); // this.display() is same as display()
this.id = id; }
this.name = name; void display() {
} System.out.println("Hi, display method");
void show() { }
System.out.println("ID = "+id+"\t Name = "+name); public static void main(String args[]) {
} Demo d = new Demo();
public static void main(String args[]) { d.show();
Demo d = new Demo(101, "Manish"); }
d.show(); }
}
} Output – Hello Show Method
Hi, display method
Output – Id = 101 Name = Manish
 this Keywords
Invoke current class constructor To pass as an argument in the method

class Demo { class Demo {

Demo() { void show(Demo obj) {
System.out.println("Hello Mr. Abc"); System.out.println("Method Invoked");
} }
Demo(int x) { void display() {
this(); show(this);
System.out.println("x = "+x); }
} public static void main(String args[]) {
public static void main(String args[]) { Demo d = new Demo();
Demo d = new Demo(20); d.display();
}} }}

Output – Hello Mr. Abc Output – Method Invoked

x = 20
 this Keywords
Actual Use of Constructor (Constructor Chaining) To prove this refer current class instance variable
class Demo {
int id, age; class Demo {
String name; void show() {
Demo(int id, String name) { System.out.println(this);
this.id = id; }
this.name = name; public static void main(String args[]) {
} Demo d = new Demo();
Demo(int id, String name, int age) { System.out.println(d);
this(id, name); d.show();
this.age = age; }
} }
void display() {
System.out.println(id+"\t"+name+"\t"+age); Output – Demo@15db9742
} Demo@15db9742
public static void main(String args[]) {
Demo d = new Demo(101,"Manish");
Demo d1 = new Demo(102,"Vishal",30);
d.display();
d1.display();
}}
Output – 101 Manish 0
102 Vishal 30
 Super keyword
 The super keyword in java refers to the object of immediate parent class. It means that when you create an
object of subclass then an object of base class is created implicitly, which is referred by super reference
variable.
 The super keyword basically used in inheritance.
 super keyword is used to refer immediate parent class instance variable.
class Test {
int age = 30;
}
class Demo extends Test {
int age = 20;
void show() {
System.out.println("Age in subclass = "+age);
System.out.println("Age in base class = "+super.age);
}
public static void main(String args[]) {
Demo d = new Demo();
d.show(); }}
Output - Age in subclass = 20
Age in base class = 30
 Super keyword
 super keyword is used to refer immediate parent class method whenever you define a method with same in
both the class i.e. Parent and child class both have same name method.
class Test {
void display() {
System.out.println("display in base class");
}}
class Demo extends Test {
void display() {
System.out.println("display in sub class");
}
void show() {
super.display();
}
public static void main(String args[]) {
Demo d = new Demo();
d.show(); }}

Output - display in base class

 Super keyword
 super keyword can also be used to access the parent class constructor. super keyword can call both
parametric and non-parametric constructors depending on the situation.
class Test {
Test() {
System.out.println("Base Class Constructor");
}
}
class Demo extends Test {
Demo() {
super();
System.out.println("Sub class Constructor");
}
public static void main(String args[]) {
Demo d = new Demo();
}}

Output - Base Class Constructor

Sub class Constructor
 Super keyword
Important Points about super keyword
 super() must be the first statement in subclass class constructor.
 If a constructor does not explicitly call a base class constructor, the Java compiler automatically inserts a call
to the non-argument constructor of the base class. If the base class does not have a non-argument constructor,
you will get a compile-time error. class Test {
Test() {
System.out.println("Base Class Constructor");
}}
class Demo extends Test {
Demo() {
System.out.println("Sub class Constructor");
}
public static void main(String args[]) {
Demo d = new Demo();
}}

Output - Base Class Constructor

Sub class Constructor
 static keyword
 In java, static keyword is mainly used for memory management.
 In order to create a static member, you need to precede its declaration with the static keyword.
 static keyword is a non-access modifier and can be used for the following:
 static block
 static variable
 static method
 static class

Static Block - In java static block is used to initialize static data member and it is executed before the main
method at the time of class loading. class Demo{
static {
System.out.println("Static Block");
}
public static void main(String args[]) { Output - Static Block
System.out.println("Main Method"); Main Method
}
}
 static keyword
Static Variable
 A variable declare with static keyword is called Static Variable.
 After declaration static variable, a single copy of the variable is created and divided among all objects at the
class level.
 Static variable can be created at class-level only and it gets memory only once in the class area at the time of
class loading.
 Static variable can’t re-initialized.
class Demo{ void show() {
int e_id; System.out.println("Emp_Id = "+e_id+"\t Emp_Name = "+name+"\t
String name; Company ="+company);
static String company = "PSIT"; }
Demo (int i, String n) { public static void main(String args[]) {
e_id = i; Demo d = new Demo(101, "Manish");
name = n; Demo d1 = new Demo(102, "Vishal");
} d.show();
Output - Emp_Id = 101 Emp_Name = Manish Company =PSIT
d1.show();
Emp_Id = 102 Emp_Name = Vishal Company =PSIT
}}
 static keyword
Static Variable
 static keyword
Static Method

 A method declared with static keyword is known as static method.

 The most common example of static method is main() method.
 Static method can be invoked directly i.e. no need to create an object of a class. So static method can be
invoked with class.
 Static method can access static data member only.
 this and super can not be used in static context.
 static keyword
Static Method
Method call with class name Static data member can not access in static method

class Demo{ class Demo{

static int e_id = 101; int e_id = 101;
static String name = "Manish"; static String name = "Manish";
static void show() { static void show() {
System.out.println("Emp_Id = "+e_id+"\t Emp_Name System.out.println("Emp_Id = "+e_id+"\t Emp_Name
= "+name); = "+name);
} }
public static void main(String args[]) { public static void main(String args[]) {
Demo.show(); Demo.show();
} }
} }

Output - Emp_Id = 101 Emp_Name = Manish Output – Compile Time Error

(non-static variable e_id cannot be referenced from a
static context)
 static keyword
Static Class

 A nested class can be static. Nested static class doesn’t need a reference of outer class.
 A static class cannot access non-static members of the outer class.
 You compile and run your nested class as usual that with outer class name.

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

Demo.NestedClass dns = new
class Demo{ Demo.NestedClass();
static String name = "Manish"; dns.show(); }
static class NestedClass {
void show() { Output - Manish
System.out.println(" Emp_Name =
"+name);
}
}
 final keyword
 The final keyword is used to make a variable as constant. That is if you make a variable as final, you cannot
change the value of that variable.
 A final variable with no value is called blank final variable. Blank final variable can be initialized in the
constructor only.
 Final keyword can be applied with following:

Variable - If you declare a variable with final keyword then it must be initialized.
Final Variable Final Variable (Can’t change value)
class Demo { class Demo {
final int x = 10; final int x = 10;
void show() { void show() {
System.out.println(x); x = 20;
} System.out.println(x);
public static void main(String args[]) { }
Demo d = new Demo(); public static void main(String args[]) {
d.show(); Demo d = new Demo();
}} d.show();
Output - 10 }}
Output - error: cannot assign a value to final variable x
 final keyword
Method - If you declare a method as final it means that you cannot override (Discuss in Inheritance) this method.

Final Method Cannot Override

class Test {
final void show() {
System.out.println("Parent Class Method");
}
}
class Demo extends Test{
void show(){
System.out.println("Cannot override due to final method.");}
public static void main(String args[]) {
Demo d = new Demo();
d.show();
}
}

Output - error: show() in Demo cannot override show() in Test

(Compile Time Error)
 final keyword
Class - If you declare a class as final it means that you cannot inherit (Discuss in Inheritance) this class. That is,
you cannot use extends keyword.
Final Class cannot inherited

final class Test {}

class Demo extends Test{
void show(){
System.out.println("Cannot override due to final method.");
}
public static void main(String args[]) {
Demo d = new Demo();
d.show();
}
}

Output - error: cannot inherit from final Test

Note – Constructor cannot be declared as final because it is never inherited.

 Finally
In java finally is a block that is used to execute important code such as closing connection, etc. Finally block is
always executed whether exception is handled or not.

Note – As finally used in Exception so it will be discussed later in Exception chapter.

finally {
// Statements;
}