Operator instanceof

by
Java instanceof operator se koristi da testira da li je objekat instanca specifikovanog tipa (klasa ili podklasa ili interfejs).
Instanceof u Javi je takođe poznat kao operator poređenja po tipu jer upoređuje instancu sa tipom. On vraća vrednost true ili false. Ako primenimo instanceof operator na bilo koju promenljivu koja ima vrednost null, on će vratiti false.

Primer 1 za Java instanceof operator:

Pogledajmo jednostavan primer ovog operatora gde on testira tekuću klasu.
1
2
3
4
5
6
7
8
9
class Simple1{ 
 public static void main(String args[]){ 
 Simple1 s=new Simple1(); 
 System.out.println(s instanceof Simple); //true 
 } 
}
Ispis na ekranu:
true
Objekat tipa podklase je takođe tipa roditeljske klase. Na primer, ako Dog nasleđuje (extends) Animal, tada objekat od Dog može da upućuje ili na Dog ili na Animal klasu.

Primer 2 za Java instanceof operator

1
2
3
4
5
6
7
8
9
10
11
class Animal{} 
class Dog1 extends Animal{ //Dog nasljeđuje Animal 
  
 public static void main(String args[]){ 
 Dog1 d=new Dog1(); 
 System.out.println(d instanceof Animal); //true 
 } 
}
Ispis na ekranu:
true

Operator instanceof sa promenljivom koja ima vrednost null

Ako primenimo instanceof operator sa promenljivom koja ima vrednost null, on će vratiti false. Pogledajmo takav primer:
1
2
3
4
5
6
7
8
9
class Dog2{ 
 public static void main(String args[]){ 
  Dog2 d=null; 
  System.out.println(d instanceof Dog2); //false 
 } 
}
Ispis na ekranu:
false

Downcasting sa java instanceof operatorom

Kada tip podklase upućuje na objekat roditeljske klase, to je poznato kao downcasting. Ako se to izvede direktno, kompajler će dati compile time error. Ako se to izvede pomoću typecastinga, biće izbačen ClassCastException u runtime-u. Ali ako koristimo instanceof operator, downcasting je moguć.
1
Dog d=new Animal(); //compile time error
Ako izvedemo downcasting pomoću typecastinga, ClassCastException će biti izbačen u runtime.
1
Dog d=(Dog)new Animal(); //uspešno kompajlirano ali ClassCastException je izbačen u runtime-u
Napomena: Typecasting u Javi je dodeljivanje jednog tipa, klase ili interfejsa, u drugi tip tj. drugu klasu ili interfejs. Npr. neka je Base superklasa, a Derived podklasa. Pogledajmo ovakav kod:
1
2
3
Base b = new Derived(); //referentna promenljiva klase Base kreira objekat klase Derived
Derived d = b; //compile time error, potreban je typecasting
Derived d = (Derived) b; // typecasting Base u Derived

Mogućnost downcastinga sa instanceof

Pogledajmo primer, gdje je downcasting moguć pomoću instanceof operatora.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
class Animal { } 
  
class Dog3 extends Animal { 
  static void method(Animal a) { 
    if(a instanceof Dog3){ 
       Dog3 d=(Dog3)a; //downcasting 
       System.out.println("ok downcasting izveden"); 
    } 
  } 
   
  public static void main (String [] args) { 
    Animal a=new Dog3(); 
    Dog3.method(a); 
  } 
    
 }
Ispis na ekranu:
ok downcasting izveden

Downcasting bez upotrebe instanceof

Downcasting se takođe može izvesti bez upotrebe instanceof operatora kao u sledećem primeru:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
class Animal { } 
class Dog4 extends Animal { 
  static void method(Animal a) { 
       Dog4 d=(Dog4)a; //downcasting 
       System.out.println("ok downcasting izveden"); 
  } 
   public static void main (String [] args) { 
    Animal a=new Dog4(); 
    Dog4.method(a); 
  } 
}
Ispis na ekranu:
ok downcasting izveden
Razmotrimo ovo detaljnije, stvarni objekat koji je označen kao a, je objekat klase Dog. Ako ga downcastujemo, to je u redu. Ali šta će se desiti ako napišemo:
1
2
Animal a=new Animal(); 
Dog.method(a); //sada imamo ClassCastException ali ne u slučaju instanceof operatora
Razumevanje stvarne upotrebe operatora instanceof: Pogledajmo stvarnu upotrebu ključne riječi instanceof u sledećem primeru:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
interface Printable{} 
class A implements Printable{ 
public void a(){System.out.println("a metoda");} 
} 
class B implements Printable{ 
public void b(){System.out.println("b metoda");} 
} 
  
class Call{ 
void invoke(Printable p){ //upcasting 
if(p instanceof A){ 
A a=(A)p; //Downcasting  
a.a(); 
} 
if(p instanceof B){ 
B b=(B)p; //Downcasting  
b.b(); 
} 
  
} 
} //kraj klase Call 
  
class Test4{ 
public static void main(String args[]){ 
Printable p=new B(); 
Call c=new Call(); 
c.invoke(p); 
} 
}
Ispis na ekranu:
b metoda

Comments

comments

Leave a Comment