Simple Output

• Output in Java follows many of the same constructs as input (which you will see shortly), but we will only be covering the basic functionality of System.out.

• We will use the following example to demonstrate how to use System.out:

      public static void main(String args[]) {
           double x,y,z;
  	 x = 4195835.0;
  	 y = 3145727.0;
  	 z = x - (x / y) * y;
  	 System.out.println("result = " + z);
      }
  

• The last statement in the example prints out the arithmetic value z.

• The statement refers to a library class called System that contains an object called out that has a method called println.

• out does basic character output.

• In Java, you have to explicitly name at the top of you source file all packages that you use, with the exception of the built-in Java language package, which includes the class System used here.

• The System.out.println uses the plus sign, +, as an operator to concatenate Strings.

• Whenever a String appears as one operand of the +, the compiler does not do arithmetic addition, but tries to convert the other operand to a String and then concatenates the two.

• In fact, concatenating an empty String with a value of a primitive type is a Java idiom to convert the value to a string.

• Look at the following example:

      int i = 256;
          ...
  
      "" + i   // yields a String containing the value of i
  

• This is much shorter than the alternative of using the static method of the String class:

      String.valueof( i )
  

• In the case of our System.out.println code above, the variable z is converted to a String, and appended to the literal message.

• Then that entire String is passed as a single argument to the println() method, causing it to be printed to the system console.

• Here are some additional examples of using System.out.println:

      System.out.println( "The character (" + 'a' + 
                          ") has the value " + ( (int) 'a' ) );
  

• This statement prints the character a and its integer value as follows:

      The character (a) has the value 97
  

• The following code prints out the statement Class average is, followed by the value of the variable average:

      average = total / 10;  // integer division
      System.out.println( "Class average is " + average );
  

Input

• JDK 1.0 built everything off 8-bit streams, which did not properly support 16-bit character streams needed for internationalization.

• The JDK 1.1 release did not cleanly fix this problem with I/O, and the I/O package virtually doubled in size in JDK 1.1, with a whole set of new 16-bit Reader/Writer classes added to the old 8-bit stream classes.

• The Reader/Writer Unicode stream classes should be used instead of the old JDK 1.0 InputStream/OutputStream classes because the Reader/Writer classes make it easy to write code that can be internationalized.

• The general two rules of character I/O are:

  • If you want to do character input, all the classes you use should have names that end in Reader (not in InputStream)

  • If you want to do character output, all the classes you use should have names that end in Writer (not in OutputStream)

• These rules don't apply to the predefined System objects for interactive I/O.

• The essentials of Java I/O are:

  • All I/O in Java is done using a stream.

  • There are two kinds of stream: 8-bit streams and 16-bit streams.

  • The 8-bit streams are know as InputStream or OutputStream. The 16-bit streams are known as Reader (input) or Writer (output).

  • Because the class name has Reader, Writer, InputStream, or OutputStream in it, it's easy to know which set of services you are using.

  • Each stream offers just one kind of service (i.e., character I/O, binary I/O, I/O to a byte array, to a file). You are supposed to connect several streams to get the exact processing you want.

  • I/O streams are connected by passing one stream as an argument to the constructor of another.

• Three predefined streams are already open and ready to use in every program. These streams are declared in the java.lang.System class and they are all byte streams:
  • System.in - InputStream used to read bytes from the keyboard

  • System.out - PrintStream used to write bytes to the screen

  • System.err - PrintStream used to report errors

• Here is an example of using System.in (a BufferedInputStream):

      int grade;
        ...
  
      System.out.print( "Enter letter grade: " );
      grade = System.in.read();
  

• The first line displays the prompt Enter letter grade: on the screen.

• The second line above uses System.in to obtain one letter grade from the user. The System.in.read method reads one character from the keyboard and stores that character in the integer variable grade.

• Characters are normally stored in variables of type char. However, a feature in Java is that characters can be stored in most integer data types because they are represented as 2-byte integers in Java.

• So we can treat a character as either an integer or a character depending on its use.

• It is good programming practice to make sure that incoming characters are correctly converted to Unicode by reading through a Reader rather than an 8-bit stream.

• The way to get Unicode characters from an InputStream (like System.in) is to layer an InputStreamReader on top of it.

• InputStreamReader is an adapter from a byte stream to a character Reader.

• You can pass the constructor one of the old-style JDK 1.0 8-bit InputStream, and it gives you back a Reader.

• So, this is how to read in characters (not bytes) from the keyboard:
  • Wrap an InputStreamReader around System.in:

    InputStreamReader isr = new InputStreamReader(System.in);
    

  • Read a character at a time from the InputStreamReader object

• We need to be comfortable with the concept of pushing streams on top of streams to get the methods we need.

• In all classes, we have to know in advance what type we are reading in. We need to know what to expect because the methods for reading in a boolean, an int, a floating-point number, and so on, are all different.

