Unit 5: Writing Classes

Classes represent either physical objects (e.g. a student) or abstract concepts (e.g. a loan) and define their attributes (instance and static variables) and behaviors (methods).

Access specifier:

private - restricts access to the declaring class (the usual designation for instance variables)
public - allows access from outside the declaring class (this is the usual scenario for classes and constructors)
protected - (not covered in the AP Java subset)

Methods can be either internal (access designation - private) or external (access designation - public)

Class name:

starts with a capital letter, no reserved words, no spaces

Data encapsulation

A technique where the implementation of the details of a class is kept secret from the user. This is done through access specifiers. Data can or cannot be accessible (read-only) and/or modifiable (R/W) from external classes.

Instance variables are typically encapsulated using the private access specifier.

Accessor and Mutator Methods

Accessor methods are used to read the object's properties (a.k.a. "getters")
Mutator methods are used to modify the object's properties (a.k.a. "setters")

Resources:

Runestone Academy - Anatomy of a Java class
Practice-It! - Classes self-check 8.1-8.7

Constructors

WALT (We Are Learning To): define instance variables for the attributes to be initialized through the constructors of a class (MOD-2)

Object's state

An object's state refers to its attributes and their corresponding values at a given point in time. Attributes "live" in the instance variables of an object. So, an object HAS instance variables (a so called "has-a" relationship). E.g. object Andy of class Student has an instance variable called firstName and its value is "Andy".

The job of the constructor

The constructor' job is to set the initial state for an object, this including the initial values for all its instance variables.

Constructor parameters

These are local variables and their job is to initialize the instance variables. When using a mutable object as a constructor parameter, I should use its copy, not an alias of the original object — this way I make sure that the object's methods cannot modify the state of the original object.

No-constructor scenario

When no constructor is provided, Java uses the so called no-argument constructor and sets all instance variables to default values:

integers and doubles are set to 0.
Strings and other data types are set to null.

Constructor's anatomy

Notice that constructors don't have a return value.

Resources:

Runestone Academy: Unit 5.2: Writing constructors
Practice-It!: Classes - self-check 8.17-8.21 and Exercises 8.16 and 8.19

Documentation with comments

Comments are ignored by the compiler and are not executed at the program run-time.

Comment types:

Block comments:

/*   .......

.............

.............

*/

These comment out a block of code - i.e. multiple lines of code.

Line comments:

// ..............

These work for individual lines only.

Javadoc comments:

/**

*......

*......

*/

These are used for creating API documentation. BlueJ supports these.

Preconditions and Postconditions:

Preconditions

A precondition is a condition that needs to be met prior to the calling of the method in question in order for the code to work properly. E.g. the public double divide(int a, int b) method would have a precondition that the second parameter is not a zero, so that the division by zero error doesn't occur. The method does not necessarily need to check whether the precondition was met, but the precondition needs to be stated explicitly in the documentation.

Postconditions

A postcondition is a condition that always needs to evaluate to true after the execution of the method/code segment. Postconditions stipulate what is being returned or in what state the object is after the execution of the method/code segment.

Methods should be written so that the postconditions are satisfied when all the preconditions were met - i.e. that the program outputs what it should so long it has been fed with correct input (the opposite of GIGO: garbage in — garbage out).

E.g. the aforementioned divide() method should return the quotient of a, the dividend and b, the divisor. This quotient should be of the double data type.

Resources:

Accessor methods (a.k.a. getters)

In order to be able keep the object's instance or static variables private, one has to provide public methods that can read the contents of these variables outside of the object itself. Such methods are called "accessors" as they access the instance variables, read them and then return their content to whoever may be asking. They also go by the name "getters" as all they do is get some data without modifying anything within the object itself.

Methods that are non-void (i.e. they have a return type specified) return a value that must be compatible with the return type. Java first evaluates the return expression and then returns a copy of the value. They return exactly one value.

Example 1:

public static int add(int a, int b)

   return a+b;

The method above is not returning a or b, it first evaluates the return expression and then sends a copy of the value, which is the value of a plus the value of b. This is called returning by value. The original values of a and b stay intact.

Example 2:

public int greater(int a, int b)

   if (a>b)

     return a;

   else

     return b;

Here neither primitive a nor b is returned - a copy of a or b is. This is another example of returning by value.

Example 3:

public String getName()

     return objectName;

As the return type is String - an object - in this case a copy of the memory reference to the objectName instance variable is returned, not the actual value(s) stored in the object (which is a string in this case).

The toString() method

Whenever you try to "print" an object, the default toString() method is called which displays its instance variables. It is very common to override this method with a class-specific version of the toString() method. This method always returns a value, not a memory reference.

Consider the example below:

public class Student

    private int studentID;

    private String firstName;

    private String lastName;

    private int noOfCredits;

    public Student(int ID, String fName, String lName, int credits)

        studentID=ID;

        firstName=fName;

        lastName=lName;

        noOfCredits=credits;

    public String toString()

        return "Student ID: "+studentID+"\n"+"First Name: "+firstName+"\n"+"Last Name: "+lastName+"\n"+"Number of Credits: "+noOfCredits;

