java tutorial

java tutorial
2011年09月01日
　　 Arbitrary Number of Arguments
　　You can use a construct called varargs to pass an arbitrary number of values to a method. You use varargs when you don't know how many of a particular type of argument will be passed to the method. It's a shortcut to creating an array manually (the previous method could have used varargs rather than an array).
　　To use varargs, you follow the type of the last parameter by an ellipsis (three dots, ...), then a space, and the parameter name. The method can then be called with any number of that parameter, including none.
　　public Polygon polygonFrom(Point... corners) {
　　int numberOfSides = corners.length;
　　double squareOfSide1, lengthOfSide1;
　　squareOfSide1 = (corners[1].x - corners[0].x)*(corners[1].x - corners[0].x)
　　+ (corners[1].y - corners[0].y)*(corners[1].y - corners[0].y) ;
　　lengthOfSide1 = Math.sqrt(squareOfSide1);
　　// more method body code follows that creates
　　// and returns a polygon connecting the Points
　　}
　　You can see that, inside the method, corners is treated like an array. The method can be called either with an array or with a sequence of arguments. The code in the method body will treat the parameter as an array in either case.
　　You will most commonly see varargs with the printing methods; for example, this printf method:
　　public PrintStream printf(String format, Object... args)
　　allows you to print an arbitrary number of objects. It can be called like this:
　　System.out.printf("%s: %d, %s%n", name, idnum, address);
　　or like this
　　System.out.printf("%s: %d, %s, %s, %s%n", name, idnum, address, phone, email);
　　or with yet a different number of arguments.
　　Controlling Access to Members of a Class
　　Access level modifiers determine whether other classes can use a particular field or invoke a particular method. There are two levels of access control:
　　At the top level―public, or package-private (no explicit modifier).
　　At the member level―public, private, protected, or package-private (no explicit modifier).
　　A class may be declared with the modifier public, in which case that class is visible to all classes everywhere. If a class has no modifier (the default, also known as package-private), it is visible only within its own package (packages are named groups of related classes―you will learn about them in a later lesson.)
　　At the member level, you can also use the public modifier or no modifier (package-private) just as with top-level classes, and with the same meaning. For members, there are two additional access modifiers: private and protected. The private modifier specifies that the member can only be accessed in its own class. The protected modifier specifies that the member can only be accessed within its own package (as with package-private) and, in addition, by a subclass of its class in another package.
　　The following table shows the access to members permitted by each modifier.
　　Access Levels
　　Modifier Class Package Subclass World
　　public Y Y Y Y
　　protected Y Y Y N
　　no modifier Y Y N N
　　private Y N N N
　　The first data column indicates whether the class itself has access to the member defined by the access level. As you can see, a class always has access to its own members. The second column indicates whether classes in the same package as the class (regardless of their parentage) have access to the member. The third column indicates whether subclasses of the class ― declared outside this package ― have access to the member. The fourth column indicates whether all classes have access to the member.
　　Access levels affect you in two ways. First, when you use classes that come from another source, such as the classes in the Java platform, access levels determine which members of those classes your own classes can use. Second, when you write a class, you need to decide what access level every member variable and every method in your class should have.
　　Let's look at a collection of classes and see how access levels affect visibility. The following figure shows the four classes in this example and how they are related.
　　Classes and Packages of the Example Used to Illustrate Access Levels
　　The following table shows where the members of the Alpha class are visible for each of the access modifiers that can be applied to them.
　　Visibility
　　Modifier Alpha Beta Alphasub Gamma
　　public Y Y Y Y
　　protected Y Y Y N
　　no modifier Y Y N N
　　private Y N N N
　　Tips on Choosing an Access Level: If other programmers use your class, you want to ensure that errors from misuse cannot happen. Access levels can help you do this.
　　Use the most restrictive access level that makes sense for a particular member. Use private unless you have a good reason not to.
　　Avoid public fields except for constants. (Many of the examples in the tutorial use public fields. This may help to illustrate some points concisely, but is not recommended for production code.) Public fields tend to link you to a particular implementation and limit your flexibility in changing your code.
　　Constants
　　The static modifier, in combination with the final modifier, is also used to define constants. The final modifier indicates that the value of this field cannot change.
　　For example, the following variable declaration defines a constant named PI, whose value is an approximation of pi (the ratio of the circumference of a circle to its diameter):
　　static final double PI = 3.141592653589793;
　　Constants defined in this way cannot be reassigned, and it is a compile-time error if your program tries to do so. By convention, the names of constant values are spelled in uppercase letters. If the name is composed of more than one word, the words are separated by an underscore (_).
　　Note: If a primitive type or a string is defined as a constant and the value is known at compile time, the compiler replaces the constant name everywhere in the code with its value. This is called a compile-time constant. If the value of the constant in the outside world changes (for example, if it is legislated that pi actually should be 3.975), you will need to recompile any classes that use this constant to get the current value.
　　Nested Classes
　　The Java programming language allows you to define a class within another class. Such a class is called a nested class and is illustrated here:
　　class OuterClass {
　　...
　　class NestedClass {
　　...
　　}
　　}
　　Terminology: Nested classes are divided into two categories: static and non-static. Nested classes that are declared static are simply called static nested classes. Non-static nested classes are called inner classes.
　　class OuterClass {
　　...
　　static class StaticNestedClass {
　　...
　　}
　　class InnerClass {
　　...
　　}
　　}
　　A nested class is a member of its enclosing class. Non-static nested classes (inner classes) have access to other members of the enclosing class, even if they are declared private. Static nested classes do not have access to other members of the enclosing class. As a member of the OuterClass, a nested class can be declared private, public, protected, or package private. (Recall that outer classes can only be declared public or package private.)
　　Why Use Nested Classes?
　　There are several compelling reasons for using nested classes, among them:
　　It is a way of logically grouping classes that are only used in one place.
　　It increases encapsulation.
　　Nested classes can lead to more readable and maintainable code.
　　Logical grouping of classes―If a class is useful to only one other class, then it is logical to embed it in that class and keep the two together. Nesting such "helper classes" makes their package more streamlined.
　　Increased encapsulation―Consider two top-level classes, A and B, where B needs access to members of A that would otherwise be declared private. By hiding class B within class A, A's members can be declared private and B can access them. In addition, B itself can be hidden from the outside world.
　　More readable, maintainable code―Nesting small classes within top-level classes places the code closer to where it is used.
　　Static Nested Classes
　　As with class methods and variables, a static nested class is associated with its outer class. And like static class methods, a static nested class cannot refer directly to instance variables or methods defined in its enclosing class ― it can use them only through an object reference.
　　Note: A static nested class interacts with the instance members of its outer class (and other classes) just like any other top-level class. In effect, a static nested class is behaviorally a top-level class that has been nested in another top-level class for packaging convenience.
　　Static nested classes are accessed using the enclosing class name:
　　OuterClass.StaticNestedClass
　　For example, to create an object for the static nested class, use this syntax:
　　OuterClass.StaticNestedClass nestedObject = new OuterClass.StaticNestedClass();
　　Inner Classes
　　As with instance methods and variables, an inner class is associated with an instance of its enclosing class and has direct access to that object's methods and fields. Also, because an inner class is associated with an instance, it cannot define any static members itself.
　　Objects that are instances of an inner class exist within an instance of the outer class. Consider the following classes:
　　class OuterClass {
　　...
　　class InnerClass {
　　...
　　}
　　}
　　An instance of InnerClass can exist only within an instance of OuterClass and has direct access to the methods and fields of its enclosing instance. The next figure illustrates this idea.
　　An Instance of InnerClass Exists Within an Instance of OuterClass
　　To instantiate an inner class, you must first instantiate the outer class. Then, create the inner object within the outer object with this syntax:
　　OuterClass.InnerClass innerObject = outerObject.new InnerClass();
　　Additionally, there are two special kinds of inner classes: local classes and anonymous classes (also called anonymous inner classes). Both of these will be discussed briefly in the next section.
　　Note: If you want more information on the taxonomy of the different kinds of classes in the Java programming language (which can be tricky to describe concisely, clearly, and correctly), you might want to read Joseph Darcy's blog: Nested, Inner, Member and Top-Level Classes.
　　The distinction between hiding and overriding has important implications. The version of the overridden method that gets invoked is the one in the subclass. The version of the hidden method that gets invoked depends on whether it is invoked from the superclass or the subclass. Let's look at an example that contains two classes. The first is Animal, which contains one instance method and one class method:
　　public class Animal {
　　public static void testClassMethod() {
　　System.out.println("The class method in Animal.");
　　}
　　public void testInstanceMethod() {
　　System.out.println("The instance method in Animal.");
　　}
　　}
　　The second class, a subclass of Animal, is called Cat:
　　public class Cat extends Animal {
　　public static void testClassMethod() {
　　System.out.println("The class method in Cat.");
　　}
　　public void testInstanceMethod() {
　　System.out.println("The instance method in Cat.");
　　}
　　public static void main(String[] args) {
　　Cat myCat = new Cat();
　　Animal myAnimal = myCat;
　　Animal.testClassMethod();
　　myAnimal.testInstanceMethod();
　　}
　　}
　　The Cat class overrides the instance method in Animal and hides the class method in Animal. The main method in this class creates an instance of Cat and calls testClassMethod() on the class and testInstanceMethod() on the instance.
　　The output from this program is as follows:
　　The class method in Animal.
　　The instance method in Cat.
　　As promised, the version of the hidden method that gets invoked is the one in the superclass, and the version of the overridden method that gets invoked is the one in the subclass
　　Summary
　　The following table summarizes what happens when you define a method with the same signature as a method in a superclass.
　　Defining a Method with the Same Signature as a Superclass's Method
　　Superclass Instance Method Superclass Static Method
　　Subclass Instance Method Overrides Generates a compile-time error
　　Subclass Static Method Generates a compile-time error Hides
　　Note: In a subclass, you can overload the methods inherited from the superclass. Such overloaded methods neither hide nor override the superclass methods―they are new methods, unique to the subclass.