Learning the Java
Language
This trail
covers the fundamentals of programming in the Java programming language.
Object-Oriented
Programming Concepts teaches you the core concepts behind
object-oriented programming: objects, messages, classes, and inheritance. This
lesson ends by showing you how these concepts translate into code. Feel free to
skip this lesson if you are already familiar with object-oriented programming.
Object-Oriented Programming Concepts
If you've never used an object-oriented
programming language before, you'll need to learn a few basic concepts before
you can begin writing any code. This lesson will introduce you to objects,
classes, inheritance, interfaces, and packages. Each discussion focuses on how
these concepts relate to the real world, while simultaneously providing an
introduction to the syntax of the Java programming language.
What Is an Object?
An object is a software bundle of related state
and behavior. Software objects are often used to model the real-world objects
that you find in everyday life. This lesson explains how state and behavior are
represented within an object, introduces the concept of data encapsulation, and
explains the benefits of designing your software in this manner.
Objects are key to understanding object-oriented
technology. Look around right now and you'll find many examples of real-world
objects: your dog, your desk, your television set, your bicycle.
Real-world objects share two characteristics:
They all have state and behavior. Dogs have state (name, color,
breed, hungry) and behavior (barking, fetching, wagging tail). Bicycles also
have state (current gear, current pedal cadence, current speed) and behavior
(changing gear, changing pedal cadence, applying brakes). Identifying the state
and behavior for real-world objects is a great way to begin thinking in terms
of object-oriented programming.
Take a minute right now to observe the
real-world objects that are in your immediate area. For each object that you
see, ask yourself two questions: "What possible states can this object be
in?" and "What possible behavior can this object perform?". Make
sure to write down your observations. As you do, you'll notice that real-world objects
vary in complexity; your desktop lamp may have only two possible states (on and
off) and two possible behaviors (turn on, turn off), but your desktop radio
might have additional states (on, off, current volume, current station) and
behavior (turn on, turn off, increase volume, decrease volume, seek, scan, and
tune). You may also notice that some objects, in turn, will also contain other
objects. These real-world observations all translate into the world of
object-oriented programming.
A software object.
Software objects are conceptually similar to
real-world objects: they too consist of state and related behavior. An object
stores its state in fields (variables in some programming languages) and
exposes its behavior through methods (functions in some programming
languages). Methods operate on an object's internal state and serve as the
primary mechanism for object-to-object communication. Hiding internal state and
requiring all interaction to be performed through an object's methods is known
as data encapsulation — a fundamental principle of object-oriented programming.
Consider a bicycle, for example:
A bicycle modeled as a software object.
By attributing state (current speed, current
pedal cadence, and current gear) and providing methods for changing that state,
the object remains in control of how the outside world is allowed to use it.
For example, if the bicycle only has 6 gears, a method to change gears could
reject any value that is less than 1 or greater than 6.
Bundling code into individual software objects
provides a number of benefits, including:
1.
Modularity: The source code for an object can
be written and maintained independently of the source code for other objects.
Once created, an object can be easily passed around inside the system.
2.
Information-hiding: By interacting only with an
object's methods, the details of its internal implementation remain hidden from
the outside world.
3.
Code re-use: If an object already exists
(perhaps written by another software developer), you can use that object in
your program. This allows specialists to implement/test/debug complex,
task-specific objects, which you can then trust to run in your own code.
4.
Pluggability and debugging ease: If a
particular object turns out to be problematic, you can simply remove it from
your application and plug in a different object as its replacement. This is
analogous to fixing mechanical problems in the real world. If a bolt breaks,
you replace it, not the entire machine.
What Is a Class?
A class is a blueprint or prototype from which
objects are created. This section defines a class that models the state and
behavior of a real-world object. It intentionally focuses on the basics,
showing how even a simple class can cleanly model state and behavior.
In the real world, you'll often find many
individual objects all of the same kind. There may be thousands of other
bicycles in existence, all of the same make and model. Each bicycle was built
from the same set of blueprints and therefore contains the same components. In
object-oriented terms, we say that your bicycle is an instance of the class
of objects known as bicycles. A class is the blueprint from which
individual objects are created.
The following Bicycle class is one possible implementation of a bicycle:
class Bicycle {
int
cadence = 0;
int
speed = 0;
int
gear = 1;
void
changeCadence(int newValue) {
cadence = newValue;
}
void
changeGear(int newValue) {
gear = newValue;
}
void
speedUp(int increment) {
speed
= speed + increment;
}
void
applyBrakes(int decrement) {
speed = speed - decrement;
}
void
printStates() {
System.out.println("cadence:" +
cadence + " speed:" +
speed + " gear:" + gear);
}
}
The syntax of the Java programming language
will look new to you, but the design of this class is based on the previous
discussion of bicycle objects. The fields cadence, speed, and gear represent
the object's state, and the methods (changeCadence, changeGear, speedUp etc.)
define its interaction with the outside world.
You may have noticed that the Bicycle class
does not contain a main method. That's because it's not a complete application;
it's just the blueprint for bicycles that might be used in an
application. The responsibility of creating and using new Bicycle objects
belongs to some other class in your application.
Here's a BicycleDemo class that creates two separate Bicycle objects
and invokes their methods:
class BicycleDemo {
public static void main(String[] args) {
// Create two different
// Bicycle objects
Bicycle bike1 = new Bicycle();
Bicycle bike2 = new Bicycle();
// Invoke methods on
// those objects
bike1.changeCadence(50);
bike1.speedUp(10);
bike1.changeGear(2);
bike1.printStates();
bike2.changeCadence(50);
bike2.speedUp(10);
bike2.changeGear(2);
bike2.changeCadence(40);
bike2.speedUp(10);
bike2.changeGear(3);
bike2.printStates();
}
}
The output of this test prints the ending pedal
cadence, speed, and gear for the two bicycles:
cadence:50 speed:10 gear:2
cadence:40 speed:20 gear:3
What Is Inheritance?
Inheritance provides a powerful and natural
mechanism for organizing and structuring your software. This section explains
how classes inherit state and behavior from their superclasses, and explains
how to derive one class from another using the simple syntax provided by the
Java programming language.
Different kinds of objects often have a certain
amount in common with each other. Mountain bikes, road bikes, and tandem bikes,
for example, all share the characteristics of bicycles (current speed, current
pedal cadence, current gear). Yet each also defines additional features that
make them different: tandem bicycles have two seats and two sets of handlebars;
road bikes have drop handlebars; some mountain bikes have an additional chain ring,
giving them a lower gear ratio.
Object-oriented programming allows classes to inherit
commonly used state and behavior from other classes. In this example, Bicycle
now becomes the superclass of MountainBike, RoadBike, and TandemBike. In
the Java programming language, each class is allowed to have one direct
superclass, and each superclass has the potential for an unlimited number of subclasses:
A hierarchy of bicycle classes.
The syntax for creating a subclass is simple.
At the beginning of your class declaration, use the extends keyword, followed
by the name of the class to inherit from:
class MountainBike extends Bicycle {
//
new fields and methods defining
// a
mountain bike would go here
}
This gives MountainBike all the same fields and
methods as Bicycle, yet allows its code to focus exclusively on the features
that make it unique. This makes code for your subclasses easy to read. However,
you must take care to properly document the state and behavior that each
superclass defines, since that code will not appear in the source file of each
subclass.
What Is an Interface?
An interface is a contract between a class and
the outside world. When a class implements an interface, it promises to provide
the behavior published by that interface. This section defines a simple
interface and explains the necessary changes for any class that implements it.
As you've already learned, objects define their
interaction with the outside world through the methods that they expose.
Methods form the object's interface with the outside world; the buttons
on the front of your television set, for example, are the interface between you
and the electrical wiring on the other side of its plastic casing. You press
the "power" button to turn the television on and off.
In its most common form, an interface is a
group of related methods with empty bodies. A bicycle's behavior, if specified
as an interface, might appear as follows:
interface Bicycle {
// wheel revolutions per minute
void
changeCadence(int newValue);
void
changeGear(int newValue);
void
speedUp(int increment);
void
applyBrakes(int decrement);
}
To implement this interface, the name of your
class would change (to a particular brand of bicycle, for example, such as ACMEBicycle),
and you'd use the implements keyword in the class declaration:
class ACMEBicycle implements Bicycle {
//
remainder of this class
// implemented
as before
}
Implementing an interface allows a class to
become more formal about the behavior it promises to provide. Interfaces form a
contract between the class and the outside world, and this contract is enforced
at build time by the compiler. If your class claims to implement an interface,
all methods defined by that interface must appear in its source code before the
class will successfully compile.
Note: To actually compile the ACMEBicycle class,
you'll need to add the public keyword to the beginning of the implemented
interface methods. You'll learn the reasons for this later in the lessons on Classes and Objects and Interfaces and Inheritance.
What Is a Package?
A package is a namespace for organizing classes
and interfaces in a logical manner. Placing your code into packages makes large
software projects easier to manage. This section explains why this is useful,
and introduces you to the Application Programming Interface (API) provided by
the Java platform.
A package is a namespace that organizes a set
of related classes and interfaces. Conceptually you can think of packages as
being similar to different folders on your computer. You might keep HTML pages
in one folder, images in another, and scripts or applications in yet another.
Because software written in the Java programming language can be composed of
hundreds or thousands of individual classes, it makes sense to keep
things organized by placing related classes and interfaces into packages.
The Java platform provides an enormous class
library (a set of packages) suitable for use in your own applications. This
library is known as the "Application Programming Interface", or
"API" for short. Its packages represent the tasks most commonly
associated with general-purpose programming. For example, a
String object
contains state and behavior for character strings; a File object
allows a programmer to easily create, delete, inspect, compare, or modify a
file on the filesystem; a Socket object
allows for the creation and use of network sockets; various GUI objects control
buttons and checkboxes and anything else related to graphical user interfaces.
There are literally thousands of classes to choose from. This allows you, the
programmer, to focus on the design of your particular application, rather than
the infrastructure required to make it work.
The Java
Platform API Specification contains the complete listing for all
packages, interfaces, classes, fields, and methods supplied by the Java SE
platform. Load the page in your browser and bookmark it. As a programmer, it
will become your single most important piece of reference documentation.
Language
Basics describes the traditional features of the language, including
variables, arrays, data types, operators, and control flow.
Variables
You've
already learned that objects store their state in fields. However, the Java
programming language also uses the term "variable" as well. This
section discusses this relationship, plus variable naming rules and
conventions, basic data types (primitive types, character strings, and arrays),
default values, and literals.
As you learned in the previous lesson, an
object stores its state in fields.
int cadence = 0;
int speed = 0;
int gear = 1;
The What Is an Object? discussion
introduced you to fields, but you probably have still a few questions, such as:
What are the rules and conventions for naming a field? Besides
int,
what other data types are there? Do fields have to be initialized when they are
declared? Are fields assigned a default value if they are not explicitly
initialized? We'll explore the answers to such questions in this lesson, but
before we do, there are a few technical distinctions you must first become
aware of. In the Java programming language, the terms "field" and
"variable" are both used; this is a common source of confusion among
new developers, since both often seem to refer to the same thing.
The Java programming language defines the
following kinds of variables:
·
Instance
Variables (Non-Static Fields) Technically
speaking, objects store their individual states in "non-static
fields", that is, fields declared without the
static keyword.
Non-static fields are also known as instance variables because their
values are unique to each instance of a class (to each object, in other
words); the currentSpeed
of one bicycle is independent from the currentSpeed
of another.
·
Class
Variables (Static Fields) A class
variable is any field declared with the
static modifier; this tells the
compiler that there is exactly one copy of this variable in existence,
regardless of how many times the class has been instantiated. A field defining
the number of gears for a particular kind of bicycle could be marked as static since
conceptually the same number of gears will apply to all instances. The code static int numGears = 6;
would create such a static field. Additionally, the keyword final could be added
to indicate that the number of gears will never change.
·
Local
Variables Similar to how an object stores its state in fields, a method will
often store its temporary state in local variables. The syntax for
declaring a local variable is similar to declaring a field (for example,
int count = 0;). There
is no special keyword designating a variable as local; that determination comes
entirely from the location in which the variable is declared — which is between
the opening and closing braces of a method. As such, local variables are only
visible to the methods in which they are declared; they are not accessible from
the rest of the class.
·
Parameters
You've already seen examples of parameters, both in the
Bicycle class and in
the main
method of the "Hello World!" application. Recall that the signature
for the main
method is public static
void main(String[] args). Here, the args variable is the parameter to
this method. The important thing to remember is that parameters are always
classified as "variables" not "fields". This applies to
other parameter-accepting constructs as well (such as constructors and
exception handlers) that you'll learn about later in the tutorial.
Having said that, the remainder of this
tutorial uses the following general guidelines when discussing fields and
variables. If we are talking about "fields in general" (excluding
local variables and parameters), we may simply say "fields". If the
discussion applies to "all of the above", we may simply say
"variables". If the context calls for a distinction, we will use
specific terms (static field, local variables, etc.) as appropriate. You may
also occasionally see the term "member" used as well. A type's
fields, methods, and nested types are collectively called its members.
Naming
·
Variable names
are case-sensitive. A variable's name can be any legal identifier — an
unlimited-length sequence of Unicode letters and digits, beginning with a
letter, the dollar sign "
$",
or the underscore character "_".
The convention, however, is to always begin your variable names with a letter,
not "$"
or "_".
Additionally, the dollar sign character, by convention, is never used at all.
You may find some situations where auto-generated names will contain the dollar
sign, but your variable names should always avoid using it. A similar
convention exists for the underscore character; while it's technically legal to
begin your variable's name with "_",
this practice is discouraged. White space is not permitted.
·
Subsequent
characters may be letters, digits, dollar signs, or underscore characters.
Conventions (and common sense) apply to this rule as well. When choosing a name
for your variables, use full words instead of cryptic abbreviations. Doing so
will make your code easier to read and understand. In many cases it will also
make your code self-documenting; fields named
cadence, speed, and gear, for example, are
much more intuitive than abbreviated versions, such as s, c, and g. Also keep in mind
that the name you choose must not be a keyword or reserved word.
·
If the name you
choose consists of only one word, spell that word in all lowercase letters. If
it consists of more than one word, capitalize the first letter of each
subsequent word. The names
gearRatio
and currentGear
are prime examples of this convention. If your variable stores a constant
value, such as static
final int NUM_GEARS = 6, the convention changes slightly,
capitalizing every letter and separating subsequent words with the underscore
character. By convention, the underscore character is never used elsewhere.Primitive Data Types
The Java programming language is
statically-typed, which means that all variables must first be declared before
they can be used. This involves stating the variable's type and name, as you've
already seen:
int gear = 1;
Doing so tells your program that a field named
"gear" exists, holds numerical data, and has an initial value of
"1". A variable's data type determines the values it may contain,
plus the operations that may be performed on it. In addition to
int,
the Java programming language supports seven other primitive data types.
A primitive type is predefined by the language and is named by a reserved
keyword. Primitive values do not share state with other primitive values. The
eight primitive data types supported by the Java programming language are:
·
byte: The
byte
data type is an 8-bit signed two's complement integer. It has a minimum value
of -128 and a maximum value of 127 (inclusive). The byte
data type can be useful for saving memory in large arrays, where the memory savings actually matters. They can
also be used in place of int where their limits help to clarify your code; the
fact that a variable's range is limited can serve as a form of documentation.
·
short: The
short
data type is a 16-bit signed two's complement integer. It has a minimum value
of -32,768 and a maximum value of 32,767 (inclusive). As with byte,
the same guidelines apply: you can use a short to save memory in large arrays, in situations
where the memory savings actually matters.
·
int: The
int
data type is a 32-bit signed two's complement integer. It has a minimum value
of -2,147,483,648 and a maximum value of 2,147,483,647 (inclusive). For
integral values, this data type is generally the default choice unless there is
a reason (like the above) to choose something else. This data type will most
likely be large enough for the numbers your program will use, but if you need a
wider range of values, use long instead.
·
long: The
long
data type is a 64-bit signed two's complement integer. It has a minimum value
of -9,223,372,036,854,775,808 and a maximum value of 9,223,372,036,854,775,807
(inclusive). Use this data type when you need a range of values wider than
those provided by int.
·
float: The
float
data type is a single-precision 32-bit IEEE 754 floating point. Its range of
values is beyond the scope of this discussion, but is specified in the Floating-Point Types, Formats, and Values section of the
Java Language Specification. As with the recommendations for byte
and short,
use a float
(instead of double) if you need to save memory in large arrays of
floating point numbers. This data type should never be used for precise values,
such as currency. For that, you will need to use the java.math.BigDecimal class instead. Numbers
and Strings covers BigDecimal and other useful classes provided by the
Java platform.
·
double: The
double
data type is a double-precision 64-bit IEEE 754 floating point. Its range of
values is beyond the scope of this discussion, but is specified in the Floating-Point Types, Formats, and Values section of the
Java Language Specification. For decimal values, this data type is generally
the default choice. As mentioned above, this data type should never be used for
precise values, such as currency.
·
boolean: The
boolean
data type has only two possible values: true and false. Use this data type for simple flags that track
true/false conditions. This data type represents one bit of information, but
its "size" isn't something that's precisely defined.
·
char: The
char
data type is a single 16-bit Unicode character. It has a minimum value of '\u0000'
(or 0) and a maximum value of '\uffff' (or 65,535 inclusive).
In addition to the eight primitive data types
listed above, the Java programming language also provides special support for
character strings via the java.lang.String class. Enclosing your character string
within double quotes will automatically create a new
String
object; for example, String s = "this is a string";. String
objects are immutable, which means that once created, their values
cannot be changed. The String class is not technically a primitive data
type, but considering the special support given to it by the language, you'll
probably tend to think of it as such. You'll learn more about the String
class in Simple Data ObjectsDefault Values
It's not always necessary to assign a value
when a field is declared. Fields that are declared but not initialized will be
set to a reasonable default by the compiler. Generally speaking, this default
will be zero or
null, depending on the data type. Relying on such
default values, however, is generally considered bad programming style.
The following chart summarizes the default
values for the above data types.
|
Data
Type
|
Default
Value (for fields)
|
|
byte
|
0
|
|
short
|
0
|
|
int
|
0
|
|
long
|
0L
|
|
float
|
0.0f
|
|
double
|
0.0d
|
|
char
|
'\u0000'
|
|
String (or any object)
|
null
|
|
boolean
|
false
|
Local variables are slightly different; the
compiler never assigns a default value to an uninitialized local variable. If
you cannot initialize your local variable where it is declared, make sure to
assign it a value before you attempt to use it. Accessing an uninitialized
local variable will result in a compile-time error.
Literals
You may have noticed that the
new
keyword isn't used when initializing a variable of a primitive type. Primitive
types are special data types built into the language; they are not objects
created from a class. A literal is the source code representation
of a fixed value; literals are represented directly in your code without
requiring computation. As shown below, it's possible to assign a literal to a
variable of a primitive type:boolean result = true;
char capitalC = 'C';
byte b = 100;
short s = 10000;
int i = 100000;
Integer Literals
An integer literal is of type
long
if it ends with the letter L or l; otherwise it is of type int.
It is recommended that you use the upper case letter L
because the lower case letter l is hard to distinguish from the digit 1.
Values of the integral types
byte,
short,
int,
and long
can be created from int literals. Values of type long
that exceed the range of int can be created from long literals. Integer
literals can be expressed by these number systems:
·
Decimal: Base
10, whose digits consists of the numbers 0 through 9; this is the number system
you use every day
·
Hexadecimal:
Base 16, whose digits consist of the numbers 0 through 9 and the letters A
through F
·
Binary: Base 2,
whose digits consists of the numbers 0 and 1 (you can create binary literals in
Java SE 7 and later)
For general-purpose programming, the decimal
system is likely to be the only number system you'll ever use. However, if you
need to use another number system, the following example shows the correct
syntax. The prefix
0x indicates hexadecimal and 0b
indicates binary:// The number 26, in decimal
int decVal = 26;
// The number 26, in hexadecimal
int hexVal = 0x1a;
// The number 26, in binary
int binVal = 0b11010;
Floating-Point Literals
A floating-point literal is of type
float
if it ends with the letter F or f; otherwise its type is double
and it can optionally end with the letter D or d.
The floating point types (
float
and double)
can also be expressed using E or e (for scientific notation), F or f (32-bit
float literal) and D or d (64-bit double literal; this is the default and by
convention is omitted).double d1 = 123.4;
// same value as d1, but in scientific notation
double d2 = 1.234e2;
float f1 = 123.4f;
Character and String Literals
Literals of types
char and String
may contain any Unicode (UTF-16) characters. If your editor and file system
allow it, you can use such characters directly in your code. If not, you can
use a "Unicode escape" such as '\u0108' (capital C with circumflex), or "S\u00ED
Se\u00F1or" (Sí Señor in Spanish). Always use 'single
quotes' for char literals and "double quotes" for String
literals. Unicode escape sequences may be used elsewhere in a program (such as
in field names, for example), not just in char or String literals.
The Java programming language also supports a
few special escape sequences for
char and String literals: \b (backspace), \t (tab), \n (line feed), \f (form feed), \r (carriage return), \" (double
quote), \'
(single quote), and \\ (backslash).
There's also a special
null
literal that can be used as a value for any reference type. null
may be assigned to any variable, except variables of primitive types. There's
little you can do with a null value beyond testing for its presence.
Therefore, null
is often used in programs as a marker to indicate that some object is
unavailable.
Finally, there's also a special kind of literal
called a class
literal, formed by taking a type name and appending "
.class";
for example, String.class. This refers to the object (of type Class)
that represents the type itself.Using Underscore Characters in Numeric Literals
In Java SE 7 and later, any number of
underscore characters (
_) can appear anywhere between digits in a numerical
literal. This feature enables you, for example. to separate groups of digits in
numeric literals, which can improve the readability of your code.
For instance, if your code contains numbers
with many digits, you can use an underscore character to separate digits in
groups of three, similar to how you would use a punctuation mark like a comma,
or a space, as a separator.
The following example shows other ways you can
use the underscore in numeric literals:
long creditCardNumber = 1234_5678_9012_3456L;
long socialSecurityNumber = 999_99_9999L;
float pi = 3.14_15F;
long hexBytes = 0xFF_EC_DE_5E;
long hexWords = 0xCAFE_BABE;
long maxLong = 0x7fff_ffff_ffff_ffffL;
byte nybbles = 0b0010_0101;
long bytes = 0b11010010_01101001_10010100_10010010;
You can place underscores only between digits;
you cannot place underscores in the following places:
·
At the
beginning or end of a number
·
Adjacent to a
decimal point in a floating point literal
·
Prior to an
F or L suffix
·
In positions
where a string of digits is expected
The following examples demonstrate valid and
invalid underscore placements (which are highlighted) in numeric literals:
// Invalid: cannot put underscores
// adjacent to a decimal point
float pi1 = 3_.1415F;
// Invalid: cannot put underscores
// adjacent to a decimal point
float pi2 = 3._1415F;
// Invalid: cannot put underscores
// prior to an L suffix
long socialSecurityNumber1 = 999_99_9999_L;
// This is an identifier, not
// a numeric literal
int x1 = _52;
// OK (decimal literal)
int x2 = 5_2;
// Invalid: cannot put underscores
// At the end of a literal
int x3 = 52_;
// OK (decimal literal)
int x4 = 5_______2;
// Invalid: cannot put underscores
// in the 0x radix prefix
int x5 = 0_x52;
// Invalid: cannot put underscores
// at the beginning of a number
int x6 = 0x_52;
// OK (hexadecimal literal)
int x7 = 0x5_2;
// Invalid: cannot put underscores
// at the end of a number
int x8 = 0x52_;
Arrays
An array is a container object that
holds a fixed number of values of a single type. The length of an array is
established when the array is created. After creation, its length is fixed.
You've seen an example of arrays already, in the
main method
of the "Hello World!" application. This section discusses arrays in
greater detail.
An array
of ten elements
Each item in an array is called an element,
and each element is accessed by its numerical index. As shown in the
above illustration, numbering begins with 0. The 9th element, for example,
would therefore be accessed at index 8.
The following program,
ArrayDemo, creates an array
of integers, puts some values in it, and prints each value to standard output.
class ArrayDemo {
public static void main(String[] args) {
// declares an array of integers
int[] anArray;
// allocates memory for 10 integers
anArray = new int[10];
// initialize first element
anArray[0] = 100;
// initialize second element
anArray[1] = 200;
// etc.
anArray[2] = 300;
anArray[3] = 400;
anArray[4] = 500;
anArray[5] = 600;
anArray[6] = 700;
anArray[7] = 800;
anArray[8] = 900;
anArray[9] = 1000;
System.out.println("Element at index 0: "
+ anArray[0]);
System.out.println("Element at index 1: "
+ anArray[1]);
System.out.println("Element at index 2: "
+ anArray[2]);
System.out.println("Element at index 3: "
+ anArray[3]);
System.out.println("Element at index 4: "
+ anArray[4]);
System.out.println("Element at index 5: "
+ anArray[5]);
System.out.println("Element at index 6: "
+ anArray[6]);
System.out.println("Element at index 7: "
+ anArray[7]);
System.out.println("Element at index 8: "
+ anArray[8]);
System.out.println("Element at index 9: "
+ anArray[9]);
}
}
The output from this program is:
Element at index 0: 100
Element at index 1: 200
Element at index 2: 300
Element at index 3: 400
Element at index 4: 500
Element at index 5: 600
Element at index 6: 700
Element at index 7: 800
Element at index 8: 900
Element at index 9: 1000
In a real-world programming situation, you'd
probably use one of the supported looping constructs to iterate through
each element of the array, rather than write each line individually as shown
above. However, this example clearly illustrates the array syntax. You'll learn
about the various looping constructs (
for, while, and do-while) in the
Control Flow section.Declaring a Variable to Refer to an Array
The above program declares
anArray with
the following line of code:// declares an array of integers
int[] anArray;
Like declarations for variables of other types,
an array declaration has two components: the array's type and the array's name.
An array's type is written as type
[], where type
is the data type of the contained elements; the square brackets are special symbols
indicating that this variable holds an array. The size of the array is not part
of its type (which is why the brackets are empty). An array's name can be
anything you want, provided that it follows the rules and conventions as
previously discussed in the naming section. As with variables of other types, the
declaration does not actually create an array — it simply tells the compiler
that this variable will hold an array of the specified type.
Similarly, you can declare arrays of other
types:
byte[] anArrayOfBytes;
short[] anArrayOfShorts;
long[] anArrayOfLongs;
float[] anArrayOfFloats;
double[] anArrayOfDoubles;
boolean[] anArrayOfBooleans;
char[] anArrayOfChars;
String[] anArrayOfStrings;
You can also place the square brackets after
the array's name:
// this form is discouraged
float anArrayOfFloats[];
However, convention discourages this form; the
brackets identify the array type and should appear with the type designation.
Creating, Initializing, and Accessing an Array
One way to create an array is with the
new
operator. The next statement in the ArrayDemo program
allocates an array with enough memory for ten integer elements and assigns the
array to the anArray
variable.// create an array of integers
anArray = new int[10];
If this statement were missing, the compiler
would print an error like the following, and compilation would fail:
ArrayDemo.java:4: Variable anArray may not have been initialized.
The next few lines assign values to each
element of the array:
anArray[0] = 100; // initialize first element
anArray[1] = 200; // initialize second element
anArray[2] = 300; // etc.
Each array element is accessed by its numerical
index:
System.out.println("Element 1 at index 0: " + anArray[0]);
System.out.println("Element 2 at index 1: " + anArray[1]);
System.out.println("Element 3 at index 2: " + anArray[2]);
Alternatively, you can use the shortcut syntax
to create and initialize an array:
int[] anArray = {
100, 200, 300,
400, 500, 600,
700, 800, 900, 1000
};
Here the length of the array is determined by
the number of values provided between { and }.
You can also declare an array of arrays (also
known as a multidimensional
array) by using two or more sets of square brackets, such as
String[][]
names. Each element, therefore, must be accessed by
a corresponding number of index values.
In the Java programming language, a
multidimensional array is simply an array whose components are themselves
arrays. This is unlike arrays in C or Fortran. A consequence of this is that
the rows are allowed to vary in length, as shown in the following
MultiDimArrayDemoprogram:class MultiDimArrayDemo {
public static void main(String[] args) {
String[][] names = {
{"Mr. ", "Mrs. ", "Ms. "},
{"Smith", "Jones"}
};
// Mr. Smith
System.out.println(names[0][0] + names[1][0]);
// Ms. Jones
System.out.println(names[0][2] + names[1][1]);
}
}
The output from this program is:
Mr. Smith
Ms. Jones
Finally, you can use the built-in
length
property to determine the size of any array. The code System.out.println(anArray.length);
will print the array's size to standard output.
Copying Arrays
The
System class
has an arraycopy method
that you can use to efficiently copy data from one array into another:public static void arraycopy(Object src, int srcPos,
Object dest, int destPos, int length)
The two
Object
arguments specify the array to copy from and the array to copy to.
The three int
arguments specify the starting position in the source array, the starting
position in the destination array, and the number of array elements to copy.
The following program,
ArrayCopyDemo, declares an
array of char
elements, spelling the word "decaffeinated". It uses arraycopy to copy
a subsequence of array components into a second array:
class ArrayCopyDemo {
public static void main(String[] args) {
char[] copyFrom = { 'd', 'e', 'c', 'a', 'f', 'f', 'e',
'i', 'n', 'a', 't', 'e', 'd' };
char[] copyTo = new char[7];
System.arraycopy(copyFrom, 2, copyTo, 0, 7);
System.out.println(new String(copyTo));
}
}
The output from this program is:
caffein
Operators
This
section describes the operators of the Java programming language. It presents
the most commonly-used operators first, and the less commonly-used operators
last. Each discussion includes code samples that you can compile and run.
Now that you've learned how to declare and
initialize variables, you probably want to know how to do something with
them. Learning the operators of the Java programming language is a good place
to start. Operators are special symbols that perform specific operations on
one, two, or three operands, and then return a result.
As we explore the operators of the Java
programming language, it may be helpful for you to know ahead of time which
operators have the highest precedence. The operators in the following table are
listed according to precedence order. The closer to the top of the table an
operator appears, the higher its precedence. Operators with higher precedence
are evaluated before operators with relatively lower precedence. Operators on
the same line have equal precedence. When operators of equal precedence appear
in the same expression, a rule must govern which is evaluated first. All binary
operators except for the assignment operators are evaluated from left to right;
assignment operators are evaluated right to left.
|
Operator Precedence
|
|
|
Operators
|
Precedence
|
|
postfix
|
expr++ expr--
|
|
unary
|
++expr
--expr +expr -expr ~ !
|
|
multiplicative
|
* / %
|
|
additive
|
+ -
|
|
shift
|
<<
>> >>>
|
|
relational
|
< >
<= >= instanceof
|
|
equality
|
== !=
|
|
bitwise AND
|
&
|
|
bitwise
exclusive OR
|
^
|
|
bitwise
inclusive OR
|
|
|
|
logical AND
|
&&
|
|
logical OR
|
||
|
|
ternary
|
? :
|
|
assignment
|
= += -= *= /=
%= &= ^= |= <<= >>= >>>=
|
In general-purpose programming, certain
operators tend to appear more frequently than others; for example, the
assignment operator "=" is far more common than the unsigned right
shift operator ">>>". With that in mind, the following
discussion focuses first on the operators that you're most likely to use on a
regular basis, and ends focusing on those that are less common. Each discussion
is accompanied by sample code that you can compile and run. Studying its output
will help reinforce what you've just learned.
Assignment, Arithmetic, and Unary Operators
The Simple Assignment Operator
One of the most common operators that you'll
encounter is the simple assignment operator "
=".
You saw this operator in the Bicycle class; it assigns the value on its right
to the operand on its left: int cadence = 0;
int speed = 0;
int gear = 1;
This operator can also be used on objects to
assign object references, as discussed in Creating Objects.
The Arithmetic Operators
The Java programming language provides
operators that perform addition, subtraction, multiplication, and division.
There's a good chance you'll recognize them by their counterparts in basic
mathematics. The only symbol that might look new to you is "
%",
which divides one operand by another and returns the remainder as its result.+ additive operator (also used for
String concatenation)
- subtraction operator
* multiplication operator
/ division operator
% remainder operator
The following program,
ArithmeticDemo, tests the
arithmetic operators.
class ArithmeticDemo {
public static void main (String[] args){
// result is now 3
int result = 1 + 2;
System.out.println(result);
// result is now 2
result = result - 1;
System.out.println(result);
// result is now 4
result = result * 2;
System.out.println(result);
// result is now 2
result = result / 2;
System.out.println(result);
// result is now 10
result = result + 8;
// result is now 3
result = result % 7;
System.out.println(result);
}
}
You can also combine the arithmetic operators
with the simple assignment operator to create compound assignments. For
example,
x+=1; and x=x+1; both
increment the value of x by 1.
The
+
operator can also be used for concatenating (joining) two strings together, as
shown in the following ConcatDemo program:
class ConcatDemo {
public static void main(String[] args){
String firstString = "This is";
String secondString =
" a concatenated string.";
String thirdString =
firstString+secondString;
System.out.println(thirdString);
}
}
By the end of this program, the variable
thirdString
contains "This is a concatenated string.", which gets printed to
standard output.The Unary Operators
The unary operators require only one operand;
they perform various operations such as incrementing/decrementing a value by
one, negating an expression, or inverting the value of a boolean.
+ Unary plus operator; indicates
positive value (numbers are
positive without this, however)
- Unary minus operator; negates
an expression
++ Increment operator; increments
a value by 1
-- Decrement operator; decrements
a value by 1
! Logical complement operator;
inverts the value of a boolean
The following program,
UnaryDemo, tests the unary
operators:
class UnaryDemo {
public static void main(String[] args){
// result is now 1
int result = +1;
System.out.println(result);
// result is now 0
result--;
System.out.println(result);
// result is now 1
result++;
System.out.println(result);
// result is now -1
result = -result;
System.out.println(result);
boolean success = false;
// false
System.out.println(success);
// true
System.out.println(!success);
}
}
The increment/decrement operators can be
applied before (prefix) or after (postfix) the operand. The code
result++; and ++result; will
both end in result being
incremented by one. The only difference is that the prefix version (++result)
evaluates to the incremented value, whereas the postfix version (result++) evaluates
to the original value. If you are just performing a simple increment/decrement,
it doesn't really matter which version you choose. But if you use this operator
in part of a larger expression, the one that you choose may make a significant
difference.
The following program,
PrePostDemo, illustrates the
prefix/postfix unary increment operator:
class PrePostDemo {
public static void main(String[] args){
int i = 3;
i++;
// prints 4
System.out.println(i);
++i;
// prints 5
System.out.println(i);
// prints 6
System.out.println(++i);
// prints 6
System.out.println(i++);
// prints 7
System.out.println(i);
}
}
Equality, Relational, and Conditional Operators
The Equality and Relational Operators
The equality and relational operators determine
if one operand is greater than, less than, equal to, or not equal to another
operand. The majority of these operators will probably look familiar to you as
well. Keep in mind that you must use "
==",
not "=",
when testing if two primitive values are equal.== equal to
!= not equal to
> greater than
>= greater than or equal to
< less than
<= less than or equal to
The following program,
ComparisonDemo, tests the
comparison operators:
class ComparisonDemo {
public static void main(String[] args){
int value1 = 1;
int value2 = 2;
if(value1 == value2)
System.out.println("value1 == value2");
if(value1 != value2)
System.out.println("value1 != value2");
if(value1 > value2)
System.out.println("value1 > value2");
if(value1 < value2)
System.out.println("value1 < value2");
if(value1 <= value2)
System.out.println("value1 <= value2");
}
}
Output:
value1 != value2
value1 < value2
value1 <= value2
The Conditional Operators
The
&& and ||
operators perform Conditional-AND and Conditional-OR
operations on two boolean expressions. These operators exhibit
"short-circuiting" behavior, which means that the second operand is
evaluated only if needed.&& Conditional-AND
|| Conditional-OR
The following program,
ConditionalDemo1, tests these
operators:
class ConditionalDemo1 {
public static void main(String[] args){
int value1 = 1;
int value2 = 2;
if((value1 == 1) && (value2 == 2))
System.out.println("value1 is 1 AND value2 is 2");
if((value1 == 1) || (value2 == 1))
System.out.println("value1 is 1 OR value2 is 1");
}
}
Another conditional operator is
?:, which
can be thought of as shorthand for an if-then-else statement
(discussed in the Control Flow Statements section of this lesson). This
operator is also known as the ternary operator because it uses three
operands. In the following example, this operator should be read as: "If someCondition is true, assign
the value of value1 to result.
Otherwise, assign the value of value2 to result."
The following program,
ConditionalDemo2, tests the ?:
operator:
class ConditionalDemo2 {
public static void main(String[] args){
int value1 = 1;
int value2 = 2;
int result;
boolean someCondition = true;
result = someCondition ? value1 : value2;
System.out.println(result);
}
}
Because
someCondition is
true, this program prints "1" to the screen. Use the ?: operator
instead of an if-then-else
statement if it makes your code more readable; for example, when the
expressions are compact and without side-effects (such as assignments).The Type Comparison Operator instanceof
The
instanceof
operator compares an object to a specified type. You can use it to test if an
object is an instance of a class, an instance of a subclass, or an instance of
a class that implements a particular interface.
The following program,
InstanceofDemo, defines a
parent class (named Parent), a
simple interface (named MyInterface), and a
child class (named Child) that
inherits from the parent and implements the interface.
class InstanceofDemo {
public static void main(String[] args) {
Parent obj1 = new Parent();
Parent obj2 = new Child();
System.out.println("obj1 instanceof Parent: "
+ (obj1 instanceof Parent));
System.out.println("obj1 instanceof Child: "
+ (obj1 instanceof Child));
System.out.println("obj1 instanceof MyInterface: "
+ (obj1 instanceof MyInterface));
System.out.println("obj2 instanceof Parent: "
+ (obj2 instanceof Parent));
System.out.println("obj2 instanceof Child: "
+ (obj2 instanceof Child));
System.out.println("obj2 instanceof MyInterface: "
+ (obj2 instanceof MyInterface));
}
}
class Parent {}
class Child extends Parent implements MyInterface {}
interface MyInterface {}
Output:
obj1 instanceof Parent: true
obj1 instanceof Child: false
obj1 instanceof MyInterface: false
obj2 instanceof Parent: true
obj2 instanceof Child: true
obj2 instanceof MyInterface: true
When using the
instanceof
operator, keep in mind that null is not
an instance of anything.Bitwise and Bit Shift Operators
The Java programming language also provides
operators that perform bitwise and bit shift operations on integral types. The operators
discussed in this section are less commonly used. Therefore, their coverage is
brief; the intent is to simply make you aware that these operators exist.
The unary bitwise complement operator "
~"
inverts a bit pattern; it can be applied to any of the integral types, making
every "0" a "1" and every "1" a "0".
For example, a byte
contains 8 bits; applying this operator to a value whose bit pattern is
"00000000" would change its pattern to "11111111".
The signed left shift operator "
<<"
shifts a bit pattern to the left, and the signed right shift operator ">>"
shifts a bit pattern to the right. The bit pattern is given by the left-hand
operand, and the number of positions to shift by the right-hand operand. The
unsigned right shift operator ">>>"
shifts a zero into the leftmost position, while the leftmost position after ">>" depends
on sign extension.
The bitwise
&
operator performs a bitwise AND operation.
The bitwise
^
operator performs a bitwise exclusive OR operation.
The bitwise
|
operator performs a bitwise inclusive OR operation.
The following program,
BitDemo, uses the bitwise AND
operator to print the number "2" to standard output.
class BitDemo {
public static void main(String[] args) {
int bitmask = 0x000F;
int val = 0x2222;
// prints "2"
System.out.println(val & bitmask);
}
}
Summary of Operators
The following quick reference summarizes the
operators supported by the Java programming language.
Simple Assignment Operator
= Simple assignment operator
Arithmetic Operators
+ Additive operator (also used
for String concatenation)
- Subtraction operator
* Multiplication operator
/ Division operator
% Remainder operator
Unary Operators
+ Unary plus operator; indicates
positive value (numbers are
positive without this, however)
- Unary minus operator; negates
an expression
++ Increment operator; increments
a value by 1
-- Decrement operator; decrements
a value by 1
! Logical complement operator;
inverts the value of a boolean
Equality and Relational Operators
== Equal to
!= Not equal to
> Greater than
>= Greater than or equal to
< Less than
<= Less than or equal to
Conditional Operators
&& Conditional-AND
|| Conditional-OR
?: Ternary (shorthand for
if-then-else statement)
Type Comparison Operator
instanceof Compares an object to
a specified type
Bitwise and Bit Shift Operators
~ Unary bitwise complement
<< Signed left shift
>> Signed right shift
>>> Unsigned right shift
& Bitwise AND
^ Bitwise exclusive OR
| Bitwise inclusive OR
Expressions, Statements, and Blocks
Operators
may be used in building expressions, which compute values; expressions are the
core components of statements; statements may be grouped into blocks. This
section discusses expressions, statements, and blocks using example code that
you've already seen.
Now that you understand variables and
operators, it's time to learn about expressions, statements, and blocks.
Operators may be used in building expressions, which compute values;
expressions are the core components of statements; statements may be grouped
into blocks.
Expressions
An expression is a
construct made up of variables, operators, and method invocations, which are
constructed according to the syntax of the language, that evaluates to a single
value. You've already seen examples of expressions, illustrated in bold below:
int cadence = 0;anArray[0] = 100;
System.out.println("Element 1 at index 0: " + anArray[0]);
int result = 1 + 2; // result is now 3if (value1 == value2) System.out.println("value1 == value2");
The data type of the value returned by an
expression depends on the elements used in the expression. The expression
cadence = 0
returns an int
because the assignment operator returns a value of the same data type as its
left-hand operand; in this case, cadence is an int. As you can see from the other expressions, an
expression can return other types of values as well, such as boolean
or String.
The Java programming language allows you to
construct compound expressions from various smaller expressions as long as the
data type required by one part of the expression matches the data type of the
other. Here's an example of a compound expression:
1 * 2 * 3
In this particular example, the order in which
the expression is evaluated is unimportant because the result of multiplication
is independent of order; the outcome is always the same, no matter in which
order you apply the multiplications. However, this is not true of all
expressions. For example, the following expression gives different results,
depending on whether you perform the addition or the division operation first:
x + y / 100 // ambiguous
You can specify exactly how an expression will
be evaluated using balanced parenthesis: ( and ). For example, to make the
previous expression unambiguous, you could write the following:
(x + y) / 100 // unambiguous, recommended
If you don't explicitly indicate the order for
the operations to be performed, the order is determined by the precedence
assigned to the operators in use within the expression. Operators that have a
higher precedence get evaluated first. For example, the division operator has a
higher precedence than does the addition operator. Therefore, the following two
statements are equivalent:
x + y / 100
x + (y / 100) // unambiguous, recommended
When writing compound expressions, be explicit
and indicate with parentheses which operators should be evaluated first. This
practice makes code easier to read and to maintain.
Statements
Statements are roughly equivalent to sentences
in natural languages. A statement forms a
complete unit of execution. The following types of expressions can be made into
a statement by terminating the expression with a semicolon (
;).
·
Assignment
expressions
·
Any use of
++ or --
·
Method
invocations
·
Object creation
expressions
Such statements are called expression
statements. Here are some examples of expression
statements.
// assignment statement
aValue = 8933.234;
// increment statement
aValue++;
// method invocation statement
System.out.println("Hello World!");
// object creation statement
Bicycle myBike = new Bicycle();
In addition to expression statements, there are
two other kinds of statements: declaration statements and control
flow statements. A declaration statement
declares a variable. You've seen many examples of declaration statements
already:
// declaration statement
double aValue = 8933.234;
Finally, control
flow statements regulate the order in which statements get
executed. You'll learn about control flow statements in the next section, Control Flow Statements
Blocks
A block is a group of zero or more
statements between balanced braces and can be used anywhere a single statement
is allowed. The following example,
BlockDemo,
illustrates the use of blocks:class BlockDemo {
public static void main(String[] args) {
boolean condition = true;
if (condition) { // begin block 1
System.out.println("Condition is true.");
} // end block one
else { // begin block 2
System.out.println("Condition is false.");
} // end block 2
}
}
The
statements inside your source files are generally executed from top to bottom,
in the order that they appear. Control flow statements, however, break
up the flow of execution by employing decision making, looping, and branching,
enabling your program to conditionally execute particular blocks of
code. This section describes the decision-making statements (
if-then, if-then-else, switch), the looping
statements (for,
while,
do-while),
and the branching statements (break,
continue,
return)
supported by the Java programming language.Control Flow Statements
This section
describes the control flow statements supported by the Java programming
language. It covers the decisions-making, looping, and branching statements
that enable your programs to conditionally execute particular blocks of code.
The if-then and if-then-else Statements
The if-then Statement
The
if-then
statement is the most basic of all the control flow statements. It tells your
program to execute a certain section of code only if a particular test
evaluates to true. For
example, the Bicycle class
could allow the brakes to decrease the bicycle's speed only if the
bicycle is already in motion. One possible implementation of the applyBrakes method
could be as follows:void applyBrakes() {
// the "if" clause: bicycle must be moving
if (isMoving){
// the "then" clause: decrease current speed
currentSpeed--;
}
}
If this test evaluates to
false
(meaning that the bicycle is not in motion), control jumps to the end of the if-then
statement.
In addition, the opening and closing braces are
optional, provided that the "then" clause contains only one
statement:
void applyBrakes() {
// same as above, but without braces
if (isMoving)
currentSpeed--;
}
Deciding when to omit the braces is a matter of
personal taste. Omitting them can make the code more brittle. If a second
statement is later added to the "then" clause, a common mistake would
be forgetting to add the newly required braces. The compiler cannot catch this
sort of error; you'll just get the wrong results.
The if-then-else Statement
The
if-then-else
statement provides a secondary path of execution when an "if" clause
evaluates to false. You
could use an if-then-else
statement in the applyBrakes method
to take some action if the brakes are applied when the bicycle is not in
motion. In this case, the action is to simply print an error message stating
that the bicycle has already stopped.void applyBrakes() {
if (isMoving) {
currentSpeed--;
} else {
System.err.println("The bicycle has " + "already stopped!");
}
}
The following program,
IfElseDemo, assigns a grade
based on the value of a test score: an A for a score of 90% or above, a B for a
score of 80% or above, and so on.
class IfElseDemo {
public static void main(String[] args) {
int testscore = 76;
char grade;
if (testscore >= 90) {
grade = 'A';
} else if (testscore >= 80) {
grade = 'B';
} else if (testscore >= 70) {
grade = 'C';
} else if (testscore >= 60) {
grade = 'D';
} else {
grade = 'F';
}
System.out.println("Grade = " + grade);
}
}
The output from the program is:
Grade = C
You may have noticed that the value of
testscore can
satisfy more than one expression in the compound statement: 76
>= 70 and 76 >= 60.
However, once a condition is satisfied, the appropriate statements are executed
(grade = 'C';) and the
remaining conditions are not evaluated.The switch Statement
Unlike
if-then and if-then-else
statements, the switch statement
can have a number of possible execution paths. A switch works
with the byte, short, char, and int
primitive data types. It also works with enumerated types (discussed in Enum Types), the String class, and a few
special classes that wrap certain primitive types: Character, Byte, Short, and Integer (discussed in Numbers
and Strings).
The following code example,
SwitchDemo, declares an int named month whose
value represents a month. The code displays the name of the month, based on the
value of month, using
the switch
statement.
public class SwitchDemo {
public static void main(String[] args) {
int month = 8;
String monthString;
switch (month) {
case 1: monthString = "January";
break;
case 2: monthString = "February";
break;
case 3: monthString = "March";
break;
case 4: monthString = "April";
break;
case 5: monthString = "May";
break;
case 6: monthString = "June";
break;
case 7: monthString = "July";
break;
case 8: monthString = "August";
break;
case 9: monthString = "September";
break;
case 10: monthString = "October";
break;
case 11: monthString = "November";
break;
case 12: monthString = "December";
break;
default: monthString = "Invalid month";
break;
}
System.out.println(monthString);
}
}
In this case,
August is
printed to standard output.
The body of a
switch
statement is known as a switch block. A statement in the switch block
can be labeled with one or more case or default labels.
The switch
statement evaluates its expression, then executes all statements that follow
the matching case label.
You could also display the name of the month
with
if-then-else
statements:int month = 8;
if (month == 1) {
System.out.println("January");
} else if (month == 2) {
System.out.println("February");
}
... // and so on
Deciding whether to use
if-then-else
statements or a switch
statement is based on readability and the expression that the statement is
testing. An if-then-else
statement can test expressions based on ranges of values or conditions, whereas
a switch
statement tests expressions based only on a single integer, enumerated value,
or String object.
Another point of interest is the
break
statement. Each break
statement terminates the enclosing switch
statement. Control flow continues with the first statement following the switch block.
The break
statements are necessary because without them, statements in switch blocks fall
through: All statements after the matching case label
are executed in sequence, regardless of the expression of subsequent case labels,
until a break
statement is encountered. The program SwitchDemoFallThrough shows
statements in a switch block
that fall through. The program displays the month corresponding to the integer month and the
months that follow in the year:
public class SwitchDemoFallThrough {
public static void main(String args[]) {
java.util.ArrayList<String> futureMonths =
new java.util.ArrayList<String>();
int month = 8;
switch (month) {
case 1: futureMonths.add("January");
case 2: futureMonths.add("February");
case 3: futureMonths.add("March");
case 4: futureMonths.add("April");
case 5: futureMonths.add("May");
case 6: futureMonths.add("June");
case 7: futureMonths.add("July");
case 8: futureMonths.add("August");
case 9: futureMonths.add("September");
case 10: futureMonths.add("October");
case 11: futureMonths.add("November");
case 12: futureMonths.add("December");
break;
default: break;
}
if (futureMonths.isEmpty()) {
System.out.println("Invalid month number");
} else {
for (String monthName : futureMonths) {
System.out.println(monthName);
}
}
}
}
This is the output from the code:
August
September
October
November
December
Technically, the final
break is not
required because flow falls out of the switch
statement. Using a break is
recommended so that modifying the code is easier and less error prone. The default section
handles all values that are not explicitly handled by one of the case
sections.
The following code example,
SwitchDemo2, shows how a
statement can have multiple case labels.
The code example calculates the number of days in a particular month:
class SwitchDemo2 {
public static void main(String[] args) {
int month = 2;
int year = 2000;
int numDays = 0;
switch (month) {
case 1: case 3: case 5:
case 7: case 8: case 10:
case 12:
numDays = 31;
break;
case 4: case 6:
case 9: case 11:
numDays = 30;
break;
case 2:
if (((year % 4 == 0) &&
!(year % 100 == 0))
|| (year % 400 == 0))
numDays = 29;
else
numDays = 28;
break;
default:
System.out.println("Invalid month.");
break;
}
System.out.println("Number of Days = "
+ numDays);
}
}
This is the output from the code:
Number of Days = 29
Using Strings in switch Statements
In Java SE 7 and later, you can use a
String object
in the switch
statement's expression. The following code example, StringSwitchDemo, displays
the number of the month based on the value of the String named month:
public class StringSwitchDemo {
public static int getMonthNumber(String month) {
int monthNumber = 0;
if (month == null) {
return monthNumber;
}
switch (month.toLowerCase()) {
case "january":
monthNumber = 1;
break;
case "february":
monthNumber = 2;
break;
case "march":
monthNumber = 3;
break;
case "april":
monthNumber = 4;
break;
case "may":
monthNumber = 5;
break;
case "june":
monthNumber = 6;
break;
case "july":
monthNumber = 7;
break;
case "august":
monthNumber = 8;
break;
case "september":
monthNumber = 9;
break;
case "october":
monthNumber = 10;
break;
case "november":
monthNumber = 11;
break;
case "december":
monthNumber = 12;
break;
default:
monthNumber = 0;
break;
}
return monthNumber;
}
public static void main(String[] args) {
String month = "August";
int returnedMonthNumber =
StringSwitchDemo.getMonthNumber(month);
if (returnedMonthNumber == 0) {
System.out.println("Invalid month");
} else {
System.out.println(returnedMonthNumber);
}
}
}
The output from this code is
8.
The
String in the switch
expression is compared with the expressions associated with each case label
as if the String.equals method were
being used. In order for the StringSwitchDemo example
to accept any month regardless of case, month is
converted to lowercase (with the toLowerCase method), and all
the strings associated with the case labels
are in lowercase.
Note: This
example checks if the expression in the
switch
statement is null. Ensure
that the expression in any switch
statement is not null to prevent a NullPointerException from
being thrown.The while and do-while Statements
The
while
statement continually executes a block of statements while a particular
condition is true. Its
syntax can be expressed as:while (expression) {
statement(s)
}
The
while
statement evaluates expression, which must return a boolean value.
If the expression evaluates to true, the while
statement executes the statement(s) in the while block.
The while
statement continues testing the expression and executing its block until the
expression evaluates to false. Using
the while
statement to print the values from 1 through 10 can be accomplished as in the
following WhileDemo program:
class WhileDemo {
public static void main(String[] args){
int count = 1;
while (count < 11) {
System.out.println("Count is: "
+ count);
count++;
}
}
}
You can implement an infinite loop using the
while
statement as follows:while (true){
// your code goes here
}
The Java programming language also provides a
do-while
statement, which can be expressed as follows:do {
statement(s)
} while (expression);
The difference between
do-while and while is that
do-while
evaluates its expression at the bottom of the loop instead of the top.
Therefore, the statements within the do block
are always executed at least once, as shown in the following DoWhileDemo program:
class DoWhileDemo {
public static void main(String[] args){
int count = 1;
do {
System.out.println("Count is: "
+ count);
count++;
} while (count < 11);
}
}
The for Statement
The for statement provides a compact way to
iterate over a range of values. Programmers often refer to it as the "for
loop" because of the way in which it repeatedly loops until a particular
condition is satisfied. The general form of the for statement can be expressed
as follows:
for (initialization; termination;
increment)
{
statement(s)
}
When using this version of the for statement,
keep in mind that:
·
The initialization expression
initializes the loop; it's executed once, as the loop begins.
·
When the termination expression
evaluates to false, the loop terminates.
·
The increment expression is invoked
after each iteration through the loop; it is perfectly acceptable for this
expression to increment or decrement a value.
The following program, ForDemo, uses the general form of the for statement to
print the numbers 1 through 10 to standard output:
class ForDemo {
public static void main(String[] args){
for(int i=1; i<11; i++){
System.out.println("Count is: "
+ i);
}
}
}
The output of this program is:
Count is: 1
Count is: 2
Count is: 3
Count is: 4
Count is: 5
Count is: 6
Count is: 7
Count is: 8
Count is: 9
Count is: 10
Notice how the code declares a variable within
the initialization expression. The scope of this variable extends from its
declaration to the end of the block governed by the for statement, so it can be
used in the termination and increment expressions as well. If the variable that
controls a for statement is not needed outside of the loop, it's best to
declare the variable in the initialization expression. The names i, j, and k
are often used to control for loops; declaring them within the initialization
expression limits their life span and reduces errors.
The three expressions of the for loop are
optional; an infinite loop can be created as follows:
// infinite loop
for ( ; ; ) {
//
your code goes here
}
The for statement also has another form
designed for iteration through Collections and arrays This form is sometimes referred to as the enhanced
for statement, and can be used to make your loops more compact and easy to
read. To demonstrate, consider the following array, which holds the numbers 1
through 10:
int[] numbers = {1,2,3,4,5,6,7,8,9,10};
The following program, EnhancedForDemo, uses the enhanced for to loop through the
array:
class EnhancedForDemo {
public static void main(String[] args){
int[] numbers =
{1,2,3,4,5,6,7,8,9,10};
for
(int item : numbers) {
System.out.println("Count is: "
+ item);
}
}
}
In this example, the variable item holds the
current value from the numbers array. The output from this program is the same as
before:
Count is: 1
Count is: 2
Count is: 3
Count is: 4
Count is: 5
Count is: 6
Count is: 7
Count is: 8
Count is: 9
Count is: 10
We recommend using this form of the for
statement instead of the general form whenever possible.
Branching Statements
The break Statement
The
break
statement has two forms: labeled and unlabeled. You saw the unlabeled form in
the previous discussion of the switch
statement. You can also use an unlabeled break to
terminate a for, while, or do-while loop,
as shown in the following BreakDemo program:class BreakDemo {
public static void main(String[] args) {
int[] arrayOfInts =
{ 32, 87, 3, 589,
12, 1076, 2000,
8, 622, 127 };
int searchfor = 12;
int i;
boolean foundIt = false;
for (i = 0; i < arrayOfInts.length; i++) {
if (arrayOfInts[i] == searchfor) {
foundIt = true;
break;
}
}
if (foundIt) {
System.out.println("Found " + searchfor + " at index " + i);
} else {
System.out.println(searchfor + " not in the array");
}
}
}
This program searches for the number 12 in an
array. The
break
statement, shown in boldface, terminates the for loop
when that value is found. Control flow then transfers to the statement after
the for loop.
This program's output is:Found 12 at index 4
An unlabeled
break
statement terminates the innermost switch, for, while, or do-while
statement, but a labeled break
terminates an outer statement. The following program, BreakWithLabelDemo, is
similar to the previous program, but uses nested for loops
to search for a value in a two-dimensional array. When the value is found, a
labeled break
terminates the outer for loop
(labeled "search"):
class BreakWithLabelDemo {
public static void main(String[] args) {
int[][] arrayOfInts = {
{ 32, 87, 3, 589 },
{ 12, 1076, 2000, 8 },
{ 622, 127, 77, 955 }
};
int searchfor = 12;
int i;
int j = 0;
boolean foundIt = false;
search:
for (i = 0; i < arrayOfInts.length; i++) {
for (j = 0; j < arrayOfInts[i].length;
j++) {
if (arrayOfInts[i][j] == searchfor) {
foundIt = true;
break search;
}
}
}
if (foundIt) {
System.out.println("Found " + searchfor +
" at " + i + ", " + j);
} else {
System.out.println(searchfor +
" not in the array");
}
}
}
This is the output of the program.
Found 12 at 1, 0
The
break
statement terminates the labeled statement; it does not transfer the flow of
control to the label. Control flow is transferred to the statement immediately
following the labeled (terminated) statement.
The continue Statement
The
continue
statement skips the current iteration of a for, while , or do-while loop.
The unlabeled form skips to the end of the innermost loop's body and evaluates
the boolean
expression that controls the loop. The following program, ContinueDemo , steps through
a String,
counting the occurences of the letter "p". If the current character
is not a p, the continue
statement skips the rest of the loop and proceeds to the next character. If it is
a "p", the program increments the letter count.
class ContinueDemo {
public static void main(String[] args) {
String searchMe
= "peter piper picked a " +
"peck of pickled peppers";
int max = searchMe.length();
int numPs = 0;
for (int i = 0; i < max; i++) {
// interested only in p's
if (searchMe.charAt(i) != 'p')
continue;
// process p's
numPs++;
}
System.out.println("Found " +
numPs + " p's in the string.");
}
}
Here is the output of this program:
Found 9 p's in the string.
To see this effect more clearly, try removing
the
continue statement
and recompiling. When you run the program again, the count will be wrong,
saying that it found 35 p's instead of 9.
A labeled
continue
statement skips the current iteration of an outer loop marked with the given
label. The following example program, ContinueWithLabelDemo, uses
nested loops to search for a substring within another string. Two nested loops
are required: one to iterate over the substring and one to iterate over the
string being searched. The following program, ContinueWithLabelDemo, uses
the labeled form of continue to skip an iteration in the outer loop.
class ContinueWithLabelDemo {
public static void main(String[] args) {
String searchMe
= "Look for a substring in me";
String substring = "sub";
boolean foundIt = false;
int max = searchMe.length() -
substring.length();
test:
for (int i = 0; i <= max; i++) {
int n = substring.length();
int j = i;
int k = 0;
while (n-- != 0) {
if (searchMe.charAt(j++)
!= substring.charAt(k++)) {
continue test;
}
}
foundIt = true;
break test;
}
System.out.println(foundIt ?
"Found it" : "Didn't find it");
}
}
Here is the output from this program.
Found it
The return Statement
The last of the branching statements is the
return
statement. The return
statement exits from the current method, and control flow returns to where the
method was invoked. The return
statement has two forms: one that returns a value, and one that doesn't. To
return a value, simply put the value (or an expression that calculates the
value) after the return
keyword.return ++count;
The data type of the returned value must match
the type of the method's declared return value. When a method is declared
void, use
the form of return that
doesn't return a value.return;
The Classes and Objects lesson will cover everything you need to
know about writing methods.
Classes
and Objects describes how to write the classes from which objects are
created, and how to create and use the objects.
With the knowledge you now have of the basics
of the Java programming language, you can learn to write your own classes. In
this lesson, you will find information about defining your own classes,
including declaring member variables, methods, and constructors.
You will learn to use your classes to create
objects, and how to use the objects you create.
This lesson also covers nesting classes within
other classes, enumerations, and annotations.
Classes
This
section shows you the anatomy of a class, and how to declare fields, methods,
and constructors.
The introduction to object-oriented concepts in
the lesson titled Object-oriented Programming Concepts used
a bicycle class as an example, with racing bikes, mountain bikes, and tandem
bikes as subclasses. Here is sample code for a possible implementation of a
Bicycle class,
to give you an overview of a class declaration. Subsequent sections of this
lesson will back up and explain class declarations step by step. For the
moment, don't concern yourself with the details.public class Bicycle {
// the Bicycle class has
// three fields
public int cadence;
public int gear;
public int speed;
// the Bicycle class has
// one constructor
public Bicycle(int startCadence, int startSpeed, int startGear) {
gear = startGear;
cadence = startCadence;
speed = startSpeed;
}
// the Bicycle class has
// four methods
public void setCadence(int newValue) {
cadence = newValue;
}
public void setGear(int newValue) {
gear = newValue;
}
public void applyBrake(int decrement) {
speed -= decrement;
}
public void speedUp(int increment) {
speed += increment;
}
}
A class declaration for a
MountainBike class
that is a subclass of Bicycle might
look like this:public class MountainBike extends Bicycle {
// the MountainBike subclass has
// one field
public int seatHeight;
// the MountainBike subclass has
// one constructor
public MountainBike(int startHeight, int startCadence,
int startSpeed, int startGear) {
super(startCadence, startSpeed, startGear);
seatHeight = startHeight;
}
// the MountainBike subclass has
// one method
public void setHeight(int newValue) {
seatHeight = newValue;
}
}
MountainBike inherits
all the fields and methods of Bicycle and
adds the field seatHeight and a
method to set it (mountain bikes have seats that can be moved up and down as
the terrain demands).
Declaring Classes
You've seen classes defined in the following
way:
class MyClass {
//
field, constructor, and
//
method declarations
}
This is a class declaration. The class
body (the area between the braces) contains all the code that provides for
the life cycle of the objects created from the class: constructors for initializing
new objects, declarations for the fields that provide the state of the class
and its objects, and methods to implement the behavior of the class and its
objects.
The preceding class declaration is a minimal
one. It contains only those components of a class declaration that are
required. You can provide more information about the class, such as the name of
its superclass, whether it implements any interfaces, and so on, at the start
of the class declaration. For example,
class MyClass extends MySuperClass
implements YourInterface {
//
field, constructor, and
//
method declarations
}
means that MyClass is a subclass of MySuperClass
and that it implements the YourInterface interface.
You can also add modifiers like public
or private at the very beginning—so you can see that the opening line of
a class declaration can become quite complicated. The modifiers public
and private, which determine what other classes can access MyClass, are
discussed later in this lesson. The lesson on interfaces and inheritance will
explain how and why you would use the extends and implements
keywords in a class declaration. For the moment you do not need to worry about
these extra complications.
In general, class declarations can include
these components, in order:
1.
Modifiers such as public, private,
and a number of others that you will encounter later.
2.
The class name, with the initial letter
capitalized by convention.
3.
The name of the class's parent (superclass), if
any, preceded by the keyword extends. A class can only extend
(subclass) one parent.
4.
A comma-separated list of interfaces
implemented by the class, if any, preceded by the keyword implements. A
class can implement more than one interface.
5.
The class body, surrounded by braces, {}.
Declaring Member Variables
There are several kinds of variables:
·
Member
variables in a class—these are called fields.
·
Variables in a
method or block of code—these are called local variables.
·
Variables in
method declarations—these are called parameters.
The
Bicycle class
uses the following lines of code to define its fields:public int cadence;
public int gear;
public int speed;
Field declarations are composed of three
components, in order:
1.
Zero or more
modifiers, such as
public or private.
2.
The field's
type.
3.
The field's
name.
The fields of
Bicycle are
named cadence, gear, and speed and are
all of data type integer (int). The public keyword
identifies these fields as public members, accessible by any object that can
access the class.Access Modifiers
The first (left-most) modifier used lets you
control what other classes have access to a member field. For the moment,
consider only
public and private. Other
access modifiers will be discussed later.
·
public
modifier—the field is accessible from all classes.
·
private
modifier—the field is accessible only within its own class.
In the spirit of encapsulation, it is common to
make fields private. This means that they can only be directly accessed
from the Bicycle class. We still need access to these values, however. This can
be done indirectly by adding public methods that obtain the field values
for us:
public class Bicycle {
private int cadence;
private int gear;
private int speed;
public Bicycle(int startCadence, int startSpeed, int startGear) {
gear = startGear;
cadence = startCadence;
speed = startSpeed;
}
public int getCadence() {
return cadence;
}
public void setCadence(int newValue) {
cadence = newValue;
}
public int getGear() {
return gear;
}
public void setGear(int newValue) {
gear = newValue;
}
public int getSpeed() {
return speed;
}
public void applyBrake(int decrement) {
speed -= decrement;
}
public void speedUp(int increment) {
speed += increment;
}
}
Types
All variables must have a type. You can use
primitive types such as
int, float, boolean, etc.
Or you can use reference types, such as strings, arrays, or objects.Variable Names
All variables, whether they are fields, local
variables, or parameters, follow the same naming rules and conventions that
were covered in the Language Basics lesson, Variables—Naming.
In this lesson, be aware that the same naming
rules and conventions are used for method and class names, except that
·
the first letter
of a class name should be capitalized, and
·
the first (or
only) word in a method name should be a verb.
Defining Methods
Here is an example of a typical method
declaration:
public double calculateAnswer(double wingSpan, int numberOfEngines,
double length, double grossTons) {
//do the calculation here
}
The only required elements of a method
declaration are the method's return type, name, a pair of parentheses,
(),
and a body between braces, {}.
More generally, method declarations have six
components, in order:
1.
Modifiers—such
as
public,
private,
and others you will learn about later.
2.
The return
type—the data type of the value returned by the method, or
void if the method
does not return a value.
3.
The method
name—the rules for field names apply to method names as well, but the
convention is a little different.
4.
The parameter
list in parenthesis—a comma-delimited list of input parameters, preceded by
their data types, enclosed by parentheses,
().
If there are no parameters, you must use empty parentheses.
5.
An exception
list—to be discussed later.
6.
The method
body, enclosed between braces—the method's code, including the declaration of
local variables, goes here.
Modifiers, return types, and parameters will be
discussed later in this lesson. Exceptions are discussed in a later lesson.
Definition: Two of the components of a method declaration comprise the method
signature—the method's name and the parameter types.
The signature of the method declared above is:
calculateAnswer(double, int, double, double)
Naming a Method
Although a method name can be any legal
identifier, code conventions restrict method names. By convention, method names
should be a verb in lowercase or a multi-word name that begins with a verb in
lowercase, followed by adjectives, nouns, etc. In multi-word names, the first
letter of each of the second and following words should be capitalized. Here
are some examples:
run
runFast
getBackground
getFinalData
compareTo
setX
isEmpty
Typically, a method has a unique name within
its class. However, a method might have the same name as other methods due to method
overloading.
Overloading Methods
The Java programming language supports overloading
methods, and Java can distinguish between methods with different method
signatures. This means that methods within a class can have the same name
if they have different parameter lists (there are some qualifications to this
that will be discussed in the lesson titled "Interfaces and
Inheritance").
Suppose that you have a class that can use
calligraphy to draw various types of data (strings, integers, and so on) and
that contains a method for drawing each data type. It is cumbersome to use a
new name for each method—for example,
drawString, drawInteger, drawFloat, and so on. In the Java programming
language, you can use the same name for all the drawing methods but pass a
different argument list to each method. Thus, the data drawing class might
declare four methods named draw, each of which has a different parameter list.public class DataArtist {
...
public void draw(String s) {
...
}
public void draw(int i) {
...
}
public void draw(double f) {
...
}
public void draw(int i, double f) {
...
}
}
Overloaded methods are differentiated by the
number and the type of the arguments passed into the method. In the code
sample,
draw(String
s) and draw(int i) are distinct and unique methods because
they require different argument types.
You cannot declare more than one method with
the same name and the same number and type of arguments, because the compiler
cannot tell them apart.
The compiler does not consider return type when
differentiating methods, so you cannot declare two methods with the same
signature even if they have a different return type.
Note: Overloaded methods should be used sparingly, as they can make
code much less readable.
Providing Constructors
for Your Classes
A class contains constructors that are invoked
to create objects from the class blueprint. Constructor declarations look like
method declarations—except that they use the name of the class and have no
return type. For example, Bicycle has one constructor:
public Bicycle(int startCadence, int
startSpeed, int startGear) {
gear
= startGear;
cadence = startCadence;
speed
= startSpeed;
}
To create a new Bicycle object called myBike, a
constructor is called by the new operator:
Bicycle myBike = new Bicycle(30, 0, 8);
new Bicycle(30, 0, 8) creates space in memory
for the object and initializes its fields.
Although Bicycle only has one constructor, it
could have others, including a no-argument constructor:
public Bicycle() {
gear
= 1;
cadence = 10;
speed
= 0;
}
Bicycle yourBike = new Bicycle(); invokes the
no-argument constructor to create a new Bicycle object called yourBike.
Both constructors could have been declared in Bicycle
because they have different argument lists. As with methods, the Java platform
differentiates constructors on the basis of the number of arguments in the list
and their types. You cannot write two constructors that have the same number
and type of arguments for the same class, because the platform would not be
able to tell them apart. Doing so causes a compile-time error.
You don't have to provide any constructors for
your class, but you must be careful when doing this. The compiler automatically
provides a no-argument, default constructor for any class without constructors.
This default constructor will call the no-argument constructor of the
superclass. In this situation, the compiler will complain if the superclass
doesn't have a no-argument constructor so you must verify that it does. If your
class has no explicit superclass, then it has an implicit superclass of Object,
which does have a no-argument constructor.
You can use a superclass constructor yourself.
The MountainBike class at the beginning of this lesson did just that. This will
be discussed later, in the lesson on interfaces and inheritance.
You can use access modifiers in a constructor's
declaration to control which other classes can call the constructor.
Note: If another class cannot call a MyClass
constructor, it cannot directly create MyClass objects.
Passing Information to a Method or a Constructor
The declaration for a method or a constructor
declares the number and the type of the arguments for that method or
constructor. For example, the following is a method that computes the monthly
payments for a home loan, based on the amount of the loan, the interest rate,
the length of the loan (the number of periods), and the future value of the
loan:
public double computePayment(
double loanAmt,
double rate,
double futureValue,
int numPeriods) {
double interest = rate / 100.0;
double partial1 = Math.pow((1 + interest),
- numPeriods);
double denominator = (1 - partial1) / interest;
double answer = (-loanAmt / denominator)
- ((futureValue * partial1) / denominator);
return answer;
}
This method has four parameters: the loan
amount, the interest rate, the future value and the number of periods. The
first three are double-precision floating point numbers, and the fourth is an
integer. The parameters are used in the method body and at runtime will take on
the values of the arguments that are passed in.
Note: Parameters refers to the list of variables in a method
declaration. Arguments are the actual values that are passed in when the
method is invoked. When you invoke a method, the arguments used must match the
declaration's parameters in type and order.
Parameter Types
You can use any data type for a parameter of a
method or a constructor. This includes primitive data types, such as doubles,
floats, and integers, as you saw in the
computePayment method, and reference data types, such
as objects and arrays.
Here's an example of a method that accepts an
array as an argument. In this example, the method creates a new
Polygon
object and initializes it from an array of Point objects (assume that Point
is a class that represents an x, y coordinate):public Polygon polygonFrom(Point[] corners) {
// method body goes here
}
Note: The Java programming language doesn't let you pass methods
into methods. But you can pass an object into a method and then invoke the
object's methods.
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.
Parameter Names
When you declare a parameter to a method or a
constructor, you provide a name for that parameter. This name is used within
the method body to refer to the passed-in argument.
The name of a parameter must be unique in its
scope. It cannot be the same as the name of another parameter for the same
method or constructor, and it cannot be the name of a local variable within the
method or constructor.
A parameter can have the same name as one of
the class's fields. If this is the case, the parameter is said to shadow
the field. Shadowing fields can make your code difficult to read and is
conventionally used only within constructors and methods that set a particular
field. For example, consider the following
Circle class and its setOrigin method:public class Circle {
private int x, y, radius;
public void setOrigin(int x, int y) {
...
}
}
The
Circle class has three fields: x,
y,
and radius.
The setOrigin
method has two parameters, each of which has the same name as one of the
fields. Each method parameter shadows the field that shares its name. So using
the simple names x or y within the body of the method refers to the
parameter, not to the field. To access the field, you must use a
qualified name. This will be discussed later in this lesson in the section
titled "Using the this Keyword."Passing Primitive Data Type Arguments
Primitive arguments, such as an
int
or a double,
are passed into methods by value. This means that any changes to the
values of the parameters exist only within the scope of the method. When the
method returns, the parameters are gone and any changes to them are lost. Here
is an example:public class PassPrimitiveByValue {
public static void main(String[] args) {
int x = 3;
// invoke passMethod() with
// x as argument
passMethod(x);
// print x to see if its
// value has changed
System.out.println("After invoking passMethod, x = " + x);
}
// change parameter in passMethod()
public static void passMethod(int p) {
p = 10;
}
}
When you run this program, the output is:
After invoking passMethod, x = 3
Passing Reference Data Type Arguments
Reference data type parameters, such as
objects, are also passed into methods by value. This means that when the
method returns, the passed-in reference still references the same object as
before. However, the values of the object's fields can be changed
in the method, if they have the proper access level.
For example, consider a method in an arbitrary
class that moves
Circle objects:public void moveCircle(Circle circle, int deltaX, int deltaY) {
// code to move origin of
// circle to x+deltaX, y+deltaY
circle.setX(circle.getX() + deltaX);
circle.setY(circle.getY() + deltaY);
// code to assign a new
// reference to circle
circle = new Circle(0, 0);
}
Let the method be invoked with these arguments:
moveCircle(myCircle, 23, 56)
Inside the method,
circle
initially refers to myCircle. The method changes the x and y coordinates
of the object that circle references (i.e., myCircle)
by 23 and 56, respectively. These changes will persist when the method returns.
Then circle
is assigned a reference to a new Circle object with x = y = 0. This
reassignment has no permanence, however, because the reference was passed in by
value and cannot change. Within the method, the object pointed to by circle
has changed, but, when the method returns, myCircle still references the same Circle
object as before the method was called.Objects
This
section covers creating and using objects. You will learn how to instantiate an
object, and, once instantiated, how to use the
dot operator to access the
object's instance variables and methods.
A typical Java program creates many objects,
which as you know, interact by invoking methods. Through these object
interactions, a program can carry out various tasks, such as implementing a
GUI, running an animation, or sending and receiving information over a network.
Once an object has completed the work for which it was created, its resources
are recycled for use by other objects.
Here's a small program, called
CreateObjectDemo, that
creates three objects: one Point object and two Rectangle objects. You will
need all three source files to compile this program.
public class CreateObjectDemo {
public static void main(String[] args) {
// Declare and create a point object
// and two rectangle objects.
Point originOne = new Point(23, 94);
Rectangle rectOne = new
Rectangle(originOne, 100, 200);
Rectangle rectTwo =
new Rectangle(50, 100);
// display rectOne's width,
// height, and area
System.out.println("Width of rectOne: "
+ rectOne.width);
System.out.println("Height of rectOne: "
+ rectOne.height);
System.out.println("Area of rectOne: "
+ rectOne.getArea());
// set rectTwo's position
rectTwo.origin = originOne;
// display rectTwo's position
System.out.println("X Position of rectTwo: "
+ rectTwo.origin.x);
System.out.println("Y Position of rectTwo: "
+ rectTwo.origin.y);
// move rectTwo and display
// its new position
rectTwo.move(40, 72);
System.out.println("X Position of rectTwo: "
+ rectTwo.origin.x);
System.out.println("Y Position of rectTwo: "
+ rectTwo.origin.y);
}
}
This program creates, manipulates, and displays
information about various objects. Here's the output:
Width of rectOne: 100
Height of rectOne: 200
Area of rectOne: 20000
X Position of rectTwo: 23
Y Position of rectTwo: 94
X Position of rectTwo: 40
Y Position of rectTwo: 72
The following three sections use the above
example to describe the life cycle of an object within a program. From them,
you will learn how to write code that creates and uses objects in your own
programs. You will also learn how the system cleans up after an object when its
life has ended.
Creating Objects
As you know, a class provides the blueprint for
objects; you create an object from a class. Each of the following statements taken
from the
CreateObjectDemo program creates an object and
assigns it to a variable:Point originOne = new Point(23, 94);
Rectangle rectOne = new Rectangle(originOne, 100, 200);
Rectangle rectTwo = new Rectangle(50, 100);
The first line creates an object of the
Point class, and the second and third lines each
create an object of the Rectangle class.
Each of these statements has three parts
(discussed in detail below):
1.
Declaration:
The code set in bold are all variable
declarations that associate a variable name with an object type.
2.
Instantiation:
The new
keyword is a Java operator that creates the object.
3.
Initialization:
The new
operator is followed by a call to a constructor, which initializes the new
object.
Declaring a Variable to Refer to an Object
Previously, you learned that to declare a
variable, you write:
type name;
This notifies the compiler that you will use name
to refer to data whose type is type. With a primitive variable,
this declaration also reserves the proper amount of memory for the variable.
You can also declare a reference variable on
its own line. For example:
Point originOne;
If you declare
originOne like this,
its value will be undetermined until an object is actually created and assigned
to it. Simply declaring a reference variable does not create an object. For
that, you need to use the new operator, as described in the next section. You
must assign an object to originOne before you use it in your code. Otherwise,
you will get a compiler error.
A variable in this state, which currently
references no object, can be illustrated as follows (the variable name,
originOne,
plus a reference pointing to nothing):
Instantiating a Class
The new operator instantiates a class by allocating memory
for a new object and returning a reference to that memory. The new
operator also invokes the object constructor.
Note: The phrase "instantiating a class" means the same
thing as "creating an object." When you create an object, you are
creating an "instance" of a class, therefore "instantiating"
a class.
The new operator requires a single, postfix argument: a
call to a constructor. The name of the constructor provides the name of the
class to instantiate.
The new operator returns a reference to the object it
created. This reference is usually assigned to a variable of the appropriate
type, like:
Point originOne = new Point(23, 94);
The reference returned by the new
operator does not have to be assigned to a variable. It can also be used
directly in an expression. For example:
int height = new Rectangle().height;
Initializing an Object
Here's the code for the Point
class:
public class Point {
public int x = 0;
public int y = 0;
//constructor
public Point(int a, int b) {
x = a;
y = b;
}
}
This class contains a single constructor. You
can recognize a constructor because its declaration uses the same name as the
class and it has no return type. The constructor in the Point
class takes two integer arguments, as declared by the code (int a, int b).
The following statement provides 23 and 94 as values for those arguments:
Point originOne = new Point(23, 94);
The result of executing this statement can be
illustrated in the next figure:
Here's the code for the Rectangle
class, which contains four constructors:
public class Rectangle {
public int width = 0;
public int height = 0;
public Point origin;
// four constructors
public Rectangle() {
origin = new Point(0, 0);
}
public Rectangle(Point p) {
origin = p;
}
public Rectangle(int w, int h) {
origin = new Point(0, 0);
width = w;
height = h;
}
public Rectangle(Point p, int w, int h) {
origin = p;
width = w;
height = h;
}
// a method for moving the rectangle
public void move(int x, int y) {
origin.x = x;
origin.y = y;
}
// a method for computing the area
// of the rectangle
public int getArea() {
return width * height;
}
}
Each constructor lets you provide initial
values for the rectangle's size and width, using both primitive and reference
types. If a class has multiple constructors, they must have different signatures.
The Java compiler differentiates the constructors based on the number and the
type of the arguments. When the Java compiler encounters the following code, it
knows to call the constructor in the Rectangle class that requires a Point
argument followed by two integer arguments:
Rectangle rectOne = new Rectangle(originOne, 100, 200);
This calls one of
Rectangle's
constructors that initializes origin to originOne. Also, the constructor sets width
to 100 and height
to 200. Now there are two references to the same Point object—an object
can have multiple references to it, as shown in the next figure:
The following line of code calls the
Rectangle
constructor that requires two integer arguments, which provide the initial
values for width
and height.
If you inspect the code within the constructor, you will see that it creates a
new Point
object whose x
and y
values are initialized to 0:Rectangle rectTwo = new Rectangle(50, 100);
The Rectangle constructor used in the following statement
doesn't take any arguments, so it's called a no-argument constructor:
Rectangle rect = new Rectangle();
All classes have at least one constructor. If a
class does not explicitly declare any, the Java compiler automatically provides
a no-argument constructor, called the default constructor. This default
constructor calls the class parent's no-argument constructor, or the
Object
constructor if the class has no other parent. If the parent has no constructor
(Object
does have one), the compiler will reject the program.Using Objects
Once you've created an object, you probably
want to use it for something. You may need to use the value of one of its
fields, change one of its fields, or call one of its methods to perform an
action.
Referencing an Object's Fields
Object fields are accessed by their name. You
must use a name that is unambiguous.
You may use a simple name for a field within
its own class. For example, we can add a statement within the
Rectangle class
that prints the width and height:System.out.println("Width and height are: " + width + ", " + height);
In this case,
width and height are
simple names.
Code that is outside the object's class must
use an object reference or expression, followed by the dot (.) operator,
followed by a simple field name, as in:
objectReference.fieldName
For example, the code in the CreateObjectDemo
class is outside the code for the Rectangle class. So to refer to the origin,
width,
and height
fields within the Rectangle object named rectOne, the CreateObjectDemo
class must use the names rectOne.origin, rectOne.width, and rectOne.height, respectively. The program uses two of
these names to display the width and the height of rectOne:
System.out.println("Width of rectOne: "
+ rectOne.width);
System.out.println("Height of rectOne: "
+ rectOne.height);
Attempting to use the simple names width
and height
from the code in the CreateObjectDemo class doesn't make sense — those
fields exist only within an object — and results in a compiler error.
Later, the program uses similar code to display
information about rectTwo. Objects of the same type have their own copy
of the same instance fields. Thus, each Rectangle object has fields named origin,
width,
and height.
When you access an instance field through an object reference, you reference
that particular object's field. The two objects rectOne and rectTwo
in the CreateObjectDemo
program have different origin, width, and height fields.
To access a field, you can use a named
reference to an object, as in the previous examples, or you can use any
expression that returns an object reference. Recall that the new
operator returns a reference to an object. So you could use the value returned
from new to access a new object's fields:
int height = new Rectangle().height;
This statement creates a new Rectangle
object and immediately gets its height. In essence, the statement calculates
the default height of a Rectangle. Note that after this statement has been
executed, the program no longer has a reference to the created Rectangle,
because the program never stored the reference anywhere. The object is
unreferenced, and its resources are free to be recycled by the Java Virtual
Machine.
Calling an Object's Methods
You also use an object reference to invoke an
object's method. You append the method's simple name to the object reference,
with an intervening dot operator (.). Also, you provide, within enclosing parentheses,
any arguments to the method. If the method does not require any arguments, use
empty parentheses.
objectReference.methodName(argumentList);
or:
objectReference.methodName();
The Rectangle class has two methods: getArea()
to compute the rectangle's area and move() to change the rectangle's origin. Here's the CreateObjectDemo
code that invokes these two methods:
System.out.println("Area of rectOne: " + rectOne.getArea());
...
rectTwo.move(40, 72);
The first statement invokes rectOne's
getArea() method
and displays the results. The second line moves rectTwo because the move()
method assigns new values to the object's origin.x and origin.y.
As with instance fields, objectReference
must be a reference to an object. You can use a variable name, but you also can
use any expression that returns an object reference. The new
operator returns an object reference, so you can use the value returned from
new to invoke a new object's methods:
new Rectangle(100, 50).getArea()
The expression new Rectangle(100, 50)
returns an object reference that refers to a Rectangle object. As shown, you can use the dot
notation to invoke the new Rectangle's getArea() method to compute the area of the new
rectangle.
Some methods, such as getArea(),
return a value. For methods that return a value, you can use the method
invocation in expressions. You can assign the return value to a variable, use
it to make decisions, or control a loop. This code assigns the value returned
by getArea()
to the variable
areaOfRectangle:int areaOfRectangle = new Rectangle(100, 50).getArea();
Remember, invoking a method on a particular
object is the same as sending a message to that object. In this case, the
object that getArea()
is invoked on is the rectangle returned by the constructor.
The Garbage Collector
Some object-oriented languages require that you
keep track of all the objects you create and that you explicitly destroy them
when they are no longer needed. Managing memory explicitly is tedious and
error-prone. The Java platform allows you to create as many objects as you want
(limited, of course, by what your system can handle), and you don't have to
worry about destroying them. The Java runtime environment deletes objects when
it determines that they are no longer being used. This process is called garbage
collection.
An object is eligible for garbage collection
when there are no more references to that object. References that are held in a
variable are usually dropped when the variable goes out of scope. Or, you can explicitly
drop an object reference by setting the variable to the special value null.
Remember that a program can have multiple references to the same object; all
references to an object must be dropped before the object is eligible for
garbage collection.
The Java runtime environment has a garbage
collector that periodically frees the memory used by objects that are no longer
referenced. The garbage collector does its job automatically when it determines
that the time is right.
Interfaces
and Inheritance describes interfaces—what they are, why you would want
to write one, and how to write one. This section also describes the way in
which you can derive one class from another. That is, how a subclass can
inherit fields and methods from a superclass. You will learn that all
classes are derived from the Object class, and how to modify the methods that a
subclass inherits from superclasses.
Interfaces
There are a number of situations in software
engineering when it is important for disparate groups of programmers to agree
to a "contract" that spells out how their software interacts. Each
group should be able to write their code without any knowledge of how the other
group's code is written. Generally speaking, interfaces are such
contracts.
For example, imagine a futuristic society where
computer-controlled robotic cars transport passengers through city streets
without a human operator. Automobile manufacturers write software (Java, of
course) that operates the automobile—stop, start, accelerate, turn left, and so
forth. Another industrial group, electronic guidance instrument manufacturers,
make computer systems that receive GPS (Global Positioning System) position data
and wireless transmission of traffic conditions and use that information to
drive the car.
The auto manufacturers must publish an
industry-standard interface that spells out in detail what methods can be
invoked to make the car move (any car, from any manufacturer). The guidance
manufacturers can then write software that invokes the methods described in the
interface to command the car. Neither industrial group needs to know how
the other group's software is implemented. In fact, each group considers its software
highly proprietary and reserves the right to modify it at any time, as long as
it continues to adhere to the published interface.
Interfaces in Java
In the Java programming language, an interface
is a reference type, similar to a class, that can contain only
constants, method signatures, and nested types. There are no method bodies.
Interfaces cannot be instantiated—they can only be implemented by
classes or extended by other interfaces. Extension is discussed later in
this lesson.
Defining an interface is similar to creating a
new class:
public interface OperateCar {
// constant declarations, if any
// method signatures
// An enum with values RIGHT, LEFT
int turn(Direction direction,
double radius,
double startSpeed,
double endSpeed);
int changeLanes(Direction direction,
double startSpeed,
double endSpeed);
int signalTurn(Direction direction,
boolean signalOn);
int getRadarFront(double distanceToCar,
double speedOfCar);
int getRadarRear(double distanceToCar,
double speedOfCar);
......
// more method signatures
}
Note that the method signatures have no braces
and are terminated with a semicolon.
To use an interface, you write a class that implements
the interface. When an instantiable class implements an interface, it provides
a method body for each of the methods declared in the interface. For example,
public class OperateBMW760i implements OperateCar {
// the OperateCar method signatures, with implementation --
// for example:
int signalTurn(Direction direction, boolean signalOn) {
// code to turn BMW's LEFT turn indicator lights on
// code to turn BMW's LEFT turn indicator lights off
// code to turn BMW's RIGHT turn indicator lights on
// code to turn BMW's RIGHT turn indicator lights off
}
// other members, as needed -- for example, helper classes not
// visible to clients of the interface
}
In the robotic car example above, it is the
automobile manufacturers who will implement the interface. Chevrolet's
implementation will be substantially different from that of Toyota, of course,
but both manufacturers will adhere to the same interface. The guidance
manufacturers, who are the clients of the interface, will build systems that
use GPS data on a car's location, digital street maps, and traffic data to
drive the car. In so doing, the guidance systems will invoke the interface
methods: turn, change lanes, brake, accelerate, and so forth.
Interfaces as APIs
The robotic car example shows an interface
being used as an industry standard Application Programming Interface (API).
APIs are also common in commercial software products. Typically, a company
sells a software package that contains complex methods that another company
wants to use in its own software product. An example would be a package of
digital image processing methods that are sold to companies making end-user
graphics programs. The image processing company writes its classes to implement
an interface, which it makes public to its customers. The graphics company then
invokes the image processing methods using the signatures and return types
defined in the interface. While the image processing company's API is made
public (to its customers), its implementation of the API is kept as a closely
guarded secret—in fact, it may revise the implementation at a later date as
long as it continues to implement the original interface that its customers
have relied on.
Interfaces and Multiple Inheritance
Interfaces have another very important role in
the Java programming language. Interfaces are not part of the class hierarchy,
although they work in combination with classes. The Java programming language
does not permit multiple inheritance (inheritance is discussed later in this
lesson), but interfaces provide an alternative.
In Java, a class can inherit from only one
class but it can implement more than one interface. Therefore, objects can have
multiple types: the type of their own class and the types of all the interfaces
that they implement. This means that if a variable is declared to be the type
of an interface, its value can reference any object that is instantiated from
any class that implements the interface. This is discussed later in this
lesson, in the section titled "Using an Interface as a Type."
Numbers
and Strings This lesson describes how to use Number and String objects
The lesson also shows you how to format data for output.
Generics
are a powerful feature of the Java programming language. They improve the type
safety of your code, making more of your bugs detectable at compile time.
Packages
are a feature of the Java programming language that help you to organize and
structure your classes and their relationships to one another.
Tag
Programming
0
Tidak ada komentar:
Posting Komentar
Assalamu'alaikum, dipersilakan untuk berkenan memberikan tanggapan komentar yang sekiranya menambah berbobot atas artikel-artikel di blog ini. Mohon maaf jika isi artikel ini dikutip/ dicopas dari berbagai sumber..