Lecture 10 : Classes and Inheritance

• relearn the basic about classes
• members -- methods and variables.
• private and public.
• constructors.
• how to declare objects
• how to access members
• learn about  class member and the use of static .
• learn about  this 
• learn how to extend classes 
• understand the keyword protected and restudy the meaning of private and public
  
• override and overload functions.
• learn how to use final.
  
• understand the keyword super.

The class body

public class BankAccount {
      <---- class body here
}

  

•  constructors for initializing new objects. (e.g.  public BankAccount(String name, int saving) )
•  declarations for the variables that provide the state of the class and its objects.(e.g. private int saving)
•  methods to implement the behavior of the class and its objects . (e.g. public String getName())

• Variables and methods collectively are called members .
•  Constructors are not methods. Nor are they members

Constructors

• All Java classes have constructors that are used to initialize a new object of that type.
• A constructor has the same name as the class. For example, the name of the BankAccount class's constructor is BankAccount , the name of the CheckingAccount class's constructor is CheckingAccount.
• BankAccount defines a single constructor:

   public BankAccount(String name, int saving) {
       this.name = name;
       this.saving = saving;
   }
  

  
  
• Java supports name overloading for constructors so that a class can have any number of constructors, all of which have the same name.

public BankAccount(String name) {
	this(name,0);
    }

Use of constructors

• Both constructors share the same name, BankAccount , but they have different parameter lists.
• The compiler differentiates these constructors based on the number of parameters in the list and their types.
• Typically, a constructor uses its arguments to initialize the new object's state. When creating an object, choose the constructor whose arguments best reflect how you want to initialize the new object. 
• The compiler knows that when you write the following code, it should use the constructor that requires a String (name) and and int (saving)

• Similarly, when you write the following code, the compiler chooses the constructor that require a String (name)

  new BankAccount("Charles");
  
        

Declaring Member Variables

• BankAccount  uses the following lines of code to define its  member variables:

  private String name;
  private int saving;
  

• the declaration are within the class body but outside of any methods or constructors.
• The member variables declared are named name, saving , and their data type are String ,int respectively. Also, the private keyword identifies them  as a private members. This means that only codes within the BankAccount class can access them.
• You specify access level (private, protected, public or nothing), type, name.
• You can add other attributes, including whether the variable is a class or instance variable and whether it's a constant. 

accessLevel

Lets you control which other classes have access to a member variable by using one of four access levels: public, protected, package, and private. You control access to methods in the same way. 

static

Declares this is a class variable rather than an instance variable. You also use static to declare class methods. 

final

Indicates that the value of this member cannot change. The following variable declaration defines a constant named SPEED_OF_LIGHT , whose value is the speed of light in vacuum = 299,792,458 m/s (meters per second).

final long SPEED_OF_LIGHT = 299792458;

It's a compile-time error if your program ever tries to change a final variable. By convention, the name of constant values are spelled in uppercase letters.

type

Like other variables, a member variable must have a type. You can use primitive type names such as int , float , or boolean . Or you can use reference types, such as array, object, or interface names.

name

A member variable's name can be any legal Java identifier and, by convention, begins with a lowercase letter. You cannot declare more than one member variable with the same name in the same class.

Implementing Methods

 access  return  method   arguments
 level   type    name      |
 |        |       |        | 
 |        |       |        |
 V        V       V        V  
 public void deposit(int depositAmount) {  <-----  method declaration
     if(depositAmount >= 0) { 
         saving+= depositAmount;            <-----  method body
      }
 }

• Like a class, a method has two major parts: method declaration and method body.
• The method declaration defines all of the method's attributes, such as access level, return type, name, and arguments.
• The method body is where all the action takes place. It contains the Java instructions that implements the method. 

Details of a Method Declaration

accessLevel

As with member variables, you control which other classes have access to a method using access levels: public, protected and private. 

static

As with member variables, static declares this method as a class method rather than an instance method. 

final

A final method cannot be overridden by subclasses. 

returnType

Java requires that a method declare the data type of the value that it returns. If your method does not return a value, use the keyword void for the return type. 

methodName

A method name can be any legal Java identifier. You need to consider several issues in regards to Java method names. 

( paramlist )

You pass information into a method through its arguments. 

Returning a Value from a Method

• You declare a method's return type in its method declaration. 
• You should use void as the return type if there is no return.
• The following method return an integer.

   
  public int getSaving() {
  	return saving; 
   } 
  

• The data type of the return value must match the method's return type . There will be a compiler error if you try to write a method in which the return value doesn't match the return type.
• Methods also can return a reference type.

Overloading

• Java supports method name overloading so that multiple methods can share the same name.
• Overloaded methods are differentiated by the number and type of the arguments passed into the method. 
• Example
  

  public class OverloadTest {
      public void method() {
  	System.out.println("no argument");
      }
      
      public int method(int a) {
  	System.out.println("argument list : int");
  	return 1;
      }
      
      public int method(String  s) {
  	System.out.println("argument list : String");
  	return 1;
      }
      
      public char method(int a, String b) {
  	System.out.println("argument list : int, string");
  	return 'a';
      }
      
      public static void main(String[] args) {
          OverloadTest test = new OverloadTest();
  	test.method();
  	test.method(1);
  	test.method("hi");
  	test.method(1,"Java");
      }
  } 
  

Passing Information into a Method

• you declare the number and type of the arguments required by that method
• You declare the type and name for each argument in the method signature. 

double computePayment(double loanAmt, double rate,
                                      double futureValue,
				      int numPeriods) {
    double I, partial1, denominator, answer;

    I = rate / 100.0;
    partial1 = Math.pow((1 + I), (0.0 - numPeriods));
    denominator = (1 - partial1) / I;
    answer = ((-1 * loanAmt) / denominator)
             - ((futureValue * partial1) / denominator);
    return answer;
}

Argument Types

• you can pass an argument of any valid Java data type into a method.
• This includes primitive data types such as doubles, floats and integers as you saw in the computePayment method, and reference data types such as objects and arrays.
  

public double method(BankAccount account, int month);
public int sum(int[] intArray);

Argument Names

• When you declare an argument to a Java method, you provide a name for that argument. This name is used within the method body to refer to the item.
• The varibles are local variables. i.e. it is only valid in the method body.
  

Pass by Value

• In Java methods, arguments are passed by value. 
• When the argument is of primitive type, pass-by-value means that the method cannot change its value. 
• When the argument is of reference type, pass-by-value means that the method cannot change the object reference, but can invoke the object's methods and modify the accessible variables within the object .

this

• this is a reference to the object itself.
• Typically, within an object's method body you can just refer directly to the object's member variables. However, sometimes you need to disambiguate the member variable name if one of the arguments to the method has the same name.
• example 

   public BankAccount(String name, int saving) {
   this.name = name;
   this.saving = saving;
   }
  

  name = name is ambigous.
• You can also use the this keyword to call one of the current object's variables and methods. This is only necessary if there is some ambiguity in the method name and is often used to make the intent of the code clearer.
• You can use this to call other constructors. e.g.

   public BankAccount(String name) {
   this(name,0); 
   }
  

  The line this(name,0) call the constructor BankAccount(name,0) and instantiate an object with name and 0 saving

A Break....

• constructor and overloading of constructors and how to use constructor to instantiate an object
• how to declare members, and you learned 2 more keywords static and final.
• final type variable means the variable cannot be changed
  
• how to return a value for the method.
• overloading of methods.
• this