ResilientSpring · ResilientSpring · Aug 10, 2021 · Jan 17, 2021 · Jan 18, 2021 · Jan 19, 2021
diff --git a/.classpath b/.classpath
@@ -15,5 +15,9 @@
 	<classpathentry kind="src" path="Chapter7"/>
 	<classpathentry kind="src" path="Chapter12"/>
 	<classpathentry kind="src" path="Chapter14"/>
+	<classpathentry kind="src" path="Miscellaneous"/>
+	<classpathentry kind="src" path="Questions_to_ask"/>
+	<classpathentry kind="src" path="Chapter8"/>
+	<classpathentry kind="src" path="Oracle_Java_Tutorials"/>
 	<classpathentry kind="output" path="bin"/>
 </classpath>
diff --git a/.metadata/.log b/.metadata/.log
diff --git a/Chapter12/Coins_used_in_the_US.java b/Chapter12/Coins_used_in_the_US.java
@@ -0,0 +1,5 @@
+// An enumeration is a list of named constants that define a new data type.
+public enum Coins_used_in_the_US {
+	penny, nickel, dime, quater, half_dollar, dollar
+
+}
diff --git a/Chapter12/Days_in_a_week.java b/Chapter12/Days_in_a_week.java
@@ -0,0 +1,11 @@
+ // An enumeration is a list of named constants that define a new data type.
+public enum Days_in_a_week {
+	Monday,
+	Tuesday,
+	Wednesday, 
+	Thursday, 
+	Friday,
+	Saturday,
+	Sunday
+
+}
diff --git a/Chapter12/EnumDemo.java b/Chapter12/EnumDemo.java
@@ -3,9 +3,48 @@ public class EnumDemo {

 	public static void main(String[] args) {
 		// TODO Auto-generated method stub
-		
+
 		Transport tpTransport;

+		tpTransport = Transport.AIRPLANE;
+
+		// Output an enumeration value.
+		System.out.println("Value of tpTransport: " + tpTransport);
+
+		System.out.println();
+
+		tpTransport = Transport.TRAIN;
+
+		// Compare two enum values.
+		if (tpTransport == Transport.TRAIN) 
+			System.out.println("tpTransport contains TRAIN.\n");
+
+		switch (tpTransport) {
+
+		case CAR: 
+			System.out.println("A car carries people.");
+			break;
+
+		case TRUCK:
+			System.out.println("A truck carries freight.");
+			break;
+
+		case AIRPLANE:
+			System.out.println("An airplane flies.");
+			break;
+
+		case TRAIN:
+			System.out.println("A train runs on rails.");
+			break;
+
+		case BOAT:
+			System.out.println("A boat sails on water.");
+			break;
+
+		default:
+			throw new IllegalArgumentException("Unexpected value: ");
+		}
+
 	}

 }
diff --git a/Chapter12/EnuumDemo2.java b/Chapter12/EnuumDemo2.java
@@ -0,0 +1,39 @@
+
+public class EnuumDemo2 {
+	public static void main(String[] args) {
+
+		int i;
+
+		i = 10;
+
+		System.out.println("Value of i: " + i);
+
+		System.out.println();
+
+		i = 2;
+
+		if (i == 2) 
+			System.out.println("i contains 2.\n");
+
+		switch (i) {
+		case 2:
+			System.out.println("A boat sails on water.");
+			break;
+		case 4:
+			System.out.println("A truck carries freight.");
+			break;
+		case 6:
+			System.out.println("An airplane flies.");
+			break;
+		case 8:
+			System.out.println("Smooth sailing.");
+			break;
+		case 10:
+			System.out.println("Freight trains.");
+			break;
+		default:
+			break;
+		}
+
+	}
+}
diff --git a/Chapter12/Months_in_a_year_Western_calender.java b/Chapter12/Months_in_a_year_Western_calender.java
@@ -0,0 +1,4 @@
+// An enumeration is a list of named constants that define a new data type.
+public enum Months_in_a_year_Western_calender {
+	January, February, March, April, May, June, July, August, September, October, November, December
+}
diff --git a/Chapter12/Transport.java b/Chapter12/Transport.java
@@ -1,4 +1,4 @@
-// An enumeration of transportation.
+// An enumeration is a list of named constants that define a new data type.
 public enum Transport {
 	CAR, TRUCK, AIRPLANE, TRAIN, BOAT
 }
