Java Basic Introduction, Classes and Objects SEEM

Transcription

1 Java Basic Introduction, Classes and Objects SEEM

2 Java A programming language specifies the words and symbols that we can use to write a program A programming language employs a set of rules that dictate how the words and symbols can be put together to form valid program statements The Java programming language was created by Sun Microsystems, Inc. It was introduced in 1995 and it's popularity has grown quickly since SEEM

3 Java Program Structure In the Java programming language: A program is made up of one or more classes A class contains one or more methods A method contains program statements These terms will be explored in detail throughout the course A Java application always contains a method called main SEEM

4 //************************************************ // Lincoln.java // // Demonstrates the basic structure of a Java application. //************************************************ public class Lincoln { // // Prints a presidential quote. // public static void main (String[] args) { System.out.println ("A quote by Abraham Lincoln:"); } } System.out.println ("Whatever you are, be a good one."); SEEM

5 Java Program Structure // comments about the class public class MyProgram { class header class body } Comments can be placed almost anywhere 5

6 Java Program Structure // comments about the class public class MyProgram { // comments about the method public static void main (String[] args) { } method body method header } 6

7 Comments Comments in a program are called inline documentation They should be included to explain the purpose of the program and describe processing steps They do not affect how a program works Java comments can take three forms: // this comment runs to the end of the line /* this comment runs to the terminating symbol, even across line breaks */ /** this is a javadoc comment */ 7

8 Identifiers Identifiers are the words a programmer uses in a program An identifier can be made up of letters, digits, the underscore character ( _ ), and the dollar sign Identifiers cannot begin with a digit Java is case sensitive - Total, total, and TOTAL are different identifiers By convention, programmers use different case styles for different types of identifiers, such as title case for class names - Lincoln upper case for constants - MAXIMUM 8

9 Identifiers Sometimes we choose identifiers ourselves when writing a program (such as Lincoln) Sometimes we are using another programmer's code, so we use the identifiers that he or she chose (such as println) Often we use special identifiers called reserved words that already have a predefined meaning in the language A reserved word cannot be used in any other way SEEM

10 10 Reserved Words The Java reserved words: abstract assert boolean break byte case catch char class const continue default do double else enum extends false final finally float for goto if implements import instanceof int interface long native new null package private protected public return short static strictfp super switch synchronized this throw throws transient true try void volatile while

11 White Space Spaces, blank lines, and tabs are called white space White space is used to separate words and symbols in a program Extra white space is ignored A valid Java program can be formatted many ways Programs should be formatted to enhance readability, using consistent indentation 11

12 Problem Solving The key to designing a solution for a problem is to break it down into manageable pieces When writing software, we design separate pieces that are responsible for certain parts of the solution An object-oriented approach lends itself to this kind of solution decomposition We will dissect our solutions into pieces called objects and classes SEEM

13 Object-Oriented Programming Java is an object-oriented programming language As the term implies, an object is a fundamental entity in a Java program Objects can be used effectively to represent real-world entities For instance, an object might represent a particular employee in a company Each employee object handles the processing and data management related to that employee SEEM

14 Classes and Objects An object is defined by a class A class is the blueprint of an object The class uses methods to define the behaviors of the object The class that contains the main method of a Java program represents the entire program A class represents a concept, and an object represents the embodiment of that concept Multiple objects can be created from the same class SEEM

15 Classes and Objects class (the concept) object (the realization) Bank Account John s Bank Account Balance: $5,257 Multiple objects from the same class Bill s Bank Account Balance: $1,245,069 Mary s Bank Account Balance: $16,833 SEEM

16 Java Translation The Java compiler translates Java source code into a special representation called bytecode Java bytecode is not the machine language for any traditional CPU Another software tool, called an interpreter, translates bytecode into machine language and executes it Therefore the Java compiler is not tied to any particular machine Java is considered to be architecture-neutral 16

17 Java Translation Java source code Bytecode interpreter machine code for target machine 1 Java compiler Java bytecode Bytecode interpreter machine code for target machine 2 17

