Transcript CHAPTER 2

CHAPTER 2
AN INTRODUCTION TO
OBJECTS AND CLASSES
Chapter Goals
• To understand the concepts of classes and objects
• To realize the difference between objects and
object references
• To become familiar with the process of
implementing classes
• To be able to implement simple methods
• To understand the purpose and use of constructors
• To understand how to access instance fields and
local variables
• To appreciate the importance of documentation
comments
Objects and Classes
 Object: entity that you can manipulate in
your programs (by invoking methods)
 Each object belongs to a class
 Class: Set of objects with the same
behavior
 Class determines legal methods
"Hello".println() // Error
"Hello".length() // OK
Rectangle Class
• Construct a rectangle:
new Rectangle(5, 10, 20, 30)
new Rectangle()
• Use the constructed object
System.out.println(new
Rectangle(5, 10, 20, 30));
prints
java.awt.Rectangle[x=5,y=10,w
idth=20,height=30]
Rectangle Shapes
A Rectangle Object
Syntax 2.1: Object Construction
• new ClassName(parameters)
–Example:
• new Rectangle(5, 10, 20, 30)
• new Car("BMW 540ti", 2004)
–Purpose:
• To construct a new object, initialize it with
the construction parameters, and return a
reference to the constructed object.
Object Variables
 Declare and optionally initialize:
Rectangle cerealBox = new
Rectangle(5, 10, 20, 30);
Rectangle crispyCrunchy;
 Apply methods:
cerealBox.translate(15, 25);
 Share objects:
r = cerealBox;
Uninitialized and Initialized
Variables
Uninitialized
Initialized
Two Object Variables Referring
to the Same Object
Syntax 2.2: Variable Definition
TypeName variableName;
TypeName variableName = expression;
–Example:
Rectangle cerealBox;
String name ="Dave";
–Purpose:
To define a new variable of a particular type
and optionally supply an initial value
Writing a Test Program
 Invent a new class, say MoveTest
 Supply a main method
 Place instructions inside the main
method
 Import library classes by specifying the
package and class name:
import java.awt.Rectangle;
 You don't need to import classes in the
java.lang package such as
String and System
Syntax 2.3 : Importing a Class
from a Package
• importpackageName.ClassName ;
•
–Example:
import java.awt.Rectangle;
–Purpose:
• To import a class from a package for use in
a program
File MoveRect.java
1
2
3
4
5
6
7
import java.awt.Rectangle;
public class MoveTest
{
public static void main(String[] args)
{
Rectangle cerealBox = new Rectangle(5,
10, 20, 30);
8 // move the rectangle
9 cerealBox.translate(15, 25);
10 // print the moved rectangle
11 System.out.println(cerealBox);
12 }
A Simple Class
public class Greeter
{
public String sayHello()
{
String message ="Hello,World!";
return message;
}
}
Method Definition
 access specifier (such as public)
 return type (such as String or
void)
 method name (such as sayHello)
 list of parameters (empty for
sayHello)
 method body in { }
Method Parameters
public class Rectangle
{
. . .
public void translate(int
x, int y)
{
method body
}
. . .
}
Syntax 2.4: Method Implementation
• public class ClassName
{
...
accessSpecifier returnType
methodName(parameterType parameterName,...)
{
method body
}
...
}
…Continue
…Continue
– Example:
•
public class Greeter
{
public String sayHello()
{
String message ="Hello,World!";
return message;
}
}
– Purpose:
• To define the behavior of a method A method
definition specifies the method name, parameters,
and the statements for carrying out the method's
actions
Syntax 2.5: The return Statement
return expression;
or
return;
–Example:
return message;
–Purpose:
To specify the value that a method returns, and
exit the method immediately. The return value
becomes the value of the method call
expression.
Testing a Class
 Test class: a class with a main method that
contains statements to test another class.
 Typically carries out the following steps:
»Construct one or more objects of the
class that is being tested.
»Invoke one or more methods.
»Print out one or more results
A Test Class for the Greeter Class
public class GreeterTest
{
public static void main(String [] args))
{
Greeter worldGreeter = new Greeter();
System.out.println(worldGreeter.sayHello())
;
}
}
Building a Test Program
1. Make a new subfolder for your
program.
2. Make two files, one for each class.
3. Compile both files.
4. Run the test program.
Testing with the SDK Tools
•
•
•
•
•
•
•
mkdir greeter
cd greeter
edit Greeter.java
edit GreeterTest.java
javac Greeter.java
javac GreeterTest.java
java GreeterTest
Testing with BlueJ
Instance Fields
public class Greeter
{
...
private String name;
}
 access specifier (such as private)
 type of variable (such as String)
 name of variable (such as name)
Instance Fields
Accessing Instance Fields
 The sayHello method of the Greeter
class can access the private
instance field:
public String sayHello()
{
String message = "Hello, " + name +
"!";
return message;
}
 Other methods cannot:
