Add files via upload

Author: divScorp

Constructor/Car.java

@@ -0,0 +1,49 @@
+package Constructor;
+
+class CarCreat {
+
+	int regNum;
+	private static int num=1000;
+	
+	CarCreat(){regNum=num++;}
+	
+	void cardetails(){
+		System.out.println("Your car: "+regNum);
+	}
+	
+	void start(){
+		System.out.println("Car Starts. ");
+	}
+	void accelerate(){
+		System.out.println("Car Accelerate. ");
+	}
+	void stop(){
+		System.out.println("Car Stops. ");
+	}
+}
+
+class Driver{
+	String name;
+	CarCreat c=new CarCreat();
+	Driver(String n){
+		name=n;		
+	}
+	void driverName(){
+		System.out.println(name);
+	}
+}
+
+public class Car{
+	public static void main(String... args){
+		
+		Driver dr=new Driver("xyz");
+		dr.driverName();
+		dr.c.cardetails();
+		dr.c.start();
+
+		Driver dr1=new Driver("abc");
+		dr.driverName();
+		dr1.c.cardetails();
+		dr1.c.start();
+	}
+}

Constructor/ConstEx1.java

@@ -0,0 +1,46 @@
+package Constructor;
+
+public class ConstEx1 {
+
+	// if we won't provide any constructor compiler adds default constructor
+	// int this case, ConstEx1(){} , but if we provide any other constructor
+	// compiler won't add.
+
+	int x, y;
+
+	// no-argument constructor
+	ConstEx1() {
+		getX(); // we can call both static and non-static method from
+				// constructor
+		x = 0;
+		y = 0;
+	}
+
+	// Parameterized Constructor
+	ConstEx1(int l) {
+
+		x = y = l;
+		getX();
+	}
+
+	ConstEx1(int l, int m) {
+		x = l;
+		y = m;
+	}
+
+	static void getX() {
+		System.out.println(" You're inside method getX() ");
+		// return x;
+	}
+
+	public static void main(String[] args) {
+		ConstEx1 c1 = new ConstEx1();
+		System.out.println("[C1]X= " + c1.x + " Y= " + c1.y);
+
+		ConstEx1 c2 = new ConstEx1(20);
+		ConstEx1 c3 = new ConstEx1(12, 13);
+
+		System.out.println("[C2]X= " + c2.x + " Y= " + c2.y);
+		System.out.println("[C3]X= " + c3.x + " Y= " + c3.y);
+	}
+}

Constructor/CopyConst.java

@@ -0,0 +1,37 @@
+package Constructor;
+
+public class CopyConst {
+
+	double real, imaginary;
+
+	public CopyConst(double re, double img) {
+		real = re;
+		imaginary = img;
+	}
+
+	// Copy Constructor
+	public CopyConst(CopyConst c) {
+
+		real = c.real;
+		imaginary = c.imaginary;
+	}
+
+	@Override // toString() is the override method of Object Class
+	public String toString() {
+		return "(" + real + " + " + imaginary + "i)";
+	}
+
+	public static void main(String[] args) {
+
+		CopyConst c1 = new CopyConst(10, 15);
+		CopyConst c2 = new CopyConst(c1);
+		CopyConst c3 = c1;
+
+		System.out.println("[C2]" + c2); // if we directly print object Output
+											// Constructor.CopyConst@6d06d69c
+
+		System.out.println("[C3]" + c3); // on directly printing object it will
+											// call toString() of Object class
+	}
+
+}

Inheritance/InheritEx.java

@@ -0,0 +1,42 @@
+package Inheritance;
+
+class SuperClass {
+	int i, j;
+
+	void showij() {
+		System.out.println("i and j: " + i + " " + j);
+	}
+}
+
+class SubClass extends SuperClass {
+	int k;
+
+	void showk() {
+		System.out.println("k:" + k);
+	}
+
+	void sum() {
+		System.out.println(i + j + k);
+	}
+
+}
+
+class InheritEx {
+	public static void main(String args[]) {
+		SuperClass sup = new SuperClass();
+		SubClass sub = new SubClass();
+
+		sup.i = 10;
+		sup.j = 20;
+		System.out.println("Contents of super class ");
+		sup.showij();
+		sub.i = 7;
+		sub.j = 8;
+		sub.k = 9;
+		System.out.println("Contents of sub class");
+		sub.showij();
+		sub.showk();
+		System.out.println("Sum of i, j and k in sub class");
+		sub.sum();
+	}
+}

Inheritance/NblockInherit.java

@@ -0,0 +1,26 @@
+package Inheritance;
+
+class Box1 {
+	{
+		System.out.println(1);
+	}
+}
+
+class Box2 extends Box1 {
+	{
+		System.out.println(2);
+	}
+}
+
+class Box3 extends Box2 {
+	{
+		System.out.println(3);
+	}
+}
+
+public class NblockInherit {
+	public static void main(String[] args) {
+		Box3 c = new Box3();
+		System.out.println(c);
+	}
+}