18 Development Environments There are many programs that support the development of Java software, including: Sun Java Development Kit (JDK) Sun NetBeans IBM Eclipse Borland JBuilder MetroWerks CodeWarrior BlueJ jgrasp Though the details of these environments differ, the basic compilation and execution process is essentially the same SEEM

19 Compiling and Running Java on Unix We can compile a Java program under Unix by: sepc92> javac Countdown.java If the compilation is successful, a bytecode file called Countdown.class will be generated. To invoke Java bytecode interpreter, we can: sepc92> java Countdown Three Two One.. Zero Liftoff! Houston, we have a problem. SEEM

20 Variables A variable is a name for a location in memory A variable must be declared by specifying the variable's name and the type of information that it will hold data type variable name int total; int count, temp, result; Multiple variables can be created in one declaration SEEM

21 Variable Initialization A variable can be given an initial value in the declaration int sum = 0; int base = 32, max = 149; When a variable is referenced in a program, its current value is used SEEM

22 Assignment An assignment statement changes the value of a variable The assignment operator is the = sign total = 55; The expression on the right is evaluated and the result is stored in the variable on the left The value that was in total is overwritten You can only assign a value to a variable that is consistent with the variable's declared type SEEM

23 Constants A constant is an identifier that is similar to a variable except that it holds the same value during its entire existence As the name implies, it is constant, not variable The compiler will issue an error if you try to change the value of a constant In Java, we use the final modifier to declare a constant final int MIN_HEIGHT = 69; SEEM

24 Constants Constants are useful for three important reasons First, they give meaning to otherwise unclear literal values For example, MAX_LOAD means more than the literal 250 Second, they facilitate program maintenance If a constant is used in multiple places, its value need only be updated in one place Third, they formally establish that a value should not change, avoiding inadvertent errors by other programmers SEEM

25 Primitive Data There are eight primitive data types in Java Four of them represent integers: byte, short, int, long Two of them represent floating point numbers: float, double One of them represents characters: char And one of them represents boolean values: boolean SEEM

26 Numeric Primitive Data The difference between the various numeric primitive types is their size, and therefore the values they can store: Type Storage Min Value Max Value byte short int long 8 bits 16 bits 32 bits 64 bits ,768-2,147,483,648 < -9 x ,767 2,147,483,647 > 9 x float double 32 bits 64 bits +/- 3.4 x with 7 significant digits +/- 1.7 x with 15 significant digits SEEM

27 Characters A char variable stores a single character Character literals are delimited by single quotes: 'a' 'X' '7' '$' ',' '\n' Example declarations: char topgrade = 'A'; char terminator = ';', separator = ' '; Note the distinction between a primitive character variable, which holds only one character, and a String object, which can hold multiple characters SEEM

28 Character Sets A character set is an ordered list of characters, with each character corresponding to a unique number A char variable in Java can store any character from the Unicode character set The Unicode character set uses sixteen bits per character, allowing for 65,536 unique characters It is an international character set, containing symbols and characters from many world languages SEEM

29 Characters The ASCII character set is older and smaller than Unicode, but is still quite popular The ASCII characters are a subset of the Unicode character set, including: uppercase letters lowercase letters punctuation digits special symbols control characters A, B, C, a, b, c, period, semi-colon, 0, 1, 2, &,, \, carriage return, tab,... SEEM

30 Boolean A boolean value represents a true or false condition The reserved words true and false are the only valid values for a boolean type boolean done = false; A boolean variable can also be used to represent any two states, such as a light bulb being on or off SEEM

31 Expression An expression is a combination of one or more operators and operands Arithmetic expressions compute numeric results and make use of the arithmetic operators: Addition Subtraction Multiplication Division Remainder + - * / % If either or both operands used by an arithmetic operator are floating point, then the result is a floating point SEEM

