Operator instanceof
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 |
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 |
1 |
Dog d=(Dog) new Animal(); //uspešno kompajlirano ali ClassCastException je izbačen u runtime-u |
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 |
1
2 |
Animal a= new Animal(); Dog.method(a); //sada imamo ClassCastException ali ne u slučaju instanceof operatora |
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 |