By
Dr. Yasser Abdelhamid
final keyword
this keyword
static methods (revisited)
static block
Instance Initialization Block(IIB)
Static Initialization Block(SIB)
Thejava final keyword is used to restrict
the use of:
Variables,
Methods, and
Classes
Value of variables defined as final, cannot be
changed(like a constant).
If the variable is a parameter, its value cannot be
changed also.
class MyClass{
final int weight=90;//final variable
void changeWeight(final int height){
weight=80; // Error, can’t change final variable
height= 180; // Error height is final
}
public static void main(String args[]){
MyClass obj=new MyClass();
obj.changeWeight(89);
}
}
Final method cannot be overridden, but
still can be inherited.
final is not allowed for Constructors.
class Bike{
final void run(){System.out.println("running");}
}
class Honda extends Bike{
void run(){System.out.println("running safely with
100kmph");} // cannot override final method
public static void main(String args[]){
Honda honda= new Honda();
honda.run();
}
}
Final class cannot be inherited.
final class Bike{}
class Honda1 extends Bike{
void run(){System.out.println("running
safely with 100kmph");}
public static void main(String args[]){
Honda1 honda= new Honda1();
honda.run();
}
}
thisis a reference variable that refers to
the current object.
There are many ways to use this keyword:
referencing current class instance variable.
calling current class method (implicitly)
calling current class constructor.
can be passed as an argument in the method call.
can be passed as argument in the constructor call.
can be used to return the current class instance from
the method.
In
case of ambiguity between the instance
variables and parameters, this keyword
resolves this problem.
public class Person {
private String name;
private intage;
public void setName(String name) {
this.name= name;
}
public String getName() {
return name;
}
}
class A{
void m(){System.out.println("hello m");}
void n(){
System.out.println("hello n");
//m();//same as this.m()
this.m();
}
}
class TestThis4{
public static void main(String args[]){
A a=new A();
a.n();
}
}
this() method refers to current class
constructor.
It is used to reuse the constructor.
it must be the first line in the constructor.
class A{
A(){
this('a');
System.out.println("Default constructor");}
A(char c){ System.out.println("char");}
A(int x){
this(); // call default constructor
System.out.println(x);
}
}
class TestThis5{
public static void main(String args[]){
A a=new A(10);
}
}
Passing
current object as an argument to
a method.
class Student{
void m(Student obj){
System.out.println("method is invoked");
}
void p(){
m(this);
}
public static void main(String args[]){
Student s1 = new Student();
s1.p();
}
}
class A{
A getA(){
return this;
}
void msg(){System.out.println("Hello java");}
}
class Test1{
public static void main(String args[]){
new A().getA().msg();
}
}
A static method can access static data
member and can change its value.
The static method can not use non static
data member or call non-static method
directly.
this and super cannot be used in static
context.
Is used to initialize the static data
member.
It is executed before the main method at
the time of class loading.
class A2{
static{
System.out.println(“Loading class…");
}
public static void main(String args[]){
System.out.println(“Start main method");
}
}
IIB run each time when an instance of the
class is created.
It is used to initialize the instance data
members.
The instance initializer block is invoked
after the parent class constructor is
invoked (i.e. after super() constructor
call).
class A{
A(){ System.out.println("parent class constructor invoked"); }
}
class B2 extends A{
B2(){
super();
System.out.println("child class constructor invoked");
}
{System.out.println("instance initializer block is invoked");}
public static void main(String args[]){
B2 b=new B2();
}
}
// (see IIBSIB.java in OOP project)
Output: parent class constructor invoked
instance initializer block is invoked
child class constructor invoked
Static Initialization Block(SIB) can be used
to initialize static variables or to call a
static method.
Static block code executes only once
during the class loading.
Instance Initialization Block (IIB) is
executed every time an instance of the
class is created, and it can be used to
initialize the instance data members.
A class can have multiple static blocks,
and they will execute in the same order as
they appear in the class.
Static Initialization Block Instance Initializer Block
It executes during class
It executes during class loading
instantiation
It can use static or non-static
It can only use static variables
(instance variables).
It can not use this It can use this
It executes only once during the
entire execution of the program It can run many times whenever
when the class loads into the there is a call to the constructor
memory
In payroll systems, it is often needed to
print a salary check for each employee in
numbers and words.
For example 16654 is written as
Sixteen thousand, six hundred, and fifty
four.
Write the code that implements this
function in Java.
You may need it soon
What parts of the project, can we do now?