32 Division and Remainder If both operands to the division operator (/) are integers, the result is an integer (the fractional part is discarded) 14 / 3 equals 8 / 12 equals 4 0 The remainder operator (%) returns the remainder after dividing the second operand into the first 14 % 3 equals 8 % 12 equals 2 8 SEEM

33 Operator Precedence Operators can be combined into complex expressions result = total + count / max - offset; Operators have a well-defined precedence which determines the order in which they are evaluated Multiplication, division, and remainder are evaluated prior to addition, subtraction, and string concatenation Arithmetic operators with the same precedence are evaluated from left to right, but parentheses can be used to force the evaluation order SEEM

34 Operator Precedence What is the order of evaluation in the following expressions? a + b + c + d + e a + b * c - d / e a / (b + c) - d % e a / (b * (c + (d - e))) SEEM

35 Expression Tree The evaluation of a particular expression can be shown using an expression tree The operators lower in the tree have higher precedence for that expression + a + (b c) / d a / - d b c SEEM

36 Assignment Revisited The assignment operator has a lower precedence than the arithmetic operators First the expression on the right hand side of the = operator is evaluated answer = sum / 4 + MAX * lowest; Then the result is stored in the variable on the left hand side SEEM

37 Assignment Revisited The right and left hand sides of an assignment statement can contain the same variable First, one is added to the original value of count count = count + 1; Then the result is stored back into count (overwriting the original value) SEEM

38 Increment and Decrement The increment and decrement operators use only one operand The increment operator (++) adds one to its operand The decrement operator (--) subtracts one from its operand The statement count++; is functionally equivalent to count = count + 1; 38

39 Increment and Decrement The increment and decrement operators can be applied in postfix form: or prefix form: count++ ++count When used as part of a larger expression, the two forms can have different effects Because of their subtleties, the increment and decrement operators should be used with care 39

40 Increment and Decrement Suppose count has a value of 15 Consider the following statement: total = count++ After the assignment, total has a value of 15, whereas count has a value of 16 Consider the following statement: total = ++count Both total and count have a value of 16 40

41 Assignment Operators Often we perform an operation on a variable, and then store the result back into that variable Java provides assignment operators to simplify that process For example, the statement is equivalent to num += count; num = num + count; 41

42 Assignment Operators There are many assignment operators in Java, including the following: Operator += -= *= /= %= Example x += y x -= y x *= y x /= y x %= y Equivalent To x = x + y x = x - y x = x * y x = x / y x = x % y 42

43 Assignment Operators The right hand side of an assignment operator can be a complex expression The entire right-hand expression is evaluated first, then the result is combined with the original variable Therefore result /= (total-min) % num; is equivalent to result = result / ((total-min) % num); 43

44 Assignment Operators The behavior of some assignment operators depends on the types of the operands If the operands to the += operator are strings, the assignment operator performs string concatenation The behavior of an assignment operator (+=) is always consistent with the behavior of the corresponding operator (+) SEEM

45 String Concatenation The string concatenation operator (+) is used to append one string to the end of another "Peanut butter " + "and jelly" It can also be used to append a number to a string A string literal cannot be broken across two lines in a program See Facts.java The println method can print a character string SEEM

46 //******************************************************** // Facts.java // // Demonstrates the use of the string concatenation operator and the // automatic conversion of an integer to a string. //******************************************************* public class Facts { // // Prints various facts. // public static void main (String[] args) { // Strings can be concatenated into one long string System.out.println ("We present the following facts for your " + "extracurricular edification:"); System.out.println (); // A string can contain numeric digits System.out.println ("Letters in the Hawaiian alphabet: 12"); // A numeric value can be concatenated to a string System.out.println ("Dialing code for Antarctica: " + 672); System.out.println ("Year in which Leonardo da Vinci invented " + "the parachute: " ); System.out.println ("Speed of ketchup: " " km per year"); } } SEEM

47 String Concatenation The + operator is also used for arithmetic addition The function that it performs depends on the type of the information on which it operates If both operands are strings, or if one is a string and one is a number, it performs string concatenation If both operands are numeric, it adds them The + operator is evaluated left to right, but parentheses can be used to force the order SEEM

