A class can’t be declared as protected. Only methods can be declared as protected.
A protected method can be accessed by the classes within the same package or by the subclass of the class in any package.
A final variable’s value can’t be changed. Final variables should be initialized before using them.
A method declared as final can’t be overridden. A sub-class can’t have the same method signature with a different implementation.
You should declare your class as final. But you can’t define your class as final, if it is an abstract class. A class declared as final can’t be extended by any other class.
Java.lang.String, java.lang.Math are final classes.
Final is a modifier which can be applied to a class or a method or a variable. Final class can’t be inherited, final method can’t be overridden and final variable can’t be changed.
Finally is an exception handling code section which gets executed whether an exception is raised or not by the try block code segment.
try{
System.out.println("Try block");
int i=1/0;
}catch(Exception ex){
System.out.println(ex.getMessage());
}
finally{
System.out.println("fianlly block");
}
finalize() is a method of object class which will be executed by the JVM just before garbage collecting object to give a final chance for resource releasing activity.
We cannot declare top level class as static, but only inner class can be declared static.
public class Test2 {
static class InnerClass{
public static void InnerMethod(){
System.out.println("InnerClass.InnerMethod()");
}
}
public static void main(String[] args){
Test2.InnerClass.InnerMethod();
}
}
When a method needs to be accessed even before the creation of the object of the class then we should declare the method as static.
A static method should not refer to instance variables without creating an instance and can’t use “this” operator to refer the instance.
public class Test2 {
static class InnerClass{
public static void InnerMethod(){
System.out.println("InnerClass.InnerMethod()");
}
}
static void a(){
System.out.println("Test2");
}
public static void main(String[] args){
Test2.a();
Test2.InnerClass.InnerMethod();
}
}
Print the statement inside a static block of code. Static blocks get executed when the class gets loaded into the memory and even before the creation of an object. Hence it will be executed before the main() method. And it will be executed only once.
Static variables are class level variables where all objects of the class refer to the same variable. If one object changed the value then the change gets reflected in all the objects.
Static variables are class level variables and they can’t be declared inside a method. If declared, the class will not compile.
A Class which doesn’t provide complete implementation is defined as an abstract class. Abstract class enforces abstraction. You need to implement abstract method which in abstract class when you inheritance form it.
Not possible. An abstract class without being inherited is of no use and hence will result in compile time error.
Variables can’t be declared as abstract. Only classes and methods can be declared as abstract.
You only can define an abstract method in abstract class; in concrete class we can’t define an abstract method.