What does the keyword "final" have to do with compiling this code?

[Harry Henriques]

The following code snippet DOES NOT compile, but the code snippet below it DOES compile and run. This problem is part of a Drag-n-Drop problem from ExamLab by M Devaka Cooray.

class A { }
class B extends A { }
class C extends B { }
final class Three {
        public static void main( String [] args ) {
                C [] c = null;
                Runnable [] ra1 = null;
                ra1 = (Runnable []) c;
        }
}    

The example below DOES compile without warnings or errors, and runs without exceptions. What is the difference between this code and the code above, and why does the keyword "final" make the difference?

class A { }
class B extends A { }
class C extends B { }
class Three {
        public static void main( String [] args ) {
                C [] c = null;
                Runnable [] ra1 = null;
                ra1 = (Runnable []) c;
        }
}   

[Rafael Angarita]

Hello,

I think they both compile fine.

What compile error are you getting?

[Alejandro Liz]

I see that both codes do the work, but the diference with the "final" modifier is that class will can't be subclased, in that case, the final class Three will never be a parent class.

[Harry Henriques]

Rafael Angarita wrote:I think they both compile fine.

Sorry, I made a mistake when I transposed the snippet. This is the correct non-compiling code below.

class A { }
class B extends A { }
final class CCC extends B {
        public static void main( String [] args ) {
                CCC [] c = null;
                Runnable [] ra1 = null;
                ra1 = (Runnable []) c;
        }
}    

C:\Documents and Settings\Harry Henriques>javac CCC.java
CCC.java:7: inconvertible types
found : CCC[]
required: java.lang.Runnable[]
ra1 = (Runnable []) c;
^
1 error

The following code snippet compiles without any problem.

class A { }
class B extends A { }
class CCC extends B {
        public static void main( String [] args ) {
                CCC [] c = null;
                Runnable [] ra1 = null;
                ra1 = (Runnable []) c;
        }
}    

[George Coolidge]

Which compiler do you use? It works fine for both versions in my eclipse.

Harry Henriques wrote:The following code snippet DOES NOT compile, but the code snippet below it DOES compile and run. This problem is part of a Drag-n-Drop problem from ExamLab by M Devaka Cooray.

class A { }
class B extends A { }
class C extends B { }
final class Three {
        public static void main( String [] args ) {
                C [] c = null;
                Runnable [] ra1 = null;
                ra1 = (Runnable []) c;
        }
}    

The example below DOES compile without warnings or errors, and runs without exceptions. What is the difference between this code and the code above, and why does the keyword "final" make the difference?

class A { }
class B extends A { }
class C extends B { }
class Three {
        public static void main( String [] args ) {
                C [] c = null;
                Runnable [] ra1 = null;
                ra1 = (Runnable []) c;
        }
}   

[Pramod P Deore]

I try the same programme in NetBeans but I also got the same error.

[Ben Zaidi]

Hello,
It is because, when you declare a class final, then all of its methods are final implicitly. So as data members also i suppose.
Umm i believe my notion is wrong, because if we do something like

c[0] = new CCC();

It works. Additionally, both of the classes are not lying in the same inheritance hierarchy.
If you change the code somehow like this.

    
package chapter2;

class A { }  

class B extends A { }  

final class CCC extends B implements Runnable {  
        public static void main( String [] args ) {  
                CCC [] c = null;
     //           c[0] = new CCC();
                Runnable [] ra1 = null;
             //   B[] b = null;
                ra1 = (Runnable []) c;
              //  b = (B []) c;
        }

		public void run() {
			// TODO Auto-generated method stub
			
		}

}    

In this case, it is compiling fine even with the keyword Final.

[Ben Zaidi]

Ben Zaidi wrote:Hello,
It is because, when you declare a class final, then all of its methods are final implicitly. So as data members also i suppose.
Umm i believe my notion is wrong, because if we do something like

c[0] = new CCC();

It works. Additionally, both of the classes are not lying in the same inheritance hierarchy.
If you change the code somehow like this.

    
package chapter2;

class A { }  

class B extends A { }  

final class CCC extends B implements Runnable {  
        public static void main( String [] args ) {  
                CCC [] c = null;
     //           c[0] = new CCC();
                Runnable [] ra1 = null;
             //   B[] b = null;
                ra1 = (Runnable []) c;
              //  b = (B []) c;
        }

		public void run() {
			// TODO Auto-generated method stub
			
		}

}    

In this case, it is compiling fine even with the keyword Final.

I believe after doing a bit of RND, in case of final keywords, the compiler does the bit of optimization, means the check of casting
which mostly happens at Runtime in non-final cases are checked at compile time in case of final keywords. Correct me please if
i am wrong.

[Ankit Garg]

In case of a non-final class, a cast to/from interface is always allowed as there might be a class that is a sub-type of both. For example

interface I {}
class C {}
class D extends C implements I {}

So even if you don't declare a class D, but it might exists somewhere or someone else might create it, so the compiler allows a cast between a non-final class and interface. But in case of final-class, if that class doesn't implement an interface, then a cast between that interface and the class is not allowed

interface I {}
final class C {}
class D extends C implements I {}   //error, C is final

Since there can't be any class that is a sub-type of both C and I, so there can't be any object that IS-A C and I. This is why a cast between C and I is rejected at compile time as the compiler knows that the cast can't succeed at runtime.

HTH

[George Coolidge]

Exactly, unless it is absolutely impossible for C to be is-a Runnable interface, the compiler will let it pass and throw ClassCastException at runtime if the referenced type (C or its subtypes) doesn't implement Runnable interface.

Ankit Garg wrote:In case of a non-final class, a cast to/from interface is always allowed as there might be a class that is a sub-type of both. For example

interface I {}
class C {}
class D extends C implements I {}

So even if you don't declare a class D, but it might exists somewhere or someone else might create it, so the compiler allows a cast between a non-final class and interface. But in case of final-class, if that class doesn't implement an interface, then a cast between that interface and the class is not allowed

interface I {}
final class C {}
class D extends C implements I {}   //error, C is final

Since there can't be any class that is a sub-type of both C and I, so there can't be any object that IS-A C and I. This is why a cast between C and I is rejected at compile time as the compiler knows that the cast can't succeed at runtime.

HTH