48 Escape Sequences What if we wanted to print a the quote character? The following line would confuse the compiler because it would interpret the second quote as the end of the string System.out.println ("I said "Hello" to you."); An escape sequence is a series of characters that represents a special character An escape sequence begins with a backslash character (\) System.out.println ("I said \"Hello\" to you."); SEEM

49 Escape Sequences Some Java escape sequences: Escape Sequence \b \t \n \r \" \' \\ Meaning backspace tab newline carriage return double quote single quote backslash SEEM

50 Character Strings A string of characters can be represented as a string literal by putting double quotes around the text: Examples: "This is a string literal." "123 Main Street" "X" Every character string is an object in Java, defined by the String class Every string literal represents a String object SEEM

51 The println Method In the previous Lincoln program, we invoked the println method to print a character string System.out is a built-in object representing a destination (the monitor screen) to which we can send output System.out.println ("Whatever you are, be a good one."); object method name information provided to the method (parameters) SEEM

52 The print Method The System.out object provides another service as well The print method is similar to the println method, except that it does not advance to the next line Therefore anything printed after a print statement will appear on the same line See Countdown.java SEEM

53 //************************************************ // Countdown.java // // Demonstrates the difference between print and println. //************************************************ public class Countdown { // // Prints two lines of output representing a rocket countdown. // public static void main (String[] args) { System.out.print ("Three... "); System.out.print ("Two... "); System.out.print ("One... "); System.out.print ("Zero... "); System.out.println ("Liftoff!"); // appears on first output line } } System.out.println ("Houston, we have a problem."); SEEM

54 Interactive Programs Programs generally need input on which to operate The built-in Scanner class provides convenient methods for reading input values of various types A Scanner object (called scan) can be set up to read input from various sources, including the user typing values on the keyboard Keyboard input is represented by the System.in object SEEM

55 Reading Input The following line creates a Scanner object, called scan, that reads from the keyboard: Scanner scan = new Scanner (System.in); The new operator creates the Scanner object, called scan Once created, the Scanner object (i.e. scan) can be used to invoke various input methods, such as nextline(): answer = scan.nextline(); SEEM

56 Reading Input The Scanner class is part of the java.util class library, and must be imported into a program to be used See Echo.java The nextline method reads all of the input until the end of the line is found The details of object creation and class libraries are discussed later SEEM

57 //************************************************************* // Echo.java // // Demonstrates the use of the nextline method of the Scanner class // to read a string from the user. //************************************************************* import java.util.scanner; public class Echo { // // Reads a character string from the user and prints it. // public static void main (String[] args) { String message; Scanner scan = new Scanner (System.in); System.out.println ("Enter a line of text:"); message = scan.nextline(); } } System.out.println ("You entered: \"" + message + "\""); SEEM

58 Echo.java - Sample Execution The following is a sample execution of Echo.class sepc92> java Echo Enter a line of text: This is a line You entered: This is a line SEEM

59 Input Tokens Unless specified otherwise, white space is used to separate the elements (called tokens) of the input White space includes space characters, tabs, new line characters The next method of the Scanner class reads the next input token and returns it as a string Methods such as nextint and nextdouble read data of particular types See GasMileage.java SEEM

60 //************************************************************* // GasMileage.java // // Demonstrates the use of the Scanner class to read numeric data. //************************************************************* import java.util.scanner; public class GasMileage { // // Calculates fuel efficiency based on values entered by the // user. // public static void main (String[] args) { int miles; double gallons, mpg; Scanner scan = new Scanner (System.in); System.out.print ("Enter the number of miles: "); miles = scan.nextint(); System.out.print ("Enter the gallons of fuel used: "); gallons = scan.nextdouble(); mpg = miles / gallons; } } System.out.println ("Miles Per Gallon: " + mpg); SEEM

61 GasMileage.java - Sample Execution The following is a sample execution of GasMileage.class sepc92> java GasMileage Enter the number of miles: 34 Enter the gallons of fuel used: 17 Miles Per Gallon: 2.0 SEEM

