Creating your own Classes

Defining your own classes

To define a class, we write,

<modifier> class <name> {
<attributeDeclaration>*
<constructorDeclaration>*
<methodDeclaration>*
}
where,
<modifier> is an access modifier, which may be combined with
other types of modifier.
 An appropriate name for our class would be StudentRecord.
Now, to define our class we write,
public class StudentRecord
{
//we'll add more code here later
}
where,
public - means that our class is accessible to other classes outside the
package
class - this is the keyword used to create a class in Java
StudentRecord - a unique identifier that describes our class
Coding Guideline:

1. The name of the class should be meaningful, don't just call your class
XYZ or any random names you can think of.

2. Class names should start with a CAPITAL letter.

3. The filename of your class should have the SAME NAME as your public
class name.
Declaring Attributes
To declare a certain attribute for our class, we write,
<modifier> <type> <name> [= <default_value>];
For example, you don't want to have a data type int for a student's
name, or a String for a student's grade.
name - String
address - String
age - int
math grade - double
english grade - double
science grade - double
average grade - double
Declaring Attributes
Since we want these attributes to be unique for each object (or for each student), we
should declare them as instance variables.
For example,
public class StudentRecord
{
private String name;
private String address;
private int age;
private double mathGrade;
private double englishGrade;
private double scienceGrade;
private double average;
//we'll add more code here later
}
 where,
private here means that the variables are only accessible within the class.
Other objects cannot access these variables directly. We will cover more about
accessibility later.

Coding Guideline:
1.Declare all your instance variables on the top of the class declaration.
2.Declare one variable for each line.
3. Instance variables, like any other variables should start with a SMALL letter.
4. Use an appropriate data type for each variable you declare.
5.Declare instance variables as private so that only class methods can access
them directly.
Class Variables or Static Variables

Now suppose, we want to know the total number of student records

we have for the whole class, we can declare one static variable that will hold
this value. Let us call this as studentCount.
To declare a static variable,
public class StudentRecord
{
//instance variables we have declared
private static int studentCount;
//we'll add more code here later
}
we use the keyword static to indicate that a variable is a static variable.
So far, our whole code now looks like this.
public class StudentRecord
{
private String name;
private String address;
private int age;
private double mathGrade;
private double englishGrade;
private double scienceGrade;
private double average;
private static int studentCount;
//we'll add more code here later
}
Declaring Methods
Before we discuss what methods we want our class to have, let us first take
a look at the general syntax for declaring methods.
To declare methods we write,
<modifier> <returnType> <name>(<parameter>*) {
<statement>*
}
where,
<modifier> can carry a number of different modifiers
<returnType> can be any data type (including void)
<name> can be any valid identifier
<parameter> ::= <parameter_type> <parameter_name>[,]
Accessor methods

- are used to read values from class variables (instance/static).

- it usually starts with a get<NameOfInstanceVariable>.
- It also returns a value.

For example:
public class StudentRecord
{
private String name;
 ..
public String getName(){
return name;
}
}
where,
public - means that the method can be called from objects outside the
class
String - is the return type of the method. This means that the method
should
return a value of type String
getName - the name of the method
() - this means that our method does not have any parameters
 The statement,
return name;
in our program signifies that it will return the value of the instance variable name to
the calling method.
Another example of an accessor method is the getAverage method,
public class StudentRecord
{
private String name;
..
public double getAverage(){
double result = 0;
result = ( mathGrade+englishGrade+scienceGrade )/3;
return result;
}
}
Mutator Methods
- is usually written as set<NameOfInstanceVariable>.
Now let's take a look at one implementation of a mutator method,
public class StudentRecord
{
private String name;
..
public void setName( String temp ){
name = temp;
}
}
 where,
public - means that the method can be called from objects outside the
class
void - imeans that the method does not return any value
setName - the name of the method
(String temp) - parameter that will be used inside our method

