Explanation:

Ex.

We have two classes named as Student and Employee

So arrange objects of both classes in single array we will declare array of Object type as given below:

Object array[]=new Object[size];

so , if we write:

array[0]=new Student();

array[1]=new Employee();

This will not generate any error.

●     Method are abstract because the implementation is left for the implementation class or the third party vendors, in this case we just need structure of method not the body content.

●     Variables are static because they can be accessible inside static as well as instance methods.

●     Variables are final because static variables share a single copy throughout all the objects. If someone change it it will affect all objects and ultimate result will have its effect. So to make it constant it has been final.

●     Use BigDecimal, long or int for monetary calculation.

●     Use BigDecimal constructor with String constructor

●     Because instances are not associated with any static methods. So the scope is for that dedicated class only and the concept is not applicable.

●     And that is possible by using constructor. Because, it has been invoked automatically before object has been created.

●     This is frequently used for immutable objects.

➢     Strings are immutable in java if store password as plain text it will be available in memory until Garbage collector clears it and since String are used in String constant pool for reusability there is pretty high chances that it will remain in memory for long duration. Learn more at Java Training In Pune.

➢     Memory dump can be accessed by anyone and that is why we encrypt the password to prevent from stealing or hacking

➢     With char[] you can set all elements blank.

●     All fields should be final.

●     Class must be final to restrict subclassing.

●     Prons-

➢     Thread safe, no need for synchronization (boost performance)

➢     Can reuse them, serving them from cache using static factory methods

●     Cons-

➢     New instances create a lot of work for Garbage collector.

●     There is a high possibility that stateless beans will have instance variables and will not be specific for any single client.

●     HTTP is a stateless protocol which means that it is actual transport protocol the server and the client is “stateless because it remembers nothing between invocations.

●     Stateful Session Bean are dedicated to one client for their entire life, there is no swapping or pooling of instances and maintain conversational state.

●     It means while method invocation instance variables of bean keep relative data of a client.

●     And this makes possible to have interdependent method calls.

➢     Final

➢     effectively final

Variable whose value is never changed after it is initialized is effectively final.

●     If we declare a variable as final it will become constant. We can’t re-assign any value for variable.

●     If a class is declared as final we can not extend that class.

●     If a method is declared as final then we can’t override that method in child class.

➢     ‘finally’ is a block, which is always associated with try and catch blocks.

➢     We write cleanup code inside finally block. That is resource deallocation.

➔     ‘finalize()’ is a method present in Object class, which has been called by the Garbage collector to perform cleanup activity just before destroying object.

1. public
2. private
3. protected
4. default
5. final
6. abstract
7. static
8. synchronized
9. native
10. strictfp
11. transient
12. volatile

Ex. Servlet

●     If we want implementation but not completely that is partial then we should go for abstract class.

Ex. GenericServlet

●     If we want implementation completely and ready to provide service then we should go for concrete class.

Ex. MyServlet

●     But in java there no terminology like specifiers. All are by default considered as modifiers.

1. public
2. private
3. protected
4. default
5. final
6. abstract
7. static
8. synchronized
9. native
10. strictfp
11. transient
12. volatile

●     out is a static variable available in System class, called as PrintStream object.

●     and println() is the method present in PrintStream class.

●     Every java application has two context areas i.e. static context and non-static context (context is an area where we process our code)

●     Static is free access area whereas non-static is restricted area where we should take permissions to access it.

●     final methods are having overriding prevention, so we can not override it.

●     If we declare method as abstract it means it needs to be overridden and if we declare it final  then are not able to override it. So both the concepts are contradictory at their places. So can not declare method as both abstract and final. This is illegal combination of modifiers.

●     Ex. IFSC code for bank account holders we can consider the common functionality whereas account is different for every account holder.

●     Where abstract is specific for pertical child.

●     So functionality like common and specific we can not combine. So these both static and abstract are illegal combination modifiers.

Ex. IOException thrown by readLine() method of BufferedReader class.

●     Unchecked exceptions are those exceptions that we get at runtime and not caught by compiler. In this case we have to apply exception handling mechanism to handle it.

Ex. Divide by zero generates ArithmeticException at runtime.

●     The availability of instance variable is after invocation of static methods.

●     So only static variables are available when we invoke static variable.

●     So we can say that JVM execution flow is responsible for it.

●     If we write try catch block without finally block then its is still fine.

●     But we can not write it without both block.

●     If we want to write it we have a concept in java i.e. try with resource.

●     But as the functionality run() method invocation is done by start() automatically when JVM schedule it then we have again call the start() of thread class by specifying the following statement inside start() method,

➔     super.start();

●     As we know abstract class contains incomplete methods so memory estimation for object is not done by JVM as its implementation is depends on its implementation class.

●     So without memory estimation we are not able to create object of it.

●     And we do upcasting to access concrete methods of abstract class.

●     In this case, Java Course In Pune have implemented class object and abstract class reference.

●     So according to inheritance functionality we can pass parameters to super class constructor by using the super keyword.