62 Writing Classes Now we will begin to design programs that rely on classes that we write ourselves The class that contains the main method is just the starting point of a program True object-oriented programming is based on defining classes that represent objects with well-defined characteristics and functionality SEEM

63 Designing Classes and Objects An object has state and behavior Consider a six-sided die (singular of dice) It s state can be defined as which face is showing It s primary behavior is that it can be rolled We can represent a die in software by designing a class called Die that models this state and behavior The class serves as the blueprint for a die object We can then instantiate as many die objects as we need for any particular program SEEM

64 Classes A class can contain data declarations and method declarations int size, weight; char category; Data declarations Method declarations SEEM

65 Classes The values of the data define the state of an object created from the class The functionality of the methods define the behaviors of the object For our Die class, we might declare an integer that represents the current value showing on the face One of the methods would roll the die by setting that value to a random number between one and six SEEM

66 Classes In general, a class share some similarities with structures in C Recall that a structure in C is a user-defined data type composed of some data fields and each field belongs to a certain data type or another structure type A class is also composed of some data fields. In addition to it, a class is also associated with some methods SEEM

67 General Design of Objects and Classes In general, we should first declare an object reference Then, we allocate memory for the object AClass obj1; The first line declares an object reference obj1 belonging to a class called AClass obj1 = new AClass(); The second line uses the new operator to allocate some memory for an object (under the class AClass) and lets obj1 points to it The second line also invokes the AClass constructor, if exists, to initialize the data in the object obj1 Data fields for obj1 SEEM

68 General Design of Objects and Classes Similar to structures in C, one can access the data fields of an object via the dot operator For example, suppose in the class AClass, there are some data fields declared such as field1 and field2. Then, we can access field1 in obj1 via: obj1.field1 = 100; We can process an object by a method specified in the corresponding class via dot operator Suppose in the class AClass, there are some methods declared such as method1 and method2 Then we can process the object obj1 by method1 via: a_value = obj1.method1(); SEEM

69 Creating Objects Another Example A variable holds either a primitive type or a reference to an object A class name can be used as a type to declare an object reference variable String title; An object reference variable holds the address of an object The object itself must be created separately Generally, we use the new operator to create an object title = new String ("Java Software Solutions"); This calls the String constructor, which is a special method that sets up the object SEEM

70 Creating Objects - Instantiation Creating an object is called instantiation An object is an instance of a particular class SEEM

71 Invoking Methods We've seen that once an object has been instantiated, we can use the dot operator to invoke its methods count = title.length() A method may return a value, which can be used in an assignment or expression A method invocation can be thought of as asking an object to perform a service SEEM

72 Object References Note that a primitive variable contains the value itself, but an object variable contains the address of the object An object reference can be thought of as a pointer to the location of the object Rather than dealing with arbitrary addresses, we often depict a reference graphically num1 38 title1 "Steve Jobs" SEEM

73 A Complete Example of Classes and Objects Return to the example of our Die class For our Die class, we might declare an integer that represents the current value showing on the face One of the methods would roll the die by setting that value to a random number between one and six We ll want to design the Die class with other data and methods to make it a versatile and reusable resource See RollingDice.java See Die.java SEEM

74 //************************************************************* // RollingDice.java // // Demonstrates the creation and use of a user-defined class. //************************************************************* public class RollingDice { // // Creates two Die objects and rolls them several times. // public static void main (String[] args) { Die die1, die2; int sum; die1 = new Die(); die2 = new Die(); die1.roll(); die2.roll(); System.out.println ("Die One: " + die1 + ", Die Two: " + die2); SEEM SEEM

75 } } die1.roll(); die2.setfacevalue(4); System.out.println ("Die One: " + die1 + ", Die Two: " + die2); sum = die1.getfacevalue() + die2.getfacevalue(); System.out.println ("Sum: " + sum); sum = die1.roll() + die2.roll(); System.out.println ("Die One: " + die1 + ", Die Two: " + die2); System.out.println ("New sum: " + sum); SEEM SEEM

