Chapter 3 Introduction to Classes and Objects

Chapter 3: Introduction to Classes and Objects All applications developed so far use only one class and locate all statements needed to perform some tasks in the method main. However, applications typically contain two or more classes each containing one or more methods. To be able to use a class and call its methods, you must create an object of that class. (However, only methods defined as static can be called without creating an object of the class in which it is defined) Classes contain attributes and methods Attributes are specified as part of the object’s class, for example, a bank account object has a balance attribute that represent the amount of money in the account. Methods describe the tasks that can be performed by the class, for example a class that represents a bank account might contain one method to deposit money, another to withdraw money and a third to inquire the balance. A method call tells the method to perform the task. Class declarations include:    Access modifier Keyword class Pair of left and right braces Each class declaration that begins with keyword public must be stored in a file that has the same name as the class and ends with the .java file-name extension. Declaring more than one public class in the same file is a compilation error. Declaring a class with a method and instantiating an object of a class The following example consists of classes GradeBook (Figure 3.1) and GradeBookTest (Figure 3.2). The class GradeBook will be used to display a message on the screen welcoming the instructor to the grade-book application. The class GradeBookTest is an application class in which the main method will use class GradeBook. Classes GradeBook and GrateBookTest must be declared in separate files because each class in declared public . Both files are stored in the same folder. 39 1 // Fig. 3.1: GradeBook.java 2 // Class declaration with one method. 3 4 public class GradeBook 5 { 6 7 // display a welcome message to the GradeBook user public void displayMessage() 8 { 9 10 System.out.println( "Welcome to the Grade Book!" ); } // end method displayMessage 11 12 } // end class GradeBook 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 // Fig. 3.2: GradeBookTest.java // Create a GradeBook object and call its displayMessage method. public class GradeBookTest { // main method begins program execution public static void main( String args[] ) { // create a GradeBook object and assign it to myGradeBook GradeBook myGradeBook = new GradeBook(); // call myGradeBook's displayMessage method myGradeBook.displayMessage(); } // end main 16 } // end class GradeBookTest Welcome to the Grade Book! 40 Line 7 in figure 3.1 is called the method header. It includes access modifier, return type, name of method and parentheses. The keyword public indicates that the method is available to public (can be accessed from outside the class), void indicates no return type. Line 9 is the body of the method which displays a welcome message. Line 10 in figure 3.2 is a class instance creation expression which includes the Keyword new, name of class to create and parentheses. We begin by declaring variable myGradeBook. The variable’s type is GradeBook (the class we declared in fig3.1). Each new class you create becomes a new type that can be used to declare variables and create objects. Programmers can declare new class types as needed (this is why Java is known as an extensible language). Variable myGradeBook is initialized with the result of the class instance creation expression new GradeBook(). The keyword new creates anew object, the GradeBook() is called the constructor which is used to initialize the object’s data. Line 13 in figure 3.2 is used to call the method displayMessage: To call a method, we use: Object name, then dot separator (.) Then method name and parentheses. When the method displaMessage completes its task, method main continues executing if any statements available, otherwise the program terminates. Declaring a method with a parameter Method parameters   Additional information passed to a method Supplied in the method call with arguments Parameters specified in method’s parameter list are part of the method header and uses a comma separator. A compilation error occurs if the number of arguments in a method call does not match the number of parameters in the method declaration. A compilation error occurs if the types of the arguments in a method call are not consistent with the types of the corresponding parameters in the method declaration. 41 1 2 3 4 5 6 // Fig. 3.4: GradeBook.java // Class declaration with a method that has a parameter. public class GradeBook { Data Type Identifier // display a welcome message to the GradeBook user 7 public void displayMessage( String courseName ) 8 { 9 10 System.out.printf( "Welcome to the grade book for\n%s!\n", courseName ); 11 } // end method displayMessage 12 13 } // end class GradeBook 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 // Fig. 3.5: GradeBookTest.java // Create GradeBook object and pass a String to // its displayMessage method. import java.util.Scanner; // program uses Scanner public class GradeBookTest { // main method begins program execution public static void main( String args[] ) { // create Scanner to obtain input from command window Scanner input = new Scanner( System.in ); // create a GradeBook object and assign it to myGradeBook GradeBook myGradeBook = new GradeBook(); // prompt for and input course name System.out.println( "Please enter the course name:" ); String nameOfCourse = input.nextLine(); // read a line of text System.out.println(); // outputs a blank line // call myGradeBook's displayMessage method // and pass nameOfCourse as an argument myGradeBook.displayMessage( nameOfCourse ); } // end main } // end class GradeBookTest Please enter the course name: CS101 Introduction to Java Programming Welcome to the grade book for CS101 Introduction to Java Programming! 42 Instance variable, set methods and get methods  local variables: ­ Is the variables that are declared in the body of method. ­ These can only be used within that method. ­ When the method terminates, the values of its local variables are lost.  ­ Local variables are not initialized by default. Field variables: ­ Is the variables that are declared in a class declaration (and outside the bodies of class’s method declarations). ­ Default initial values are provided for all fields not initialized (Equal to null for Strings, 0 for byte, char, short, int, long, float and double variables, and false for boolean variables). ­ Field variables can be: (1) instance variables (non-static fields). Each object of the class has a separate instance of the variable in memory. (2) class variables (static fields). ­ Declaration begins with the keyword static. ­ Static variables are used when all objects of a class must use the same copy of the variable. (Only one copy of a particular variable should be shared by all objects of the class). ­ The following example contains one instance variable and 3 methods. 43 1 // Fig. 3.7: GradeBook.java 4 5 public class GradeBook 2 3 6 7 8 9 // GradeBook class that contains a courseName instance variable // and methods to set and get its value. { Instance Variable private String courseName; // course name for this GradeBook // method to set the course name 10 11 public void setCourseName( String name ) { 14 15 // method to retrieve the course name 12 13 16 17 18 19 20 21 22 23 24 25 26 27 28 29 set method courseName = name; // store the course name } // end method setCourseName get method public String getCourseName() { return courseName; } // end method getCourseName // display a welcome message to the GradeBook user public void displayMessage() { // this statement calls getCourseName to get the // name of the course this GradeBook represents System.out.printf( "Welcome to the grade book for\n%s!\n", getCourseName() ); Call get method } // end method displayMessage 30 } // end class GradeBook ­ Line 7 in figure 3.7 is a declaration for an instance variable. It declares that courseName is a variable of type string. Each instance (object) of class GradeBook contains one copy of each instance variable. ­ The keyword private is used for most instance variables: ­ private variables and methods are accessible only to methods of the class in which they are declared. For example, the instance variable GradeBook can only be accessed by the methods: setCourseName, getCourseName and displayMessage. ­ Declaring instance variables private is known as data hiding ­ Method setCourseName, (lines 10-13), receives one parameter, name, and assigns it to the instance variable courseName. void indicates that the method doesn’t return any value. 44 ­ Method getCourseName (lines 16-19) returns a particular GradeBook object’s courseName. The method has an empty parameter list, so it doesn’t require additional information to perform its task. The method specifies the return type as a String. When a method that specifies a return type is called and completes its task, the method returns a result to its calling method. ­ Method displayMessage (lines 22-28) doesn’t return any data (return type is void). The method doesn’t receive parameters. Lines 26-27 output a welcome message that includes the value of instance variable courseName. ­ Note: The order in which the methods are declared in a class doesn’t determine when they are called at execution time. 1 // Fig. 3.8: GradeBookTest.java 3 import java.util.Scanner; // program uses Scanner 2 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 // Create and manipulate a GradeBook object. public class GradeBookTest { // main method begins program execution public static void main( String args[] ) { // create Scanner to obtain input from command window Scanner input = new Scanner( System.in ); // create a GradeBook object and assign it to myGradeBook GradeBook myGradeBook = new GradeBook(); // display initial value of courseName System.out.printf( "Initial course name is: %s\n\n", myGradeBook.getCourseName() ); 19 20 // prompt for and read course name 22 String theName = input.nextLine(); // read a line of text 21 23 24 25 26 27 28 29 System.out.println( "Please enter the course name:" ); myGradeBook.setCourseName( theName ); // set the course name System.out.println(); // outputs a blank line // display welcome message after specifying course name myGradeBook.displayMessage(); } // end main 30 } // end class GradeBookTest Initial course name is: null Please enter the course name: CS101 Introduction to Java Programming Welcome to the grade book for CS101 Introduction to Java Programming! 45 Figure 3.8 creates one object of class GradeBook and demonstrates its methods. The course name is obtained from the used. • • • • • Line 14 creates a GradeBook object and assigns it to local variable myGradeBook of type GradeBook. Lines 17-18 display the initial course name (which is null) by calling the object’s getCourseName method. Line 21 prompts the user to enter a course name. This will be stored in the local variable theName (line 22) Line 23 calls object muGradeBook’s setCourseName method and passes theName as an argument. The method is called and theName is assigned to the instance variable courseName. Line 27 calls object my GradeBook’s displayMessage method to display the welcome message containing the course name. - Primitive Types vs. Reference Types • • Recall, Types in Java Primitive: boolean, byte, char, short, int, long, float, double Reference (sometimes called non-primitive types) o Objects o Default value of null o Used to invoke an object’s methods Accordingly, the variable myGradeBook is a reference to a GradeBook object. ­ Constructors: • • • • • • Initialize an object of a class when the object is created Java requires a constructor for every class Java will provide a default no-argument constructor if none is provided, where the class’s instance variables will be initialized to their default values. Called when keyword new is followed by the class name and parentheses When you create a class, you can provide your own constructor to provide custom initialization for objects of your class. (Java will not create a default constructor for that class). Differences between constructors and method: ­ Constructors must have the same name as its class. ­ Constructors can’t return values, so they can’t specify a return type (not even void). ­ Constructors are declared public 46 In the following example, two constructors are declared for class GradeBook. The first constructor indicates that class GradeBook’s constructor has a String parameter called name. At line 5, the name passed to the constructor is assigned to the instance variable courseName in the constructor’s body. The second constructor indicates that the class GradeBook’s constructor has no parameter and will assign null to the instance variable courseName 1 2 3 4 5 6 // GradeBook.java public class GradeBook { private String courseName; public GradeBook( String name ) { courseName = name; // initializes courseName } // end constructor 7 8 9 public GradeBook() { // initializes courseName } // end constructor 10 11 12 public void setCourseName( String name ) courseName = name; } // end method setCourseName 13 14 15 public String getCourseName() { return courseName; } // end method getCourseName 16 17 18 19 20 21 { public void displayMessage() { System.out.printf( "Welcome to the grade book for\n%s!\n", getCourseName() ); } // end method displayMessage } // end class GradeBook The following code will initialize the GradeBook objects using the constructor. Two objects of class GradeBook were created and initialized. The first object is gradeBook1 whose courseName instance variable is null and the second object is gradeBook2 whose courseName instance variable is “CS102 Data Structures in Java” 47 1 2 3 4 5 6 7 8 9 10 11 12 13 14 // GradeBookTest.java public class GradeBookTest { public static void main( String args[] ) { GradeBook gradeBook1 = new GradeBook(); GradeBook gradeBook2 = new GradeBook( "CS102 Data Structures in Java" ); System.out.printf( "gradeBook1 course name is: %s\n", gradeBook1.getCourseName() ); System.out.printf( "gradeBook2 course name is: %s\n", gradeBook2.getCourseName() ); } // end main } // end class GradeBookTest Account Class with an instance variable of type double: The following application contains a class named account that maintains the balance of a bank account. The class contains one instance variable, a constructor and 2 methods. 1 2 3 4 5 6 7 8 9 10 // Account.java ­ Account class with a constructor // to initialize instance variable balance. public class Account { private double balance; // instance variable // constructor public Account( double initialBalance ) { //validate that initialBalance is greater than 0.0; if ( initialBalance > 0.0 ) balance = initialBalance; } // end constructor 11 12 13 14 // credit (add) an amount to the account public void credit( double amount ) { balance = balance + amount;// add amount to balance } // end method credit 15 16 17 18 19 // return the account balance public double getBalance() { return balance; } // end method getBalance } // end class Account 48 AccountTest class to use class Account Class AccountTest creates two account objects and initialized them with 50.00 and -7.53, respectively. Balance of account2 is 0.00 because the constructor insures that the balance is >0. We use the format specifier %.2f to display the initial balances. (Recall, f is used to format float or double, .2 represents the number of decimal places that should be to the right of the decimal point). 1 2 3 4 5 6 //AccountTest.java­Create and manipulate Account object import java.util.Scanner; public class AccountTest { public static void main( String args[] ) { Account account1 = new Account( 50.00 ); Account account2 = new Account( ­7.53 ); 7 // display initial balance of each object 8 System.out.printf( "account1 balance: $%.2f\n", 9 account1.getBalance() ); 10 System.out.printf( "account2 balance: $%.2f\n\n", 11 account2.getBalance() ); 12 // create Scanner to obtain input 13 Scanner input = new Scanner( System.in ); 14 double depositAmount; // to read from user 15 System.out.print("Enter deposit amount for account1:"); 16 depositAmount = input.nextDouble(); 17 System.out.printf( 18 "\nadding %.2f to account1 balance\n" ,depositAmount); 19 account1.credit( depositAmount ); // add to balance 20 System.out.printf( "account1 balance: $%.2f\n", 21 account1.getBalance() ); 22 System.out.printf( "account2 balance: $%.2f\n\n", 23 account2.getBalance() ); 24 System.out.print("Enter deposit amount for account2"); 25 depositAmount = input.nextDouble(); 26 System.out.printf( 27 "\nadding %.2f to account2 balance\n",depositAmount); 28 account2.credit( depositAmount ); 29 System.out.printf( "account1 balance: $%.2f\n", 30 account1.getBalance() ); 31 System.out.printf( "account2 balance: $%.2f\n", 32 account2.getBalance() ); 33 } // end main 34 } // end class AccountTest 49  Using dialog boxes – Many Java applications use dialog boxes to display output and input information. – JOptionPane class • Is defined in the package javax.swing • Declares static method showMessageDialog for displaying a message dialog • Declares another static method showInputDialog for allowing users to input information 50  To convert String to number Integer.parseInt(String s) Double.parseDouble(String s) Example: int n = Integer.parseInt( JOptionPane.showInputDialog("Enter a number"));  To convert number to String - use concatenation operator +  To compare strings use the equals method of class String String s1 = new String("hello"); String s2 = new String("hello"); if(s1.equals(s2)) System.out.println("s1 and s2 are equal"); 51