3.1 Class Declaration

Transcription

1 Chapter 3 Classes and Objects OBJECTIVES To be able to declare classes To understand object references To understand the mechanism of parameter passing To be able to use static member and instance member properly To become familiar with the organization of classes To understand the object life cycle and the scope of variables 3.1 Class Declaration Objects and classes are the bricks and mortar used to build Java programs. A class is a template for multiple objects with similar attributes and behaviors. An object-oriented program consists of classes from the static viewpoint and objects from the dynamic viewpoint. An instance of a class is another word for an actual object. If class is the abstract representation of an object, an instance is its concrete representation. We use the terms object and instance interchangeably. An object has a unique identity, state, and behaviors. The state of an object is represented by fields (also known as member variables) with their current values. The behavior of an object is defined by a set of methods. Invoking a method on an object means that you ask the object to perform a task. A Java class uses variables to define attributes and methods to define behaviors of an object. Additionally, a class provides methods of a special type, known as constructors, which are invoked when a new object is created. A constructor is a special kind of method and is designed to perform initializations. All the qualities of a class are specified in the class declaration, which consists of optional fields, optional methods, optional constructors, and optional member classes (inner classes). There are several kinds of variables in a class: member variables in a class these are also called fields; Variables in a method or block of code these are called local variables; Variables at the head of a method these are called parameters. Think of a car with attributes name, height, width and coordinate position. It can move ahead (measured in pixels) as well as move back (with a negative number of pixels). For the sake of simplicity, we suppose the car here can only turn left and turn right by 90 degrees, that is, either move in a counter-clockwise direction or a clockwise direction. Fig. 3.1 illustrates the model. 87