76 //************************************************************* // Die.java // // Represents one die (singular of dice) with faces showing values // between 1 and 6. //************************************************************* public class Die { private final int MAX = 6; // maximum face value private int facevalue; // current value showing on the die // // Constructor: Sets the initial face value. // public Die() { facevalue = 1; } SEEM SEEM

77 // // Rolls the die and returns the result. // public int roll() { facevalue = (int)(math.random() * MAX) + 1; return facevalue; } // // Face value mutator. // public void setfacevalue (int value) { facevalue = value; } // // Face value accessor. // public int getfacevalue() { return facevalue; } SEEM SEEM

78 // // Returns a string representation of this die. // public String tostring() { String result = Integer.toString(faceValue); } } return result; SEEM SEEM

79 The Die Class The Die class contains two data values a constant MAX that represents the maximum face value an integer facevalue that represents the current face value The roll method uses the random method of the Math class to determine a new face value There are also methods to explicitly set and retrieve the current face value at any time SEEM

80 Data Scope The scope of data is the area in a program in which that data can be referenced (used) Data declared at the class level can be referenced by all methods in that class Data declared within a method can be used only in that method Data declared within a method is called local data In the Die class, the variable result is declared inside the tostring method -- it is local to that method and cannot be referenced anywhere else SEEM

81 Instance Data The facevalue variable in the Die class is called instance data because each instance (object) that is created has its own version of it A class declares the type of the data, but it does not reserve any memory space for it Every time a Die object is created, a new facevalue variable is created as well The objects of a class share the method definitions, but each object has its own data space That's the only way two objects can have different states SEEM

82 Instance Data We can depict the two Die objects from the RollingDice program as follows: die1 facevalue 5 die2 facevalue 2 Each object maintains its own facevalue variable, and thus its own state SEEM

83 The tostring Method All classes that represent objects should define a tostring method The tostring method returns a character string that represents the object in some way It is called automatically when an object is concatenated to a string or when it is passed to the println method SEEM

84 Constructors A constructor is a special method that is used to set up an object when it is initially created A constructor has the same name as the class and it has no return data type The Die constructor is used to set the initial face value of each new die object to one We examine constructors in more detail later SEEM

85 RollingDice.java - Compilation Assume that both RollingDice.java and Die.java are stored under the same directory in an Unix account To compile under Unix platform, we can simply compile the RollingDice.java: sepc92> javac RollingDice.java The compiler will first compile RollingDice.java. When it finds out that it needs to make use of the class Die.java. It will automatically compile Die.java If the compilation is successful, you can find two bytecodes, namely, RollingDice.class and Die.class If there is compilation error, the error message will be displayed on the terminal. If you wish to make the error message be displayed screen by screen, you can compile in the following way: sepc92> javac RollingDice.java & more SEEM

86 RollingDice.java - Sample Execution The following is a sample execution of RollingDice.class sepc92> java RollingDice Die One: 6, Die Two: 1 Die One: 4, Die Two: 4 Sum: 8 Die One: 3, Die Two: 2 New sum: 5 SEEM

87 Assignment Revisited In traditional programming language (non object-oriented) such as C, we can declare variables and conduct assignment on variables The act of assignment takes a copy of a value and stores it in a variable For example, consider the integer variables: int num1, num2; num2 = num1; Before: num1 38 num2 96 After: num1 38 num2 38 SEEM

88 Reference Assignment For object references, assignment copies the address For example, suppose that name1 and name2 are two object references Before: title1 title2 "Steve Jobs" "Steve Wozniak" title2 = title1; After: title1 title2 "Steve Jobs" SEEM

89 Aliases Two or more references that refer to the same object are called aliases of each other That creates an interesting situation: one object can be accessed using multiple reference variables Aliases can be useful, but should be managed carefully Changing an object through one reference changes it for all of its aliases, because there is really only one object SEEM