diff --git a/Chapter6/AccessDemo2.java b/Chapter6/AccessDemo2.java
@@ -0,0 +1,32 @@
+
+class MyClass2{
+	private static int alpha;
+	public static int beta;
+	static int gamma;
+
+	static int delta = 1;
+
+//	alpha = delta;
+
+	public static void setAlpha(int alpha) {
+		MyClass2.alpha = alpha;
+	}
+
+	public static int getAlpha() {
+		return alpha;
+	}
+}
+
+public class AccessDemo2 {
+
+	public static void main(String[] args) {
+		// TODO Auto-generated method stub
+
+		System.out.println(MyClass2.delta);
+		System.out.println(MyClass2.beta);
+		System.out.println(MyClass2.getAlpha());
+//		System.out.println(MyClass2.alpha);
+
+	}
+
+}
diff --git a/Chapter6/AccessExperiment.java b/Chapter6/AccessExperiment.java
@@ -0,0 +1,28 @@
+
+public class AccessExperiment {
+
+	private int alpha; // private access
+	public int beta;  // public access
+	int gamma;       // default access
+
+	/* Methods to access alpha. It is OK for a member of a class to access a private member of the same class.*/
+	void setAlpha(int a) {
+		alpha = a;
+	}
+
+	int getAlpha() {
+		return alpha;
+	}
+
+	public static void main(String[] args) {
+		// TODO Auto-generated method stub
+
+		AccessExperiment exploitationAccessExperiment = new AccessExperiment();
+
+		exploitationAccessExperiment.alpha = 10;
+
+		System.out.println("exploitation.alpha is " + exploitationAccessExperiment.getAlpha());
+
+	}
+
+}
diff --git a/Chapter6/ErrorMessage2.java b/Chapter6/ErrorMessage2.java
@@ -0,0 +1,17 @@
+
+class ErrorMsg2 {
+	String messages[] = {"Output Error", "Input Error", "Disk Full", "Index Out-Of-Bounds"};
+}
+
+public class ErrorMessage2 {
+
+	public static void main(String[] args) {
+		// TODO Auto-generated method stub
+
+		ErrorMsg2 errorMsg2 = new ErrorMsg2();
+		System.out.println(errorMsg2.messages[1]);
+		System.out.println(errorMsg2.messages[4]);
+
+	}
+
+}
diff --git a/Chapter6/FSDemo_experiment.java b/Chapter6/FSDemo_experiment.java
@@ -0,0 +1,20 @@
+
+public class FSDemo_experiment {
+
+	public static void main(String[] args) {
+		// TODO Auto-generated method stub
+
+		FailSoftArray failSoftArray = new FailSoftArray(12, -1);
+
+		System.out.println(failSoftArray.get(4)); 
+
+		int b[] = new int[12];
+		System.out.println(b[4]);
+
+		failSoftArray.put(18, 6);
+
+		System.out.println(failSoftArray.get(18));
+
+	}
+
+}
diff --git a/Chapter7/An_example_of_inheritance.java b/Chapter7/An_example_of_inheritance.java
@@ -0,0 +1,104 @@
+// Source: https://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html
+class Bicycle {
+
+    // the Bicycle class has three fields
+    public int cadence;
+    public int gear;
+    public int speed;
+
+    // the Bicycle class has one constructor
+    public Bicycle(int startCadence, int startSpeed, int startGear) {
+        gear = startGear;
+        cadence = startCadence;
+        speed = startSpeed;
+    }
+
+    // the Bicycle class has four methods
+    public void setCadence(int newValue) {
+        cadence = newValue;
+    }
+
+    public void setGear(int newValue) {
+        gear = newValue;
+    }
+
+    public void applyBrake(int decrement) {
+        speed -= decrement;
+    }
+
+    public void speedUp(int increment) {
+        speed += increment;
+    }
+
+}
+
+class MountainBike extends Bicycle {
+
+    // the MountainBike subclass adds one field
+    public int seatHeight;
+
+    // the MountainBike subclass has one constructor
+    public MountainBike(int startHeight, int startCadence, int startSpeed, int startGear) {
+        super(startCadence, startSpeed, startGear);
+
+        seatHeight = startHeight;
+    }   
+
+    // the MountainBike subclass adds one method
+    public void setHeight(int newValue) {
+        seatHeight = newValue;
+    }   
+}
+
+/* MountainBike inherits all the fields and methods of Bicycle and adds the field seatHeight and a method to set it. 
+ * Except for the constructor, it is as if you had written a new MountainBike class entirely from scratch, 
+ * with four fields and five methods. 
+ * 
+ * However, you didn't have to do all the work. 
+ * 
+ * This would be especially valuable if the methods in the Bicycle class were complex 
+ * and had taken substantial time to debug.
+ * 
+ * */
+
+public class An_example_of_inheritance {
+
+	public static void main(String[] args) {
+
+		MountainBike giantBike = new MountainBike(15, 28, 0, 10);
+
+		System.out.println(giantBike.cadence);
+
+	}	
+}
+
+/* Keynote: 
+ * In the Java language, classes can be derived from other classes, 
+ * thereby inheriting fields and methods from those classes.
+ * 
+ * Definitions: 
+ * A class that is derived from another class is called a subclass (also a derived class, 
+ * extended class, or child class). The class from which the subclass is derived is called a superclass 
+ * (also a base class or a parent class).
+ * 
+ * The idea of inheritance is simple but powerful: When you want to create a new class and 
+ * there is already a class that includes some of the code that you want, 
+ * you can derive your new class from the existing class. 
+ * 
+ * In doing this, you can reuse the fields and methods of the existing class without having to write 
+ * (and debug!) them yourself.
+ * 
+ * A subclass inherits all the members (fields, methods, and nested classes) from its superclass. 
+ * Constructors are not members, so they are not inherited by subclasses, 
+ * but the constructor of the superclass can be invoked from the subclass.
+ * 
+Private Members in a Superclass:
+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.
+
+A nested class has access to all the private members of its enclosing class—both fields and methods. 
+Therefore, a public or protected nested class inherited by a subclass has indirect access to 
+all of the private members of the superclass.
+ * 
+ * */
diff --git a/Chapter7/An_example_of_inheritance2.java b/Chapter7/An_example_of_inheritance2.java
@@ -0,0 +1,34 @@
+// Source: https://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html
+
+/* What You Can Do in a Subclass:
+ * 
+ * A subclass inherits all of the public and protected members of its parent, 
+ * no matter what package the subclass is in.
+ * 
+ * If the subclass is in the same package as its parent, it also inherits the package-private members of the parent.
+ *  
+ * You can use the inherited members as is, replace them, hide them, or supplement them with new members:
+ * 
+ ** The inherited fields can be used directly, just like any other fields.
+ * 
+ ** You can declare a field in the subclass with the same name as the one in the superclass, 
+ *  thus hiding it (not recommended).
+ * 
+ ** You can declare new fields in the subclass that are not in the superclass.
+ * 
+ ** The inherited methods can be used directly as they are.
+ * 
+ ** You can write a new "instance" method in the subclass that has the same signature as the one in the superclass, 
+ *  thus overriding it.
+ * 
+ ** You can write a new "static" method in the subclass that has the same signature as the one in the superclass, 
+ *  thus hiding it.
+ * 
+ ** You can write a subclass constructor that invokes the constructor of the superclass, 
+ *  either implicitly or by using the keyword super.
+ * 
+ * */
+
+public class An_example_of_inheritance2 {
+
+}
diff --git a/Chapter7/Final/Named_constant.java b/Chapter7/Final/Named_constant.java
@@ -0,0 +1,12 @@
+package Final;
+
+public class Named_constant {
+
+
+
+	public static void main(String[] args) {
+		// TODO Auto-generated method stub
+
+	}
+
+}
diff --git a/Chapter7/Final/Named_constants.java b/Chapter7/Final/Named_constants.java
@@ -0,0 +1,16 @@
+package Final;
+
+public class Named_constants {
+
+	static int constant = 1;
+	final static int named_constant = 2;
+
+	public static void main(String[] args) {
+		// TODO Auto-generated method stub
+
+		System.out.println(constant);
+		System.out.println(named_constant);
+
+	}
+
+}