public class GreeterTest
{
public static void
main(String[] args)
{
. . .
System.out.println(daveGreeter.
name); // ERROR
}
}
 Encapsulation = Hiding data and providing
access through methods
Syntax 2.6 : Instance Field
Declaration
• accessSpecifier class
ClassName
{
...
accessSpecifier fieldType
fieldName;
...
}
– Example:
public class Greeter
•
{
...
private String name;
...
}
– Purpose:
• To define a field that is present in every object of a
class
Constructors
 A constructor initializes the instance variables
 Constructor name = class name
–public class Greeter()
{
public Greeter(String aName)
{
name = aName;
}
. . .
}
 Invoked in new expression
new Greeter("Dave")
Syntax 2.7 : Constructor
Implementation
• accessSpecifier class ClassName
{
...
accessSpecifier
ClassName(parameterType
parameterName ...)
{
constructor implementation
}
...
}
– Example:
public class Greeter
{
...
public Greeter(String aName)
{
name = aName;
} ...
}
– Purpose:
• To define the behavior of a constructor, which is
used to initialize the instance fields of newly
created objects
File Greeter.java
1 public class Greeter
2 {
3 public Greeter(String aName)
4 {
5 name = aName;
6 }
7
8 public String sayHello()
9 {
10 String message = "Hello, " +
name + "!";
11 return message;
12 }
13
14 private String name;
15 }
File GreeterTest.java
1 public class GreeterTest
2 {
3 public static void
main(String[] args)
4 {
5 Greeter worldGreeter = new
Greeter("World");
6System.out.println(worldGreeter.
sayHello());
7
8 Greeter daveGreeter = new
Greeter("Dave");
9System.out.println(daveGreeter.s
ayHello());
10 }
11 }
Designing the Public Interface
Behavior of bank account:
 deposit money
 withdraw money
 get balance
Methods of BankAccount class:
 deposit
 withdraw
 getBalance
BankAccount Public Interface
• public BankAccount()
• public BankAccount(double
initialBalance)
• public void deposit(double
amount)
• public void withdraw(double
amount)
• public double getBalance()
Using the Public Interface
 Transfer balance
–double amt = 500;
momsSavings.withdraw(amt);
harrysChecking.deposit(amt);
 Add interest
–double rate = 5; // 5%
double amt = acct.getBalance()
* rate / 100;
acct.deposit(amt);
Commenting the Public Interface
• /**
Withdraws money from the bank account.
@param the amount to withdraw
*/
public void withdraw(double amount)
{
implementation filled in later
}
• /**
Gets the current balance of the bank
account.
@return the current balance
*/
public double getBalance()
{
implementation filled in later
}
Class Comment
/**
A bank account has a balance that can
be changed by deposits and withdrawals.
*/
public class BankAccount
{
...
}
Javadoc Method Summary
Javadoc Method Detail
BankAccount Class
Implementation
• Determine instance variables to hold object
state
private double balance
• Implement methods and constructors
File BankAccount.java
1 /**
2 A bank account has a balance that can be
changed by
3 deposits and withdrawals.
4 */
5 public class BankAccount
6{
7 /**
8 Constructs a bank account with a zero
balance
9 */
10 public BankAccount()
11 {
12 balance = 0;
13 }
14
15 /**
16 Constructs a bank account with a given
balance
17 @param initialBalance the initial balance
18 */
19 public BankAccount(double initialBalance)
20 {
21 balance = initialBalance;
22 }
23
24 /**
25 Deposits money into the bank account.
26 @param amount the amount to deposit
27 */
28 public void deposit(double amount)
29 {
30 double newBalance = balance + amount;
31 balance = newBalance;
32 }
33
34 /**
35 Withdraws money from the bank account.
36 @param amount the amount to withdraw
37 */
38 public void withdraw(double amount)
39 {
40 double newBalance = balance - amount;
41 balance = newBalance;
42 }
43
44 /**
45 Gets the current balance of the bank account.
46 @return the current balance
47 */
48 public double getBalance()
49 {
50 return balance;
51 }
52
53 private double balance;
54 }
File BankAccountTest.java
1 /**
2 A class to test the BankAccount class.
3 */
4 public class BankAccountTest
5{
6 /**
7 Tests the methods of the BankAccount class.
8 @param args not used
9 */
10 public static void main(String[] args)
11 {
12 BankAccount harrysChecking = new
BankAccount();
13 harrysChecking.deposit(2000)
14 harrysChecking.withdraw(500)
15 System.out.println(harrysChecking.getBalance());
16 }
17 }
Calling a Method in BlueJ
The Method Return Value in
BlueJ
Variable Types
 Instance fields (balance in BankAccount)
 Local variables (newBalance in deposit
method)
 Parameter variables (amount in deposit
method)
Explicit and Implicit Parameters
public void withdraw(double amount)
{
double newBalance = balance - amount;
balance = newBalance;
}
balance is the balance of the object to the left of the dot:
momsSavings.withdraw(500)
means
double newBalance = momsSavings.balance - amount;
momsSavings.balance = newBalance;