1 chapter 4 language fundamentals. 2 identifiers program parts such as packages, classes, and class...
Post on 20-Dec-2015
213 views
TRANSCRIPT
2
Identifiers
• Program parts such as packages, classes, and class members have names, which are formally known as identifiers.
• Java, like all languages, has rules that govern identifiers.
• The compiler generates errors on invalid identifiers.
3
Identifiers
• A valid identifier must begin with a letter, an underscore (_), or a dollar sign ($).
• The remaining characters must be letters, numerals, underscores, or dollar signs.
• Because compiler-generated identifiers typically include the dollar sign, the programmer typically does not use this symbol.
4
Variables
• A variable is a named storage cell that can hold a value of a particular type.
• A variable must be declared before used. A declaration provides the name, which must be a valid identifier, and the data type together with any attributes such as public. A sample is
int n; // n is the name, int the type
5
Variables
• Variables occur as class fields and as local variables in constructors and methods.
• Fields have default values. For example, integer fields default to 0, floating-point fields to 0.0, and Boolean fields to false.– Object references default to the special value null.
6
Local variables
• Local variables, unlike fields, do not have default values.
• A local variable’s value must be set before using the variable, for example, in a function call or as the source of an assignment operation.
• A variable can be declared final to mark the variable as a constant.
7
Constructors and methods
• All Java functions are encapsulated as either constructors or methods.
• A constructor has the same name as its encapsulating class and no return type or void in place of a return type. For instance, a Date constructor would have the name Date.
8
Constructors and methods
• Constructors are used with the new operator to construct instances of a class. The statement
Date today = new Date();
illustrates.
• Constructors are typically overloaded; that is, a class typically has several constructors.
9
Constructors and methods
• A method does not have the same name as its encapsulating class and has either a return type or void in place of a return type.
• Methods define the operations appropriate to a class and its instances.
10
Constructors and methods
• A constructor cannot be static, but a method can be static.
• Constructors and methods can be parameterized. The parameter names and data types must be provided.
• Methods, like constructors, can be overloaded but must be distinguished by their names and/or parameter types.
11
Primitive types
• Java has standard class types such as Date and standard nonclass or primitive types such as int and double.
• Integer types have fixed bit sizes and ranges. For instance, a byte is 8 bits, its minimum value is -128, and its maximum value is +127.
12
Integer types
• The integer types (with bit sizes in parentheses) are byte (8), short (16), int (32), and long (64).
• All integer types are signed and have 2’s complement internal representation.
• An integer constant such as 12 is of type int, whereas 12L and 12l are of type long.
13
Integer types
• A decimal constant must not begin with a 0. An octal constant begins with a 0 and a hexadecimal constant begins with 0x or 0X.
• The java.math package has a BigInteger class for arbitrary-precision integer arithmetic.
14
Floating-point types
• The floating-point types are float (32 bits) and double (64 bits).
• A floating-point constant such as 3.14 is of type double, whereas 3.14F and 3.14f are of type float.
• The floating-point types follow the IEEE 754 floating-point standard.
15
Cast operations
• The code segment
float f = 3.14; //*** ERROR
is in error because it tries to assign a double value to a float variable. The problem can be corrected in several ways, including a cast operation
float f = (float) 3.14; // ok
16
Cast operations
• In a cast operation, the target type is enclosed in parentheses.
• Java imposes restrictions on casts. For example, a boolean value such as true cannot be cast to any other type, and no nonboolean value can be cast to boolean.
• Casts should be used with great caution.
17
Arithmetic operators
• Java supports the usual arithmetic operations: addition (+), subtraction (-), multiplication (*), division (/), and remainder (%).
• The arithmetic operators apply to integer and floating-point operands.
• Java also provides bit and shift operators for integers.
18
Assignment operators
• The symbol = is the basic assignment operator.
• Java also provides special assignment operators such as +=, *=, and the like.– The code segment
int x = 4; x *= 6; // x is 24
illustrates.
19
Character type
• The char is based on 16-bit Unicode characters.
• Character literals are placed in single quotes. For instance, ‘A’ is a character literal that could be assigned to a char variable.
• Special characters such as ‘\n’ (newline) begin with a backslash.
20
Character type
• Arithmetic and relational operations can be performed on characters. The code segment
char c1 = ‘A’, char c2 = c1 + 1; // ‘B’
if ( c2 > c1 ) // true
...
illustrates.
21
Boolean type
• The boolean type has two values, true and false.
• Boolean values are not integer values.
• Boolean values cannot be cast.
• Boolean expressions are used in if statements, loops, and relational expressions.
22
Relational operators
• Java has the standard relational operators for comparing values: greater than (>), less than (<), greater than or equal to (>=), less than or equal to (<=), equals (==), and not equals (!=).
• The equality operator should be used with caution on floating-point values and object references.
23
Logical operators
• Java has the standard logical operators: and (&&), inclusive-or (||), and not (!).
• Evaluation of a logical-and expression terminates with a value of false at the first false subexpression.
• Evaluation of a logical-or expression terminates with a value of true at the first true subexpression.
24
Logical operators
• Logical expressions evaluate left to right.
• The bit operators & and |behave as logical operators if their operands are booleans instead of integers.
25
instanceof operator
• This operator tests whether an object instantiates a class. The code segment
Date d = new Date(); if ( d instanceof Object ) // false
...
else if ( d instanceof Date ) // true
...
illustrates.
26
Arrays
• Arrays of primitive and class types are supported.
• Arrays are fixed size.• Arrays constructed with new
int[ ] nums = new int[ 100 ];
have their elements initialized to the appropriate default value (e.g., 0 for numbers and false for Booleans).
27
Arrays
• Arrays can be initialized in their declarations. The code segment
int[ ] nums = { 1, 2, 3 };
illustrates.
• “Multidimensional” arrays are supported:
int[ ][ ] nums = new int[ 2 ][ 4 ];
28
Arrays
• All arrays have a convenient length member:
int[ ] nums1 = new int[ 10 ];
int n1 = nums1.length; // 10
int[ ][ ] nums2 = new int[ 2 ][ 4 ];
int n2 = nums2.length; // 2
int n3 = nums2[ 0 ].length // 4
29
Arrays
• A “multidimensional” array is really an array of arrays. For instance,
int[ ][ ] nums = new int[ 2 ][ 4 ];
is an array of two elements, each of which is an array of four ints.
30
Arrays
• The Java compiler does not perform bounds checking on array accesses:
int[ ] nums = new int[ 10 ]; nums[ -1 ] = 999; // compiles
• The Java runtime throws an exception if an array index is out of bounds.
31
Blocks
• A block is sequence of instructions enclosed in curly braces.
• Variables declared inside a block have block scope; that is, such variables are visible only within their containing block.
• Name conflicts among local variables are not allowed; hence, local variables with the same name must occur in different blocks.
32
Loops
• Java provides three loop constructs: while, do while, and for.
• The while and do while are suited for conditional loops, and the for loop is suited for counted loops.
• Any loop construct can be rewritten in principle with one of the other loop constructs.
33
Loops
• The while loop int i = 0;
final int n = 100;
while ( i < n ){
System.out.println( i );
i = i + 1;
}
prints 0,1,…,99.
34
Loops
• The do while loop int i = 0;
final int n = 100;
do {
System.out.println( i );
i = i + 1;
} while ( i < n; }
prints 0,1,…,99.
35
Loops
• The for loop final int n = 100;
for ( int i = 0; i < n; i++ )
System.out.println( i );
prints 0,1,…,99.
• In a for loop, the three clauses are the initialization, the loop condition, and the post-body expression.
36
Exceptions
• An exception is an unexpected condition that arises during a program’s execution.– For instance, a program might inadvertently
divide an integer by zero, which would cause or “throw” an exception.
• Exception handling is a mechanism for handling exceptions.
37
Exceptions
• The runtime environment implicitly throws an exception whenever a program violates some condition such as trying to open a nonexistent file or dividing an integer by zero.
• A program can explicitly throw an exception with the throw statement.
38
Exceptions
• Code that might throw exceptions is placed in a try block:
try { FileInputStream in =
new FileInputStream( “in.dat” );
//*** remaining code
}
catch( IOException e ) { /*...*/ }
39
Exceptions
• A try block is followed by one or more catch blocks, which represent the exception handlers, or by a finally block, whose code executes regardless of whether an exception is thrown in the corresponding try block.