2 Code 3.1 Car.java package carrace; /** * The basic car class Donald. Dong (original) */ public class Car { public Car() { Fig. 3.1 The Car model name = "N/A"; public Car(String name) { this.name = name; /** * Immediately moves your car moveahead (forward) by distance measured * in pixels. * Example: * <pre> * //Move the car 100 pixels forward * moveahead(100); * * //Afterwards, move the car 50 pixels backward * moveahead(-50); * </pre> * distance the distance to move moveahead measured in pixels. * If this value is negative, the car will move backword instead of move forward. */ public void moveahead(int distance) { switch (direction) { case 0: y = y + distance; break; case 1: x = x + distance; break; case 2: y = y - distance; break; case 3: x = x - distance; break; 88

3 /** * Turn the car to another direction clockwise. */ public void turnright() { direction = (byte) ((direction + 1) % 4); /** * Turn the car to another direction counter-clockwise. */ public void turnleft() { direction = (byte) ((direction - 1) % 4); /** * Returns the height of the car measured in pixels. the height of the car measured in pixels. #getwidth() */ public double getheight() { return height; /** * Returns the width of the car measured in pixels. the width of the car measured in pixels. #getheight() */ public double getwidth() { return width; /** * Returns the car's name. the car's name. */ public String getname() { return name; /** * Returns the X position of the car. (0,0) is at the bottom left of the racecourse. the X position of the car. #gety() */ public double getx() { 89

4 return x; /** * Returns the Y position of the car. (0,0) is at the bottom left of the racecourse. the Y position of the car. #getx() */ public double gety() { return y; private String name; private double width = 40, height = 30; private int x = 400, y = 300; private byte direction = 0; //0: top; 1: right; 2: bottom; 3: left The components of the class code are depicted in Fig Fig. 3.2 The components of a class The member variables declare the attributes of a car such as its coordinate position (x, y) as an integer type. By default, the two variables will be initialized to 0 implicitly. How different member variables are initialized implicitly is shown in Table 3.1. Table 3.1 Default initial values Type byte short int long float double char boolean object Initial value L 0.0f 0.0d '\u0000' false null 90

5 The member variables will only be visible to, or in the scope of, all the methods in the class following the "private" modifier. A class declaration typically includes one or more member variables of various types. Member variables can use either the default values or explicit initialization. A class declaration typically includes one or more methods, which implement some behaviors. Methods resemble the functions in C language. A method will be called, or invoked, by some other methods. A method does not need to return a value. Such a method uses the void return type modifier as shown in the Car class(table 3.2). On the other hand, a method usually returns a value. Method public class Car{ public int getx (){ return x; public void setx (int i){ x = i; public boolean fire() { int i = 2; return (bullets - i < 0); private int x, y; private int bullets; Table 3.2 Methods in a class Comment A method to return the value of the x variable. A method to set the value of the x variable. The parameter i defines what kind of value is passed to the method. A variable declared in a method is a local variable. A local variable is valid only within the method. It must be assigned a value before it is used. The structure of a method includes a method head and a code body: <access_modifier> <return_type> <method_name> (<list_of_parameters>) { The method s name and the parameter types of a method declaration comprise the method signature. The method body, enclosed between braces, consists of the method s code and the declaration of local variables, as shown in Fig A constructor is called when an instance of this class is first created. It is used to initialize the member variables. The constructor signature looks similar to that of a regular method. It has a name that matches the class name and holds a list of parameters in parentheses. However, a constructor has no return type. Constructors are invoked using the new operator when an object is created. 91

6 Fig. 3.3 A method declaration public Car() { name = "N/A"; public Car(String name) { this.name = name; The code above shows two constructors with the class Car in code 3.1. If there is no constructor in a class declaration, the Java compiler will create a default constructor with an empty parameter list. For example, if there is no constructor is defined in the class Car, JVM will use the default parameterless constructor. The default constructor calls the default parent constructor (super()) and initializes all instance variables to default value (zero for numeric types, null for object references, and false for booleans). Once any constructor is defined in the class Car, there will be no constructor generated by the Java compiler. Code 3.2 shows that a compilation error occurs in the case when a constructor with parameters is defined while a constructor with an empty parameter list is invoked. Code 3.2 Test.java public class Test { public static void main(string[] args) { Car a = new Car(); //Compilation error //Car.java class Car { 92

7 public Car (String name) { this.name = name; String name; The Java compiler puts the initialization data for the member variable into the byte code for the constructor. So, for a class with several fields, the initialization of the default or explicit values occurs in the constructor. For example, Car1 and Car2 defined in Code 3.3 have the same effect in the client class Test after being created. Code 3.3 Test1.java and Test2.java class Car1 { public Car1() { width = 1.0; height = 2.0; private String name; private double width, height; private int x, y; public class Test1{ public static void main(string[] args) { Car1 a = new Car1(); class Car2 { private String name; private double width = 1.0, height = 2.0; private int x, y; public class Test2 { public static void main(string[] args) { Car2 a = new Car2(); Note that multiple constructors provide optional ways to create and initialize instances of the class. 93

8 3.2 Creating Objects A class is the template of objects. An object is created from a class. For example, Car a = new Car(1.0, 2.0); The Car class is already defined in Fig The expression new Car(1.0, 2.0) returns an object reference that refers to a Car object. Each of these statements has three parts: declaration, instantiation and initialization. Car a = new Car(1.0, 2.0); Declaration Instantiation Initialization Declaration means to associates a variable name with an object type. Instantiation implies to create the object with the new operator. A constructor is called to initialize the new object when the initialization performs. The phrase instantiating a class has the same meaning as creating an object. To create an object is to allocate memory space for the member variables of the object, execute the constructor and return the reference to the new object. The statement a = new Car(1.0, 2.0); can be read as: create an object of type Car and assign its reference to a. The memory assignments for the object created and its reference by the statement are visualized in Fig Fig. 3.4 The memory assignments by a = new Car(1.0, 2.0); 3.3 Accessing Objects via Reference Variables Once an object is created, it is ready to be used for something. For example, let a car move ahead: a.moveahead(7); The client code that is outside the object s class must use an object reference, followed by the dot (.) operator, followed by a method name, within enclosing parentheses and any arguments to the method. If the method does not require any arguments, use empty parentheses. As in <object_reference>. <method_name>(<arguments_list>) 94

9 or <object_reference>. <method_name>() The statement a.moveahead(7); sends the message moveahead with an argument of 7 to the object a. Sending a message to that object is the same as invoking a method on the particular object. Object member variables are accessed by their name within its own class. For example, there is a statement within the area() method that uses the width and height: public double area(){ double result = 0.0; result = width*height; return result; Code that is outside the object s class must use an object reference or expression, followed by the dot (.) operator, followed by a member variable name, as in <object_reference>.<member_variable_name> The client code Test uses two of these names to display the width and the height of a: System.out.println("Width of a: " + a.width); System.out.println("Height of a: " + a.height); Attempting to access width and height from the code in the Test class results in a compiler error since their private modifier indicates that this can only be visited inside the class Car. It will be successful if the modifier is changed to public. Details about access modifiers will be discussed later. 3.4 Object Reference this this is a reference to the current object which is the object whose method or constructor is being called. It refers to the newly created object in constructors, or refers to the object that a method belongs to in the method. For example, this is used to distinguish member variables from parameters in the constructor of the class Car declaration. public class Car { public Car(double width, double height) { this.width = width; this.height = height; 95

10 private double width, height; By this, a constructor can invoke another constructor: public class Car { public Car(double width, double height) { this.width = width; this.height = height; public Car() { this(0.0, 0.0); private double width, height; Note that this(0.0, 0.0); must be the first statement in the constructor in this case. public void setlocation(point p){ currentlocation = p; is equivalent to public void setlocation(point p){ this.currentlocation = p; and so is also in a method. 3.5 Parameter Passing The list of variables in a method head declaration are the parameters. The actual values that are passed when the method is invoked are called the arguments. When a method is invoked, the arguments must match the corresponding parameters in type and order. All the arguments are passed by value, that is, a copy of the argument is assigned to the corresponding parameter. The typical method call sequence is: 1. Evaluate arguments left-to-right. If an argument is a simple variable or a literal value, there is no need to evaluate it. When an expression is used, the expression must be evaluated before the call can be made. 2. When a method is called, a temporary piece of memory is required to store the following information: parameter and local variable storage, where to continue execution when the called method returns and any other working storage needed by the method. 96

11 3. Initialize the parameters. When the arguments are evaluated, they are assigned to the local parameters in the called method. 4. Execute the method. Execution starts with the first statement and continues as normal. 5. Return from the method. When a return statement is encountered, or the end of a void method is reached, the method returns. For non-void methods, the return value is passed back to the calling method. Execution is continued in the calling method immediately following where the call took place. Any data type can be used for a parameter of a method or a constructor. This includes primitive data types, such as doubles, floats, and integers, and reference data types, such as objects. Code 3.4 shows how to use primitive types or reference type as parameter types. Code 3.4 Car.java and Point.java public class Car { public Car() { this(0, 0); public Car(double width, double height) { this.width = width; this.height = height; public double area() { return width * height; public void setlocation(point p){ currentlocation = p; public void setlocation(int x, int y){ Point p = new Point(x, y); currentlocation = p; private double width, height; private Point currentlocation; //The current location of this object public class Point { public Point() { public Point(int xvalue, int yvalue) { x = xvalue; y = yvalue; //return x from coordinate pair public int getx() { 97

12 return x; //return y from coordinate pair public int gety() { return y; public void setxy(int x, int y) { this.x = x; this.y = y; public String tostring() { return "[" + getx() + ", " + gety() + "]"; private int x; //x part of coordinate pair private int y; //y part of coordinate pair The method setlocation is used to set the position of a car. The argument can be either a Point object reference or a coordinate pair. Java doesn t allow passing methods into methods. However, an object reference can be passed into a method and the object s methods can then be invoked. Any changes to the values of the parameters exist only within the scope of the method. When the method returns, the parameters disappear and any changes made to them are lost. In the case of reference type, the passed-in reference still references the same object as before when the method returns. However, the values of the object s fields can be changed in the method. Code 3.5 creates a car with the argument width 3 and the argument height 6. It then set its location to (10, 20). Code 3.5 ParaDemo.java public class ParaDemo { public static void main(string args[]) { Car a = new Car(3,6); a.setlocation(10, 20); 20). After invoking setlocation(10, 20), the parameter x holds 10 and y holds 20. Code 3.6 creates a car in which the width is 3 and the height is 6. It sets its location to (10, Code 3.6 ParaDemo.java public class ParaDemo { 98

13 public static void main(string args[]) { Car a = new Car(3, 6); Point apoint = new Point(10, 20); a.setlocation(apoint); Assume setlocation() is invoked as below. public void setlocation(point p){ currentlocation = p; Just before the statement currentlocation = p; executes, the parameter p holds exactly what apoint holds, which is the reference to the Point object created. The Point object still remains, i.e, no copy or clone is made. The states of the Point object and Car object are visualized in Fig Fig. 3.5 The memory assignments for the Point object and Car object before the statement currentlocation = p; After the call a.setlocation(apoint); control returns to the main method, public static void main(string args[]) { Car a = new Car(3,6); Point apoint = new Point(10,20); a.setlocation(apoint); The states of the objects are shown in Fig Observe that the parameter p has disappeared after the setlocation() method returns. However, the Car object a has changed: its field currentlocation refers to the new object created in main(). 99

14 Fig. 3.6 The memory assignments for the Point object and Car object After the call a.setlocation (apoint); This mechanism is known as pass-by-value. There are important differences between passing the values of primitive data types and passing objects: For an argument of a primitive type, the argument s value is passed. For an argument of a reference type, the value of the argument contains a reference to an object and this reference is passed to the method. The example below contains two methods for swapping elements in an array, which is an object. The first method, named swap, fails to swap two int arguments. The second method, named exchange, successfully swaps the first two elements in the array arguments. Code 3.7 does the job. Code 3.7 ArrayAsPara.java public class ArrayAsPara { public static void main(string[] args) { int[] a = {2,3; swap(a[0],a[1]); exchange(a); static void swap(int x, int y){ int temp = x; x = y; y = temp; static void exchange(int[] a){ int temp = a[0]; a[0] = a[1]; a[1] = temp; Fig. 3.7, Fig. 3.8, and Fig. 3.9 show the content of array a before invoking swap(), after invoking swap(), and after invoking exchange() respectively in the Eclipse debug view. It results the two elements of the array remaining unchanged after the execution of swap(a[0],a[1]); while they are exchanged after the execution of exchange(a). 100

15 Fig. 3.7 The content of the array a before invoking swap() Fig. 3.8 The content of the array a after invoking swap() 101

16 Fig. 3.9 The content of the array a after invoking exchange() 3.6 Returning from a Method A method returns in three ways: all the statements in the method are completed; a return statement is reached; or an exception is thrown. A return statement can be used to exit a method: return; If a method returns a value, the return statement contains a corresponding return value, like this: return <returnvalue>; Any method declared void doesn t return a value and it is unnecessary to contain a return statement in these methods. Any method that is not declared void must contain a return statement with a corresponding return value and the data type of the return value must match the method s declared return type. Code 3.8 demonstrates the return statement. Code 3.8 ReturnDemo.java public class ReturnDemo { public static void main(string[] args) { 102

17 A a = new A(); B b1 = a.getb(); b1.say(); class A { public B getb(){ B b= new B(); return b; class B{ public void say(){ System.out.println("I am B."); It displays I am B. 3.7 Method Overloading Java supports overloading methods, and it can distinguish between methods with different method signatures. That is, two or more methods within a class can have the same name if they have a different parameter list. Observe the method setlocation in Code 3.4: public void setlocation(point p){ currentlocation = p; public void setlocation(int x, int y){ Point p = new Point(x, y); currentlocation = p; This phenomenon is so-called method overloading. The PrintWriter class in Java provides many println methods using this technology: java.io.printwriter.println() java.io.printwriter.println(boolean) java.io.printwriter.println(char) java.io.printwriter.println(char[]) java.io.printwriter.println(double) java.io.printwriter.println(float) 103

18 java.io.printwriter.println(int) java.io.printwriter.println(java.lang.object) java.io.printwriter.println(java.lang.string) java.io.printwriter.println(long) 3.8 Class Variables and Instance Variables Any object has its own state. For example, Car a = new Car(1.0, 2.0); Car b = new Car(2.0, 2.0); The states of the object a and b are shown in Fig Fig The memory assignments for the object a and b Java does everything with objects. There are no global variables, for example, as in C/C++ that exist outside of the objects. To provide public resources visited by objects, Java offers static variables and methods that are contained in a class definition but exist and can be accessed without creating an instance of the class. A static variable or method is also called a class variable or method, since it belongs to the class itself rather than to an instance of that class. A variable is declared as static by the static modifier. The non-static member variables are referred to as instance variables since the values belong to a unique instance of the class. The instance variable has the same life cycle as the object it belongs to. Note that class methods can only refer to static members and to the parameter list. Code 3.9 shows car a notifying car b and c when a dog is detected ahead. Code 3.9 StaticViariableDemo.java public class StaticViariableDemo { public static void main(string args[]) { Car a = new Car(); Car b = new Car(); 104

19 Car c = new Car(); a.notify("a dog ahead!"); System.out.println("Car b: " + b.response()); System.out.println("Car c: " + c.response()); class Car { public Car() { this.width = 3; this.height = 4; public void notify(string note) { Car.note = note; public String response() { return Car.note; public static String note; //Message shared by the two Cars. double width, height; In this demonstration, car a noticed a dog ahead and notifies other cars b and c this message via invoking its method a.notify("a dog ahead!"). The method post this message on the static member variable note, which can be accessed by car b and c. Car b and c can get the message via their own method response(). We can access the static variables directly using the name of the class, as in Car.note="Dog!"; The general form is <class_name>.<static_variable> There are three ways to initialize instance variables: declaration, creation and invoking a method. 1. Declaration public class A { public void amethod() { private int amember = 1; //Instance variable that has a initial value 105

20 2. Constructor class A { A(int i) { amember = i; private int amember; //Instance the variable by a constructor 3. Method class A { void f() { amember = 0; //Instance the variable by a method int amember; Static variables cannot be initialized by constructors. Initialization can be done by declaration or a regular method. In summary, a static variable is a variable that belongs to the class and not to an object. A single copy is shared by all instances of the class. A static variable can be accessed directly by the class name and does not need any object. 3.9 Class Methods and Instance Methods There are two types of methods. One type is instance methods that are associated with an object and operate the instance variables of that object. This is the default. The other type is static methods that cannot use any instance variables of any object of the class they are defined in. The typical usage of static methods is to do some kind of generic calculation such as methods in Math and java.util.random. A method is declared as static by the static modifier. Static methods are invoked with the class name, without the need for creating an instance of the class, as in <class_name>.<method_name>(<argument_list>) Remember that an instance method is called by prefixing it with an object reference outside the defining class. The following static method converts a thermograph from degrees Centigrade to Fahrenheit. public class Thermograph{ public static int centigradetofahrenheit(int cent){ return cent * 9 / ; 106