Fixes and improves a few previous files and finishes code for module 7 about classes.

Author: mbarsott

src/JF01_TheBasics.java

@@ -21,8 +21,8 @@ public class JF01_TheBasics {
 
   // This a program entry point. If a method (function inside of a class) has this exact signature:
   // public static void main(String[] args)
-  // it can be where your program starts running: the entry point.
-  public static void main(String[] args) {
+  // This is where your program starts running, the entry point.
+  public static void main(String[] args) { // we will explain the "public" keyword when we explain classes in detail.
 
     // Statements end with a semicolon. Spaces (or tabs, or new line characters) do not matter for the compiler.
     // This is a statement and it prints the string "Hello Java Fundamentals" on the console (System.out).

src/com/fledger/javafundamentals/JF03_VarsTypesOperators.java

@@ -72,7 +72,7 @@ public static void main(String[] args) {
     // When you declare non primitive type variables (objects), space is allocated for the value and the
     // variable receives a reference to that space: objects are stored by reference, indirectly. See the example:
     Date now = new Date(); // creates a Date object variable, that contains current date and time... by reference!
-    Date oneHourAgo = new Date(now.getTime() - 60 /*minutes*/ * 60 /*seconds*/ * 1000 /*milis*/);
+    Date oneHourAgo = new Date(now.getTime() - 60 /* minutes */ * 60 /* seconds */ * 1000 /* milliseconds */);
     System.out.println("Objects are stored by reference: now and oneHourAgo");
     System.out.println(now); // prints current date and time
     System.out.println(oneHourAgo); // prints date and time of one hour ago

src/com/fledger/javafundamentals/JF06_ArraysLoops.java

@@ -74,7 +74,7 @@ public static void main(String[] args) {
       double d = myArrayOfDoubles[j];
       System.out.print(d + "; ");
     }
-    System.out.println("These are the elements in myArrayOfDoubles");
+    System.out.println("These are also the elements in myArrayOfDoubles");
 
     // And with a while loop
     int j = 0;
@@ -83,7 +83,25 @@ public static void main(String[] args) {
       System.out.print(d + "; ");
       j++;
     }
-    System.out.println("These are the elements in myArrayOfDoubles");
+    System.out.println("And one more time, the elements in myArrayOfDoubles");
+
+    // A special type of loop is the forever loop. Make the loop run forever, then break out under a certain condition:
+    while (true) {
+      System.out.print(j + "... ");
+      if (j-- <= 0) {
+        System.out.println("Breaking out the forever loop");
+        break; // Never, never forget to break out of a forever loop!
+      }
+    }
+
+    // Another way to write a forever loop:
+    for (; ; ) { // If you leave the condition empty in the for loop, it is considered true.
+      System.out.print(j + "... ");
+      if (j++ >= 5) {
+        System.out.println("You got the idea about breaking out the forever loop");
+        break; // Never, never forget to break out of a forever loop!
+      }
+    }
   }
 }
 

src/com/fledger/javafundamentals/jf07classes/Alarm.java

@@ -0,0 +1,16 @@
+package com.fledger.javafundamentals.jf07classes;
+
+import java.util.Date;
+
+// This is the class Alarm. It contains the definition for all data and all methods of an alarm:
+class Alarm {
+
+  // alarmDateAndTime and alarmMessage are attributes of the class Alarm.
+  Date alarmDateAndTime;
+  String alarmMessage;
+
+  // goOff() is a method of the class Alarm.
+  void goOff() {
+    System.out.println(alarmMessage);
+  }
+}

src/com/fledger/javafundamentals/jf07classes/BetterAlarm.java

@@ -2,24 +2,62 @@
 
 import java.util.Date;
 
+// This is the class BetterAlarm. It is better because it encapsulates the attributes, by making them private.
+// Notice that this class uses the public access modifier. This means any class can import and use it.
 public class BetterAlarm {
+
+  // The private access modifiers mean these attributes are only visible within the class
   private Date dateAndTimeToGoOff;
   private String message;
 
+  // The public access modifiers mean these methods are visible to any class that uses (imports) the BetterAlarm class.
   public void setToGoOffInTheseManySeconds(int i) {
     dateAndTimeToGoOff = new Date();
     dateAndTimeToGoOff.setTime(dateAndTimeToGoOff.getTime() + i * 1000L);
   }
 
+  // If no access modifier is used, the member is package private: it is visible anywhere in the same package.
+  int defaultDelayToGoOff = 2;
+
+  // The next two methods below are visible anywhere in the com.fledger.javafundamentals.jf07classes package:
+  void setDefaultDelayToGoOff(int i) {
+    defaultDelayToGoOff = i;
+  }
+
+  void prepareAlarm() {
+    setMessage(defaultMessageForBetterAlarm);
+    setToGoOffInTheseManySeconds(defaultDelayToGoOff);
+  }
+
+  // There is one additional access modifier: protected. We will talk about protected when we see inheritance.
+
+  // Since private attributes are not visible outside this class, only methods defined by you can change them.
+  // This guarantees that only your code will mess with the attribute, usually through a setter.
+  // This is a setter, or mutator, method. It is used to set a value in a private attribute.
   public void setMessage(String s) {
     message = s;
   }
 
+  // This is a getter, or accessor, method. It is used to get the value of a private attribute.
   public Date getDateTime() {
     return dateAndTimeToGoOff;
   }
 
+  // This is a regular public method. Can be called by any code that uses this class.
   public void goOff() {
     System.out.println(message);
   }
+
+  // Class and Instance variables (or attributes)
+  // If a member has the static keyword, it is a class member. It means it belongs to the class.
+  // Class members can be used from classes or instances (objects). Instance members cannot be used from the class.
+  private static String defaultMessageForBetterAlarm;
+
+  // The following is a static member, or a class method. It cannot access any instance member.
+  static void setDefaultMessageForBetterAlarm(String s) {
+    defaultMessageForBetterAlarm = s;
+    // The compiler would not allow the following statement because setMessage is not static (it is an instance member)
+    // setMessage(defaultMessageForBetterAlarm);
+  }
+
 }

src/com/fledger/javafundamentals/jf07classes/JF07_Classes.java

@@ -0,0 +1,88 @@
+// Java Fundamentals 07 - Classes, methods, fields, access modifiers
+package com.fledger.javafundamentals.jf07classes;
+
+import java.util.Date;
+
+// From now on we will have a separate package per module, as we may use multiple files for each module.
+// All files for this module are inside the com.fledger.javafundamentals.jf07classes package.
+// Java is an object oriented language. Objects are elements containing data, in the form of fields,
+// and code, in the form of functions. In Object Oriented (OO) lingo, object fields are known as attributes
+// and object functions are known as methods.
+// We say that objects contain a state (given by the attributes) and a behavior (given by the methods).
+// An object is a computational model of an entity, like a specific car, or a specific alarm, etc.
+// A class is a definition, or a blueprint, for a type of entity, like "Car" (the idea of a car) or "Alarm" (same).
+// Objects are created based on a class. For example, in Java, in the following statement:
+// Alarm wakeUpAlarm = new Alarm();
+// wakeUpAlarm is an object, or instance, of class Alarm. The class Alarm defines the fields and methods of all alarms.
+
+// The following statement and block (com.fledger.javafundamentals.jf07classes.JF07_Classes) define a class:
+public class JF07_Classes {
+  // Everything between the { } following the class name define the content of the class.
+  // As we said, a class can have data... inside a class, data members, or fields, are called fields or attributes:
+  int anIntegerField;
+
+  // A class can also have Java code within functions, also are called methods:
+  void thisIsAMethod() {
+    System.out.println("This is a method that returns nothing (void) and prints this message.");
+  }
+
+  // This class contains the entry point (function main) for our program (see JF01_TheBasics.java)
+  public static void main(String[] args) {
+
+    // A static method can call another static method. Static methods belong directly to the class (see BetterAlarm)
+    printCurrentTime(); // prints current date and time
+    // A class in java is a type, so you can declare variables of the class type (see Alarm.java in this package):
+    Alarm wakeUpAlarm;
+    // You can assign a value to a variable of the class type. The variable contains a reference to an object:
+    wakeUpAlarm = new Alarm(); // the keyword "new", followed by a class type and (), creates a new object of that type;
+    // You can access members (fields and methods) of an object by using a reference variable, dot (.), and member name:
+    wakeUpAlarm.alarmMessage = "It is time to wake up... WAKE UP!!!";
+    // You can have fields that are also references to other objects:
+    wakeUpAlarm.alarmDateAndTime = new Date(); // sets alarmDateAndTime of WakeUpAlarm to a new Date object set to now.
+    // You can access members of these fields with the dot (.) notation:
+    Long currentTime = wakeUpAlarm.alarmDateAndTime.getTime(); // get the time (now) from the Date object as a long.
+    Long inThreeSeconds = currentTime + 3000L; // Adds 3 thousand milliseconds (5 seconds) to the current time (now).
+    wakeUpAlarm.alarmDateAndTime.setTime(inThreeSeconds);
+    while (true) { // forever loop. There are better ways to wait for a timed event, but this will do for now.
+      Date now = new Date(); // create a new object with the current time;
+      if (now.after(wakeUpAlarm.alarmDateAndTime)) { // if current time passed the time set in the alarm
+        wakeUpAlarm.goOff(); // alarm goes off and prints message on the console... this is an object behavior (method)
+        break; // if you use forever, you need to break out of loop under some condition (see JF06_ArraysLoops)
+      }
+    }
+    printCurrentTime(); // should be 3 seconds after previous printed time.
+
+    // One of the principles of object oriented programming is encapsulation or "data hiding".
+    // You can hide the object fields from external access (hide the data, or encapsulate),
+    // so only methods of the object can access them. This way you ensure no one else will corrupt your object data.
+    // To do so we use access modifiers in the BetterAlarm.java file (look into that file):
+    BetterAlarm anotherWakeUpAlarm = new BetterAlarm();
+    anotherWakeUpAlarm.setToGoOffInTheseManySeconds(1);
+    anotherWakeUpAlarm.setMessage("Please, wake up. Better alarms are more polite.");
+    for (; ; ) { // another way to write the forever loop
+      Date now = new Date(); // create a new object with the current time;
+      if (now.after(anotherWakeUpAlarm.getDateTime())) { // if current time passed the time set in the alarm
+        anotherWakeUpAlarm.goOff(); // alarm goes off and prints message on the console...
+        break; // get out of the "forever" loop (see JF06_ArraysLoops)
+      }
+    }
+    printCurrentTime(); // should be one second after previous printed time.
+
+    // BetterAlarm contains static members. You don't need to instantiate an object in order to access the static
+    // member. You access it directly using the class name:
+    BetterAlarm.setDefaultMessageForBetterAlarm("Better Alarm also asks you to wake up.");
+    // Creates a betterAlarm object:
+    BetterAlarm betterAlarm = new BetterAlarm();
+    // All you need to do to prepare the alarm now is call one method.
+    betterAlarm.prepareAlarm(); // This is a package private method: only classes in this package can call it.
+    // This is even another way to write the code to make the alarm go off, with only two lines of code:
+    for (Date now = new Date(); now.before(betterAlarm.getDateTime()); now = new Date()) ;
+    betterAlarm.goOff();
+    printCurrentTime(); // should be two seconds (default delay for BetterAlarm) after previous printed time.
+  }
+
+  private static void printCurrentTime() {
+    Date now = new Date();
+    System.out.println("The date and time now is: " + now);
+  }
+}