EEC-681/781 Distributed Computing Systems Java Tutorial Wenbing Zhao Cleveland State University [email protected].

EEC-681/781EEC-681/781Distributed Computing SystemsDistributed Computing Systems

Java TutorialJava Tutorial

Wenbing ZhaoWenbing Zhao

Cleveland State UniversityCleveland State University

[email protected]@ieee.org

22

Fall Semester 2008Fall Semester 2008 EEC-681: Distributed Computing SystemsEEC-681: Distributed Computing Systems Wenbing ZhaoWenbing Zhao

OutlineOutline

• 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/

33


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; }

44


/* 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; } }

55


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); } }

66


Object ConceptObject 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

77


Software ObjectSoftware Object

• A software object mimics a real-world object– 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

Fields (state)

Methods (behavior)

88


Object Oriented ConceptObject 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

99


ClassClass• 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; } }

1010


Access Level ModifiersAccess 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 Class Package Subclass World

public Y Y Y Y

protected

Y Y Y N

no modifier Y Y N N

private Y N N N

1111


Creating ObjectsCreating 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

1212


Using ObjectsUsing Objects

• Calling an object’s methods:

• Referencing an object’s fields:

Bicycle b = new Bicycle() b.speedup(10);

objectReference.fieldName

1313


Returning a Value from a MethodReturning 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; If no return value is needed

1414


InheritanceInheritance

• 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

1515



• 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 }

1616



Super class

Subclasses

1717



• 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

1818


InheritanceInheritance• 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; } }

1919



• 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;

2020


Abstract ClassAbstract 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(); }

2121


Abstract ClassAbstract 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

2222


Abstract Class: ExampleAbstract Class: Example

abstract class GraphicObject { int x, y; ... void moveTo(int newX, int newY) { ... } abstract void draw(); abstract void resize(); }

class Circle extends GraphicObject { void draw() { ... } void resize() { ... } } class Rectangle extends GraphicObject { void draw() { ... } void resize() { ... } }

2323


InterfaceInterface

• 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

bodiesinterface Bicycle { void changeCadence(int newValue); void changeGear(int newValue); void speedUp(int increment); void applyBrakes(int decrement); }

2424


InterfaceInterface

• To implement this interface, use the implements keyword in the class declaration:

class ACMEBicycle implements Bicycle { // remainder of this class implemented as before }

2525


InterfaceInterface

• 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

2626


ExceptionException• An exception is an event, which occurs during

the execution of a program, that disrupts the normal flow of the program's instructions

2727


ExceptionException• 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 {…}

2828


ExceptionException• 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(); } }

2929


How to Throw an ExceptionHow 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; }

3030


Throwable Class and Its Throwable Class and Its SubclassesSubclasses

3131


PackagePackage• 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)

3232


Benefits of Creating a PackageBenefits 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

3333


Creating a PackageCreating 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

3434


//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 { . . . }

3535


Managing Source and Class FilesManaging 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() { . . . }

3636


Managing Source and Class FilesManaging 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 graphics.Rectanglepathname to file graphics/Rectangle.java

• Produce a jar file for your classes– Under the parent directory of graphics– jar –cf graphics.jar graphics

3737


Using a PackageUsing 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();

3838


Accessing a Package Accessing a Package (Compilation and Execution) (Compilation and Execution)

• For compilation: – javac –classpath graphics.jar YourClass.java

• For execution: – java –classpath graphics.jar YourClass

3939


QuestionsQuestions

• 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 ___.

4040


QuestionsQuestions

• 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 ___?

4141


QuestionsQuestions

• What is wrong with the following interface?

• Is the following interface valid?

public interface SomethingIsWrong { void aMethod(int aValue){ System.out.println("Hi Mom"); } }

public interface Marker { }

4242


QuestionsQuestions

• Is the following code legal? try { } finally { }

EEC-681/781 Distributed Computing Systems Java Tutorial Wenbing Zhao Cleveland State University [email protected].

Documents