Answer. Parameters are used to send information into a subroutine when the subroutine is called. A subroutine can have formal parameters in its definition such as the str in public static void reverse(String str). When the subroutine is called, an actual parameter is passed to the subroutine, such as "Hello" in reverse("Hello"). The actual parameter value is assigned to the formal parameter so that its value can be used in the subroutine. Parameters are so important because they allow a subroutine to process different data each time it is called.

Answer. A private instance variable can only be used in the class where it is declared. (More exactly, this means the "outer," non-nested class that contains the declaration of the variable.) This protects the variable from having anything done to it, except for what is done in that class. This makes it possible, for example, to be sure that the value of the instance variable is a valid value at all times. It is possible to allow indirect access to the variale from outside the class by writing a getter method for reading the value and/or a setter method for changing the value. Note that a setter method can ensure that the value that is being assigned to the variable is valid.

Answer. This line says that MyClass is being defined as a subclass of YourClass. The class YourClass must already exist. All of the instance variables and methods that are already defined in YourClass will be inherited into MyClass (almost as if the definition of YourClass were re-typed into MyClass). Anything that I write in the definition of MyClass will either add to or override things that are inherited from YourClass.

Answer.

  public static String shorterString( String s1, String s2 ) {
      if (s1.length() <= s2.length()) {
          return s1;
      }
      else {
          return s2;
      }
  }

Answer.

  public static boolean containsZ(String str) {
      for (int i = 0; i < str.length(); i++) {
          if (str.charAt(i) == 'Z') {
             return true;
          }
      }
      return false;
  }

Note that this can be written more simply using the indexOf method from the String class:

  public static boolean containsZ(String str) {
      return str.indexOf('Z') >= 0;
  }

Answer.

  public static void fill( double[] array, double value ) {
      for (int i = 0; i < array.length; i++) {
          array[i] = value;
      }
  }

Answer.

  public class Averager {
  
      private double total;  // sum of the numbers entered
      private int count;     // count of the numbers entered
      
      public void addData( double item ) {
          total = total + item;
          count = count + 1;
      }
      
      public double getAverage() {
          return total / count;
      }
  
  }

Answer.

  Averager avg = new Averager;
  avg.addData( 3.7 );
  avg.addData( 21 );
  avg.addData( 18.9 );
  System.out.println( "The average is " + avg.getAverage() );

Answer.

  Date today, start;
  today = new Date();
  start = today;
  today.month = 4;
  today.day = 5;
  today.year = 2017;

Answer. The idea of a black box is that it is something that can be used without understanding what goes on inside the box. A black box has an interface, which defines how the box is used, and it has an implementation, which is what is inside the box. To use a black box, you only need to know its interface. When you are building a black box, you are creating the implementation, and for that you don't need to think about what the black box will be used for -- you just have to make it work correctly internally. This makes it easier to build complex systems, because you can work on smaller components of the system (the black boxes or modules) independently.

A subroutine is a black box in the sense that you don't need to understand the code inside the subroutine in order to use it. You just need to know its interface (including, for example, its name and parameter list.) Similarly, to use a class, you just need to know its public API. You don't need to know anything about the private part of the class or about the code inside its methods.