TECHNO SCIENCE

JVM,Part3

noreply@blogger.com (Rishi Ranjan) — Thu, 01 May 2014 08:51:00 +0000

Something important about java.lang.ClassLoader

The class ClassLoader is an abstract class. Given the binary name of a class, a class loader should attempt to locate or generate data that constitutes a definition for the class.
Applications implement subclasses of ClassLoader in order to extend the manner in which the Java virtual machine dynamically loads classes.
The ClassLoader class uses a delegation model to search for classes and resources. Each instance of ClassLoader has an associated parent class loader. When requested to find a class or resource, a ClassLoader instance will delegate the search for the class or resource to its parent class loader before attempting to find the class or resource itself.
Normally, the Java virtual machine loads classes from the local file system in a platform-dependent manner. For example, on UNIX systems, the virtual machine loads classes from the directory defined by the CLASSPATH environment variable.
However, some classes may not originate from a file; they may originate from other sources, such as the network, or they could be constructed by an application. The method defineClass(String, byte[], int, int) converts an array of bytes into an instance of class.Instances of this newly defined class can be created using Class.newInstance.
The methods and constructors of objects created by a classloader may reference other classes. To determine the class(es) referred to, the Java virtual machine invokes the loadClass method of the class loader that originally created the class.

For example, an application could create a network class loader to download class files from a server. Sample code might look like:

ClassLoader loader=new NetworkClassLoader(host,port);

Object main= loader.loadClass("Main", true).newInstance();

The network class loader subclass must define the method findClass() and loadClassData to load a class from the network. Once it has downloaded the bytes that make up the class, it should use the method defineClass to create a class instance. A sample implementation is:

class NetworkClassLoader extends ClassLoader {

String host;

int port;

public Class findClass(String name) {

byte[] b = loadClassData(name);

return defineClass(name, b, 0, b.length);

}

private byte[] loadClassData(String name) {

// load the class data from the connection

}

How class loader behaves in case of array?

Class objects for array classes are not created by class loaders, but are created automatically as required by the Java runtime. The class loader for an array class, as returned by getClassLoader() is the same as the class loader for its element type; if the element type is a primitive type, then the array class has no class loader.

Is there any other related class loaders available in JDK?

1) public class SecureClassLoader extends ClassLoader = This class extends ClassLoader with additional support for defining classes with an associated code source and permissions which are retrieved by the system policy by default.

2) public class URLClassLoader extends SecureClassLoader =This class loader is used to load classes and resources from a search path of URLs referring to both JAR files and directories. Any URL that ends with a '/' is assumed to refer to a directory. Otherwise, the URL is assumed to refer to a JAR file which will be opened as needed. The AccessControlContext of the thread that created the instance of URLClassLoader will be used when subsequently loading classes and resources.

3) There is also class loader related with RMI called as RMIClassLoader

Some of the methods of ClassLoader that you need to care and it is useful in case of user-defined class loader:

1) protected final Class<?> defineClass(String name, byte[] b, int off, int len) throws ClassFormatError: Converts an array of bytes into an instance of class Class Before the class can be used it must be resolved. Every Java virtual machine implementation must make sure the defineClass()method of class ClassLoader can cause a new type to be imported into the method area.

2)protected final Class findSystemClass(String name):The findSystemClass()method accepts a String representing a fully qualified name of a type. If the bootstrap class loader has already loaded or successfully loads the type, it returns a reference to the Class object representing the type. If it can't locate the binary data for the type, it throws ClassNotFoundException. In JAVA2 the findSystemClass() method attempts to load the requested type from the system class loader.

3) protected final void resolveClass(Class c):The resolveClass() method accepts a reference to a Class instance. This method causes the type represented by the Class instance to be linked (if it hasn't already been linked). The defineClass() method, only takes care of loading. When defineClass() returns a Class instance, the binary file for the type has definitely been located and imported into the method area, but not necessarily linked and initialized. Java virtual machine implementations make sure the resolveClass() method of class ClassLoader can cause the class loader subsystem to perform linking.

JVM,Part2

noreply@blogger.com (Rishi Ranjan) — Wed, 30 Apr 2014 20:29:00 +0000

ClassLoading in Java

Classloading in Java is achieved by an entity called the Classloader.

A Classloader takes in the raw bytes from a .class file , standard Java api's provided with the SDK (or) any other custom classes required by class file and then creates the right bytecodes to run .class file

- The ClassLoader: It takes care of finding and loading the types( class, interface , enum and Annotation) in class loader subsystem.
- There are two types of class loader: Bootstrap class loader and User defined class loader or also called as Custom class loader
  - Bootstrap class loader is provided by the vendor which implements the abstract specification of the JVM.
  - User-defined class loaders or custom loader are the part of running java application. Classes loaded by different class loaders which are placed into separate namespaces inside JVM.
  - user-defined class loaders are regular Java objects whose class extend from java.lang.ClassLoader.For every type a Java virtual machine loads, it creates an instance of class java.lang.Class to represent that type. Like all objects, user-defined class loaders and instances of class Class reside on the heap. Data for loaded types resides in the method area.
The class loader subsystem deals with three steps process:
1) Loading: In loading process the class loader subsystem finds and brings the binary data required by the type into JVM. Means read the .class bytes into the JVM process memory

2) Linking:In Linking process binary type data is incorporated into the runtime state of the virtual machine. It involves three process:
- Verification: the binary data imported for the type being loaded is correct or not.
- Preparation: it involves building up JVM internal data structures to store the class entities in a way the JVM finds .The preparation phase allocates the memory needed by the type like memory for class variables and memory are initializes with the default values.
- Resolution: It is the process of transforming symbolic references in the constant pool into direct references. After verification, preparation, and (optionally) resolution are completed, the type is ready for initialization. the previous step had built up the data structures with relative offsets and symbol references - in this step we "resolve"
- These three steps mean to be happen in order. Only exception condition may be resolution step which can occur after initialization.

ClassLoader in java

1) Every Java virtual machine implementation has a bootstrap class loader, which knows how to load trusted classes, including the classes of the Java API. The Java virtual machine specification doesn't define how the bootstrap loader should locate classes.

2) The bootstrap loader looks in each directory, in the order the directories appear in the CLASSPATH, until it finds a file with the appropriate name: the type's simple name plus ".class". Unless the type is part of the unnamed package, the bootstrap loader expects the file to be in a subdirectory of one the directories in the CLASSPATH. The path name of the subdirectory is built from the package name of the type. For example, if the bootstrap class loader is searching for class java.lang.Object, it will look for Object.class in the java\lang subdirectory of each CLASSPATH directory.

3) BootStrap classloader Loads JDK internal classes, java.*packages. (as defined in the sun.boot.class.path system property, typically loads rt.jar and i18n.jar).

4) Apart from this there is extension class loader which Loads jar files from JDK extensions directory (as defined in the java.ext.dirs system property – usually lib/ext directory of the JRE)

5) In Java 2 SDK virtual machine, searching the class path is the job of the system class loader, a user-defined class loader that is created automatically when the virtual machine starts up.

6) System class loader Loads classes from system classpath (as defined by the java.class.path property, which is set by the CLASSPATH environment variable or –classpath or –cp command line options)

The class loader follows the delegation model where All , except the bootstrap ClassLoader, must have a parent -.

Bootstrap

Extension

Application

UserdefinedCL1 , UserdefinedCL2

What is delegation model?

The delegation model requires that any request for a class loader to load a given class is first delegated to its parent class loader before the requested class loader tries to load the class itself. The parent class loader, in turn, goes through the same process of asking its parent. This chain of delegation continues through to the bootstrap class loader (also known as the system class loader). If a class loader's parent can load a given class, it returns that class. Otherwise, the class loader attempts to load the class itself.

Consider an example: Say you have your own implementation of java.lang.String class.
Place it in the classpath Run your app, say, HelloWorld, with a custom classloader MyClassloader to load the String class Without parent delegation: you could probably force the classloading of your own implementation, rather than the more trusted one which comes with the SDK. In which case the chances of crashing the JVM rises from 99-100% With parent delegation: JVM go on with its usual business of asking bootstrap to load it from the RIGHT jar.

--MORE TO COME, KEEP VISITING

JVM

noreply@blogger.com (Rishi Ranjan) — Tue, 29 Apr 2014 00:24:00 +0000

Some Points you would love to know about JVM internals:
1) when we download JDK from oracle site and install it on machine then we get the JVM provided by the Oracle vendor same way IBM also provide its JVM and when you use linux then also there is Open JDK. That means there must be some abstraction or abstract specification which is implemented by these vendors. so when we talk about JVM three points come in light.

Abstract Specification that is implemented by different vendors
The concrete implementation provided by the different vendors like oracle, IBM and many more.
The runtime instance : the host where the java application will be running.

2) When java application starts the runtime instance is created and it dies with the completion of the program.Each java application runs inside its own Java virtual machine. i mean when if you will start three java application at same time on same computer then you will get three java virtual machine instances.

3) A JVM instance starts with the invocation of the main method of an application and with the invocation of main method a initial thread starts and which can run the other threads also.

4) In JAVA there is two types of thread one is daemon thread and other is non-daemon thread. Daemon thread is thread that is used by the JVM itself such thread is thread that perform garbage collection. Any thread can be marked as daemon thread. The initial thread that starts with the execution of main method is termed as the non-daemon thread.

5)When we talk about JVM instance then it is described in terms of subsystem,memory areas,data types and instruction set and these components describe the internal architecture for abstract java virtual machine.

6) Each JVM has class loader subsystem that provides the loading mechanism for the types that is class,interface,enums and annotations. Apart from that there is execution engine which helps to execute the instruction contained in methods of loaded classes.

7) After loading the class when we run a program , JVM needs memory to store many things including byte-codes , object created, method parameters return values ,local variables and intermediate result of computations. and these required memories are organized into several runtime data areas.

8) Each instance of JVM has one method area and one heap which are shared by all threads running inside the java virtual machine.

9)When the virtual machine loads a class file, it parses information about a type from the binary data contained in the class file. It places this type information into the method area. As the program runs, the virtual machine places all objects the program instantiates onto the heap.