90 Class Libraries A class library is a collection of classes that we can use when developing programs The Java standard class library is part of any Java development environment Its classes are not part of the Java language per se, but we rely on them heavily Various classes we've already used (System, Scanner, String) are part of the Java standard class library Other class libraries can be obtained through third party vendors, or you can create them yourself SEEM

91 Packages The classes of the Java standard class library are organized into packages Some of the packages in the standard class library are: Package Purpose java.lang java.applet java.awt javax.swing java.net java.util javax.xml.parsers General support Creating applets for the web Graphics and graphical user interfaces Additional graphics capabilities Network communication Utilities XML document processing SEEM

92 The import Declaration When you want to use a class from a package, you could use its fully qualified name java.util.scanner Or you can import the class, and then use just the class name import java.util.scanner; To import all classes in a particular package, you can use the * wildcard character import java.util.*; SEEM

93 The import Declaration All classes of the java.lang package are imported automatically into all programs It's as if all programs contain the following line: import java.lang.*; That's why we didn't have to import the System or String classes explicitly in earlier programs The Scanner class, on the other hand, is part of the java.util package, and therefore must be imported SEEM

94 The Random Class The Random class is part of the java.util package It provides methods that generate pseudorandom numbers A Random object performs complicated calculations based on a seed value to produce a stream of seemingly random values See RandomNumbers.java SEEM

95 //************************************************************* // RandomNumbers.java // // Demonstrates the creation of pseudo-random numbers using the // Random class. //************************************************************* import java.util.random; public class RandomNumbers { // // Generates random numbers in various ranges. // public static void main (String[] args) { Random generator = new Random(); int num1; float num2; num1 = generator.nextint(); System.out.println ("A random integer: " + num1); SEEM SEEM

96 } } num1 = generator.nextint(10); System.out.println ("From 0 to 9: " + num1); num1 = generator.nextint(10) + 1; System.out.println ("From 1 to 10: " + num1); num1 = generator.nextint(15) + 20; System.out.println ("From 20 to 34: " + num1); num1 = generator.nextint(20) - 10; System.out.println ("From -10 to 9: " + num1); num2 = generator.nextfloat(); System.out.println ("A random float (between 0-1): " + num2); num2 = generator.nextfloat() * 6; // 0.0 to num1 = (int)num2 + 1; System.out.println ("From 1 to 6: " + num1); SEEM SEEM

97 RandomNumbers.java - Sample Execution The following is a sample execution of RandomNumbers.class sepc92> java RandomNumbers A random integer: From 0 to 9: 2 From 1 to 10: 9 From 20 to 34: 31 From -10 to 9: 1 A random float (between 0-1): From 1 to 6: 2 SEEM

98 Encapsulation We can take one of two views of an object: internal - the details of the variables and methods of the class that defines it external - the services that an object provides and how the object interacts with the rest of the system From the external view, an object is an encapsulated entity, providing a set of specific services These services define the interface to the object SEEM

99 Encapsulation An encapsulated object can be thought of as a black box -- its inner workings are hidden from the client The client invokes the interface methods of the object, which manages the instance data Client Methods Data SEEM

100 Method Declarations Let s now examine method declarations in more detail A method declaration specifies the code that will be executed when the method is invoked (called) When a method is invoked, the flow of control jumps to the method and executes its code When complete, the flow returns to the place where the method was called and continues The invocation may or may not return a value, depending on how the method is defined SEEM

101 Method Control Flow If the called method is in the same class, only the method name is needed compute mymethod mymethod(); SEEM

102 Method Control Flow The called method is often part of another class or object main doit helpme obj.doit(); helpme(); SEEM

103 Method Header A method declaration begins with a method header char calc (int num1, int num2, String message) return type method name parameter list The parameter list specifies the type and name of each parameter The name of a parameter in the method declaration is called a formal parameter SEEM

104 Method Body The method header is followed by the method body char calc (int num1, int num2, String message) { int sum = num1 + num2; char result = message.charat (sum); } return result; sum and result are local data The return expression must be consistent with the return type They are created each time the method is called, and are destroyed when it finishes executing SEEM