• Follow this process:
  • Layer an InputStreamReader on System.in. This gives us a Reader class, on which we can layer other Readers.

  • Layer a BufferedReader on the InputStreamReader. This gives us a method that reads an entire line, allowing us to get all the text as a string when the user presses Return.

  • Layer a java.util.StringTokenizer on the String just read in. Call the nextToken() method to extract just the nonspace characters. This makes the input format a little more forgiving by removing trailing and leading whitespace.

  • Use the parseXxx method of the primitive types wrapper classes to extract the expected value.

• Here is how to read values from the keyboard and get them into a primitive type in your program.

• Preliminary Declarations:

      import java.io.*;
      import java.util.*;
      ...
      
      InputStreamReader is = new InputStreamReader( System.in );
      BufferedReader br = new BufferedReader( is );
      ...
      String s = br.readLine();
      StringTokenizer st = new StringTokenizer(s);
  

• NOTE: An exception handler is also needed. You must wrap a try...catch around the input statements (we will discuss exceptions later).

• Here is the code to read the following primitive types from the keyboard (assuming the preliminary declarations made above).

• char

      int i = is.read();  // -1 denotes EOF
      char c = (char) i;
  

• String

      String s = br.readLine();
  

• boolean

      boolean bo = new Boolean(st.nextToken()).booleanValue();
  

• int

      int i = Integer.parseInt(st.nextToken());
  

• byte

      byte by = Byte.parseByte(st.nextToken());
  

• short

      short sh = Short.parseShort(st.nextToken());
  

• long

      long lo = Long.parseLong(st.nextToken());
  

• float

      float fl = new Float(st.nextToken()).floatValue();
  

• double

      double db = new Double(st.nextToken()).doubleValue();
  

• Each statement or group of statements must have an exception handler wrapped around it, as shown below (or the method must declare that it throws an IOException):

      try {
        // put I/O statement here
      } catch (IOException ioe)
         { ioe.printStackTrace(); }
  

• For completeness, here is the full code to prompt for and read an int value:

  import java.io.*;
  import java.util.*
  
  public class exreadin2 {
          
    public static void main(String args[]) {
      int i=0;
      char c;
      InputStreamReader is = new InputStreamReader( System.in );
      BufferedReader br = new BufferedReader( is );
      StringTokenizer st;
  
      try {
         System.out.print( "int: ");  System.out.flush();
         String myline = br.readLine();
         st = new StringTokenizer(myline);
         i = Integer.parseInt(st.nextToken());
         System.out.println( "got: " + i );
      } catch (IOException ioe) {
         System.out.println( "IO error:" + ioe );
      }
    }
  }
  

• Output in Java is very similar, but we will not be covering that in this review.

Inheritance

• Inheritance means building on a class that is already defined, to extend it in some way.

• Inheritance means being able to declare a type which builds on the fields (data and methods) of a previously-declared type.

• As well as inheriting all the operations and data, you get a chance to declare your own versions and new versions of methods, to refine, specialize, replace or extend the ones in the parent class.

• Here is some important terminology:
  • class - a data type.

  • extend - to make a new class that inherits the contents of an existing class.

  • superclass - a parent or base class. Superclass is a very poor choice of names as it wrongly suggests the parent class has more than the subclass.

  • subclass - a child class that inherits, or extends, a superclass.

• Note that in Java, almost everything is an object, and in particular, all the classes that you declare are subclasses of the built-in root class Object.

• Inheritance usually provides increasing specialization as you go from a general superclass class (i.e. vehicle) to a more specific subclass (i.e. passenger car, fire truck, or delivery van).

• Here is an example of inheritance; the following is the base class:

      class Fruit {
             int grams;
             int cals_per_gram;
  
  	   int total_calories() { ... }
      }
  

  And here is an example of class inheritance:

      class Citrus extends Fruit {
             void squeeze() { ... } 
      }
  

• This makes Citrus a subclass that inherits all the Fruit class operations and adds this squeeze() specialization of its own.

• You can call the squeeze method on a Citrus object, and you can also call the total_calories() method.

• The code says that Citrus is based on (extends) Fruit. A Citrus is a specialization of Fruit; it has all the fields that Fruit has, and adds a method of its own.

• Heres an example of how various fruits might be declared and inherited:

      class test2e {
             public static void main(String args[]) {
  	       Fruit somefruit = new Fruit();
  	       Citrus lemon = new Citrus();
  
  	       lemon.squeeze();
  	       somefruit = lemon;
  	   }
      }
  

• Notice the assignment of lemon (a Citrus object) into somefruit (a Fruit object). You can always make a more general object hold a more specialized one, but the reverse is not true without an explicit type conversion (you are encouraged to read about casting on your own).

• All citrus are fruit, but not all fruits are citrus (for example, the fruit may be a plum).