10) As each new thread comes into existence, it gets its own pc register (program counter) and Java stack. If the thread is executing a Java method (not a native method), the value of the pc register indicates the next instruction to execute.

11) A thread's Java stack stores the state of Java (not native) method invocations for the thread. The state of a Java method invocation includes its local variables, the parameters with which it was invoked, its return value (if any), and intermediate calculations.

12)The Java stack is composed of stack frames (or frames). A stack frame contains the state of one Java method invocation. When a thread invokes a method, the Java virtual machine pushes a new frame onto that thread's Java stack. When the method completes, the virtual machine pops and discards the frame for that method.

13)The Java virtual machine has no registers to hold intermediate data values. The instruction set uses the Java stack for storage of intermediate data values. The stack-based architecture of the Java virtual machine's instruction set facilitates the code optimization work done by just-in-time and dynamic compilers that operate at run-time in some virtual machine implementations.

thread 1 and 2 executing java methods and thread 3 executing the native methods.

Non-Aaccess Modifier- final,Part4

noreply@blogger.com (Rishi Ranjan) — Mon, 28 Apr 2014 08:57:00 +0000

Scenarion7: Using Final with the reference variable and array.

What is impact of using final with reference variable or an array in java ?

Example 1: after using final also, we can change the element of an array.

package in.technoscience.finalreference;

class TestForFinal {
 public static void main(String args[]) {
  final int arr[] = { 1, 2, 3, 4, 5 }; // focus on final.
  for (int i = 0; i < arr.length; i++) {
   arr[i] = arr[i] * 10;
   System.out.println(arr[i]);
  }
 }
}

Output: 10 20 30 40 50

Que 2: what is happening here?

1)The array arr is declared as final, but the elements of array are changed without any problem.
2) Arrays are objects and object variables are always references in Java.
3) when we declare an object variable as final, it means that the variable cannot be changed to refer to anything else.

Example2: A simple program where reference variable is final

package in.technoscience.finalreference;

class Testing {
 int wilChange = 20;
 private int willChange;

 public static void main(String args[]) {
  final Testing t = new Testing();
  t.willChange = 30;
  System.out.println(t.willChange);
 }
}

Example3:impact of final keyword with reference variable

package in.technoscience.finalreference;

class TestForFinal2 {
 int iWillMakeUSuffer = 20;

 public static void main(String args[]) {
  final TestForFinal2 t1 = new TestForFinal2();
  TestForFinal2 t2 = new TestForFinal2();
  // t1 = t2; // compiler will be unhappy

                //t1= t2 means t1= new TestForFinal2 and that is not possible due to final 
  System.out.println(t1.iWillMakeUSuffer);
 }
}

Output: Compiler Error: cannot assign a value to final variable t1

In the above code t1 reference variable is pointing to TestForFinal2 and declared as final and t2 is another reference variable pointing to TestForFinal2.

Now in next line when we trying to refer final variable to refer to new type and that will not be possible as t1 is final.

So a final array means that the array variable which is actually a reference to an object, cannot be changed to refer to anything else, but the members of array can be modified.

Example 4: impact of using with the array.

package in.technoscience.finalreference;

class ExerciseTest {
 public static void main(String args[]) {
  final int arr1[] = { 1, 2, 3, 4, 5 };
  int arr2[] = { 10, 20, 30, 40, 50 };
  arr2 = arr1;
  //arr1 = arr2; // here compiler will say remove final from arr1.
  for (int i = 0; i < arr2.length; i++)
   System.out.println(arr2[i]);
 }
}

output will be : compile time error.

As array is an object in java and array name treated as reference variable and again we are using final with an array name and that means that can not point to the another array.

Practical 5th - Demo of Overriding

noreply@blogger.com (Rishi Ranjan) — Thu, 24 Apr 2014 07:46:00 +0000

Here I will explain the concepts of overriding through example code

To understand the reason go through the comments, but do not copy paste the code, it will generate error in your IDE, you can download the code from My Git Repository

import java.lang.IllegalAccessException;
// A class with some methods 
public class SamsungNote2 {

 public void openInNote2() {
  System.out.println("you are using note2");
 }

 protected void playWithNote2(String whatToPlay) {
  System.out.println("you are playing with argumented method");
 }

 public Object note2Feature() {
  System.out.println("i will deal with covariant return ");
  return null;
 }

 public void exceptionInNote2() throws IllegalAccessException {
  System.out.println("i will explain exception");
 }

 public void ExceptionalException() throws Exception {
  System.out.println("i behave different in polymorphism condition");
 }

}

Second class Extending Superclass

package in.technoscience.overriding;
//another class called as subclass extending superclass
public class SamsungNote3 extends SamsungNote2 {

 // method being overridden
 @Override
 public void openInNote2() {
 // if you wish to call method of superclass first then, back to subclass
  super.openInNote2();
  System.out.println("i m in note 3");
 }

 /*
  * while overriding changing the argument type if we change the argument
  * type then it will not be overridden method it will become new method for
  * subclass called as overloaded 
  */
 // @Override 
 //  protected void playWithNote2(int whatToPlay) {
  
  // }
  

 /*
  * // here focus on accessifier in super class we have used protected but
  * while overridding public and its alryt, so it satisfy accessifier rule
  */
 @Override
 public void playWithNote2(String whatToPlay) {
  System.out.println("i am overriden properly in note3");
 }/*
  * // now using higher restriction than superclass compiler is angry now...show red red           red red..
  */ 
  // @Override 
  // private void playWithNote2(String whatToPlay) { 
  //  super.playWithNote2(whatToPlay); 
  //  }
  

 // focus on return type
 // in superclass return type is object,here string and compiler is happy

 @Override
 public String note2Feature() {
 System.out.println("covariant return ==> as String is subclass of Object so allow");
        return "happy";
 }

 /*
  * // focus on Exception // superclass throws checked exception and here
  * this throw runtimeexception== compiler happy
  */
 @Override
 public void exceptionInNote2() throws ArithmeticException {
  System.out.println("i am in note 3 exception");

 }
    // superclass is throwing exception but subclass is not
    // compiler is happy here
 @Override
 public void ExceptionalException() {
 System.out
 .println("i will be called afther handling the exception,if not handled compilere thinks about superclass only note2!");
 }

 /*
  * // comliper is angry now, in subclass we are trying to throw new
  * checked exception and this is not allowed
  */
  // @Override 
  // public void exceptionInNote2() throws SQLException { 
   // TODO Auto-generated method stub 
 //  super.exceptionInNote2(); }
  

 // here compiler is again angry
 // we are trying to throw exception higher in hierarchy than exception
 // thrown in superclass method
    // @Override 
 //  public void exceptionInNote2() throws Exception { 
   
 //   super.exceptionInNote2(); 
  }

package in.technoscience.overriding;

import java.io.FileNotFoundException;
// a class with main method to test the concepts
public class Tsting {
 public static void main(String[] args) {

  // an object of subclass
  SamsungNote3 sn3 = new SamsungNote3();

  // check first are those methods inherited

  sn3.exceptionInNote2();

  sn3.openInNote2();
  sn3.note2Feature();
  sn3.playWithNote2("note3");

 }

}

Output:
i am in note 3 exception
you are using note2
i m in note 3
covariant return ==> as String is subclass of Object so allow
i am overriden properly in note3

Another class with main method to check polymorphic behaviour

package in.technoscience.overriding;

public class TestingOverridingInPolymorphism {
 
 public static void main(String[] args) {
  
  // reference type of super class and object creation of subclass
  //runtime polymorphism.
  SamsungNote2 sn4= new SamsungNote3();
  
  // due to polymorphism it will call the overriden method.
  sn4.openInNote2();
  sn4.playWithNote2("polymorphically");
  sn4.note2Feature();
  try {
   sn4.exceptionInNote2();
  } catch (IllegalAccessException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }
  
  // in subclass method have not thrown any exception, but
  // compiler sees left side of assignement operator and 
  //still thinks that we want to call method of super class
  //so suggest us to handle the exception.
  
  //sn4.ExceptionalException();
  
  try {
   sn4.ExceptionalException();
  } catch (Exception e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }
 }

}

output:
i m in note 3
i am overriden properly in note3
covariant return ==> as String is subclass of Object so allow
i am in note 3 exception
i will be called afther handling the exception,if not handled compilere thinks about superclass only note2!

Object Programming language Part7 - Overriding

noreply@blogger.com (Rishi Ranjan) — Thu, 24 Apr 2014 05:47:00 +0000

Overriding

When we code on basis of inheritance, abstract class,interface and polymorphism then we think and implement overriding concept.

The dictionary meaning of overriding is to counteract the normal operation going on.

There are certain rules that we need to keep in mind while using overriding concept:

First inheritance then only overriding. It is not possible to override without inheriting.
We can not override class field members,it can be only inherited.
Constructor of super class can not be overridden is subclass.
Only methods can be overridden.
In case of overriding, we can override abstract as well as concrete methods. Abstract methods meant to be being overridden unless and until class overriding the method is not an abstract class.

Rules to consider while overriding any method:

Imp: first method should be inherited then only it can be overridden

Method signature + return type should be same as superclass. Method signature means name of the method and argument list.
There is some exceptional rule in terms of return type that is called as co-variant return type that states that return type of overriding method can be subtype of the return type declared in method of superclass.
As there is always an access modifier attached with method so in that case overriding method(method of subclass) can not be more restrictive than the overridden method(method of super class). Although it can have any less restrictive access modifier. ( why? i will explain in sample code)
In case of subclass and superclass define in same package, we can override all those methods which are not private,final and static.
In case of subclass and superclass define in different package, we can override only those method which have public or protected access.

As methods can throw exception so there are some specific rules about exception in terms of overriding. ( i will explain exception in upcoming post). Till now think exception as some exceptional condition that has arisen in your code that can not be handled by your Jvm or Compiler.

Rules need to be consider in terms of exception while overriding any method

The overriding methods can throw any runtime Exception , here in the case of runtime exception overriding method (subclass method) should not worry about exception being thrown by superclass method.
If superclass method does not throw any exception then while overriding the subclass method can not throw any new checked exception but it can throw any runtime exception
Different exceptions in java follow some hierarchy tree(inheritance). In this case , if superclass method throws any checked exception , then while overriding the method in subclass we can not throw any new checked exception or any checked exception which are higher in hierarchy than the exception thrown in superclass method.

