Transcript .ppt

Announcements
• Homework P1 due on Thursday
• Homework P2 handed out
CS100
Lecture 6
1
Today’s Topics
•
•
•
•
Review of Friday
Review of topics covered so far
Scope of variables
Introduction to while
CS100
Lecture 6
2
Review of Friday
•
•
•
•
•
Inheritance: subclass vs. superclass
The method toString()
Overriding methods
super()
public vs. private
CS100
Lecture 6
3
Confusion on Strings
String s = new String("Millett");
String t = new String("Millett");
if (s == t) System.out.println("s and t are equal!");
String r = "Millett";
String q = "Millett";
if (r == q) System.out.println("r and q are equal!");
if (s == r) System.out.println("s and r are equal!");
CS100
Lecture 6
4
Today:
• Definitions of basic entities that make up a
Java program
• Syntax of these entities
• Memorize these
• Be able to come up with definitions and
examples on a test
CS100
Lecture 6
5
Class
• A “model” or blueprint for the objects (or instances) of the class; a class
defines the fields (or variables) and methods of each object of the class.
• Analogy: a blueprint for a house is a design for a house, many houses
(objects) can be built from the same blueprint, but they may differ in
color of rooms, wallpaper, etc.
• Java syntax: public class <class name>
{declaration of fields and methods }
• Example: public class C
{int x;
String s;
public C(String sp);
{x= 0; s= sp;}
public void addToX(int y)
{x= x+y;} }
CS100
Lecture 6
6
Variable
• A named box that can contain the value of some type or class. For
a type like int, the value is an integer. For a class, it is the name of
(or reference to) an instance of the class
• Declaration: a definition of the name of the variable and the type
or class of value it can containt
• Syntax: <class or type name> <identifier>;
• Examples:
// a variable x that can contain an integer
int x;
// variable s that can contain the name of an object of class String
String s;
// a variable that can contain a boolean value (true or false)
boolean b;
CS100
Lecture 6
7
Method
• A parameterized sequence of statements,
whose execution performs some task. In Java,
there are three kinds of methods:
– procedures,
– functions,
– constructors.
• The next few slides describe them
CS100
Lecture 6
8
Notes on methods
• A method should be accompanied by a comment that says what
the method does. This is the specification of the method. The
comment has to be precise and clear. A potential user of the
method should be able to look only at the comment and the list of
parameters to know how to use it; they should not have to look at
the list of instructions.
• Example: When you want to bake a cake, you look at the title of a
recipe, a short description, and the list of ingredients to determine
whether you want to use that recipe --not the list of instructions to
bake it.
CS100
Lecture 6
9
Procedure
• A method that performs some task and doesn’t return a value
• Java syntax:
// comment that explains what the procedure does
public void <method name> (<parameter(s)>)
{ sequence of statements to execute }
• Example: // Raise the salary by n dollars if the salary is <$20000
public void raiseSal(double n);
{if (salary < 20000)
salary= salary + n; }
• Example procedure call:
raiseSal(20 * y);
CS100
Lecture 6
10
Function
• A method that performs some task and returns a value. Instead of the keyword
void, the type or class of the return value is used. Statement return <value> is used
to terminate execution of a function call and return <value>.
• Syntax: // Comment that explains what the function does. It should include
// something like “Yield …” to describe what the function returns.
public <type> <method name> (<parameters>)
{Sequence of statements to execute}
• Example: // Yield the maximum of x and y
public int max (int x, int y);
{if (x>= y) return x;
return y; }
• Example function call (within some statement)
z = 1 + max(x, y);
CS100
Lecture 6
11
Constructor
• A method that initializes the fields of an instance of a class when the instance is
created.
• Syntax: // Comment that explains what the constructor does.
public <class name> (<parameters>)
{Sequence of statements to execute}
• Example (within class Employee):
// Constructor: an Employee with name n,salary 0, and year hired d
public Employee Employee (String n, int d);
{name= n; salary= 0; yearHired= d;
}
• Example use (when creating a new instance):
d = new Employee(“Millett”, 1999);
CS100
Lecture 6
12
Execution of Assignment
• Execution of an assignment statement stores
a value in a variable
• Syntax:
<variable name> = <expression>;
• Examples:
b = 2 + c;
s = “Millett” + “ ” + yearHired;
CS100
Lecture 6
13
Block
• A block is used to unify a sequence of statements
into a single statement.
• Syntax: { sequence of statements }
• Example: Here is a sequence of statements:
a = 10;
if (a < c) then a = c;
• Here is a single statement which is a block:
{ a = 10;
if (a < c) then a = c; }
CS100
Lecture 6
14
Conditional Statement
• Execution of a conditional statement allows
a choice of execution
• Syntax: if (<boolean expression>)
<statement>
or
if (<boolean expression>)
<statement1>
else <statement2>
CS100
Lecture 6
15
Subclass
• A subclass B (say) is a class that extends another class A (say). This means that
an instance of B has all the fields and methods that an instance of A has, in
addition to the ones declared in B.
• Syntax: public class <class name> extends <class name>
{ declarations of fields and methods }
• Example: public class VIP extends Employee
{private double bonus;
// Constructor: an VIP with name n, salary s, bonus b, and year hired d
public VIP (String n, double s, double b, int d)
{super(n,d);
salary= s;
bonus= b;} }
• Note the use of super to call a constructor of the superclass Employee
CS100
Lecture 6
16
Access modifiers
• Suppose d is an instance of Employee, where class Employee is declared
as:
public class Employee
{<access modifier> int x;
…
}
• If the <access modifier> is:
– public, then field d.x can be referenced anywhere that d can be
referenced.
– private, then field d.x can be referenced anywhere within class
Employee that d can be referenced
– protected, then field d.x can be referenced anywhere within the
package in which Employee is declared (packages are discussed
later).
CS100
Lecture 6
17
Scope of Variables
public class Class1
{public int x;
public int y;
A field of Class1
// Constructor: …
public Class1 (int z)
{z= z; y= 2*z;}
// Set y to the maximum of p and -p
public void sety(int p) {
int x;
x= p;
if (p < -p)
x= -p;
y= x;}}
CS100
Lecture 6
parameters
A local variable
of method sety
18
More on Scope
• The scope of a variable is the set of places in which it
can be referenced. A variable can be declared only once
within a method. We call this a local variable.
• The scope of a local variable of a method is the
sequence of statements following it
• Example: // Set y to the maximum of p and -p
public void sety(int p)
{int x;
x= p;
if (p > -p)
x= -p;
y= p;
}
CS100
Scope of x
Lecture 6
19
Another example
// ...
public sety(int p)
{if (y= p);
{int x;
x= p;
if (p > -p)
x= -p;
}
y= p;
y= -y;
}
CS100
Scope of x
x cannot be
referenced here
Lecture 6
20
Scope of parameters
• The scope of a parameter of a method is the method body. A parameter
may not be redeclared within the body.
// ...
public test(int p)
{if (y= p);
Scope of p
{int x;
x= p;
if (p > -p)
x= -p;
}
y= p; }
CS100
Lecture 6
21
Scope of fields
• The scope of a field of a class consists of:
(1) the bodies of all methods declared in the class and
(2) all declarations of fields that follow the declaration of the field.
public class Text
{int x= 5;
int y= x+15;
public void test(int p)
{if (x= p);
{int x= 35;
x= p;
if (p > -p)
x= -p;}
x= p; }
CS100
Lecture 6
22
The while loop -- briefly
• Computer programs are very good at
repetition (and don’t get bored)
• Sometimes it is necessary to repeat a
statement or block many times
• One way to do this is with a while loop
• A while statement controls how many times
another statement/block is executed
CS100
Lecture 6
23
While syntax
while ( condition )
while(B)
statement;
S;
• Similar to if, but at the end of the statement,
the condition is checked again
Evaluate B
true Execute S
false
CS100
Lecture 6
24
Example
// use while to print first 10 powers of 2
final static int LIMIT = 10;
int count = 1, power_of_two = 1;
while (count <= LIMIT) {
power_of_two = power_of_two * 2;
System.out.println(power_of_two);
count = count + 1;
}
CS100
Lecture 6
25