Inheritance/SblockInherit.java

@@ -0,0 +1,26 @@
+package Inheritance;
+
+class Box11 {
+	static {
+		System.out.println(1);
+	}
+}
+
+class Box12 extends Box11 {
+	static {
+		System.out.println(2);
+	}
+}
+
+class Box13 extends Box12 {
+	static {
+		System.out.println(3);
+	}
+}
+
+public class SblockInherit {
+	public static void main(String[] args) {
+		Box13 c = new Box13();
+		System.out.println(c);
+	}
+}

Inheritance/SingleLevel.java

@@ -0,0 +1,62 @@
+package Inheritance;
+
+class A {
+	private int i = 12;
+	protected int j = 13;
+	public int k = 14;
+	int m = 3;
+
+	A() {
+		System.out.println("I'm Constructor from class A.");
+	}
+
+	private void m1() {
+		System.out.println("Private method of class A " + i);
+	}
+
+	protected void m2() {
+		System.out.println("Protected method of class A " + j);
+		m1();
+	}
+
+	public void m3() {
+		System.out.println("Public method of class A " + k);
+	}
+
+	void m4() {
+		System.out.println("Package method of class A" + i + " " + m);
+	}
+}
+
+class B extends A {
+
+	B() {
+		System.out.println("I'm Constructor from class B.");
+	}
+
+	public void m5() {
+		// System.out.println(i); // private variables not accessible in
+		// sub-class
+		System.out.println(" Method from class B. ");
+		System.out.println("Protected j= " + j);
+		System.out.println("public k= " + k);
+		System.out.println("Package m= " + m);
+		// m1(); // Private method is not accessible in sub-class
+		m2();
+		m3();
+		m4();
+	}
+
+}
+
+public class SingleLevel {
+	public static void main(String[] args) {
+		B b = new B();
+		System.out.println("----------------------------------");
+		System.out.println(" From Main method. ");
+		b.m5();
+		b.m4();
+		System.out.println("----------------------------------");
+	}
+
+}

Inheritance/TrickyEx.java

@@ -0,0 +1,35 @@
+package Inheritance;
+
+class Test {
+	static int i = 56;
+
+	static {
+		i = i-- - --i;
+		System.out.println("i value Static Block of Test Class: "+i);
+	}
+
+	{
+		i = i++ + ++i;
+		System.out.println("i value Non-Static Block of Test Class: "+i);
+	}
+}
+
+class Test1 extends Test {
+	static {
+		i = --i - i--;
+		System.out.println("i value Static Block of Test1 Class: "+i);
+	}
+
+	{
+		i = ++i + i++;
+		System.out.println("i value Non-Static Block of Test1 Class: "+i);
+	}
+}
+
+public class TrickyEx {
+	public static void main(String[] args) {
+//		Test1 b = new Test1();
+//		System.out.println(b.i);
+		System.out.println(Test.i);
+	}
+}

MethodOverloading/NullTest1.java

@@ -0,0 +1,35 @@
+package MethodOverloading;
+
+public class NullTest1 {
+	
+	/*
+	 * If more than one member method is both accessible and applicable to a method invocation, 
+	 * it is necessary to choose one to provide the descriptor for the run-time method dispatch.
+	 * 
+	 * The Java programming language uses the rule that the most specific method is chosen.
+	 * */
+
+	public static void method(Object obj){
+	     System.out.println("method with param type - Object");
+	   }
+	 
+	   public static void method(String obj){
+	     System.out.println("method with param type - String");
+	   }
+	   
+//	   public static void method(StringBuffer strBuf){
+//		     System.out.println("method with param type - StringBuffer");
+//		   }
+	   
+	   /*
+	    * Why is the compiler not able to pick 'the most specific' here - because both "String" and "StringBuffer" are are sub-classes.
+		  of the Object class, but without being in the same inheritance hierarchy. For finding 
+		  'the most specific' method, the compiler needs to find a method having the parameter type, 
+		  which is a sub-class of the parameter types of all other overloaded methods. 
+	    * */
+	 
+	   public static void main(String [] args){
+	     method(null);
+	   }
+}
+

MethodOverloading/NullTest2.java

@@ -0,0 +1,22 @@
+package MethodOverloading;
+
+public class NullTest2 {
+
+	public static void method(Object obj, Object obj1){
+		   System.out.println("method with param types - Object, Object");
+		 }
+
+		 public static void method(String str, Object obj){
+		   System.out.println("method with param types - String, Object");
+		 }
+/*
+ * In this case the compiler can easily pick 'the most specific' as the method having parameter types (String, Object) as
+ 	the other overloaded method is having its parameter types as (Object, Object) - clearly 'String' is a subclass of 'Object' 
+ 	and the other parameter is of same type, so the method with parameter types (String, Object) can be picked with ease.
+ * 
+ * */
+		 public static void main(String [] args){
+		   method(null, null);
+		 }
+
+}