As in OOPs there is also concept of polymorphism and in case of polymorphism the accessibility of overriding methods adds some more concept that i will Explain using codes then only it will easy to understand.

To understand these all points in term of code follow my next post: Practical 5th - Demo of Overriding
--keep visiting

Object Oriented Programming Part6 - Inheritance

noreply@blogger.com (Rishi Ranjan) — Wed, 23 Apr 2014 11:36:00 +0000

Inheritance

The dictionary meaning of inheritance is the process of transmission of characteristics from parent to offspring.

In term of OOPs we can correlate the parents and offspring as type. so in OOPs inheritance means process of transmission of characteristics from one type to Other type where one is called as the supertype or base type and other type inheriting the base type called as the derived type or subtype.

Understanding inheritance is very important in java because it provides the foundation for understanding different hierarchies used JavaSE library like exception , thread and many more.

Coding in terms of inheritance provides re-usability which is very important paradigm of object-oriented methodology. Besides code re-usability it also plays an important role in achieving Polymorphism.

Inheritance helps to establish relationship between two types in java- these relationships are: IS-A relation and HAS-A relation.

With the rise of relationship inheritance give birth to two new concepts called as : Aggregation and composition.

To use the inheritance concept in our code we need to use the "extend" keyword with superclass name.

Example:

package in.technoscience.inheritance;

public class ParentClass {

}

package in.technoscience.inheritance;

public class ChildClass extends ParentClass {

}

For inheritance, these are things which we perform at class level.

Note: when you write any simple class in java without extending any other class then that simple class inherit java.lang.Object class. means since the first program we have written in java knowingly or unknowingly we are using the concept of inheritance. And this also states that Java.lang.Object is superclass of every class in java.

When we should adopt inheritance?
It all depends on the requirement, but before adopting to code level try to think for "is-a" relationship at class modelling level.
consider an example: if you are working on House management system then in that case house can be of different types it can be bungalow, Apartment type, independent house, hut. And house will build of bricks and cement. so in that case we can think as "is-a" relationship and can conclude that bungalow is a house, Apartment is a house, hut is a house. so in that scenario we can go for the inheritance concept. But when we think about dinning room , bathroom, kitchen then we can not say kitchen is a house or bathroom is a house. Here we can say house "has-a" kitchen, house "has-a" bathroom. here "has-a"will lead to composition.

What we can do after sub-classing a class?

A subclass will always inherit the public and protected member of superclass.
if superclass and subclass will be in same package then subclass can inherit the package-level members also.
After inheriting the fields in subclass, inherited fields can be used directly , here subclass will pretend that inherited fields are local to that class.
After extending any class we can declare any new fields in subclass which are not present in superclass.
In inheritance we can also declare a field in subclass which can have same name as superclass field, this technique is called as hiding.
In case of methods also we can use those directly considering as local method of that class.
Due to inheritance we can write same instance method signature in subclass like as in superclass this is called as overriding.
We can also write new methods in subclass which are not present in super class.
In inheritance we can write static methods in sublclass which can have same signature as the one in superclass -- this also represents hiding. but remember we can not override any static methods.
Constructors can not be inherited but from subclass we can call the constructor of superclass using super keyword.
A subclass does not inherit the private members of its parent class. However, if the superclass has public or protected methods for accessing its private fields, these can also be used by the subclass.

Example :
Look for comments for explanation.

package in.technoscience.inheritance;
//implicitly it is subclass of java.lang.Object
public class ParentClass {
 // instance methods with package level accessifier
 int a = 100;

 int b = 200;
    // static variable
 private static int noOfTimes;
 public static int noOfVisit;
 
 //private instance variable
 private boolean indicator;
 protected String name;
 
 
 // constructor
 public ParentClass() {
  
  indicator = true;
  name = "parent class";
  noOfTimes++;
  }
 
   // instance methods
 public void m1() {
  System.out.println("i am in m1 method of parent class");
 }

 public void m2() {
  System.out.println("i am in m2 method of parent class");

 }

 // static method accessing private variables
 public static void writeCount() {
  System.out.println("Number of times from super class: " + noOfTimes);
 }
 
 //normal static method
 public static void display()
 {  
  System.out.println("from parent class ");
 
 }
 
 //final method
 public  final void finalMethod(){
  System.out.println("i am final method of super class");
 }

}

Look around comments for explanation.

package in.technoscience.inheritance;

// subclass of Parentclass
public class ChildClass extends ParentClass {

 // same variable name as present in superclass
 int b = 30;

 // new variable of sub class
 int c = 40;

 // overridden method
 public void m2() {
  System.out.println("i am in m2 method of child class");
 }

 // new method of subclass
 public void m3() {
  System.out.println("i am in m3 method of child class");

 }

 // method hiding.
 public static void writeCount() {
  System.out.println("Number of visit from subclass: " + noOfVisit);
 }

 // here compiler complains in term of accessibility and
 // don't consider as new method of subclass
 /*
  * static void display() { System.out.println("from child class"); }
  */
 // here we used public accessifier now compiler is happy and considering as
 // new method of subclass
 public static void display() {
  System.out.println("i am from child class");
 }
 // final method can not be overridden but can be inherited
 /*
  * public final void finalMethod(){
  * System.out.println("i am final method of sub class"); }
  */

}

look around comments if you don't understand then ping me on facebook.

package in.technoscience.inheritance;

// a class for testing the concept
public class TestingInheritance {
 public static void main(String[] args) {

  System.out.println("first case===>");
 
  // creating an object of parent class
  ParentClass pc=new ParentClass();
  
  //accessing all members from parent class only, a normal scenario
  System.out.println(pc.a); //output : 100
  System.out.println(pc.b);//output : 200
  System.out.println(pc.name); // output : parentclass
  pc.m1(); // accessing m1 method of parentclass
  pc.m2(); // accessing m2 method of parentclass.
  pc.display(); // accessing static method of parentclass
  pc.writeCount(); // a static method of parent class dealing with private field
  pc.finalMethod(); // accessing final method of parent class.

  
        System.out.println("second case===>");
        
        // an object of child class
  ChildClass cb =new ChildClass();
  
  System.out.println(cb.a);//output : 100 ==> can be accessed due to inheritance
  System.out.println(cb.b);//output : 30==> same name as parentclass but value changed==> explain hiding
  System.out.println(cb.c);//output : 40 ==> new member of subclass only
  //System.out.println(cb.noOfTimes); can not inherit private member so not accessible through subclass
  System.out.println(cb.name); // o/p: parent class , protected members can be inherited so accessible
  //System.out.println(cb.indicator); // again private member
  cb.m1(); // accessible due to inheritance.inheritingly present in subclass
  cb.m2(); // overridden method
  cb.m3(); // new method of subclss
  cb.display(); // static method, it will called as new method and it also explain hiding
  cb.writeCount();// subclass hiding the static method of superclass.
  cb.finalMethod();// final method being inherited but not overriden
 
  
  
  System.out.println("third case =====>");
        // another object of parent class
  ParentClass pc1=new ParentClass();
  
  System.out.println(pc1.a);//o/p ==> 100 accessing member of his own class(parentclass)
  System.out.println(pc1.b);//o/p ==> 200 accessing member of his own class(parentclass)
  
  /*parent class does not have any information that who is going to extend him, so parent class does not know
   about members of subclass.*/
  // System.out.println(pc1.c); // c is presnt in subclass not in parent class. 
  
  pc1.m1();// method present in his own class
  pc1.m2();// method present in his own class
  
  //pc1.m3(); its not present in his own class, so parent class does not have any info about subclass member.
  
  
  
  // following code will explain static methods can not be overridden
  System.out.println("special scenario for static methods");
  ParentClass pc2= new ParentClass();
  ChildClass cc= new ChildClass(); 
  
  //runtime polymorphism
  ParentClass pc3= new ChildClass();
  
  pc2.writeCount(); //Number of times from super class: 6
  cc.writeCount();//Number of visit from subclass:0
  pc3.writeCount();//Number of times from super class: 6
  
  //if static method could have been overridden then last line and second last line both would have been giving
  //same output.its inherited but not overridden
  }

}

you can find the code at : My Git

more to come : aggregation,composition and scenario based on typecasting, types of inheritance supported in java, why not multiple inheritance.

Non-access modifier - final,part3

noreply@blogger.com (Rishi Ranjan) — Tue, 22 Apr 2014 13:03:00 +0000

Scenario 5 : Using final with Class

If we use final with Class then we restrict other class from extending that class, means final means end point of inheritance tree.
To create a final class we need to use final keyword with class declaration.
If we can not inherit the class then that means we can not use overriding concepts also.
Apart from using final, there is another way by which we can restrict inheritance that is by making all the constructor private.( i will explain this concept in constructor topic and singleton design pattern)
Making class final plays a vital role when we want to create an immutable type in java( i will explain immutability in another post).
In JavaSE library , java.lang.String is best example where String class is declared final.
In JavaSe library , java.lang.Runtime is class which have used private constructor.

Example :

package in.technoscience.finalclass;

public final class SomeClass { // class declared with final keyword
 public static void main(String[] args) {
  System.out.println("hello");
 }

}

public class AnotherClass extends SomeClass { // compiler unhappy

}

Here compiler will be unhappy, it will suggest you that if you want to extend the SomeClass then remove the final keyword from class declaration.

Note: We can not use abstract and final together with class declaration as the whole purpose of abstract is to be extended.

Scenario 6: Final methods in class

when we use final with methods in any class, then we allow inheritance but we prevent our methods from being overridden.
we can not override final method in extending class to write our own logic.
Here also we can not use abstract and final together with method,because abstract method means we need to override that method by extending the abstract class.

One example of a situation in which making a method final is the proper route to take is when a read-only property is used:

package in.technoscience.finalclass;

public class FinalMethod {
 private final String name;

 protected FinalMethod(final String name) {
  this.name = name;

 }

 public final String getName() {

  return this.name;

 }

}