The statement,
name = temp;
assigns the value of temp to name and thus changes the data inside the
instance variable name.
Take note that mutator methods don't return values. However, it contains some
program argument or arguments that will be used inside the method.
Multiple Return statements
For example, consider the method,
public String getNumberInWords( int num ){
String defaultNum = "zero";
if( num == 1 ){
return "one"; //return a constant
}
else if( num == 2){
return "two"; //return a constant
}
//return a variable
return defaultNum;
}
Static methods

For the static variable studentCount, we can create a static method to

access its value.
public class StudentRecord
{
private static int studentCount;
public static int getStudentCount(){
return studentCount;
}
}
 where,

public - means that the method can be called from objects outside the class
static - means that the method is static and should be called by
typing,[ClassName].[methodName]. For example, in this case, we call the method
StudentRecord.getStudentCount()
int - is the return type of the method. This means that the method should
return a value of type int
getStudentCount - the name of the method
() - this means that our method does not have any parameters
Coding Guideline:

1. Method names should start with a SMALL letter.

2. Method names should be verbs

3. Always provide documentation before the declaration of the method. You can
use javadocs style for this. Please see example.
Sample Source Code for StudentRecord
class
Here is the code for our StudentRecord class,
public class StudentRecord
{
private String name;
private String address;
private int age;
private double mathGrade;
private double englishGrade;
private double scienceGrade;
private double average;
private static int studentCount;
/**
* Returns the name of the student
*/
public String getName(){
return name;
}

/**
* Changes the name of the student
*/
public void setName( String temp ){
name = temp;
}
// other code here ....

/**
* Computes the average of the english, math and science
* grades
*/
public double getAverage(){
double result = 0;
result = ( mathGrade+englishGrade+scienceGrade )/3;
return result;
}
 /**
* returns the number of instances of StudentRecords
*/
public static int getStudentCount(){
return studentCount;
}
}
Now, here's a sample code of a class that uses our StudentRecord class.

public class StudentRecordExample

{
public static void main( String[] args ){
//create three objects for Student record
StudentRecord annaRecord = new StudentRecord();
StudentRecord beahRecord = new StudentRecord();
StudentRecord crisRecord = new StudentRecord();
//set the name of the students
annaRecord.setName("Anna");
beahRecord.setName("Beah");
crisRecord.setName("Cris");

//print anna's name

System.out.println( annaRecord.getName() );
 //print number of students
System.out.println("Count="+StudentRecord.getStudentCount());
}
}

The output of this program is,

Anna
Student Count = 0
The this reference

- is used to access the instance variables shadowed by the

parameters. To understand this better, let's take for example the
setAge method. Suppose we have the following declaration for
setAge.

public void setAge( int age ){

age = age; //WRONG!!!
}
 Since the parameter age is the closest declaration to the method, the value
of the parameter age will be used. So in the statement,
age = age;
we are just assigning the value of the parameter age to itself! This is not
what we want to happen in our code. In order to correct this mistake, we use the
this reference. To use the this reference, we type,
this.<nameOfTheInstanceVariable> So for example, we can now rewrite our code
to,
public void setAge( int age ){
this.age = age;
}
This method will then assign the value of the parameter age to the instance
variable of the object StudentRecord.

NOTE: You can only use the this reference for instance variables and NOT static
or class variables.
Declaring Constructors
- are important in instantiating an object. It is a method where
all the initializations are placed.

The following are the properties of a constructor:

1. Constructors have the same name as the class

2. A constructor is just like an ordinary method, however only the following

information can be placed in the header of the constructor, scope or
accessibility identifier (like public...), constructor's name and parameters if it
has any.
3. Constructors does not have any return value

4. You cannot call a constructor directly, it can only be called by using the new
operator during class instantiation.

To declare a constructor, we write,

<modifier> <className> (<parameter>*) {
<statement>*
}
Default Constructor
- is the constructor without any parameters. If the class does
not specify any constructors, then an implicit default constructor is
created.
- Every class has a default constructor.
For example, in our StudentRecord class, the default constructor
would look like this,
public StudentRecord()
{
//some code here
}
Overloading Constructors
For example, we have here four overloaded constructors,