Visibility and Name Modifiers

• A package is a group of classes that you want to bundle together (you should read more about packages on you own).

Class Modifiers

• There are modifiers that you can apply to a class.

• When you declare a class, the general form looks like this:
  modifier class name [extends name] [implements namelist] body

• The modifier can be one or more of abstract, final, or public (abstract and final are opposites and are not allowed together).
  abstract: class must be extended (to be useful)

  final: class must not be extended

  public: class is visible in other packages

• Examples:

      abstract public class Fruit { ...
      final public class Citrus extends Fruit { ...
  

Data Field Modifiers

• The field in a class body can be variables, or methods. The field can similarly start with a modifier that says how visible it is, and qualifies it in some other way.

• These are the some of the modifiers that can apply to a field that is data:
  (Keywords that modify visibility)

  public - fields is visible everywhere (class must be public too).

  (blank) - what you get by default. Field is only visible in this package.

  protected - like default, and the field is visible in subclasses in other packages extended from this class, too.

  private - field is only visible in this class.

  (keywords that modify the way the field is used)

  static - one per class, not one for each object. Where you see static read it as "only one".

  final - field is only visible in this class.

• Here is an example:

      protected static final int upper_bound = 2047;
  

• upper_bound is visible throughout this package and in subclasses of this class, even ones in other packages. The data is associated with the class, not an individual object, so any change made to it would be seen by all objects. It won't change though, because it has been assigned a final value.

Method Field Modifiers

• These are some of the modifiers that you apply to a field that is a method:
  (Keywords that modify visibility)

  public - fields is visible everywhere (class must be public too).

  (blank) - what you get by default. Field is only visible in this package.

  protected - like default, and the field is visible in subclasses in other packages extended from this class, too.

  private - field is only visible in this class (and so can never be abstract, as it's not visible to be overridden).

  (keywords that modify the way the method is used)

  final - cannot be overridden.

  static - one per class, not one for each object.

  abstract - must be overridden (to be useful).

• Here is an example:

      protected abstract int total_calories() { ... }
  

• Don't make any fields public without good reason. In general you should give things the most restricted visibility that still makes it possible for them to work.

Static

• There are three varieties of static thing (once-only) in Java. A static thing is something in a class that occurs once only, instead of once for each instance of the class.

Static Data

• So far we have explained a class in terms of a template: any object of the class gets its own copy of all the data fields.

• There is a way to change this though, and label a data fields as occurring just once, no matter how many instances of the class there are.

• This is what the keyword static does, as in the example below:

      class Employee {
          String[]  name;
  	long      salary;
  	short	  employee_number;
  
  	static int total_employees;
  	...
      }
  

• The purpose of the Employee class is to store and process data on an individual employee. However, we also use the class to hold the total number of employees that we have on the payroll.

• The variable total_employees is a quantity associated with employees in general, so this class might be a good home for it.

• It would be wasteful and error-prone to duplicate this value in every employee object.

• total_employees is a value associated with the class as a whole, not each object of it.

• Applying the storage modifier static to a data field makes this happen.

• Inside the class, static data is accessed by giving its name. Outside the class, static data can be accessed by prefixing it with the names of an object, or the name of the class.

• Heres an example:

  Employee newhire = new Employee();
  newhire.total_employees++;  // reference through an instance
  Employee.total_employees = 0; // reference through the class
  

• The second form, referencing static variables through the class name, is preferred because it provides a cue that this is not instance data.

Static Methods

• Just as there can be static data that belongs to the class as a whole, there can also be static methods (also called class methods) that do some class-wide operations, and do not apply to an individual object.

• You can call a static method by prefixing it with the name of an object or the name of the class (use the latter).

• Here is an example:

      class Employee {
              String[]  name;
  	    long      salary;
  	    short     employee_number;
  	    
  	    static int total_employees;
  	    
  	    static void clear() {
  	             total_employees = 0;
  	    }
      }
      ...
  
      newhire.clear();  // reference through an instance
      Employee.clear(); // better: reference through the class
  

• NOTE: static methods cannot access any instance data.

• The static routine clear is not applied to an individual object, and therefore cannot touch the data fields or call the methods that belong to individual objects.

• A static method can only directly access other static fields.

Static Blocks

• This is a portion of code belonging to a class, commonly used for initialization.

• A static block is executed once when the class is first loaded.

• The static precedes the curly braces that delimit the static block, as shown here:

      public class Employee {
         String[] name;
         long     salary;
         short    employee_number;
  	     
         static int total_employees;
  
         static {
  	 System.out.println("Calculating how many employees");
  	 if ( some_condition )
  	       total_employees = 100;
  	 else total_employees = 0;
         }
      }
  

• static blocks can only access static data.

• There can be multiple static blocks in a class, and they are executed in the order in which they occur in the source.

• Remember: whenever you see static in Java, think once only.