In this example, the name property is set at construction time and can never be changed and we never want that a subclass to hide this property (which it could by declaring its own name property if getName( ) wasn't final).

This is a good reason to make a method final. By making getName( ) a final method, we can guarantee that the user of subclasses of this object will always call this method(not own method overridden in subclass) when that executes getName( ).

In the JDK, the method getClass( ) in java.lang.Object is final for this very reason.

Non-Access Modifier-final,Part 2

noreply@blogger.com (Rishi Ranjan) — Mon, 21 Apr 2014 16:29:00 +0000

Scenario3: Final local Variables
There can be scenario where we can use final keyword with the local variables.

package in.technoscience.finalasconstant;

1.public class FinalVariables {
2. public static String someMethod(final String environmentVariable){
3.  final String pathVariable= "env."+environmentVariable;
4.  System.out.println("pathVariable is"+pathVariable);
5.  return (System.getProperty(pathVariable));
 }

}

Here we have used final variable inside the method means as a local variable.In this case, the final variable is final only within the execution of method, which is different at each execution of the method. Each time the control enters inside method, the final is reconstructed and its can not change during the execution of the method.

package in.technoscience.finalasconstant;

public class TestingFinalVariable {
 public static void main(final String[] args) {
  System.out.println("note the change in path variable after method invocation:");
  FinalVariables.someMethod("JAVA_HOME");
  FinalVariables.someMethod("MAVEN_HOME");

 }

}

Each time the method is entered, the passed-in environmentVariable parameter is appended to the constant prefix and then fix for the duration of the method call. So why make the variable final? Because once this variable is set in the body of the method, it cannot be changed.

There may be below situation where not using the final can create problem:

package in.technoscience.finalasconstant;

public class FinalVariable {

 public static String wrongMethod(final String environmentVariable){
  final String path="Path_Variable :"+environmentVariable;
  System.out.println("path variable is:"+path);
 // path= new String("may be different value"); compiler unhappy
  return System.getenv(path);
 }
}

In this example, compiler was unhappy because I was trying to reassign path to a different value. But as we have used the final keyword, the compiler tells us that an error was made.

The technique of fixing variables with final become useful for long or complicated methods that have many local variables.

Note:
Method-scoped final variables aren't the same as constants even they behave like constant during method execution.

The difference is that method-scoped final variables are variable. Each time the method is entered, their values are changed based on the needs of that method execution.

However, method-scoped constants always have the same values regardless of the circumstances under which the method is run.

Scenario4:

package in.technoscience.finalasconstant;

1.public class ChainingOfFinals {
2. public final String name;

3. public final int nameLength = this.name.length();

4. // public final int nameLength = name.length();// compiler unhappy

5. // public final String anotherValue = name; // compiler unhappy

6. public ChainingOfFinals(final String name) {

7.  this.name = name;

 }

}

In this code,
line no 3 will work properly, final variable name must be initialized in the constructor of class Therefore, variable nameLength can take advantage of name when the instance is initialized. However, we must use the this keyword in front of the variable name. If we don't, it won't compile. we can visualize this at line no 4.

At line no 4 and 5 compiler will issue an error as follow:
The blank final field name may not be initialized.

....... To be continued in next post, keep visiting

Non-Access Modifier- Final, Part1.

noreply@blogger.com (Rishi Ranjan) — Mon, 21 Apr 2014 15:26:00 +0000

In Java final plays a vital role whenever we want to declare some constant in our code.

We can use Final keyword with following:

class
instance variable
instance methods
reference variables
static variables
static methods
local variables
parameters(inside methods)

In all these scenario, it imposes some restriction with their usage, Here in this series I will cover all different scenarios.

Scenario 1: when we need to use some constant value repeatedly

package in.technoscience.finalasconstant.Before;
// here i have not used the final keyword
public class FinalTheConstant {
 
 public static class ToolsForCircle{
  
  public double getCircleArea(final double radius){
   return (Math.pow(radius, 2)*3.141);
  }
  
  public double getCircumfere(final double radius){
   return ((radius*2)*3.14);
  }
  
  public double getVolume(final double radius, final double height){
   return ((radius*2*height)*3.141);
  }
 }

}

Problem: The problem with this code is that the developer has to change all three instances of the value 3.141 in all three methods if he wants to make his calculations more precise.

Improvement:

package in.technoscience.finalasconstant.After;

public class FinalAsConstant {
 public static class BetterCircleTool{
  
  // value of pi as constant using final
  public static final double pi=3.14;
  
  public double getCircleArea(final double radius){
   return (Math.pow(radius, 2)*pi);
  }
  
  public double getCircumfere(final double radius){
   return ((radius*2)*pi);
  }
  
  public double getVolume(final double radius, final double height){
   return ((radius*2*height)*pi);
  }
 }

}

Now the developer can change the constant, and this one change will propagate throughout the class

Scenario2: How compiler reacts when it sees the final

package in.technoscience.finalasconstant.Before;

public class Color {
 int red;
 int green;
 int black;
 public Color(int red, int green, int black) {
  super();
  this.red = red;
  this.green = green;
  this.black = black;
 }
 

}

Different type of instance variable declared as final

package in.technoscience.finalasconstant.Before;

public class ReplacementForFinal {

 /** A string constant */

 public final static String A_STRING = "I Am Java Developer";

 /** An int constant. */

 public final static int AN_INT_Type = 51;

 /** A double constant. */

 public final static double A_DOUBLE_Type = 12.55d;

 /** An array constant. */

 public final static int[] AN_ARRAY_Type = new int[] { 1, 2, 3, 6, 9, 18, 36 };

 /** A color constant. */

 public final static Color A_COLOR = new Color(45, 0, 155);

 public void someMethod() {

  System.out.println(A_STRING);

  System.out.println(AN_INT_Type);

  System.out.println(A_DOUBLE_Type);

  System.out.println(AN_ARRAY_Type);

  System.out.println(A_COLOR);

 }

}

Compiler reaction:
it starts substituting out the primitives and Strings objects as below:

package in.technoscience.finalasconstant.Before;

public class ReplacementForFinal {

 /** A string constant */

 public final static String A_STRING = "I Am Java Developer";

 /** An int constant. */

 public final static int AN_INT_Type = 51;

 /** A double constant. */

 public final static double A_DOUBLE_Type = 12.55d;

 /** An array constant. */

 public final static int[] AN_ARRAY_Type = new int[] { 1, 2, 3, 6, 9, 18, 36 };

 /** A color constant. */

 public final static Color A_COLOR = new Color(45, 0, 155);

 public void someMethod() {

  System.out.println("I Am Java Developer");

  System.out.println(51);

  System.out.println(12.55d);

  System.out.println(AN_ARRAY_Type);

  System.out.println(A_COLOR);

 }

}

Note:
As we have written whole code is all in one class, if we change a constant, we have to recompile this class anyway. However, if another class (for example, TheClient) is using the constant A_STRING and you change it in ReplacementForFinal then we have a problem. TheClient will have to be recompiled to trigger a re-substitution using the new A_STRING value, but the Java compiler will not notice this dependency.

package in.technoscience.finalasconstant.Before;

public class TheClient {
 public static void main(String[] args) {
  System.out.println("i wish to be::" + ReplacementForFinal.A_STRING);
 }
}

More scenarios on next post final part2

Practical 3rd - Demo of type conversion

noreply@blogger.com (Rishi Ranjan) — Mon, 21 Apr 2014 06:31:00 +0000

In last post I had explained about, Type Conversion, Here I will be presenting you the demo for type conversion with explanation.

you can find below code at my Git Repository,

package in.technoscience;

1.public class Demo3 {
2. public static void main(String as[]) {
3.  byte b1 = 10;
4.  Short s1= 14;
5.  long l1= 18;
6.  int intType = 15;
7.  intType= b1; // widening 
8.  intType= s1; // widening
9. // intType= l1; // compiler unhappy (narrowing)
10.  intType=(int)l1; // narrowing from long to int
11. // float f= 30.0; // compiler unhappy
  
12.  float fv= 30.4f;
13.  float fv1=(float)30.0;
14.  //intType=fv;// compiler unhappy
15.  intType=(int) fv;
16.  System.out.println(intType); // output 30.0
17.  // same will happen in case of double also
  
18.  //byte b2 = b1+2; // compiler unhappy
19.  byte b3 = (byte) (b1 + 2);
20.  System.out.println(b1);
21.  System.out.println(b3);
  
22.  float f1 = 10.0f;
23.  float f2 = (float) (100.4 / f1);
24.  float f3 = (float)(f1-0.0);
25.  System.out.println(f1);
26.  System.out.println(f2);
27.  System.out.println(f3);

 }

}

Explanation:

At line no 7: Widening as we are assigning byte type variable to int type, so it is handled by java implicitly. no explicit cast requires for these type of conversion

At line no 8: same as line no 7, short from int

for theoretical part of type conversion follow my post Type Conversion

At line no 9: compiler is unhappy, as here we want to perform narrowing by assigning long to int but for narrowing we need to tell compiler explicitly, so we need to perform explicit cast that i have perform at line no 10.

At line no 11: In java the decimal value is considered as double by compiler.so at this line no compiler is considering that we want to convert double value to float means narrowing , so compiler complains here. To sort this problem we can use explicit cast as line no 13 or can use f with float value as i have done in line no 12.

At line no 14: here compiler is unhappy due to same narrowing reason( float to int). To get rid of that we need to use explicit cast as line no 15 and when we will print this value we will get output as 30(loss of precision according to floating point rule)

At line no 18: To understand this take a note as follow:

The result of an expression involving anything int-sized or smaller is always an int.

so at this line no we are adding two bytes together and as per rule compiler wants to assign it to int type, but we are assign the result to byte so compiler is unhappy and complains as below

Type mismatch: cannot convert from int to byte

To get rid of this problem either we can change the type of b2 to int or we can use explicit cast like i had did at line no 19.

At line no 23 & 24: if you will see .class file using decompiler you will find

        float f1 = 10F;
        float f2 = (float)(100.40000000000001D / (double)f1);
        float f3 = (float)((double)f1 - 0.0D);

here compiler is first converting the denominator to double and then performing the division and then converting the result to float value.this is all done by the compiler.

Same way in next line it is converting the f1 to double and then performing the subtraction and then converting to double.

To know the theoretical part of narrowing follow my post :Widening and narrowing in java.

Basic Java Language Fundamentals - Type Conversion

noreply@blogger.com (Rishi Ranjan) — Sun, 20 Apr 2014 20:04:00 +0000

As we know Java is a strongly typed language, each data value is associated with a particular type. But sometimes it may require to convert a data value of one
type to another type, but we must be careful that we don’t lose important information in the process.

Conversion between one primitive type to another primitive type is termed as widening and narrowing conversion.

Widening conversion: They are called widening conversions because they go from one data type to another type that uses an equal or greater amount of space to store the value. It is something like you want to put a smaller box in larger box

Example: converting from a byte to a short is called widening conversion because a byte is stored in 8 bits and a short is stored in 16 bits. There is no loss of information.
All widening conversions that go from an integer type to another integer type, or from a floating point type to another floating point type, preserve the numeric value exactly.

When converting from an int or a long to a float, or from long to double , then some of least significant digits may lost.In this case,the resulting floating point value will be a rounded version of the integer value,following the rounding techniques defined in the IEEE 754 floating point standard.

Narrowing conversion: They often go from one type to a type that uses less space to store a value, and therefore some of the information may be lost. Narrowing conversions can lose both numeric magnitude and precision. correlate this with example like, trying to put larger box in smaller box and to make that fit into you need to cut it from sides means there will be loss of something.

when we convert a byte(8 bits) or short(16 bits) to a char(16 bits), then also it is considered as narrow conversioning because the sign bit is incorporated into the new character value.
Since a character value is unsigned, a negative integer will be converted into a character that has no particular relationship to the numeric value of the original integer.

A boolean value cannot be converted to any other primitive type and vice versa so boolean type in java does not play any role in type conversion.

Type conversion come in light during:

Assignment conversion
Arithmetic conversion
casting

Assignment conversion occurs when a value of one type is assigned to a variable of another type during which the value is converted to the new type.

For example,

float money;

int pound = 50;

Then we write money = pound ( widening ,so automatic conversion). Here it will be money = 25.0

But if we try to write as below:

dollar=money (compiler will issue an error due to narrowing conversion, to complete the conversion we have to use explicit conversion(means we have to tell compiler that yes i want this conversion).

Arithmetic promotion occurs automatically when certain arithmetic operators need to modify their operands in order to perform the operation.

For example,

float sum;

int count;

result = sum/count

Here value of count is promoted to a floating point value automatically, before the division takes place, producing a floating point result.

Casting: A cast is a Java operator that is specified by a type name in parenthesis. It is placed in front of the value to be converted.

For example, to convert money to an integer value, we could put a cast in front of it: pound = (int) money;
The cast returns the value in money, truncating any fractional part. If money contained the value 87.69, then after the assignment, pond would contain the value 84.

Casts are helpful in many situations where we need to treat a value temporarily as another type. For example, if we want to divide the integer value total by the integer value count and get a floating point result, we could do it as follows:
result = (float) total / count;

First, the cast operator convert a floating point version of the value in total. Then, count is treated as a floating point value via arithmetic promotion.

Now the division operator will perform floating point division and produce the intended result.

If the cast had not been included, the operation would have performed integer division and truncated the answer before assigning it to result.

Also note that because the cast operator has a higher precedence than the division operator, the cast operates on the value of total, not on the result of the division.

Object Oriented Programming, Part 5 - Abstraction

noreply@blogger.com (Rishi Ranjan) — Sun, 20 Apr 2014 07:05:00 +0000

Abstraction

The literal meaning of Abstract is to Extract something. Same way, in OOPs abstraction means to extract something that is required and to leave that is not going to solve our purpose.

Instead of going in technical aspects,I will explain it from real world:

Consider a situation you are sitting in your room and reading my blog, then there may be lots of things in your room, may be your study table , laptop and many more.. In addition, each one of these components in turn has details associated with it, like: the type of material used to make the legs of the table (wood or metal), the wattage of the lightbulbs, etc. These all information are processed by our brains, but with all processing, there also an abstraction process involves which focus on recognizing and focusing on important characteristics of a situation of a Object and filtering out unwanted details.

One familiar example of an abstraction is a road map. As an abstraction, a road map represents those features of a given geographic area relevant to someone trying to navigate with the map, perhaps by car: major roads and places of interest, obstacles such as large bodies of water,etc.

Abstraction in term of software development:

As with all abstractions, we take decisions on inclusion versus elimination when building a software system, and this abstraction must be made within the context of the overall purpose and domain, or subject matter focus, of the future system.

When representing a person in a software system, for example, is their eye color important? How about their genetic profile? Salary? Hobbies? The answer is, any of these features of a person may be relevant or irrelevant, depending on whether the system to be developed is:

payroll system, patient record system for hospital management, police record tracking system and many more...

After determining the essential aspect we focus on preparing a model and it helps us to build pattern for something that we want to build.

How we achieve abstraction in java? Which concepts we use to achieve abstraction in java?

here answer is : The concept of Abstract class and Interface ( I will be writing about abstract class and interface in details in next post).

Object Oriented Programming, Part 4 - Encapsulation

noreply@blogger.com (Rishi Ranjan) — Wed, 16 Apr 2014 18:39:00 +0000

Encapsulation

The literal meaning of encapsulation is to encase the things together like capsule.

Same way, In OOPs encapsulation is the process of binding data members( variables) and member functions(methods) into single unit. In that case defining a class in java is best example.

In Object Oriented Programming we need to focus on the proper encapsulation. To achieve proper encapsulation the access modifier plays a vital role. To know about access modifier follow my post,Access Modifier .

Why we need proper Encapsulation?

When we work on any application, we will not be the single developer working on that.

Now consider the following code:

package in.technoscience;

public class WrongEncapsulation {

 public int age; // an instance variable with public access modifier.
 public String name;
}

now suppose other developer use your code like as below :

package in.technoscience;

public class Testing {
public static void main(String[] args) {
 WrongEncapsulation we= new WrongEncapsulation();
 we.age=-6; // its legal no complain from compiler but its bad
 System.out.println(we.age);
}
}

From above code the other developer can access the class variable and can modify that, here other developer accessed the age instance variable directly and change its to negative value, so in any case does negative age makes any sense?

Now to achieve the proper encapsulation, we need to follow following steps:

use private access modifier with the instance variables.
to access those instance variables, use the public methods, in terms of java we called those methods as setter and getters. To write those methods we use JavaBean naming convention.

Improving the above code:

package in.technoscience;

public class ProperEncapsulation {

 private int age;// private instance variable
 private String name;
 public int getAge() {// setter and getters methods to access instance variable
  return age;
 }
 public void setAge(int age) {
  this.age = age;
 }
 public String getName() {
  return name;
 }
 public void setName(String name) {
  this.name = name;
 }

Summary:

Encapsulation helps to write more flexible and maintainable code
Encapsulation helps to bind all variables and methods into single unit called as class
Encapsulation provides an ability to make changes in our implementation code without breaking the code of others who use our code.
Encapsulation solves the problem at implementation level and hide the implementation and protect the data from outer world (which can modify our code) using access modifier.

WEB DEVELOPMENT - HTTP(PART 2)

noreply@blogger.com (Rishi Ranjan) — Tue, 15 Apr 2014 18:12:00 +0000

In the HTTP series, in last post Http Fundamentals, I have explained about the basic of HTTP, In this post i will explain about the , message exchanged between in an HTTP transaction. I will explain here about the message types, methods incorporated, Http headers, and status codes that server respond after getting the request from the client.

Message types:

consider a scenario , you are traveling somewhere and during your travel you asked someone about time. Now to get answer from that person, that person should understand the language you have asked and he/she should must have access to some of time keeping device. The HTTP works same way.our browser is client and our browser will make request to server to get some resource.

The HTTP/1.1 specification defines a language so that everyone on web like all clients and servers can understand each other.

According to HTTP/1.1 specification , there is two types of messages

Http request: This is first type of message that is sent by the client to the server and there is some format and message type that should be included while sending to the server.

Http response: In response to the request received by server, server respond to the client and that will contain some formatted message which should understand by the client.

The HTTP standard defines what goes into these messages, so that everyone who speaks Http will understand each other and will able to exchange resources. And when resource does not exist , the HTTP response will contain an error message in some format that client will understand.

To Understand what it contains in Http request message and what it contains in Http response message, then install a addons for firefox called Live Http Headers.

Http Methods
Every request message have to include one of the available HTTP method and these methods tells the server what requests want to do.

Some of the common Http Methods

In web development only two methods are important, these are : Get and Post.
A web browser issue get request to retrieve resources from server means basically to read the data. while post usually used, when we want to send some data to server. Post requests are typically generated by a form element on a web page like the form that we fill out with input elements for address and credit card information.
Post method is use to process a credit card transaction, update an account, submit an order or perform other operation that will bring changes on server side.

I will demonstrate this with an example:
Suppose while visiting a website from web browser you request signup.html, then it will request to server and will bring back HTML and will display this form. In this case you refresh this page as many times as you want it will present same thing and it will not change anything.
Now you fill that form and submit that , here http request will issue post method and once submit you refresh that again then browser will issue a warning because browser this time know that while refreshing you can submit a duplicate information and later its consequences can have alter affect, That's why browser issue warning for the user.

Being a developer we can improve with coding and we can store these at server side in session and this technique called as post/redirect/get. To know more follow this link.

When we use get method to send http request then browser put the input the query string. so most of time if you see any link in any document, that link is something incorporated with the get method, that's why when you click on that link that directly open in web browser.

A full request message consist of :

Example: GET http://server.com/articles/741.jsp HTTP/1.1
The common request header:

If-Modified-Since is used to retrieve mostly in case of accessing JPEG times, if the image the request trying to access has not modified then the server will not send that image again, browser can retrieve that from cache of browser.

Example:
GET / HTTP/1.1
Host: server.com
Connection: keep-alive
User-Agent: Mozilla/5.0 (Windows NT 6.1; WOW64) Chrome/16.0.912.75 Safari/535.7
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Referer: http://www.google.com/url?&q= java
Accept-Encoding: gzip,deflate,sdch
Accept-Language: en-US,en;q=0.8
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.3

Here you can notice something written in bold that represents Q value which represents the relative quality value. the default Q value is 1.0.

Complete response message:

Example:

HTTP/1.1 200 OK
Cache-Control: private
Content-Type: text/html; charset=utf-8
Server: Microsoft-IIS/7.0
X-AspNet-Version: 2.0.50727
X-Powered-By: ASP.NET
Date: Sat, 14 apr 2014 04:00:08 GMT
Content-Length: 17151

<html>

content ...

</html>

Status code:

Details:

In case of 304 status code, client will fetched the resource from the cached locally.

403 status code tells that you have tried to gain access to something that server do not want you to have access to.

status code 500 means internal server error and that could be due to exception in application code and it could be also possible due to problem in server software itself.

Status code 503 will be issued when server is under heavy load and can not handle any additional connections and can not process any additional request.

Web Development - HTTP

noreply@blogger.com (Rishi Ranjan) — Fri, 11 Apr 2014 18:48:00 +0000

What is HTTP and Why it is required to understand?

HTTP means Hypertext Transfer Protocol. HTTP is the protocol that lets us search for a book on google and buy one from flipkart.com. It's also the protocol that lets us reunite with old friends on a Facebook chat or watch a music video on you tube.It's a protocol that allows a web server from a data center in the United States to ship information to an Internet cafe in India where a student can read a web page describing the great wall of China. I.

Having a solid understanding of HTTP can help you write better web applications and web services. It can also help you debug applications and services when things go wrong.

Uniform Resource Locator

It represents HTTP address. whenever we need to buy a book to study we open a web browser and enter http://amazon.com in address bar and there we search for book we want.
Here our browser makes Http request to server name amazon.com and then that get response from server according to availability.
http://www.amazon.com it is called as URL which represent specific resource on web. Resources may be image,pages,files or video or anything to which we want to interact. Two different resources on web will have two different URL.

When we write any URL , we can break the URL into three parts.
1st there is http part before colon and double slash it is called as URL scheme and describes how to access particular resource. there can be other URL scheme like HTTPs it describes secure protocol.

Everything after colon and double slash will be specific to specific to particular scheme.

The first part after colon slash is amazon.com that is called as host. this part tells browser which computer on internet is hosting the resource. computer will use the domain name system to look up an address for amazon.com and turn that into network address and then it will know exactly where to find a request.
Host portions can be also specified using IP address like 204.78.50.82

The last path of URL is URL path which tells which specific resources is requested by this path. That path can point to the specific resource present in real on server.some path can represent dynamic content by using content from database.

These days websites try to avoid to have any real file name in URL. Many websites try to place key word in URL, which helps in search engine optimization that will rank the resource higher in search engine results.

Including URL scheme,host name, URL path , URLs also contain port number that host is going to use to listen for Http request. The default port for Http is port 80.
consider another URL as : http://google.com/search?q=java
Here everything after ? mark is called as query or query string. This query Sting contain information for the website and it is interpreted by the application and its interpretation will tell what resource you want.The query string always appears in name value pairs.

consider another URL as : http://wikipedia.org/wiki/java#description
here everything after # symbol called as fragments and when you will type in address of browser , this portion of website will appear on top of screen.

so the normal url can be represented as :
http://host:80/path?q=query#fragment .

URL Encoding
It helps us to understand the character and encoding issue with URLs like which characters are safe for URLs and which characters are unsafe for URLs.
The space, pound sign and caret these are unsafe characters for the URLs. RFC 3986 provides rules for URLs. Uppercase letters, lower case letters, digit and astresik, paranthesis,dollar sign, underscore these are safe characters for URLs.

We can also include unsafe characters in URLs using URL encoding.

Example : http://abc.com/rishi%20ranjan.
here 20 is hexadecimal value for space character in US ASCII character set. Almost Every web framework use APIs for URL encoding

Content type:
As web is full of resources like image, videos and different types of document And when we make request for specific type of resource the host should represent that resource in the way the client want it.

so when host respond to Http request , it returns the resources as well as it also specify content type.

The content type a server depends on multi-purpose internet main extension or MIME standards. so when the client requests an HTML web page then host respond to request with HTML labels as text/html where text is primary media type and HTML is sub type. when host respond for image request, host label the resource with content type of image/jpeg or gif or png. here text will appear in HTTP response and location where the client can parse it. To deal with such situation and content type we need to configure the MIME type in web server.

Content Negotiation:
suppose we want to visit a site for any kind of recipe, a recipe can be represented in different languages like English,German or may be other and their format for presentation can also differ from HTML to PDF or may be Plain text
In this case when an client makes an HTTP request to a server client can also specify the media types here client can specify what it can accept back from host and on the basis of availability the host will return to the client so that's why it is called as content negotiation.

In terms of language you can see content negotiation while changing language preference in google .com.

This content negotiation plays a vital role when developer deal with web services. A piece of code written in Java script can make request to server and ask for a JSON representation. meanwhile a piece of code written in C++ can make a request to same server to same URL and ask for an XML representation of a resource. And in both case host will satisfy the request and information will arrive at client in ideal format for parsing.

Practical 2nd : Demo of reference,static and local variable

noreply@blogger.com (Rishi Ranjan) — Thu, 10 Apr 2014 08:53:00 +0000

In last post, I have presented code for literals and primitive type instance variable , Here i will present practical explanation and different scenarios in terms of reference variable, static variable and local variable.

package variableFirst;

1.public class KnowYourVariable {
2. KnowYourVariable myVariable; // it can point to object of KnowYourVariable class 
                            
3. static KnowYourVariable myVariable2; // static variable

4. AnotherReferenceVariable anotherVariable;// it can point to object of AnotherReferenceVariable class only
     
5. AnotherReferenceVariable arv = new KnowYourVariable(); // compiler unhappy

6. public void show() {
7.  System.out.println("printing myVariable:" + myVariable);
8.  System.out.println("printing myVariable2:" + myVariable2);
9.  myVariable = new KnowYourVariable();
 }

10. public static void main(String[] args) {
11.  KnowYourVariable knw;
12.  knw.show(); // compiler unhappy
13.  KnowYourVariable knw = new KnowYourVariable(); // compiler unhappy
14.  myVariable2.show(); //JVM unhappy

15.  KnowYourVariable knw1 = new KnowYourVariable();
16.             knw1.show();
17.             System.out.println(knw1.myVariable);
18.             System.out.println(KnowYourVariable.myVariable2);
 }

}

19.class AnotherReferenceVariable {

}

Output:
printing myVariable:null
printing myVariable2:null
variableFirst.KnowYourVariable@4283df14
null

Explanation:

line no 1: creating a new class.
line no 2: Uninitialized reference variable whose type is KnowYourVariable class.
line no 3: static variable also called as class variable whose type is KnowYourVariable class

line no 4: Another instance variable whose type is AnotherReferenceVariable.
line no 5:here compiler is unhappy because reference variable is arv whose type is AnotherReferenceVariable but reference value that it is pointing is KnowYourVariable and there is no relation between KnowYourVariable and AnotherReferenceVariable. so here to make compiler happy arv reference variable should point to the its reference type that is AnotherReferenceVariable. but in case of inheritance and polymorphism this situation can change that we will see in another demo.

line no 6: a method to represent some behavior
line no 7: here it will print the implicit value of instance reference variable as null.
line no 8: here it will print the implicit value of static variable as null.
line no 9: here myVariable reference variable will refer to object created of its type that is declared at line no 2.
line no 10: main method to invoke JVM and test the program

line no 11: a local variable of type KnowYourVariable class.
line no 12:compiler is unhappy here because we are using the uninitialized local variable.
line no 13: here we have initialize the variable but compiler is again happy due to duplication of name of variable knw.

line no 14: here compiler will not complain, but java runtime environment will complain ,when we will run the program because here we are using static variable myVariabe2 which points to implicit initialized value that is null. here myVariable2 does not understand whose methods to call, or it does not understand it is pointing to which reference value. so JVM issue NullpointerException means the reference variable you are using to call the method is pointing to null instead of object whose method you want to call.

line no 15: Creating an object of KnowYourVariable class and reference variable knw1
line no 16: properly accessing the method defined in class, here compiler as well as jvm both are happy.
line no 17: printing the value pointed by myVariable by accessing it using dot operator with knw1 reference variable.
line no 18: printing the value pointed by myVariable2 , as it is prefixed with static so we can treat it as class variable and we can access it through class name as well as reference variable.

To know the theoretical about this practical follow my post HERE

BASIC JAVA LANGUAGE FUNDAMENTALS - Variables

noreply@blogger.com (Rishi Ranjan) — Thu, 10 Apr 2014 08:38:00 +0000

Variables

A variable has a name, type , and a value associated with it and a variable can stores value of particular type associated with it.
In java variables can store values of primitive type as well as reference values of object.
In java, depending upon position of declaration, variables are categorized as instance variables and local variables. With these the variables which stores reference values of objects are called reference variables.
Apart from reference variable ,there is concept of class variable which is prefixed with keyword static.
The declaration of variables implicitly determines about memory allocation and values that can be stored in them.

Example : int first ;
here it represents declaration of variables which is not initialized explicitly. here in this example first is the name of the variable and int represents the type of variable.

Instance Variables:

When we create a class in java, we write fields within class, those fields are termed as instance variables.
Each object created from class will have its own copies of the fields defined in the class.
The values of these instance variables, represent the state of an object.
Two different object can have same state , if their instance variables have same values.

To know the practical demo, follow my post Here

static variables

static variables are those variables which are prefixed with static keyword

static variables belongs to class , not to any object of class.
static variables is initialized when the class is loaded at run-time.

Reference variables

Reference variables store reference value of an object and can be used to manipulate the object denoted by reference value.
When we declare reference variable then there is reference type associated with the reference variable and that reference type can specify to name of class,interface and an array.
Before we can use a reference variable to manipulate an object, it must be declared and initialized with the reference value of the object.

A reference variable can be of only one type, and once declared, that type can never be changed (although the object it references can change)

A reference is a variable, so it can be reassigned to other objects, only exception is use of final with reference variable( i will explain use of final in separate post)
A reference variable's type determines the methods that can be invoked on
the object the variable is referencing.
If the variable is declared as an interface type, it can reference any object of any class that implements the interface. ( i will explain interface separately in different post)
A reference variable can refer to any object of the same type as the declared reference, it can refer to any subtype of the declared type ( i will refer it again when i will explain inheritance and polymorphism in separate post).

Note :
In case of instance variable,static variable and in Array, if we don't provide any explicit initialization ,then those instance variable are awarded with default initial values depending upon their type.

The implicitly assigned default values are as follows:
boolean ---> false
byte ----> 0
short ----> 0
int -----> 0
long ------> 0l
char -----> /u0000
float ------> 0.0f
double ----> 0.0d
any object reference ----> null

Local variables

local variables are variables which are declared in methods, constructors and blocks.
local variables must be explicitly initialized before we can use . if we will try to use uninitialized local variables then compiler will issue an error.

To know the practical demo , follow my post HERE

Practical 1st : Demo of primitive types in java

noreply@blogger.com (Rishi Ranjan) — Tue, 08 Apr 2014 14:10:00 +0000

Practical code to understand the Primitive types in java, to know theoretical part follow my post here,Basic Java Fundamentals

package in.technoscience;

class hello {
 byte b;        
 short s;          
  int i;
 long l;
 float f;
  double d;
  char ch;
  boolean b1;
  float f1 = 10.9f;
 

 void show1() {
  System.out.println("instance Variables default value  demo :");
  System.out.println(b);
   System.out.println(s);
  System.out.println(i);
   System.out.println(l);
  System.out.println(f);
   System.out.println(d);
  System.out.println(ch);
   System.out.println(b1);
   System.out.println(f1);
  
 }

 void show2() {
  System.out.println("Integer literal demo :");
   int a = 12;
  int b = 012;
   int c = 0x12;
   int c1 = 0x12a;
  byte d = 012;
// when you will check .class file using decompiler you will find it has been replaced
as follow: //int a = 12;
               // int b = 10;
                //int c = 18;
               // int c1 = 298;
               // byte d = 10;                System.out.println(a);
   System.out.println(b);
   System.out.println(c);
   System.out.println(c1);
  System.out.println(d);
  }

 void show3() {
   System.out.println("Floating point literal demo :");
   float f1 = 99.9f;
   double d1 = 9.9e-9;
   double d2 = 9.9E+9;
// when you will check .class file using decompiler you will find it has been replaced
as follow:    //float f1 = 99.9F;
              //double d1 = 9.8999999999999993E-009D;
              //double d2 = 9900000000D;
  System.out.println(f1);
  System.out.println(d1);
  System.out.println(d2);
  }

  void show4() {
    System.out.println("Character literal demo :");
   char ch1 = 'A';
   int x1 = 'A';
   char ch2 = ' ';
   int x2 = ' ';
   char ch3 = '1';
    int x3 = '1';
  char ch = ' ';
// when you will check .class file using decompiler you will find it has been replaced
as follow:    // char ch1 = 'A';
             //  int x1 = 65; //ASCII value according to type we have used for value
             //  char ch2 = ' ';
             //  int x2 = 32;
             //  char ch3 = '1';
              // int x3 = 49;
              // char ch = ' ';
   System.out.println(ch1);
   System.out.println(x1);
  System.out.println(ch2);
   System.out.println(x2);
   System.out.println(ch3);
   System.out.println(x3);
   System.out.println(ch);
  }

 void show5() {
   System.out.println("Boolean literal demo :");
   boolean bb1 = false;
   boolean bb2 = true;
   boolean bb3 = true;

  System.out.println(bb1);
   System.out.println(bb2);
   System.out.println(bb3);
 }

  void show6() {
  System.out.println("string literal demo :");
   String str1 = "";
  String str2 = "123 abc + ";
  String str3 = "      1";
// when you will check .class file using decompiler you will find it has been replaced
as follow: //System.out.println((new StringBuilder("Str1=")).append(str1).toString());
        //System.out.println(str1.length());
       // System.out.println((new StringBuilder("Str2=")).append(str2).toString());
       // System.out.println(str2.length());
        //System.out.println((new StringBuilder("Str3=")).append(str3).toString());
       // System.out.println(str3.length());
  System.out.println("Str1=" + str1);
  System.out.println(str1.length());
  System.out.println("Str2=" + str2);
   System.out.println(str2.length());
  System.out.println("Str3=" + str3);
  System.out.println(str3.length());
  }
 }

class lab2 {
  public static void main(String as[]) {

  hello h = new hello();
   h.show1();
  h.show2();
  h.show3();
   h.show4();
  h.show5();
   h.show6();
 }

}

Output :

Instance variables default demo :
0
0
0
0
0.0
0.0
false
10.9

Integer literal demo :
12
10
18
298
10

Floating point literal demo :
99.9
9.9E-9
9.9E9

Character literal demo :
A
65

32
1
49

Boolean literal demo :
false
true
true

string literal demo :
Str1=
0
Str2=123 abc +
10
Str3= 1
7

BASIC JAVA LANGUAGE FUNDAMENTALS - Object creation( instantiation).

noreply@blogger.com (Rishi Ranjan) — Tue, 08 Apr 2014 10:38:00 +0000

In OOPs Series, i have explained Class and Object. But to use an object and to get the work done first we need to create an object by considering Class as an template for Creating an object in java.

As an object is an instance of a class, so by using our understanding we can say, creating an instance of class is called as instantiation.

In java there are different ways through which we can create an object like ...

using new keyword.
using class.forName()
using clone() method
Using object desirialization.
using ClassLoader mechanism

Apart from that if we dive much deeper then there is also a design pattern called as Factory Design Pattern, which is also used.

But every technique has its own importance and there is some boundation bounds with them.

Here I will explain about using new keyword for creating an object. In upcoming post i will Explain about all other techniques.

Example :

package in.technoscience.first;

1. public class ObjectCreation {

2. public static void main(String[] args) {

3.  ObjectCreation oc = new ObjectCreation();
 }

}

(reference
At line no 3: variable) (call to class constructor)
ObjectCreation oc = new ObjectCreation()

(classname) (keyword)

To understand the instantiation process try to correlate it with remote and television.
consider television as an object and remote as an reference. as long you are holding the reference you have connection with the television. as soon as one says to change the channel or volume you work with reference which modifies an object. And if you want to move to different place you move with remote (reference ) not with the television (object).

same way in above code ObjectCreation oc is the reference to the object created by the statement new ObjectCreation() pointed by right hand side of assignment operator.

Object Oriented Programming , Part 3 - Class and Objects

noreply@blogger.com (Rishi Ranjan) — Mon, 07 Apr 2014 14:35:00 +0000

In my last post, i had posted Basic definitions related with OOPs, here we will explain the details about Class and Objects.

Objects

If we talk about OOPs then that means Everything is an Object. if you are Solving a problem in OOPs ,then element of problem domain will map to object in solution of that problem.

What an object represents?

Consider yourself, what you can represent about yourself, you have height, you have some weight, your skin complexity means these all things will present your state at one time.

Now what you can do? you can walk , you can talk or can do things.. what it represents? it represents your behavior.

Now you might be having any social security number or may be any number that meant for you only, means that will represent your identity and through that number or identity no body else can be represented.

An object has state,behavior and identity. An object can have internal data (which gives it state), methods (to produce behavior), and each object can be uniquely distinguished from every other object—each object has a unique address in memory.

Class

A class represents categories of object.

A class provides template for creating an object.

A class represent a type in java.so when we create any object for a class then that object will have some type and that type will be represented by the name of class.

While writing a java program , when we write any class we write a variable that is called a s field in world of java, along with variable we write methods which can perform some operations.

Field in a class used to store value that represents particular property of an object and using operations we can manipulate the values stored in variable or fields.

The members (elements) of each class share some commonality: Every customer has an account, every account has a balance, every teller can accept a deposit, etc.

At the same time, each member has its own state: Each account has a different balance, each teller has a name.

Thus, the tellers, customers, accounts, transactions, etc., can each be represented with a unique entity in the computer program. This entity is the object, and each object belongs to a particular class that defines its characteristics and behaviors.

NOTE: When we talk about software design, then in that case we need to consider "Object as Service Provider". And considering Object in that way supports High Cohesion. In simple words high cohesion means how different components fits together.

In upcoming post i will explain about this quality of object with a use case.

Basic Java Language Fundamentals.

noreply@blogger.com (Rishi Ranjan) — Mon, 07 Apr 2014 08:39:00 +0000

Tokens

Tokens are low level elements of any language and using tokens higher level constructs are build.

Ex :numbers, identifiers,special characters and operators are the example of tokens and using this we build classes,methods, expressions.

Identifiers:

Its just a name with some convention, used to denote classes,methods,variables and labels.

The first character must be always must be a letter, underscore(_) or currency symbol like dollar($).

Keywords

keywords means reserved words in java that can not be used to denote another entities. ex: final,abstract,package,public,private....so on...

Literals

It represents constant value , its value can not be changed once that is assigned to an literal.

it represents boolean , character , numeric and string values.

A Unicode character can always be specified as a four digit hexadecimal number (i.e., 16 bits) with the prefix \u.

Escape sequence

It defines special characters,that can be single-quoted to define character literals.

Note : the character literals '\t' and '\u0009' are equivalent.

the character literals '\u000a' and '\u000d' should not be used to represent newline and carriage return in the source code. These values are interpreted as line-terminator characters by the compiler, and will cause compile time errors.

Primitive data types

Three main categories :

Integral types : signed integers ( byte ,int, short, long) , unsigned(char)
Floating -point types: fractional signed numbers (float, double)
boolean type : represent logical values( true and false)

Integer Primitive Data Types :

Their values are signed integers represented by 2’s complement

The char type :

Their values are unsigned integers that denote all the 65536 (216) characters in the 16-bit Unicode character set. This set includes letters, digits, and special characters.

The floating-point types:

Floating-point numbers conform to the IEEE 754-1985 binary floating-point standard.Since the size representation is a finite number of bits, certain floating-point numbers can only be represented as approximations

boolean data type

Boolean values are produced by all relational, conditional and boolean logical operators, and are primarily used to govern the flow of control during program execution.

The presence of primitive data types in java has been always a point which dictates it against complete object oriented programming language.

In support of complete object oriented programming ,java has a Wrapper class that resemble the primitive data type. ( I will post separately about Wrapper class)

To understand these primitives type with working code, follow my post Code To understand primitive type in java

Access Modifier with some one liner questions and answers

noreply@blogger.com (Rishi Ranjan) — Thu, 03 Apr 2014 14:19:00 +0000

Q. why we need access modifier ? or what is purpose of access modifier?

Ans: Access modifier controls the visibility of class and class members. And controlling the accessibility of class and class members relates one of the famous OOPs concept that is Proper Encapsulation.

Q. what are different types of access modifier supported in java.

Ans: There are four different types of access modifier supported in java.

public.
private
default (package-level)
protected.

Q. Out of four Access modifier which modifier can we use with class ?

Ans: we can use only two access modifier with class

public and default

Q. At this stage some of interviewer may ask some vague question why we can not use private or protected access modifier with class?

Ans: here again you can answer in terms of visibility if class will not be visible to jvm then how it will execute and how other parts of application will use that class.

Q.What can be accessibility order for java access modifier?

Ans:

public : accessible everywhere -- so highly accessible,less restrictive comes at top

protected: Accessible by any class in the same package as its class, and accessible only by subclasses of its class in other packages . so it comes below public access modifier at second position

default: Accessible by any class in the same package as its class, and accessible only by subclasses of its class in other package .it comes at 3rd position below protected.

private: Only accessible in its own class and not anywhere else. so it comes at last position,very less accessibility.

Q. Explain different access modifier in java.

Ans:

public

for detail explanation follow my post here :public access modifier

protected

for detail explanation follow my post here: protected access modifier

default or package-level

for detail explanation follow my post here :default or package level modifier

private access modifier

for detail explanation follow my post here:package access modifier

Accessible inside class where it is declared.

Q: What is difference between public, default and protected access modifier?

Q: how you explain different scenarios related with the access modifier in java?

Ans: to know these all answer follow my post here :Access Modifier

If you have any more unanswered questions, then write your questions as comment, i will answers all.

...MORE QUESTIONS TO COME

JAVA CONCEPTS ,Access Modifier - Part 5 (protected)

noreply@blogger.com (Rishi Ranjan) — Thu, 03 Apr 2014 13:29:00 +0000

In the last post of modifier series, I have explained about the package-level access modifier .In this post I will explain about protected access modifier.

protected access modifier

protected access modifier means default(package-level) + something more. So we need to focus on something more part here.
protected means, protected = inheritance , but we can not consider it as public. there is some subtle difference between accessing public and protected members, that i will explain in this post.

To understand accessing of protected members we need to understand inheritance. I will explain inheritance in detail in OOPs concept, till now you can understand inheritance like if any class extends any other class then there will be a superclass and a subclass, in that situation subclass will inherit all property of superclass and subclass will pretend that property being inherited are member of subclass.

when we use protected access modifier with any class member then in that case we can avail all the accessibility provided by the package level access modifier + accessibility to the subclass in different package also.
As the subclass in different package can access the protected members but there is some limitation.In this case if we create an instance of superclass in subclass that is present in different package ,then we can't access the protected members of superclass using the reference of superclass.
Means we can not use the dot operator with superclass reference to access protected member from subclass.
We can only access the protected members by considering, that member as inherited property and that will pretend that, that member is member of subclass only.

Example :

here we will write a class in a package and then we will write another class in different package and that class will inherit the class from first package using extend keyword.then we will try to access the protected member of superclass from subclass of different package, we will consider different scenarios.

let us write first class here in a package:

package protectedAccess;
// a class with protected access modifier attached with class members
public class Parent {
 protected int parentVariableB;
 
 protected void parentMethodA() {
  System.out.println("do something");
 }

}

Now we will write a class extending this class in different package.

package protectedAccess2; // different package

import protectedAccess.*;
// class extending Parent class.
1. public class Subclass extends Parent {

2. public void testing() { // method for testing purpose
3.  System.out.println("value of variable " + parentVariableB); // ok
4.  Parent pc = new Parent();
5.  int d = pc.parentVariableB;// compiler unhappy
6.  pc.parentMethodA();//  compiler unhappy

7.  Subclass sc = new Subclass();
8.  System.out.println(sc.parentVariableB); // compiler happy
9.  sc.parentMethodA(); // compiler happy

 }

 public static void main(String[] args) {
  Subclass sc = new Subclass();
  sc.testing();
 }

}

In the above written code :
Line no 1: At line no 1 , we created a new class extending another class of different package, means Parent is superclass and Subclass is subclass here.
Line no 2 : A method to test all concepts that had mentioned above and later we can call this method from main method to test.
Line no 3: We can access protected variable parentVariableB because due to inheritance this variable will be inheriting in this Subclass.
Line no 4: We create the instance of Parent class.
Line no 5: With the reference of Parent class and using dot (.) operator we are trying to access protected member, but here compiler will complain as follow
The field Parent.parentVariableB is not visible
The method parentMethodA() from the type Parent is not visible
here it counts the difference between protected and public, if those class member would have been public then from Subclass also we could have access using the reference of Superclass, but here due to protected access modifier we can not access protected members using the reference of parent class.

Line no 6: here also compiler complain and provides same reason.
Line no 7: here we create an object of current class of this package(class Subclass)
Line no 8: here we can access the the protected member using the reference of Subclass because due to inheritance those members are inherited to subclass also and Subclass pretend that those members are their members defined like in Subclass only.
Line no 9: same reason as line no 8.

Now there can be situation where any other class could extend Subclass in that package , then in that case how the inherited protected member will behave?
Example :

package protectedAccess2; // same package as Subclass
//class extending Subclass
1.public class AnotherSubclass extends Subclass {
2. public static void main(String[] args) {
3.  Subclass sc = new Subclass();
4.  System.out.println(sc.parentVariableB); // compiler unhappy
5.  sc.parentMethodA(); // compiler unhappy
  
6.  AnotherSubclass asc= new AnotherSubclass();
7.  System.out.println(asc.parentVariableB); //compiler happy
8.  asc.parentMethodA();//compiler happy
 }

}

In above code At :
Line no 3: creating the object of Subclass
Line no 4: with the reference of superclass of AnotherSubclass trying to access inherited protected members again, so here again compiler complains like line no 5 of previous example.
Line no 7: compiler is happy and not restricting us, as those class member is again inherited to AnotherSubclass from Subclass.

summary:
In case of protected members we can access protected members as like default level access modifier + inheritance for the class outside the package.

JAVA CONCEPTS, Modifier - Part 4

noreply@blogger.com (Rishi Ranjan) — Thu, 03 Apr 2014 08:32:00 +0000

In the last post of modifier series, I have explained about the private access modifier , here I will explain about the default access modifier which is also called package level modifier.

Default Access modifier(package-level)

Mostly,it is called as the package level modifier because using default let it conflict with the default key word used with switch statement.
If we don't use any access modifier keyword then implicitly default access modifier is present there.
To specify package level access modifier we don't need to use the default keyword explicitly.
you can use package level access modifier with class also.
A default member may be accessed only if the class accessing the members belongs to same package.

To keep it in mind you can relate it like, you own a flat in a society , your own flat can resemble with private access as you can access only and your society can be called as the package as every one of society can access your flat externally.

Example :

here we will write a class in a package and we will try to access that from inside the package as well as from outside this package and we will see what our compiler complains in different scenarios.
first write a class with class members with default modifier

package defaultAccess; 
// a class in package with default access with members
public class Parent {
 int parentVariableB; // no modifiers means default(implicitly)
 
  void parentMethodA() { // no modifiers means default(implicitly)
  System.out.println("do something");
 }
}

now we will write two more classes to test our concepts:

package defaultAccess;
// A subclass in same package and compiler is happy as well as jvm also
public class SubclassInSame extends Parent {
 public static void main(String[] args) {
  Parent pc = new Parent();
  System.out.println(pc.parentVariableB); //no complain from compiler
  pc.parentMethodA(); // compiler is happy
 }

}

Now we will write a new class in same package but no relation with Parent:

package defaultAccess;
// Another class in same package acceesing the default members of parent class
public class OtherClass {
 public static void main(String[] args) {
  Parent pc= new Parent();
  System.out.println(pc.parentVariableB); // compiler is happy
  pc.parentMethodA(); //here also compiler is happy
 }

}

From above example you can conclude, at any point if we don't change the package till then compiler is happy and we can easily access the default members.

Example 2:
Here we will create another class in different package and try to access default member present in different package(defaultAccess).

package defaultAccess2; // different package

import defaultAccess.*;

1. public class SubclassInDifferent extends Parent {
2. public static void main(String[] args) {
3.  Parent ps = new Parent();

4.  System.out.println(ps.parentVariableB); // compiler is not happy
5.  ps.parentMethodA(); // compiler is not happy
 }

}

At line no 4 and 5 , compiler complains
Exception in thread "main" java.lang.Error: Unresolved compilation problems:
The field Parent.parentVariableB is not visible
The method parentMethodA() from the type Parent is not visible

Now write a class in different package (defaultAccess2) and that class should not show any relationship with the Parent class.

package defaultAccess2;

import defaultAccess.*;

1. public class AnotherClass { // no relation with parent class
2. public static void main(String[] args) {
3.  Parent ps = new Parent();
4.  System.out.println(ps.parentVariableB); // compiler is not happy
5.  ps.parentMethodA();// compiler is not happy
 }
}

in above code also At line no 4 and 5 compiler complains as below :
Exception in thread "main" java.lang.Error: Unresolved compilation problems:
The field Parent.parentVariableB is not visible
The method parentMethodA() from the type Parent is not visible

summary:
The package level accessifier restrict the accessibility and lets the members visible within package only. again you must be thinking what is use of making such restriction and how we can access the members then?

here it leads to the proper encapsulation concept where we make the method public and we will access the variables using the methods( JavaBean Style), i will explain in upcoming posts of OOPs series.

there is one more variation in package level modifier which adds some extra functionality and that called as protected access modifier that i will explain in next post.