Classes and Instances

Introduction Classes, Objects, Methods and Instance Variables Declaring a Class with a Method and Instantiating an Object of a Class Declaring a Method with a Parameter Instance Variables, set Methods and get Methods Primitive Types vs. Reference Types Initializing Objects with Constructors

Class There are many objects of the same type, customers, cars, bicycles… The same kinds of objects are grouped into classes A class defines the fields and the methods that each object of that type will have –a class is a blueprint or template E.g. Customer class defines all the fields and the method implementations that each customer will have

Instances Each object of a particular type is an instance of the class –your bike is an instance of the class Bicycle –Joe Bloggs is an instance of the class Customer All instance objects share the same blueprint i.e. class Each instance object of a class is separate, and individual –each has the same structure and behaviour –each has different actual values There are many instance objects for each class

Class vs Instance Objects Class Instance 1 Instance 4 Instance 3 Instance 2 All instances of the same class

Class vs Instance Objects Student Mary Black Sean Smith Eoin Murphy Niamh Connor All instances of the same class

Declaring a Class with a Method and Instantiating an Object of a Class keyword public is an access modifier Class declarations include: –Access modifier –Keyword class –Pair of left and right braces

classes are defined in the following way: class MyClass { //field, constructor, and method declarations }

Class Definition class Student { // fields String name; int studentNo; String course; //related to other Objects // methods void register(){... } void completeYear(int year){... } void graduate(){... } }

Class Members There are two types of members of a class –class members –instance members Class members are associated with the class object –exist once, a single copy Instance members are associated with each instance object –multiple copies of an instance member exists, one copy in each instance object Note: object members = object fields + object methods

Class vs Instance Members Class: Student Reg Fee: E600 Mary Black FT211 register() completeYear(int) graduate() Sean Smith FT228 Niamh Connor FT211 register() completeYear(int) graduate() Eoin Murphy FT228 register() completeYear(int) graduate() register() completeYear( graduate() changeFee(double)

Class vs Instance members class Student { // instance fields String name; int studentNo; String course; // class fields static double regFee = 600; // class methods static void changeFee(double fee){... } // instance methods void register(){... } } class members declared using keyword static

Class members Class fields –a class field has the same value for all instances of the object –a class field declared with a final modifier is a constant public static final double PI= ; Class methods –a class method cannot use any instance members (fields or methods)

Declaring a Class with a Method and Instantiating an Object of a Class Method declarations –Keyword public indicates method is available to public –Keyword void indicates no return type –Access modifier, return type, name of method and parentheses comprise method header

Creating Instance Objects - new keyword Instance objects are created from the class definition To create instance objects need a special type of method called a constructor Instance objects are created using the keyword new E.g. Student me = new Student(); class type instance object variable name constructor

Constructor The constructor –has the same name as the class (watch case sensitivity!) –allocates enough space for an instance object of the class specified –does not specify a return type –should initialise all instance fields

Constructor class Student { // fields String name; int studentNo; String course; // constructor Student (String n, int s, String c){ name=n; studentNo=s; course=c; } // methods... }

Program Structure An OO program is a collection of objects interacting with each other There are three types of classes –business class – for objects which represent persistent data in the system, –interface class – for objects that represents an interface (e.g. screen, file reader, etc…) –control class – for objects that control the flow of interaction All programs need a program control class that starts the program running (i.e. has the main method)

Example One technique is to –instantiate the program control class in the main method –include the work of the program in the program control class constructor Could include main work of program in main but cannot access instance members…

Simple Program class Classid{ // constructor Classid(){ Data and Control } // main method to start execution public static void main (String[] args) { new Classid(); // instantiating } Simple Program The Java system calls the main method which instantiates the program via a new on the constructor for Classid. Execution of the program proceeds from the constructor and ends with the last statement in sequence has been reached.

Example: Creating Objects public class HelloWorld1{ // constructor HelloWorld1(){ System.out.println( "Hello World yet again..."); } // main method to start execution public static void main (String[] args) { new HelloWorld1(); // instantiating } program control class

Another Example // Class declaration with one method. public class GradeBook { public GradeBook(){ System.out.println( "Welcome to the Grade Book!" ); } // display a welcome message to the GradeBook user public void displayMessage() { System.out.println( "Welcome to the Grade Book!" ); } // end method displayMessage } // end class GradeBook

This is called from this class // Create a GradeBook object and call its displayMessage method. public class GradeBookTest { GradeBookTest() { // create a GradeBook object and assign it to myGradeBook // call the constructor for the class GradeBook GradeBook myGradeBook = new GradeBook(); // call myGradeBook's displayMessage method myGradeBook.displayMessage(); } // end main public static void main (String[] args) { // Start the program running from its constructor new GradeBookTest();} } // end class GradeBookTest

Consider what is happening We are creating an instance of GradeBook from this class GradeBookTest See the line GradeBook myGradeBook = new GradeBook(); We then call on the line myGradeBook.displayMessage(); This calls the displayMessage method from the GradeBook class

Next Lecture How do we implement all this

Some Background Activities Around Classes We discussed some classes and programs that called them. For example we had the GradeBook and Grade Book Test Classes

Another Example // Class declaration with one method. public class GradeBook { // display a welcome message to the GradeBook user public void displayMessage() { System.out.println( "Welcome to the Grade Book!" ); } // end method displayMessage } // end class GradeBook

This is called from this class // Create a GradeBook object and call its displayMessage method. public class GradeBookTest { GradeBookTest() { // create a GradeBook object and assign it to myGradeBook // call the constructor for the class GradeBook GradeBook myGradeBook = new GradeBook(); // call myGradeBook's displayMessage method myGradeBook.displayMessage(); } // end main public static void main (String[] args) { // Start the program running from its constructor new GradeBookTest();} } // end class GradeBookTest

Consider what is happening We are creating an instance of GradeBook from this class GradeBookTest See the line GradeBook myGradeBook = new GradeBook(); We then call on the line myGradeBook.displayMessage(); This calls the displayMessage method from the GradeBook class

Next How do we implement all this We need to do this by linking all the classes together. One way of doing this is with the – classpath qualifier at compilation time using the javac command We have already seen this at run time with the java command. But we can use the same idea at compilation time This will tell the compiler where to find classes. See the following dialogue

Directory mnemonics In Dos the directory hierarchy uses some short cuts \ refers to the root directory So if we type cd \ We will be returned to the root directory The parent directory of any directory is indicated by.. So if we were in C:\johns\java\progs and we typed cd.. We will be returned to C:\johns\java

Directory mnemonics. notation The current directory is indicated by. So when we use. We are referring to the current directory So javac –classpath. GradeBook will look for classes in the current directory. So the java classes used must be there.

Consider the following two Classes Book And Bookstore1 due to June Barrett Their Code is

Book.java public class Book { // Declare instance fields String name; int price; // The constructor initialises the instance fields Book (String n, int p) { name = n; price = p; } // a method to output the object details void write() { System.out.println(name + " for £" +price); }

BookStore1.java public class BookStore1 { /* Illustrating the basic structure of an object oriented program */ // Declare three object variables representing type of // goods sold in the store Book TextBook, Novel,ShortStory;

BookStore1.java continued // The constructor for the program is // where the initial work gets done BookStore1 () { // Create three objects with different initial values TextBook = new Book("Java Programming", 6); Novel = new Book("The Unsung Hero", 30); ShortStory = new Book("Stories for 5 year olds", 80); // Print out a header System.out.println("The Book Store sells\n"); // Print the values contained in each of the objects TextBook.write(); Novel.write(); ShortStory.write(); }

And Finally // The program control class must have a main method public static void main (String[] args) { // Start the program running from its constructor new BookStore1 (); }

The Constructor BookStore1 We see from the code that the constructor BookStore1() make three instance of the class Book, namely TextBook,Novel and ShortStory It then calls on the Book write method to display details about the book.

Next How do we compile these Firstly Book.java and BookStore1.java must be in the same directory

From a Directory Listing We see that they are both in the c:\ directory Next we compile and run the classes using the Javac and Java commands with –classpath.

From this screen we see That the class correctly executes the specific objects.

Some Dos issues The javac command is in the jdk bin subdirectory and I am fed up typing out C:\program files\java\jdk1.5.0_16\bin\javac Or whatever in order to use the command

Solution set a dos path set path=c:\program files\java\jdk1.5.0_16\bin This is the path on my computer for Java jdk version 5 NBNBNB You need whatever path there is to the bin directory in java jdk where javac is stored ON YOUR COMPUTER!!!!! Then the O/S will try this path when you invoke javac