Thinking in Java - 4th Edition
1079 pág.

Thinking in Java - 4th Edition

DisciplinaProgramação Orientada A Objetos5.153 materiais78.325 seguidores
Pré-visualização50 páginas
file that it\u2019s being 
called from. In that case, you simply use the class\u2014even if the class doesn\u2019t get defined until 
later in the file (Java eliminates the so-called \u201cforward referencing\u201d problem). 
What about a class that exists in some other file? You might think that the compiler should 
be smart enough to simply go and find it, but there is a problem. Imagine that you want to 
use a class with a particular name, but more than one definition for that class exists 
(presumably these are different definitions). Or worse, imagine that you\u2019re writing a 
program, and as you\u2019re building it you add a new class to your library that conflicts with the 
name of an existing class. 
To solve this problem, you must eliminate all potential ambiguities. This is accomplished by 
telling the Java compiler exactly what classes you want by using the import keyword. 
import tells the compiler to bring in a package, which is a library of classes. (In other 
languages, a library could consist of functions and data as well as classes, but remember that 
all code in Java must be written inside a class.) 
50 Thinking in Java Bruce Eckel 
Everything Is an Object 51 
Most of the time you\u2019ll be using components from the standard Java libraries that come with 
your compiler. With these, you don\u2019t need to worry about long, reversed domain names; you 
just say, for example: 
import java.util.ArrayList; 
to tell the compiler that you want to use Java\u2019s ArrayList class. However, util contains a 
number of classes, and you might want to use several of them without declaring them all 
explicitly. This is easily accomplished by using \u2018*\u2019 to indicate a wild card: 
import java.util.*; 
It is more common to import a collection of classes in this manner than to import classes 
The static keyword 
Ordinarily, when you create a class you are describing how objects of that class look and how 
they will behave. You don\u2019t actually get an object until you create one using new, and at that 
point storage is allocated and methods become available. 
There are two situations in which this approach is not sufficient. One is if you want to have 
only a single piece of storage for a particular field, regardless of how many objects of that 
class are created, or even if no objects are created. The other is if you need a method that isn\u2019t 
associated with any particular object of this class. That is, you need a method that you can 
call even if no objects are created. 
You can achieve both of these effects with the static keyword. When you say something is 
static, it means that particular field or method is not tied to any particular object instance of 
that class. So even if you\u2019ve never created an object of that class you can call a static method 
or access a static field. With ordinary, non-static fields and methods, you must create an 
object and use that object to access the field or method, since non-static fields and methods 
must know the particular object they are working with.4 
Some object-oriented languages use the terms class data and class methods, meaning that 
the data and methods exist only for the class as a whole, and not for any particular objects of 
the class. Sometimes the Java literature uses these terms too. 
To make a field or method static, you simply place the keyword before the definition. For 
example, the following produces a static field and initializes it: 
class StaticTest { 
 static int i = 47; 
Now even if you make two StaticTest objects, there will still be only one piece of storage for 
StaticTest.i. Both objects will share the same i. Consider: 
StaticTest st1 = new StaticTest(); 
StaticTest st2 = new StaticTest(); 
4 Of course, since static methods don\u2019t need any objects to be created before they are used, they cannot directly access 
non-static members or methods by simply calling those other members without referring to a named object (since non-
static members and methods must be tied to a particular object). 
At this point, both st1.i and st2.i have the same value of 47 since they refer to the same piece 
of memory. 
There are two ways to refer to a static variable. As the preceding example indicates, you can 
name it via an object, by saying, for example, st2.i. You can also refer to it directly through 
its class name, something you cannot do with a non-static member. 
The ++ operator adds one to the variable. At this point, both st1.i and st2.i will have the 
value 48. 
Using the class name is the preferred way to refer to a static variable. Not only does it 
emphasize that variable\u2019s static nature, but in some cases it gives the compiler better 
opportunities for optimization. 
Similar logic applies to static methods. You can refer to a static method either through an 
object as you can with any method, or with the special additional syntax 
ClassName.method( ). You define a static method in a similar way: 
class Incrementable { 
 static void increment() { StaticTest.i++; } 
You can see that the Incrementable method increment( ) increments the static data i 
using the ++ operator. You can call increment( ) in the typical way, through an object: 
Incrementable sf = new Incrementable(); 
Or, because increment( ) is a static method, you can call it directly through its class: 
Although static, when applied to a field, definitely changes the way the data is created (one 
for each class versus the non-static one for each object), when applied to a method it\u2019s not so 
dramatic. An important use of static for methods is to allow you to call that method without 
creating an object. This is essential, as you will see, in defining the main( ) method that is 
the entry point for running an application. 
Your first Java program 
Finally, here\u2019s the first complete program. It starts by printing a string, and then the date, 
using the Date class from the Java standard library. 
import java.util.*; 
public class HelloDate { 
 public static void main(String[] args) { 
 System.out.println("Hello, it\u2019s: "); 
 System.out.println(new Date()); 
52 Thinking in Java Bruce Eckel 
Everything Is an Object 53 
At the beginning of each program file, you must place any necessary import statements to 
bring in extra classes you\u2019ll need for the code in that file. Note that I say \u201cextra\u201d. That\u2019s 
because there\u2019s a certain library of classes that are automatically brought into every Java file: 
java.lang. Start up your Web browser and look at the documentation from Sun. (If you 
haven\u2019t downloaded the JDK documentation from, do so now.5 Note 
that this documentation doesn\u2019t come packed with the JDK; you must do a separate 
download to get it.) If you look at the list of the packages, you\u2019ll see all the different class 
libraries that come with Java. Select java.lang. This will bring up a list of all the classes that 
are part of that library. Since java.lang is implicitly included in every Java code file, these 
classes are automatically available. There\u2019s no Date class listed in java.lang, which means 
you must import another library to use that. If you don\u2019t know the library where a particular 
class is, or if you want to see all of the classes, you can select \u201cTree\u201d in the Java 
documentation. Now you can find every single class that comes with Java. Then you can use 
the browser\u2019s \u201cfind\u201d function to find Date. When you do you\u2019ll see it listed as 
java.util.Date, which lets you know that it\u2019s in the util library and that you must import 
java.util.* in order to use Date. 
If you go back to the beginning, select java.lang and then System, you\u2019ll see that the 
System class has several fields, and if you select out, you\u2019ll discover that it\u2019s a static 
PrintStream object. Since it\u2019s static, you don\u2019t need to create anything with new. The out 
object is always there, and you