105 The return Statement The return type of a method indicates the type of value that the method sends back to the calling location A method that does not return a value has a void return type A return statement specifies the value that will be returned return expression; Its expression must conform to the return type SEEM

106 Parameters When a method is called, the actual parameters in the invocation are copied into the formal parameters in the method header ch = obj.calc (25, count, "Hello"); char calc (int num1, int num2, String message) { int sum = num1 + num2; char result = message.charat (sum); } return result; SEEM

107 Local Data As we ve seen, local variables can be declared inside a method The formal parameters of a method create automatic local variables when the method is invoked When the method finishes, all local variables are destroyed (including the formal parameters) Keep in mind that instance variables, declared at the class level, exists as long as the object exists SEEM

108 Bank Account Example Let s look at another example that demonstrates the implementation details of classes and methods We ll represent a bank account by a class named Account It s state can include the account number, the current balance, and the name of the owner An account s behaviors (or services) include deposits and withdrawals, and adding interest SEEM

109 Driver Programs A driver program drives the use of other, more interesting parts of a program Driver programs are often used to test other parts of the software The Transactions class contains a main method that drives the use of the Account class, exercising its services See Transactions.java See Account.java SEEM

110 //************************************************************* // Transactions.java // // Demonstrates the creation and use of multiple Account objects. //************************************************************* public class Transactions { // // Creates some bank accounts and requests various services. // public static void main (String[] args) { Account acct1 = new Account ("Ted Murphy", 72354, ); Account acct2 = new Account ("Jane Smith", 69713, 40.00); Account acct3 = new Account ("Edward Demsey", 93757, ); acct1.deposit (25.85); double smithbalance = acct2.deposit (500.00); System.out.println ("Smith balance after deposit: " + smithbalance); SEEM SEEM

111 } } System.out.println ("Smith balance after withdrawal: " + acct2.withdraw (430.75, 1.50)); acct1.addinterest(); acct2.addinterest(); acct3.addinterest(); System.out.println (); System.out.println (acct1); System.out.println (acct2); System.out.println (acct3); SEEM SEEM

112 //************************************************************* // Account.java // // Represents a bank account with basic services such as deposit // and withdraw. //************************************************************* import java.text.numberformat; public class Account { private final double RATE = 0.035; // interest rate of 3.5% private long acctnumber; private double balance; private String name; // // Sets up the account by defining its owner, account number, // and initial balance. // public Account (String owner, long account, double initial) { name = owner; acctnumber = account; balance = initial; } SEEM SEEM

113 // // Deposits the specified amount into the account. Returns the // new balance. // public double deposit (double amount) { balance = balance + amount; } return balance; // // Withdraws the specified amount from the account and applies // the fee. Returns the new balance. // public double withdraw (double amount, double fee) { balance = balance - amount - fee; } return balance; SEEM SEEM

114 // // Adds interest to the account and returns the new balance. // public double addinterest () { balance += (balance * RATE); return balance; } // // Returns the current balance of the account. // public double getbalance () { return balance; } // // Returns a one-line description of the account as a string. // public String tostring () { NumberFormat fmt = NumberFormat.getCurrencyInstance(); } } return (acctnumber + "\t" + name + "\t" + fmt.format(balance)); SEEM SEEM

115 Transactions.java - Sample Execution The following is a sample execution of Transactions.class sepc92> java Transactions Smith balance after deposit: Smith balance after withdrawal: Ted Murphy $ Jane Smith $ Edward Demsey $ SEEM

116 Bank Account Example acct acctnumber balance name Ted Murphy acct acctnumber balance name Jane Smith SEEM

117 Constructors Revisited Note that a constructor has no return type specified in the method header, not even void A common error is to put a return type on a constructor, which makes it a regular method that happens to have the same name as the class The programmer does not have to define a constructor for a class Each class has a default constructor that accepts no parameters SEEM