8.7 Static Variables, Constants, and Methods

Добавил:

Upload Опубликованный материал нарушает ваши авторские права? Сообщите нам.

Вуз:

Белорусский национальный технический университет

Предмет:

[НЕСОРТИРОВАННОЕ]

Файл:

Intro_Java_brief_Liang2011.pdf

Скачиваний:

195

Добавлен:

26.03.2016

Размер:

10.44 Mб

Скачать

☆

<<< < Предыдущая 30 31 32 33 34 35 36 37 38 39 40 4142 / 10342 43 44 45 46 47 48 49 50 51 52 53 54 > Следующая >>>

278 Chapter 8			Objects and Classes
			radio button, and combo box (lines 35–43). The program then creates a frame and adds the
			panel to the frame (line 45). The frame is displayed in line 51.
			8.7 Static Variables, Constants, and Methods
instance variable			The data field radius in the circle class in Listing 8.1 is known as an instance variable. An
			instance variable is tied to a specific instance of the class; it is not shared among objects of the
			same class. For example, suppose that you create the following objects:

Video Note static vs. instance

static variable

static method

Circle circle1 = new Circle();

Circle circle2 = new Circle(5);

The radius in circle1 is independent of the radius in circle2 and is stored in a different memory location. Changes made to circle1’s radius do not affect circle2’s radius, and vice versa.

If you want all the instances of a class to share data, use static variables, also known as class variables. Static variables store values for the variables in a common memory location. Because of this common location, if one object changes the value of a static variable, all objects of the same class are affected. Java supports static methods as well as static variables. Static methods can be called without creating an instance of the class.

Let us modify the Circle class by adding a static variable numberOfObjects to count the number of circle objects created. When the first object of this class is created, numberOfObjects is 1. When the second object is created, numberOfObjects becomes 2. The UML of the new circle class is shown in Figure 8.12. The Circle class defines the instance variable radius and the static variable numberOfObjects, the instance methods getRadius, setRadius, and getArea, and the static method getNumberOfObjects. (Note that static variables and methods are underlined in the UML class diagram.)

UML Notation:

underline: static variables or methods

instantiate

circle1: Circle

Memory

After two Circle

radius = 1

radius

numberOfObjects = 2

Objects were created,

Circle

numberOfObjects

radius: double

is 2.

numberOfObjects: int

numberOfObjects

getNumberOfObjects(): int

instantiate

getArea(): double

circle2: Circle

radius = 5

radius

numberOfObjects = 2

FIGURE 8.12 Instance variables belong to the instances and have memory storage independent of one another. Static variables are shared by all the instances of the same class.

To declare a static variable or define a static method, put the modifier static in the variable or method declaration. The static variable numberOfObjects and the static method getNumberOfObjects() can be declared as follows:

declare static variable	static	int numberOfObjects;

define static method	static	int getNumberObjects() {
	return numberOfObjects;
	}

Constants in a class are shared by all objects of the class. Thus, constants should be declared final static. For example, the constant PI in the Math class is defined as:

declare constant

final static double PI = 3.14159265358979323846;

8.7 Static Variables, Constants, and Methods 279

The new circle class, named Circle2, is declared in Listing 8.7:

LISTING 8.7 Circle2.java

1 public class Circle2 {

2 /** The radius of the circle */

3 double radius;

5/** The number of objects created */

6	static int numberOfObjects = 0;	static variable
7
8	/** Construct a circle with radius 1 */

9Circle2() {

10		radius = 1.0;
11		numberOfObjects++;	increase by 1
12	}
13

14/** Construct a circle with a specified radius */

15Circle2(double newRadius) {

16radius = newRadius;

17		numberOfObjects++;	increase by 1
18	}
19
20	/** Return numberOfObjects */
21	static int getNumberOfObjects() {		static method

22return numberOfObjects;

23}

25/** Return the area of this circle */

26double getArea() {

27return radius * radius * Math.PI;

28}

29}

Method getNumberOfObjects() in Circle2 is a static method. Other examples of static methods are showMessageDialog and showInputDialog in the JOptionPane class and all the methods in the Math class. The main method is static, too.

Instance methods (e.g., getArea()) and instance data (e.g., radius) belong to instances and can be used only after the instances are created. They are accessed via a reference variable. Static methods (e.g., getNumberOfObjects()) and static data (e.g., numberOfObjects) can be accessed from a reference variable or from their class name.

The program in Listing 8.8 demonstrates how to use instance and static variables and methods and illustrates the effects of using them.

LISTING 8.8 TestCircle2.java

1 public class TestCircle2 {

2/** Main method */

3public static void main(String[] args) {

4System.out.println("Before creating objects");

5System.out.println("The number of Circle objects is " +

6	Circle2.numberOfObjects);	static variable
7

8// Create c1

9 Circle2 c1 = new Circle2();

11// Display c1 BEFORE c2 is created

12System.out.println("\nAfter creating c1");

13	System.out.println("c1: radius ("	+ c1.radius +	instance variable
14	") and number of Circle objects	(" +

280 Chapter 8	Objects and Classes

static variable	15		c1.numberOfObjects			+ ")");
	16
	17	// Create c2
	18	Circle2 c2 = new Circle2(5);
	19
	20	// Modify c1
instance variable	21	c1.radius = 9;
	22
	23	// Display c1 and c2 AFTER c2 was created
	24	System.out.println("\nAfter creating c2 and modifying c1");
	25	System.out.println("c1: radius (" + c1.radius +
	26		") and number of Circle objects (" +
static variable	27		c1.numberOfObjects		+ ")");
	28	System.out.println("c2: radius (" + c2.radius +
	29		") and number of Circle objects (" +
static variable	30		c2.numberOfObjects	+ ")");

31}

32}

