Static variables cannot be serialized since the static variables are variable per Class but serialization is intended to serialize the class instance.but still...............
Static variables can be made to serialize if values are assigned there at time of initialization itself as below.
Class Employee implements Serializable{ static String name;
Employee(){
}
Garbage Collection:
Has following steps:
1.Marking: Marking live and dead Objects.
2.Normal deletion and Compact Deletion
Since many Objects live for shorter time;
thus, Generational GC
Young: called minor collection
Old:called major collection, objects move to Old geneartion for young geneartion after a threshold time elapses.
Permanent:Conatins meta dta needed for classes from JVM or libraries gets collected under full garbage collection
When Objects are created they are moved to EDEN space, one first MINOR GC moves to survival space1.Same is repeated for second MINOR GC and the objects that survives are promoted from
YOUNG generation to OLD , after they crosses the age threshold.
ConcurrentMarkSweep is the collector in latest java, here garbage collection is done without moving the live Objects
JAVA is an architecture neutral language. As stated in article1, the JAVA compiler generates JAVA Virtual Machine codes instead of machine codes specific to the computer system we are using.
These Virtual Machine codes, or JAVA bytecodes, are all architecturally neutral; the compiled codes are executable on any processors and systems, provided of course, that the JAVA Virtual machine (interpreter) is installed in those systems JVM Architecture: ClassLoader:RunTime Data Area: Aresa used during runtime which comprsises of some data Areas relative to JVM and Thread LifeCycle span. PC Register: Contains address of the JVM instrauction if NOT native, i.e. method written in C or that doenot run in JVM. JVM Stack: Fixed or dynamic Sized Stack containg frames,i..e local variables or partial results and is created at time of Thread creation. This might lead to two errors: If thread execution needs larger stack for execution than throws stackOverFlow error and if stack allocation is dynamic,the Stack might get allocated extra memory but still the Stack memory required by JVM for new Thread might run out of memory thus causing OutOFMemory Error. Heap: Runtime area ffrom which memory is allocated to all class instances and arrays. Method Area: Comprisies within heap and is shared among all threads of JVM and conaytins per class structures as: constant pool,field, methods, data, Interfaces.This contains the compiled code. This method area further comprises of: run-time contant pool: this is the per-class,per-interface runtime representation of the class anf it contains the literals or symbolic references generated by compiler. and is created the time class or interface is created. Native Method Stacks:To Supports native methods. Frames: used to store data and partial results, return vales from method. Heap ^ Method Area ^ Constant Pool JVM has following lifecycle for classes: Loading: Finding the binary representation for the class/interface with particular name and create class/interface from that binary represenatation. Linking:Combinting class/interfcae with run time state of JVM so can be executed. Initializing:intiialzation of classes JVM StartUp: The Java Virtual Machine starts up by creating an initial class, which is specified
in an implementation-dependent manner, using the bootstrap class loader (§5.3.1).
The Java Virtual Machine then links the initial class, initializes it, and invokes
the public class method void main(String[]). JVM implemention as: Linux based, windows. JRE is implementaion for JVM Loading ^ Linking ^ Initializing ^ Vertfication, check if class/interfcae are structurally correct To Exit JVM:Runtime class exit method JIT: Just in Time compiler is part of JVm and it bypasses the interpretaion phase by compiling bytecodea to machine native language at runtime
Factory Pattern: new means instantiating a concreate class
By Coding to interface, the class will work with any new classes implementing that classes through Polymorphism.
But if using the new operator/concrete classes it would make class liable to modification thus, "closed for modification" fails.
hence we need to take that code out from class to different object and encapsulate the same since addeing new implementation clesses
through modification will need to change the code. The new Object is called factory that takes out the object creation code out from
class defined earlier.PreRequisite: Differentiate which part of Code is supposed to be eligile to move out of the earlier class defination and hence
eligible for encapsulation.
By pulling the Object creation from earlier class to Factory class will make that concreate objects thus created to be eligible
to be called from different client, means there could be many different client calling for same Factory objects, hence
1.Concrete implementation is removed from client code.
2.By Encapsulating the Object creation at only one place, change of code for modification is restricted to that specific area.
Static Method Vs Simple Factory?
Write a class to implement interface: Not only implementing interface BUT could also be a concfete class implementing a method from
a supertype that could be clss/interface
1. case: When the Pizza Store is Single
public class PizzaStore{
SimplePizzaFactory factory; // HAS-A Composition // Reference to Interface
public PizzaStore(SimplePizzaFactory factory){
this.factory = factory;
}
public Pizza orderPizza(String type){
Pizza pizza;// Reference to interface /Abstract Class
pizza = factory.createPizza(type);// Code to be moved from concrete implementation from here to another Object(Factory)
// This is the part to be Encapsulated so that futher modifications will be restricted to this code itself
pizza.prepare();//Remains as earlier, where we had the concrete implementations
}
}
class abstract Pizza{
abstract createPizza();
}
class SimplePizzaFactory{
public Pizza createPizza(String type){// Return Interface to Object Called Pizza
if(type==""){
/*********************/
}elseif(type=""){
/*******************/
}
}
}
2. Case: When the Pizza Stores are Different ,so need to abstract the method and have concrete implementations in
different classes.(Abstract Factory Pattern)
public abstract class PizzaStore{//Defined Abstract so that implementations with be the type of factory
public abstract Pizza createPizza(type);
pizza.prepare();
}
abstract createPizza(String type);
/*
belos are the implementations for the PizzaStore
*/
public class NYPizza extends PizzaStore{
//Pizza createPizza(String type){
}
}
public class ChicagoPizza extends PizzaStore{
//Pizza createPizza(String type){
}
}
Here the subclasses ChicagoPizza and NYPizza is supposed to make decision of the Object creation
