ObjectsAndThings.pdf

(1)

Objects and Things

(2)

2

Agenda

✦ Announcements

✦ Grade Reports and Midterms ✦ Review Lab

✦ Break

✦ Exception Handling

(3)

Review Java Syntax (Lab)

• _{Create a new project called Review}

• _{Create a package called edu.aubih.review} • _{Create a new class in the package called}

– _HelloWorld

• _{Write HelloWorld program from scratch} • _{Write Circle class from scratch}

(4)

4

HelloWorld

• _{HelloWorld program should}

– _{output Hello World! when invoked} – _{define the Hello World message in a}

(5)

Circle

• _{Circle program should}

– _{declare radius as instance variable (private)} – _{create getters and setters for the radius}

– _{define a no-arg constructor that sets the}

radius to 1.0

– _{define a constructor that accepts a double as}

input and set the radius to that value

(6)

6

Statistics

• _{Statistics program should}

– _{calculateMean(double[] array) as class}

method

– _{calculateMedian(double[] array) as class}

method

– _{calculateMax(double[] array) as class}

method

(7)

Test Your Code

• _{Verify that your code works} • _{Run sample data}

• _{Try to break it}

• _{Use the main method to test each of your}

objects

(8)

8

Exception Handling

• _{Why exception handling important?}

– _{quality software demands it} – _{secure software demands it}

• _{runtime errors cause program to terminate}

abnormally

(9)

Runtime error example (p. 626)

• _{Write a program that accepts two integers as}

input (Quotient.java)

• _{the program should divide the two numbers}

and display the result to the user

• _{After testing it, see what happens if you use}

(10)

10

Runtime error example

• _{java.lang.ArithmeticException}

• _{These error messages confuse users} • _{They also can result in more serious}

problems – security, etc

(11)

Prevent the Error (p. 626-627)

• _{Adjust Quotient.java to prevent the divide}

by zero error.

• _{This is a perfectly acceptable solution}

• _{In some cases, however, it is not so simple}

to prevent errors.

• _{For those cases, Java provides exception}

(12)

12

Handle the Error

try{

// code to execute }

catch(type ex){ // exception we handle // code to handle exception

(13)

Handle the Error

• _{Rewrite the divide program with Java try}

catch block (p. 627)

• _{If you have time, rewrite the divide program}

(14)

14

Exception Handling Advantages

• _{Exception handling enables a method to}

throw an exception to its caller.

• _{Without this capability, a method must}

(15)

Common Exceptions

• _{ClassNotFoundException}

– _{use a class that does not exist}

• _IOException

– input/output problem: file does not exist

• _{ArithmeticException}

– _{divide by zero}

• _{NullPointerException}

(16)

16

Finally...

• _{Sometimes you want code to execute}

regardless of whether an exception occurs or not

finally{ } block accomplishes this...

• _{Often used to clean up resources}

– _{close file handles}

(17)

Objects and Things

• _{Additional Keywords: this, protected} • _{Encapsulation}

• _Inheritance

• _{Overriding vs. Overloading} • _Polymorphism

(18)

18

This keyword

• _{How does an object refer to itself?}

– _this

• _{Common uses}

– _{reference a class's hidden data fields}

– _{invoke another constructor of the same class}

• _Example:

(19)

Design and Test Course Class

• _{Write the programs to model a class on}

pages 343 and 342

• _{The Course class models the process of}

registering a student in a class

• _{Review the following concepts:}

– _{state and behavior}

(20)

20

Inheritance

• _{Inheritance allows new classes to be derived}

from existing classes

• _{Every class you define in Java is inherited}

from an existing class

• _{Think of shapes: square and circle} • _{They have many things in common}

• _{Can we use these common features to}

(21)

Inheritance Concepts

• _{subclass: a subclass inherits accessible}

fields and methods from its superclass

• _{subclass also called: child class, extended}

class, derived class

(22)

22

Modeling Geometric Objects

• _{Write code on pp. 359 – 362.}

• _{Note that the keyword “extends” defines an}

inheritance relationship

public class Circle4 extends GeometricObject1

• Therefore, if we want a class to be derived from another, we simply extend it in the class definition

(23)

Overriding vs. Overloading

• _{Overloading methods}_{: methods with the}

same name but different signatures

• _{Overriding methods}_{: methods in a subclass}

with the same method signature as methods in a superclass

• _{A method override provides different}

(24)

24

Polymorphism

• _{a variable of a supertype can refer to a}

subtype object

• _{an object of a subclass can be used}

whenever its superclass is required

• _{The JVM uses}_{dynamic binding}_to

determine which implementation will be used

• _{Dynamic binding allows new classes to be}

(25)

Polymorphism Example

• _{Write the code on page 369-370}

• _{Notice that we can invoke m with any type}

(26)

26

Protected data and methods

• _{protected is a visibility modifier like public}

and private

• _{protected resources can be accessed by any}

class in the same package or its subclasses

• _{Three visibility modifiers}

– _public

(27)

Another use for final

• _{If you want methods or classes not to be}

extended, use the final modifier

• _{public final class C will prevent extensions}

to this class

• _{public final void m() will prevent the m}

(28)

28

Abstraction

• _{Abstract class cannot have any specific}

instances

• _{Abstract classes are like regular classes}

except that you cannot create an instance with the new operator

• _{Abstract methods represent behavior that is}

only appropriate for subclasses

(29)

Abstraction Example

• _{Write new version of GeometricObject,}

Circle, Rectangle, and

(30)

30

Interfaces

• _{An interface is a classlike construct that}

contains only constants and methods.

• _{Interfaces specify the behavior that a class}

must implement (contract)

class Chicken extends Animal implements Edible

• _{implements keyword denotes using}

(31)

Interface Example

• _{Write code on page 397 – 398 to}

demonstrate how interfaces work

• _{If you want to implement features similar to}

(32)

32

Interfaces vs. Abstractions

• _Interfaces

– _{variables must be public static final} – _{no constructors}

– _{all methods are public instance methods}

• _Abstraction

– _{all variables permitted}

(33)

Class Design and Modeling

• _Association

– _{Students take courses} – _{Faculty teach courses}

• _{Aggregation – has-a relationship}

• _{Composition – exclusive has-a relationship} • _{Dependency – one class uses another}

(34)

34

Class Design and Modeling

• _Cohesion_{: classes should describe single}

entities and class operations should fit together logically

• _Consistency_{: choose names consistently,}

follow a standard

• _{Encapsulation}_{: data protection}

(35)

Class Design and Modeling

• _{Completeness:}_{classes can be configured for}

many purposes

• _{Instance vs. Static}

• _{Inheritance vs. Aggregation}_{: prefer}

composition whenever possible

(36)

36

Design Patterns

• _{Design patterns are proven sound strategies}

for designing classes.

• _{Help to arrange classes into meaningful}

software solutions.

• _{Exercise: Write singleton pattern on page}

442 – 443.