Before creating objects

The number of Circle objects is 0

After creating c1

c1: radius (1.0) and number of Circle objects (1)

After creating c2 and modifying c1

c1: radius (9.0) and number of Circle objects (2) c2: radius (5.0) and number of Circle objects (2)

When you compile TestCircle2.java, the Java compiler automatically compiles Circle2.java if it has not been compiled since the last change.

Static variables and methods can be accessed without creating objects. Line 6 displays the number of objects, which is 0, since no objects have been created.

The main method creates two circles, c1 and c2 (lines 9, 18). The instance variable radius in c1 is modified to become 9 (line 21). This change does not affect the instance variable radius in c2, since these two instance variables are independent. The static variable numberOfObjects becomes 1 after c1 is created (line 9), and it becomes 2 after c2 is created (line 18).

	Note that PI is a constant defined in Math, and Math.PI references the constant.
	c.numberOfObjects could be replaced by Circle2.numberOfObjects. This improves
	readability, because the reader can easily recognize the static variable. You can also replace
	Circle2.numberOfObjects by Circle2.getNumberOfObjects().
	Tip
use class name	Use ClassName.methodName(arguments) to invoke a static method and ClassName.-
	staticVariable to access a static variable. This improves readability, because the user can
	easily recognize the static method and data in the class.

Static variables and methods can be used from instance or static methods in the class. However, instance variables and methods can be used only from instance methods, not from static methods, since static variables and methods don’t belong to a particular object. Thus the code given below is wrong.

1 public class Foo {

2int i = 5;

3 static int k = 2;

5public static void main(String[] args) {

6 int j = i; // Wrong because i is an instance variable 7 m1(); // Wrong because m1() is an instance method

8.7 Static Variables, Constants, and Methods 281

8	}
9

10public void m1() {

11// Correct since instance and static variables and methods

12// can be used in an instance method

13i = i + k + m2(i, k);

14}

16public static int m2(int i, int j) {

17return (int)(Math.pow(i, j));

18}

19}

Note that if you replace the code in lines 5–8 with the following new code, the program is fine, because the instance data field i and method m1 are now accessed from an object foo (lines 6–7):

1 public class Foo {

2int i = 5;

3 static int k = 2;

5 public static void main(String[] args) {

6Foo foo = new Foo();

7int j = foo.i; // OK, foo.i accesses the object's instance variable

8		foo.m1();	// OK. Foo.m1() invokes object's instance method
9	}

11public void m1() {

12i = i + k + m2(i, k);

13}

14
15	public static int m2(int i, int j) {
16	return (int)(Math.pow(i, j));
17	}
18	}

Design Guide

How do you decide whether a variable or method should be an instance one or a static one? A vari-	instance or static?
able or method that is dependent on a specific instance of the class should be an instance variable or
method. A variable or method that is not dependent on a specific instance of the class should be a
static variable or method. For example, every circle has its own radius. Radius is dependent on a spe-
cific circle. Therefore, radius is an instance variable of the Circle class. Since the getArea
method is dependent on a specific circle, it is an instance method. None of the methods in the Math
class, such as random, pow, sin, and cos, is dependent on a specific instance. Therefore, these
methods are static methods. The main method is static and can be invoked directly from a class.

Caution

It is a common design error to define an instance method that should have been defined static.	common design error
For example, the method factorial(int n) should be defined static, as shown below,
because it is independent of any specific instance.

public class Test {

public int factorial(int n) { int result = 1;

for (int i = 1; i <= n; i++) result *= i;

return result;

}

public class Test {

public static int factorial(int n) int result = 1;

for (int i = 1; i <= n; i++) result *= i;

return result;

}

(a) Wrong design

(b) Correct design

<<< < Предыдущая 30 31 32 33 34 35 36 37 38 39 40 4142 / 10342 43 44 45 46 47 48 49 50 51 52 53 54 > Следующая >>>

Соседние файлы в предмете [НЕСОРТИРОВАННОЕ]

#
31.05.20153.64 Mб108ingeneria.docx
#
18.09.201955.81 Кб7Interne_769_t_lektsia_1.doc
#
18.09.201991.65 Кб4Interne_769_t_lektsia_2.doc
#
18.09.2019222.72 Кб8Interne_769_t_lektsia_3.doc
#
24.09.201946.59 Кб39INTRODUCTION.doc
#
26.03.201610.44 Mб195Intro_Java_brief_Liang2011.pdf
#
31.05.2015951.81 Кб41IPF1.doc
#
23.09.2019378.37 Кб42Istoria-shpory_11-20.doc
#
31.05.2015202.73 Кб639istoria_Belarusi.docx
#
31.05.2015256.12 Кб439Istoria_Iskusstv1sem.docx
#
31.05.2015556.54 Кб73Istoria_shpora.doc