Lecture 4_Java Method-constructor_imp_keywords

Java Programming
Manish Kumar
(manish87it@gmail.com)
Lecture- 4

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
class Test {
public static void main(String args []) {
int c = show();
System.out.println(c);
}
int show() {
int z = 10 + 20;
return z;
}
}
Output - 30
With No Return a Value
class Test {
Test t = new Test();
t.show();
}
void show() {
int z = 10 + 20;
System.out.println(z);
}
}
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 {
int x = 10, y = 20;
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
class Test {
int z = x + y;
System.out.println("z = "+z);
}
void show(int x, int y, int a) {
int c = x + y + a;
System.out.println("c = "+c);
}
int x = 10, y = 20, a = 30;
t.show(x, y);
t.show(x, y, a);
}
}
Output – z = 30
c = 60
By changing the data type
class Test {
int z = x + y;
System.out.println("z = "+z);
}
void show(int x, int y, double a) {
double c = x + y + a;
System.out.println("c = "+c);
}
int x = 10, y = 20; double a = 30.5;
t.show(x, y);
t.show(x, y, a);
}
}
Output – z = 30
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.
Compiler
 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.
class Test {
}
class Test {
Test() { }
}

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
class Test{
int id;
String name;
Test(int i, String n){
id = i;
name = n;
}
void show(){
System.out.println("Id = "+id+"t"+"Name = "+name);
}
Test t1=new Test(101, "Manish");
t1.show();
}
}
Output – Id = 101 Name = Manish
Non-Parameterized Constructor
class Test{
int id;
String name;
Test(){
id = 101;
name = “Manish”;
}
void show(){
System.out.println("Id = "+id);
System.out.println("Name = "+name);
}
Test t1=new Test();
t1.show();
}
}
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.
Constructor Overloading
class Demo{
int id, salary;
String name;
Demo(int i, String n){
id = i;
name = n;
}
Demo(int i, String n, int sal){
id = i;
name = n; salary = sal;
}
void show(){
System.out.println("Id = "+id+"t"+"Name = "+name);
}
void show1(){
System.out.println("Id = "+id+"t"+"Name = "+name+"tSalary = "+salary);
}
Demo t=new Demo(101, "Manish");
Demo t1=new Demo(102, "Manish", 2000);
t.show(); t1.show1();
} }
Id = 102 Name = Manish Salary = 2000

Constructors
Constructor Vs. Method
Java Constructor Java Method
A constructor is used to initialize the
state of an object.
A method is used to expose the behavior
of an object.
A constructor must not have a return
type.
A method must have a return type.
The constructor is invoked implicitly. The method is invoked explicitly.
The Java compiler provides a default
constructor if you don't have any
constructor in a class.
The method is not provided by the
compiler in any case.
The constructor name must be same
as the class name.
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() 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 (Reference Variable) object

this Keywords
this keyword
class Demo {
int id;
String name;
Demo(int id, String name) {
this.id = id;
this.name = name;
}
void show() {
System.out.println("ID = "+id+"t Name = "+name);
}
Demo d = new Demo(101, "Manish");
d.show();
}
}
Used to call current class method
class Demo {
void show() {
System.out.println("Hello Show Method");
this.display(); // this.display() is same as display()
}
void display() {
System.out.println("Hi, display method");
}
Demo d = new Demo();
d.show();
}
}
Output – Hello Show Method
Hi, display method

this Keywords
Invoke current class constructor
class Demo {
Demo() {
System.out.println("Hello Mr. Abc");
}
Demo(int x) {
this();
System.out.println("x = "+x);
}
Demo d = new Demo(20);
}}
Output – Hello Mr. Abc
x = 20
To pass as an argument in the method
class Demo {
void show(Demo obj) {
System.out.println("Method Invoked");
}
void display() {
show(this);
}
d.display();
}}
Output – Method Invoked

this Keywords
Actual Use of Constructor (Constructor Chaining)
class Demo {
int id, age;
String name;
Demo(int id, String name) {
this.id = id;
this.name = name;
}
Demo(int id, String name, int age) {
this(id, name);
this.age = age;
}
void display() {
System.out.println(id+"t"+name+"t"+age);
}
Demo d = new Demo(101,"Manish");
Demo d1 = new Demo(102,"Vishal",30);
d.display();
d1.display();
}}
Output – 101 Manish 0
102 Vishal 30
To prove this refer current class instance variable
class Demo {
void show() {
System.out.println(this);
}
System.out.println(d);
d.show();
}
}
Output – Demo@15db9742
Demo@15db9742

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);
}
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");
}}
void display() {
System.out.println("display in sub class");
}
void show() {
super.display();
}
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");
}
}
Demo() {
super();
System.out.println("Sub class Constructor");
}
} }
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");
}}
Demo() {
System.out.println("Sub class Constructor");
}
}}
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");
}
System.out.println("Main Method");
}
}
Output - Static Block
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{
int e_id;
String name;
static String company = "PSIT";
Demo (int i, String n) {
e_id = i;
name = n;
}
void show() {
System.out.println("Emp_Id = "+e_id+"t Emp_Name = "+name+"t
Company ="+company);
}
Demo d = new Demo(101, "Manish");
Demo d1 = new Demo(102, "Vishal");
d.show();
d1.show();
}}
Output - Emp_Id = 101 Emp_Name = Manish Company =PSIT
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
class Demo{
static int e_id = 101;
static String name = "Manish";
static void show() {
System.out.println("Emp_Id = "+e_id+"t Emp_Name
= "+name);
}
Demo.show();
}
}
Output - Emp_Id = 101 Emp_Name = Manish
Static data member can not access in static method
class Demo{
int e_id = 101;
static void show() {
System.out.println("Emp_Id = "+e_id+"t Emp_Name
= "+name);
}
Demo.show();
}
}
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
class Demo{
static class NestedClass {
void show() {
System.out.println(" Emp_Name =
"+name);
}
}
Demo.NestedClass dns = new
Demo.NestedClass();
dns.show(); }
Output - Manish

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
class Demo {
final int x = 10;
void show() {
System.out.println(x);
}
d.show();
} }
Output - 10
Final Variable (Can’t change value)
class Demo {
final int x = 10;
void show() {
x = 20;
System.out.println(x);
}
d.show();
}}
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.");}
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.");
}
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;
}

Lecture 4_Java Method-constructor_imp_keywords

Lecture 4_Java Method-constructor_imp_keywords

Recommended

More Related Content

What's hot (20)

Similar to Lecture 4_Java Method-constructor_imp_keywords (20)

More from manish kumar (7)

Recently uploaded (20)

Lecture 4_Java Method-constructor_imp_keywords