• Computers and computing: I begin the year with a historical overview of computing and the general nature of computer hardware and software. We also discuss some of the ethical issues surrounding computer use, especially within the context of wide area networks such as the Internet.
• Introduction to the Java development cycle:
  • Writing source code: Here I introduce the use of a text editor (often TextPad) and, in our case, an IDE (JCreator). The general structure of *.java source files is introduced. As we develop early classes, I try to keep test classes implementing the main() method separate from our working classes. Indeed, even the Hello World application introduced in Part II can be cast as a general String display class exercised by its own, separate test class.
  • Compilation to metacode: The use of metacode to achieve a high degree of platform independence is discussed. The production of the *.class file is demonstrated.
  • Execution of metacode: Platform-specific Java virtual machines are explained. Here, metacode is used to generate native code.
  • Rewriting/debugging: In my introductory courses I avoid the use of a formal debugger environment. I think it does more to obscure than to clarify basic principles. This same argument can be made against the use of IDEs in general, and I think it's easy to dispense with their use in an introductory course in favor of a rather simple text editor. I do find keyword highlighting useful, and most programming text editors implement that. Students are introduced to the use of embedded calls to System.out.println() and other rudimentary forms of debugging. They suffice.
  • Console i/o: Java's support of console i/o is rudimentary. It is a GUI-oriented language. Calls to System.out.print() or System.out.println() are fine for console output much of the time, but console input is more problematic. Many people are making simple i/o classes available specifically for teaching. I recommend their use. See the AP Computer Science Electronic Discussion Group (EDG) for some excellent guidance.
  • Applications and applets: Java applications and applets are compared and contrasted. Students are often more interested in applets than I am. The Java3D API (which can be downloaded separately from Sun's Web site) provides a MainFrame class (com.sun.j3d.utils.applet.MainFrame) that permits applets to be displayed as applications. In any case, applets are fun, and they are especially appropriate in a Pre-AP class that does some Web authoring.
• Introduction to object-orientation: Introduce the concept of user-defined types and require careful thinking about objects as an application is designed. The general guideline to think of object nouns as fields and object verbs as methods is helpful. It may be useful to have students begin to document their code using Sun's Javadoc facility. Personally, I find it not very useful for small applications, and it can, like IDEs, get in the way of more central issues. In any case, have students document their code briefly but effectively from the onset.
  • User-defined types: classes
    • Fields
    • Methods (including Object methods that should frequently be overridden, like the toString() method)
    • Public interface
      • Constructors
      • Other public methods
  • Reusability
  • Encapsulation
  • Data hiding
• Primitive data types (and their wrapper classes): Many people feel that the existence of primitive data types in Java is contrary to the general principles of objected-oriented design. However, they're here, and we all use them. This is probably a good time to introduce the Java API class documentation. Students can study, for example, the documentation for class Integer to discover goodies like parseInt() and intValue(). I also usually introduce one-dimensional arrays here.
  • Integers
    • byte (class Byte)
    • short (class Short)
    • int (class Integer)
    • long (class Long)
  • Floating point numbers
    • float (class Float)
    • double (class Double)
  • Special
    • boolean (class Boolean)
    • char (class Character)
• Operators
  • Assignment
    • =
    • +=, -=, *=, /=, %=
  • Increment and decrement
    • pre ++, pre --
    • post ++, post -
  • Grouping: ()
  • Unary +, -
  • Multiplication: *, /, %
  • Addition: +, -
  • Comparison: <, <=, >, >=, ==, !=
  • Boolean &, ^, |
  • Logical &&, ||
• Control structures
  • if, if/else
  • while
  • for
  • switch
  • do/while
  • break, continue
• Object-orientation details
  • Inheritance
  • Interfaces
  • Polymorphism
  • Static fields and methods
  • Java API documentation; a more extensive overview

• Each handout is headed with a specific topic and a subheading identifying the class. This helps with student organization and also makes it easy to refer to the handout by topic rather than as "that handout I gave you about simple GUIs."
• I use subsection headings to allow students quick access to specific subtopics.
• Writing is broken into small bites of information separated by blank lines. This is a holdover from my early journalism training -- large blocks of text are intimidating.
• Keywords are boldfaced.
• I often use hyperlinks to link to related documents, both those of my own making and others available on the Internet.
• Programming statements are set in a nonproportional font, usually Courier New.
• Program segments, set in Courier New, are placed in boxes to clearly define their extent.
• I try to keep the narrative tone light. Programming is inherently ponderous enough without my encouragement!

public class Spacecraft
{
   // private, hidden fields

   private String name;   // i.e.,  USS Challenger
   private int speed;   // m/s
   private int maxSpeed;   // m/s
   private int fuel;   // L
   private int maxFuel;   // L
   private double position;  // m traveled from 
                             //start of trip (like an odometer)
	
   private final int mpL = 2000;   // fuel mileage in m/L
	
   // a constructor ================================================

   public Spacecraft(String n, int maxS, int maxF)
   {
	   name = n;
	   speed = 100;   // default speed
	   maxSpeed = maxS;
	   fuel = 1000;   // default fuel
	   maxFuel = maxF;
	   position = 0.0;
   }
	
   // get methods ==================================================
	
   public String getName()
   {
	  return name;	
   }	
	
   public int getSpeed()
   {
	   return speed;	
   }
	
   public int getMaxSpeed()
   {
	   return maxSpeed;	
   }
	
   public int getFuel()
   {
	   return fuel;	
   }
	
   public int getMaxFuel()
   {
	   return maxFuel;	
   }
	
   public double getPosition()
   {
	   return position;	
   }
	
   // set methods ==================================================
	
   public boolean setSpeed(int s)
   {	
	   boolean resultFlag = false;
	
	   if (s <= maxSpeed)
	   {
		   speed = s;	
		   resultFlag = true;
	   }
		
	   return resultFlag;
   }
	
   // some other public methods ====================================
	
   public boolean addFuel(int f)
   {
	   boolean resultFlag = false;
	
	   if ((fuel + f) < maxFuel)
	   {
		   fuel += f;	
		   resultFlag = true;
	   }
	   else
	   {
		   fuel = maxFuel;	
	   }
		
	   return resultFlag;
   }
	
   public boolean travel(int t)   // travel time in s
   {
	   boolean resultFlag = false;

	   int requestedTravel = speed * t;   // in m
	   int maxTravel = fuel * mpL;   // in m

	   if (requestedTravel < maxTravel)
	   {
		   position += requestedTravel;
		   fuel -= ((speed * t) / mpL);
		   resultFlag = true;
	    } 
	   else
	    {
		   position += maxTravel;
		   fuel = 0;
	   }
		
	   return resultFlag;
   } 
	
   public String toString()
   {
	   String s1 = " Spacecraft name: " + name + "\n";
	   String s2 = "           speed: " + speed + " m/s \n";
	   String s3 = "   maximum speed: " + maxSpeed + " m/s\n";
	   String s4 = "            fuel: " + fuel + " L \n";
	   String s5 = "    maximum fuel: " + maxFuel + " L\n";
	   String s6 = "current position: " + position +
	   " m traveled so far.";
	   return (s1 + s2 + s3 + s4 + s5 + s6);
   }
}

public class TestSpacecraft
{
   public static void main(String args[])
   {
	   Spacecraft sc1 = new Spacecraft("USS Challenger", 10000, 4000);
		
	   System.out.println(sc1);
		
	   if (sc1.travel(1000))
	   {
		   System.out.println("\nTravel fully successful!\n");
	   }
	   else
	   {
		   System.out.println("\nTravel not fully successful.\n");
	   }
		
	   System.out.println(sc1);
   }	
}

• The final variables cannot be given a new value; they're essentially constants.
• The get and set methods provide read and write access to private fields.
• Most classes implement a toString()method that overrides the simple one inherited from Object (all Java classes are descendants of class Object).
• TestSpacecraft's only method is static; this means that it can be used without creating an instance of the enclosing class; in this case, the Java Virtual Machine invokes main() without creating any instance of class TestSpacecraft.

public class SuperSpacecraft extends Spacecraft
{
   // private, hidden fields
	
   private int photonTorpedoes;   // count
   private int phaserMegaJoules;   // in MJ

   // a constructor ================================================

   public SuperSpacecraft(String n, int maxS, int maxF,
   int torps, int phaserCharge)
   {
	   super(n, maxS, maxF);
		
	   photonTorpedoes = torps;
	   phaserMegaJoules = phaserCharge;	
   }	
	
   // get methods ==================================================
	
   public int getTorpedoes()
   {
	   return photonTorpedoes;
   }
	
   public int getPhaserCharge()
   {
	   return phaserMegaJoules;	
   }

   // some other public methods ====================================

   public void addTorpedoes(int t)
   {
	   photonTorpedoes += t;
   }
	
   public void addCharge(int c)
   {
	   phaserMegaJoules += c;	
   }
	
   public boolean firePhotonTorpedoes(int t)
   {
      // implementation here
	  
	  return true;
   }
	
   public boolean firePhasers(int p)
   {
	   // implementation here	
		
	   return true;
   }
	
   public String toString()
   {
	   String s1 = super.toString();
	   String s2 = "\n     photo torps: " + photonTorpedoes + "\n";
	   String s3 = "   phaser charge: " + phaserMegaJoules + " MJ\n";
	   return (s1 + s2 + s3);
   }
}

And here is the associated test file:

public class TestSuperSpacecraft
{
   public static void main(String args[])
   {   
	   Spacecraft craft[] = new Spacecraft[10];
		
	   for (int index = 0; index < 10; index += 2)
	   {
		   craft[index] = new Spacecraft("USS Enterprise " +
		   index, 5000, 12000);
		   craft[index + 1] = new SuperSpacecraft("USS Voyager " +
		   index, 5000, 12000, 50, 4525);
	   }
		
	   for (int index = 0; index < 10; index ++)
	   {
	   	   System.out.println("Craft " + index + "\n:"
		   + craft[index].toString() + "\n==========\n");
	   }
		
   }	
}

• There's a superclass call in the constructor and in the toString() method.
• The test file uses arrays and introduces polymorphism by using references to Spacecraft objects to refer to both Spacecraft and SuperSpacecraft objects.