public StudentRecord(){
//some initialization code here
}
public StudentRecord(String temp){
this.name = temp;
}
public StudentRecord(String name, String address){
this.name = name;
this.address = address;
}
public StudentRecord(double mGrade, double eGrade, double sGrade){
mathGrade = mGrade;
englishGrade = eGrade;
scienceGrade = sGrade;
}
Using Constructors
To use these constructors, we have the following code,
public static void main( String[] args )
{
//create three objects for Student record
StudentRecord annaRecord=new StudentRecord("Anna");
StudentRecord beahRecord=new StudentRecord("Beah",
"Philippines");
StudentRecord crisRecord=new
StudentRecord(80,90,100);
//some code here
}
 A good location to modify and increment the value of studentCount is in the
constructors, because it is always called everytime an object is instantiated.
For example,
public StudentRecord(){
//some initialization code here
studentCount++; //add a student
}

public StudentRecord(String temp){

this.name = temp;
studentCount++; //add a student
}
public StudentRecord(String name, String address){
this.name = name;
this.address = address;
studentCount++; //add a student
}

public StudentRecord(double mGrade, double eGrade,

double sGrade){
mathGrade = mGrade;
englishGrade = eGrade;
scienceGrade = sGrade;
studentCount++; //add a student
}
The this() Constructor Call
- can be chained, meaning, you can call another constructor
from inside another constructor. We use the this() call for this. For
example, given the following code,

1: public StudentRecord(){
2: this("some string");
3:
4: }
5:
6: public StudentRecord(String temp){
 7: this.name = temp;
8: }
9:
10: public static void main( String[] args )
11: {
12:
13: StudentRecord annaRecord = new StudentRecord();
14: }
Given the code above, when the statement at line 13 is called, it will call
the default constructor line 1. When statement in line 2 is executed, it will then call
the constructor that has a String parameter (in line 6).
There are a few things to remember when using the this constructor call:

1. When using the this constructor call, IT MUST OCCUR AS THE FIRST
STATEMENT in a constructor

2. It can ONLY BE USED IN A CONSTRUCTOR DEFINITION. The this call can

then be followed by any other relevant statements.
Packages
- are Javas means of grouping related classes and interfaces
together in a single unit (interfaces will be discussed later).

- This powerful feature provides for a convenient mechanism

for managing a large group of classes and interfaces while avoiding
potential naming conflicts.
Importing Packages
The syntax for importing packages is as follows,
import <nameOfPackage>;

For example, if you want to use the class Color inside package awt,
you have to type the following,
import java.awt.Color;
import java.awt.*;
This is done by using the package name to declare an object of a class.
java.awt.Color color;
Creating your own packages
To create our own package, we write,
package <packageName>;
Copy all the classes that you want to belong to this package inside this
folder. After copying, add the following code at the top of the class file. For
example,
package schoolClasses;
public class StudentRecord
{
private String name;
private String address;
private int age;
..
 Access Modifiers

There are four different types of member access modifiers in Java: public,
private, protected and default. The first three access modifiers are explicitly written
in the code to indicate the access type, for the fourth one which is default, no
keyword is used.
default access (also called package accessibility)
This specifies that only classes in the same package can have access to
the class' variables and methods.

public class StudentRecord

{
//default access to instance variable
int name;

//default access to method

String getName(){
return name;
}
}
public access
This specifies that class members are accessible to anyone, both inside
and outside the class.
public class StudentRecord
{
//public access to instance variable
public int name;

//public access to method

public String getName(){
return name;
}
}
private access
This specifies that the class members are only accessible by the
class they are defined in. For example,
public class StudentRecord
{
//private access to instance variable
private int name;

//private access to method

private String getName(){
return name;
}
}
Coding Guidelines:

The instance variables of a class should normally be declared private, and

the class will just provide accessor and mutator methods to these variables.