public class Main

    public static void main()

        Student s1=new Student(001,"Andy","Daubner",55);

        System.out.print(s1);

<- declaring instance variables

<- initializing instance variables

<- defining own toString() - overriding the default one

creating a test class

creating a test instance of the Student class
trying out the toString() class-specific method by printing the object itself.

Instead of just merely printing the object reference, System.out.print(s1) will call the class-specific toString() method which we defined in the class above and which formats the output in a more useful way.

Generic toString() printing of objects:

Printing s1 with the generic toString() method (no class-specific toString() method just prints the memory reference to the object:

Student@3e242412

Class-specific toString() printing of objects:

Printing s1 with the class-specific toString() method produces a more intelligible output:

Student ID: 1

First Name: John

Last Name: Smith

Number of Credits: 55

Here, the class-specific toString() method has overriden the generic toString() method.

Checklist for writing accessor methods:

Did I include the return type in the method signature?
Did I user the return keyword at the end of the method?
Did I processed the returned value (e.g. did I save it in a variable)?

Resources:

Mutator Methods (a.k.a. Setters)

Mutator methods are meant to change ("mutate") the instance variables of an object. This is in order to protect the instance variables of an object from direct access by other objects.
They are also know as modifier methods, setters or set methods.
Mutator methods are usually (not always) void methods. Void methods do not return a value. These are indicated by the void keyword in the method signature.
Mutator methods always take a parameter - the new value the instance variable is to be changed to.
It is common to have pairs of methods for each private instance variable - a setter and a getter.
Naming conventions: setXYZ(), changeXYZ(), updateXYZ(), renameXYZ(), etc. These are not mandatory, though... There will be situations where you will not use any of the above, such as in a bank account deposit() method, which is a mutator method - it modifies the account balance. See the example below:

Example of a setter method:

public class BankAccount

  private double balance;

public void deposit(double amount)

  balance+=amount;

<- defining instance variables - the balance is a private variable readable and modifiable by the object itself only.

<- a mutator method that changes the balance instance variable - it adds the amount deposited to the existing balance.

Another example of a mutator method:

public class File

  private String fileName;

public void changeFileName(String newFileName)

  fileName=newFileName;

<- defining instance variables

<- a mutator method that changes the fileName instance variable

Setters vs. Getters

Setters:

typically have no return value (void)
access private instance variables
modify instance variables of an object
take a parameter (the new value to be set)
sample method signature:

public void setName(String studentName)

Getters:

return a value (data type required)
access private instance variables
do not modify instance variables of an object
do not take a parameter
sample method signature:

public double getBalance()

Resources:

Writing Methods

Procedural abstraction is the idea of being able to take a block of code that can be reusable in multiple instance away from the main method and put it in a separate method instead, so we can just call the method whenever we need it without worrying about its implementation. This is called procedural abstraction.

Advantages of procedural abstraction:

reduced the complexity of the code (the code becomes easier to read as opposed to the so called "spaghetti code" (TM holder Andy) when no methods are used, easier to digest for the reader in "bite-size" chunks, larger problems are split into smaller sub-problems
reduces the redundancy of the code (as you can call the same method whenever you need it, you can reuse it later for other projects)
makes debugging easier (fix problems in one place only, easier to debug a shorter block of code)
makes maintenance (later updates, fixes, modifications) easier
makes teamwork easier (easier to divide the labor)

(loosely based on the Runestone Academy CSAwesome course)

In order to be able to call a non-void method, you must first create an object of the same class as your method. In contrast, static methods do not require an object to be called upon.
When passing parameters that are objects, the method that receives this parameter (an object) can access this object's private methods and data only in case the object passed on to it as a parameter belongs to the same class as the method itself.
Non-void methods that include parameters receive input (data) through these parameters that get processes and then the outcome is output using the return statement in the data type set in the method signature.
You should avoid modifying mutable objects that are passed on as a parameter, unless the specification calls for it. Instead, call a mutator method on the object itself.
When passing a reference parameter, Java creates another alias to the object the reference is pointing to.

Method header (a.k.a. method signature):

Formal vs. actual parameters

The parameters defined in the method header are called formal parameters (such as String password and double amount in the example method header above. The actual parameters are the values passed on to the method when it's being called and are saved in the local variables declared in the method signature, such as in the example below:

public class Account

  private double balance;

  private int noOfOpenAccounts=0;

  public Account()

  balance=0.0;

  Account.noOfOpenAccounts++;

public void withdraw(String password, double amount)

 { if password.equals("pass123")

     balance-=amount;

public static void main()

  Account account1 = new Account()

  account1.withdraw("pass123",100.00);

Here the value "pass123" got saved in the password local variable and the value 100.00 got saved in the local variable called amount.

These variables are local to the method - they cannot be used outside of it.

In short: the method header declares its local variables and the calling of the method with parameters initializes the local variables with concrete values that were sent as parameters.

Calling by value vs. calling by reference:

When passing primitives as parameters, Java makes a copy of the value in the argument and sends that to the method. This is called calling by value. If you change the value that was passed on as parameter in the method, the original value will stay unaltered.

When sending an object as a parameter to a method, a copy of the reference to that object is made (an alias), which is then passed on to the method. See the example below:

Creating aliases (multiple references) to the same object:

In the example on your left we see that two objects were created but three references exist. The "MrKubes" and the "MrMatej" references both refer (point) to the same object. We call such references as aliases. When passing objects as arguments, a new alias is created and only the alias, not the entire object, is passed on to the method.

Some pointers for writing methods

You should create methods that are short enough and each should focus on solving one specific problem; have you methods in the enclosed class definition; remember to state the method header correctly, paying attention to the access type (typically public), whether the method is static or not, its parameters, and the return value (void or not).
When calling non-static methods, you must first create an object to call the method on — see the Formal vs. actual parameters example above, where in the Main class we first had to create an account object account1 in order to be able to call the withdraw() method by stating account1.withdraw("pass123", 100.00) having included the correct type and number of parameters.

Resources:

Static Variables and Methods

Static variables

Static variables don't belong to a specific object but to the class they are contained in - all objects of this class share these static variables.
We use the static keyword in the method signature to indicate that a variable is static.
Static variables can be designated as public or private.
Static variables are refered to as follows: className.variableName. Example for the Account class (see the code above):

  System.out.println("The number of open accounts is: "+Account.noOfOpenAccounts)

The line of code above (if placed in the main method) reads the static variable noOfOpenAccounts which holds the number of accounts open (whenever the Account() constructor is called, this variable's value increases by one)

Static methods

Static methods don't belong to a specific object but to the class they are contained in.
We use the static keyword in the method signature to indicate that a method is static.
Static methods cannot access/modify instance variables of the objects in its class.
Static methods can access/modify static variables.
the this keyword cannot be used with static methods as there is no object reference.

Resources:

RunestoneAcademy CSAwesome: Unit 5.7

Scope and Access

The scope of a variable is where the variable can be accessed and used - i.e. in what parts of your program the variable will be usable.
The scope of a variable depends on where in the code it was declared - look for the nearest set of curly braces { } — this will be the variable's scope.

Levels of scope in Java

Class level scope - these are your instance variables that are available throughout the whole class
Method level scope - these are local variable declared inside your methods - these will be accessible only within this method; these are for instance the method's parameters used within the method.
Block level scope - these are variables inside blocks such as loops or any other block of code enclosed in between { and }. These will only work within the scope of this block. An example would be the iterator in your for loop.

Different scopes example:

public class Teacher

 private String firstName;

 private String lastName;

public void printName(int howManyTimes)

 { for (i=0;i<howManyTimes;i++)

      System.out.println("Copy number :"+i);

      System.out.println(firstName+" "+lastName;

<- declaring instance variables firstName and lastName - their scope is class-wide

<- parameter howManyTimes has a method scope - it will only be usable within this method. It is also known as a local variable.

<- iterator i has a block scope - it only works within the for loop.

Scope and access reminders:

It is common to declare local variables at the top of the method; the parameters are declared in the method's signature
The variable does not live outside of its scope - it is invisible to the code outside of the scope.
The scope of a variable is determined by the nearest set of curly brackets { }.
Instance variables are accessible to all methods in a class; if marked as public, they can be accessed outside the class as well.
It is a good programming practice to keep the scope of variables to a minimum - in other words, it is not recommended to make all your variables instance variables unless they are to be accessed by multiple methods of that class.
If there are several variables with the same name within some scope of the program, the one with narrower scope will be used. In other words, the variable that is "closer" to the point in the program will be used. See the example below.

public class Student

 private String lastName;

public Student(String name)

    lastName=name;

public void printStudent()

    String lastName="Smith";

    System.out.println(lastName);

public static void main()

 Student s1=new Student("Shin");

 s1.printStudent();

When we run the main method, the output will be "Smith" and not "Shin" as we have both a local and and instance variable called lastName and it is the local one that "wins".

In Java IDEs the scope of variables can be usually identified by individual areas of scope (blocks) shaded in different colors for easier identification (this provided you've done your indentation properly). Here, BlueJ uses green, white, yellow and white again for different levels of scope.

Resources:

RunestoneAcademy CSAwesome: Unit 5.8 - Scope and Access

"this" keyword

The this keyword refers to the object whose method or constructor is being called.
this can only be used with non-static methods or constructors
this can be used to pass the current object as a parameter to a method or constructor

Consider this example:

public class Parent

 private String lastName;

public Parent(String name)

    lastName=name;

public void printParent()

    String lastName="Baker";

    System.out.println(this.lastName);

public static void main()

 Parent p1=new Parent("Smith");

 p1.printParent();

<- We are using this to identify the object (in this case it is p1, hence this.lastName refers to the instance variable lastName, not the local variable lastName.

When we run the main method, the output will be "Smith" and not "Baker" as we have clearly indicated, using the this keyword, that we are interested in the instance variable and not the local or block variable.

Resources:

RunestoneAcademy: CSAwesome: Unit 5.9 - "this" keyword

Page updated

Google Sites

Report abuse