Download notes1 - Academic Csuohio - Cleveland State University

EEC-681/781
Distributed Computing Systems
Java Tutorial
Wenbing Zhao
Cleveland State University
[email protected]
2
Outline
•
•
•
•
•
Dissect a simple Java program
Object-oriented programming concepts
Exceptions handling
Packages
Materials taken from Sun’s Java Tutorial:
– http://java.sun.com/docs/books/tutorial/java/index.html
• Another good Java tutorial:
– http://www.cafeaulait.org/course/
Fall Semester 2008
EEC-681: Distributed Computing Systems
Wenbing Zhao
3
public class Calculator {
private int m_num1; // first number
private int m_num2; // second number
private char m_op; // operator: add, sub, mul, div
private int m_result; // result of the calculation
public Calculator() {
m_num1 = 0; m_num2 = 0; m_op = ' '; m_result = 0;
}
public void enter1stNumber(int num1) {
m_num1 = num1;
}
public void enter2ndNumber(int num2) {
m_num2 = num2;
}
public void enterOperator(char op) {
m_op = op;
}
Fall Semester 2008
EEC-681: Distributed Computing Systems
Wenbing Zhao
4
/* return the result of the calculation */
public int calculate() {
switch(m_op) {
case '+':
return m_num1 + m_num2;
case '-':
return m_num1 - m_num2;
case '*':
return m_num1 * m_num2;
case '/':
return m_num1 / m_num2;
default:
return 0;
}
}
Fall Semester 2008
EEC-681: Distributed Computing Systems
Wenbing Zhao
5
public static void main(String[] args) {
Calculator c = new Calculator();
c.enter1stNumber(1);
c.enterOperator('+');
c.enter2ndNumber(1);
int result = c.calculate();
System.out.println("1+1="+result);
}
}
Fall Semester 2008
EEC-681: Distributed Computing Systems
Wenbing Zhao
6
Object Concept
• Real-world objects: state and behavior
– State of a bicycle: current gear, current pedal
cadence, current speed
– Behavior of a bicycle: changing gear, changing pedal
cadence, applying brakes
Fall Semester 2008
EEC-681: Distributed Computing Systems
Wenbing Zhao
7
Software Object
• A software object mimics
a real-world object
Fields (state)
– Member variables (or
fields): store the state of
the object
– Member functions (or
Methods): expose the
object behavior
– Methods operate on an
object's internal state
Methods (behavior)
Fall Semester 2008
EEC-681: Distributed Computing Systems
Wenbing Zhao
8
Object Oriented Concept
• Object-oriented communication: Different objects
communicate (interact) with each other by
calling methods defined in the objects
• Data encapsulation: Hiding internal state and
requiring all interaction to be performed through
an object's methods
Fall Semester 2008
EEC-681: Distributed Computing Systems
Wenbing Zhao
9
Class
• A class is the blueprint from which individual
objects are created
public class Bicycle {
private int speed = 0;
private int gear = 1;
public Bicycle() {
gear = 1; speed = 0;
}
public void changeGear(int newValue) {
gear = newValue;
}
public void speedUp(int increment) {
speed = speed + increment;
}
public void applyBrakes(int decrement) {
speed = speed - decrement;
}
}
Fall Semester 2008
EEC-681: Distributed Computing Systems
Wenbing Zhao
10
Access Level Modifiers
• At the top level—public, or package-private (no explicit
modifier)
• At the member level—public, private, protected, or
package-private (no explicit modifier)
Access Levels
Modifier
public
protected
Class Package Subclass World
Y
Y
Y
Y
Y
no modifier Y
private
Y
Fall Semester 2008
Y
Y
Y
N
N
N
N
N
N
EEC-681: Distributed Computing Systems
Wenbing Zhao
11
Creating Objects
Bicycle b = new Bicycle()
• Declaration: associate a variable name with an object
type
• Instantiation: The new keyword is a Java operator that
creates the object.
• Initialization: The new operator is followed by a call to a
constructor, which initializes the new object
Fall Semester 2008
EEC-681: Distributed Computing Systems
Wenbing Zhao
12
Using Objects
• Calling an object’s methods:
Bicycle b = new Bicycle()
b.speedup(10);
• Referencing an object’s fields:
objectReference.fieldName
Fall Semester 2008
EEC-681: Distributed Computing Systems
Wenbing Zhao
13
Returning a Value from a Method
• A method returns to the code that invoked it
when it
– completes all the statements in the method,
– reaches a return statement, or
– throws an exception (covered later),
whichever occurs first
return returnValue;
return;
Fall Semester 2008
If no return value is needed
EEC-681: Distributed Computing Systems
Wenbing Zhao
14
Inheritance
• Different kinds of objects often have a certain
amount in common with each other
– Mountain bikes, road bikes, all share the
characteristics of bicycles (current speed, current
pedal cadence, current gear)
• Yet each also defines additional features that
make them different
– Road bikes have drop handlebars; some mountain
bikes have an additional chain ring, giving them a
lower gear ratio
Fall Semester 2008
EEC-681: Distributed Computing Systems
Wenbing Zhao
15
Inheritance
• Classes can inherit commonly used state and
behavior from other classes. Bicycle is the
superclass of MountainBike, RoadBike, and
TandemBike
– In the Java, each class is allowed to have one direct
superclass, and each superclass has the potential for
an unlimited number of subclasses
class MountainBike extends Bicycle {
// new fields and methods defining a mountain bike would go here
}
Fall Semester 2008
EEC-681: Distributed Computing Systems
Wenbing Zhao
16
Inheritance
Super class
Subclasses
Fall Semester 2008
EEC-681: Distributed Computing Systems
Wenbing Zhao
17
Inheritance
• A class that is derived from another class is called a
subclass (also a derived class, extended class, or child
class)
• The class from which the subclass is derived is called a
superclass (also a base class or a parent class)
• A subclass inherits all the members (fields, methods,
and nested classes) from its superclass
• Constructors are not members, so they are not inherited
by subclasses, but the constructor of the superclass can
be invoked from the subclass
Fall Semester 2008
EEC-681: Distributed Computing Systems
Wenbing Zhao
18
Inheritance
• MountainBike inherits all the fields and methods of Bicycle
and adds the field seatHeight and a method to set it
public class MountainBike extends Bicycle {
// the MountainBike subclass adds one field
public int seatHeight;
// the MountainBike subclass has one constructor
public MountainBike(int startHeight) {
super();
seatHeight = startHeight;
}
// the MountainBike subclass adds one method
public void setHeight(int newValue) {
seatHeight = newValue;
}
}
Fall Semester 2008
EEC-681: Distributed Computing Systems
Wenbing Zhao
19
Inheritance
• You can assign a subclass to a superclass
variable
– Bicycle b = new MountainBike(10);
• But not the other way around. You have to cast
a superclass object to a sublass object
– MountainBike mb = (MountainBike)b;
Fall Semester 2008
EEC-681: Distributed Computing Systems
Wenbing Zhao
20
Abstract Class
• An abstract class is a class that is declared
abstract: it may or may not include abstract
methods
public abstract class GraphicObject {
// declare fields
// declare non-abstract methods
abstract void draw();
}
Fall Semester 2008
EEC-681: Distributed Computing Systems
Wenbing Zhao
21
Abstract Class
• An abstract method is a method that is declared
without an implementation (without braces, and
followed by a semicolon
• If a class includes abstract methods, the class
itself must be declared abstract
• Abstract classes cannot be instantiated, but they
can be subclassed
Fall Semester 2008
EEC-681: Distributed Computing Systems
Wenbing Zhao
22
Abstract Class: Example
abstract class GraphicObject {
int x, y;
...
void moveTo(int newX, int newY) {
...
}
abstract void draw();
abstract void resize();
}
Fall Semester 2008
class Circle extends GraphicObject {
void draw() {
...
}
void resize() {
...
}
}
class Rectangle extends GraphicObject {
void draw() {
...
}
void resize() {
...
}
}
EEC-681: Distributed Computing Systems
Wenbing Zhao
23
Interface
• Objects define their interaction with the outside world
through the methods that they expose.
• Methods form the object's interface with outside world
• An interface is a group of related methods with empty
bodies
interface Bicycle {
void changeCadence(int newValue);
void changeGear(int newValue);
void speedUp(int increment);
void applyBrakes(int decrement);
}
Fall Semester 2008
EEC-681: Distributed Computing Systems
Wenbing Zhao
24
Interface
• To implement this interface, use the implements
keyword in the class declaration:
class ACMEBicycle implements Bicycle {
// remainder of this class implemented as before
}
Fall Semester 2008
EEC-681: Distributed Computing Systems
Wenbing Zhao
25
Interface
• Interfaces form a contract between the class and
the outside world
– 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
Fall Semester 2008
EEC-681: Distributed Computing Systems
Wenbing Zhao
26
Exception
• An exception is an event, which occurs during
the execution of a program, that disrupts the
normal flow of the program's instructions
Fall Semester 2008
EEC-681: Distributed Computing Systems
Wenbing Zhao
27
Exception
• Code that might throw certain exceptions must
be enclosed by either of the following:
– A try statement that catches the exception. The try
must provide a handler for the exception
– A method that specifies that it can throw the
exception. The method must provide a throws clause
that lists the exception
public void writeList() throws IOException {
…
}
Fall Semester 2008
EEC-681: Distributed Computing Systems
Wenbing Zhao
28
Exception
• Try-Catch-Finally
try {
} catch (FileNotFoundException e) {
System.err.println("FileNotFoundException: "
+ e.getMessage());
throw new SampleException(e);
} catch (IOException e) {
System.err.println("Caught IOException: "
+ e.getMessage());
} finally {
if (out != null) {
System.out.println("Closing PrintWriter");
out.close();
}
}
Fall Semester 2008
EEC-681: Distributed Computing Systems
Wenbing Zhao
29
How to Throw an Exception
• All methods use the throw statement to throw an
exception. The throw statement requires a single
argument: a throwable object
public Object pop() {
Object obj;
if (size == 0) {
throw new EmptyStackException();
}
obj = objectAt(size - 1);
setObjectAt(size - 1, null);
size--;
return obj;
}
Fall Semester 2008
EEC-681: Distributed Computing Systems
Wenbing Zhao
30
Throwable Class and Its
Subclasses
Fall Semester 2008
EEC-681: Distributed Computing Systems
Wenbing Zhao
31
Package
• A package is a namespace that organizes a set
of related classes and interfaces
– Think of packages as being similar to different folders
• The Java platform provides an enormous class
library (a set of packages)
– This library is known as the "Application Programming
Interface", or "API" for short
– Java platform API specification:
http://java.sun.com/j2se/1.5.0/docs/api/
– Example packages: java.lang (Fundamental classes),
java.io (Classes for reading and writing)
Fall Semester 2008
EEC-681: Distributed Computing Systems
Wenbing Zhao
32
Benefits of Creating a Package
• You and other programmers can easily determine that
these types are related
• You and other programmers know where to find types
that can provide graphics-related functions
• The names of your types won't conflict with the type
names in other packages because the package creates
a new namespace
• You can allow types within the package to have
unrestricted access to one another yet still restrict
access for types outside the package
Fall Semester 2008
EEC-681: Distributed Computing Systems
Wenbing Zhao
33
Creating a Package
• To create a package, you choose a name for the
package and put a package statement with that
name at the top of every source file that contains
the types (classes, interfaces, enumerations,
and annotation types) that you want to include in
the package
• The package statement (for example, package
graphics;) must be the first line in the source file.
• There can be only one package statement in
each source file
Fall Semester 2008
EEC-681: Distributed Computing Systems
Wenbing Zhao
34
//in the Draggable.java file
package graphics;
public interface Draggable {
. . .
}
//in the Graphic.java file
package graphics;
public abstract class Graphic {
. . .
}
//in the Circle.java file
package graphics;
public class Circle extends Graphic implements Draggable {
. . .
}
//in the Rectangle.java file
package graphics;
public class Rectangle extends Graphic implements Draggable {
. . .
}
Fall Semester 2008
EEC-681: Distributed Computing Systems
Wenbing Zhao
35
Managing Source and Class Files
• Put the source code for a class, interface,
enumeration, or annotation type in a text file
whose name is the simple name of the type and
whose extension is .java.
• For example:
// in the Rectangle.java file
package graphics;
public class Rectangle() {
. . .
}
Fall Semester 2008
EEC-681: Distributed Computing Systems
Wenbing Zhao
36
Managing Source and Class Files
• Then, put the source file in a directory whose
name reflects the name of the package:
.....\graphics\Rectangle.java
• The qualified name of the package member and
the path name to the file are parallel
class name
pathname to file
graphics.Rectangle
graphics/Rectangle.java
• Produce a jar file for your classes
– Under the parent directory of graphics
– jar –cf graphics.jar graphics
Fall Semester 2008
EEC-681: Distributed Computing Systems
Wenbing Zhao
37
Using a Package
• To use a public package member from outside
its package, you must do one of the following:
– Refer to the member by its fully qualified name:
System.out.println(“Hello World”);
– Import the package member
import graphics.Rectange;
Rectangle r = new Rectangle();
– Import the member's entire package
import graphics.*;
Circle c = new Circle();
Fall Semester 2008
EEC-681: Distributed Computing Systems
Wenbing Zhao
Accessing a Package
(Compilation and Execution)
• For compilation:
– javac –classpath graphics.jar YourClass.java
• For execution:
– java –classpath graphics.jar YourClass
Fall Semester 2008
EEC-681: Distributed Computing Systems
Wenbing Zhao
38
39
Questions
• Real-world objects contain ___ and ___.
• A software object's state is stored in ___.
• A software object's behavior is exposed through
___.
• Hiding internal data from the outside world, and
accessing it only through publicly-exposed
methods is known as data ___.
• A blueprint for a software object is called a ___.
Fall Semester 2008
EEC-681: Distributed Computing Systems
Wenbing Zhao
40
Questions
• Common behavior can be defined in a ___ and
inherited into a ___ using the ___ keyword.
• A collection of methods with no implementation
is called an ___.
• A namespace that organizes classes and
interfaces by functionality is called a ___.
• The term API stands for ___?
Fall Semester 2008
EEC-681: Distributed Computing Systems
Wenbing Zhao
41
Questions
• What is wrong with the following interface?
public interface SomethingIsWrong {
void aMethod(int aValue){
System.out.println("Hi Mom");
}
}
• Is the following interface valid?
public interface Marker {
}
Fall Semester 2008
EEC-681: Distributed Computing Systems
Wenbing Zhao
42
Questions
• Is the following code legal?
try {
} finally {
}
Fall Semester 2008
EEC-681: Distributed Computing Systems
Wenbing Zhao