java chapter 2 creating classes. class defines structure of an object or set of objects; includes...

Java

Chapter 2

Creating Classes

Class

Defines structure of an object or set of objects;

Includes variables (data) and methods (actions) which determine how an object behaves

Construction a Data Declaration Section Variable classifications:

Instance – within a class but outside a method. Every object created receives a variable of this type. The keyword static may not be used.

Example: public class Date int year; int month; int day;Position: top of a class’s body. Values vary for each

different instance of an object of that class.

Class variable

Class – located within a class’s body but outside any method. The keyword static must be used.

e.g. p public class Date

static double time; public static final int YEAR = 1583;

Note the modifier “final” – indicates that the variable YEAR is a constant. Note capitalization.

Local Variables Local – within a method body. Neither an access

specifier nor the keyword static may be used.public static void main (String[] args)

{double payRate;int employeeNumber;. . .

parameter – within the () of a method’s header line. Neither an access specifier nor the keyword static may be used.

public double area (double length; double width){ . . .

Declaration Statements

1. Naming a variable optionalAcccessSpecifier dataType variableName

e. g. private double totalDebits Use identifier rules

2. Initializing a variable’s value If already declared: totalDebits = 4982.34; If undeclared: private int age = 22; Watch out for floats: float amtOwed = 27.39 is

incorrect

Task: Construct a program to calculate floor area In what terms could we define the floor? What datatype should we use?

private double width;(Reserved word private used almost universally for all

instance variables) private double length;

Do I need to declare a variable area?

Data types

Primitive vs. ReferenceSee p. 61 in text

Note that with floats – always add either f or F to the literal values

float tax = 0.0825f; Escape sequences – p. 67

Objectives

You should be able to describe: Data Values and Arithmetic Operations Constructing a Data Declaration Section:

Variables Completing the Class: Methods Assignment Operations

Objectives (continued)

Program Design and Development: Object Identification

Common Programming Errors

Data Values and Arithmetic Operations General data types:

Primitive Reference

Literal Value that explicitly identifies itself Example:

1 “xyz”

Data Values and Arithmetic Operations (continued)

Figure 2.1: Primitive data types

Data Values and Arithmetic Operations (continued)

Figure 2.2: Reference types

Integer Literals

Zero or any positive or negative numerical value without decimal point

Examples: 1 -406 352563

Other data types: Byte Short integer

Integer Literals (continued)

Table 2.1: Integer Data Types

Floating-Point Values

Also called real numbers Numerical value with decimal point Examples:

-1.24 0.0 2435.34

Data types: Double Float

Floating-Point Values (continued)

Table 2.2: Floating-Point Data Types

Character Values

Letters of alphabet Both uppercase and lowercase

10 digits 0 through 9 Special symbols such as 1 $ . , - ! Stored as 16-bit unsigned values using

Unicode

Escape Sequences

\ before characters Tells compiler to execute differently from

normal behavior

Escape Sequences (continued)

Table 2.4: Escape Sequences

Boolean Values

Restricted to one of two values: True False

Arithmetic Operations

Used for mathematical calculations Operators:

Addition: + Subtraction: - Multiplication: * Division: / Modulus: %

Arithmetic Operations (continued) Simple arithmetic expression Integer expression Real expression Mixed-mode expression Overloaded operator

Symbol represents more than one operation Execution depends on types of operands

encountered (e.x. 2 + 3.354)

Integer Division

Division of two integers can produce strange results for unwary

Integers cannot contain fractional part It is dropped

Example: 15/7 = 2

The Modulus Operator

Retain remainder of division Operator symbol:

% Example:

9.2 % 4 = 1.2 15 % 4 = 3

Negation

Unary operator One that operates on single operand

Same symbol as binary subtraction (-) Negates or reverses number

Negation (continued)

Table 2.6: Summary of Arithmetic Operations

Operator Precedence and Associativity Rules for working with arithmetic operators:

Two binary arithmetic operator symbols must never be placed side by side

Parentheses may be used to form groupings Expressions in parentheses are evaluated first

Parentheses can be nested Parentheses cannot be used to indicate

multiplication

Operator Precedence and Associativity (continued) Order of operations:

All negations are done first Multiplication, division, and modulus

operations are computed first Addition and subtraction are computed last

String Concatenation

Joins two or more strings into single string Only operation that directly manipulates

string data in similar fashion as numerical data

Has same precedence as addition operator Always use parentheses when performing

arithmetic operations in any expression that contains a string

e.g. “The sum is” + 10 +20 producesThe sum is 1020

Constructing a Data Declaration Section: Variables Values in computer program are stored and

retrieved from computer’s memory unit Variable:

Name given by programmer Refers to computer storage locations that

store primitive data type value Selection of variable names is left to

programmer

Constructing a Data Declaration Section Classifications of variables:

Instance Class Local Parameter

Dependent on: Variable placement within class Presence or absence of reserved word static

Constructing a Data Declaration Section (continued)

Table 2.8: Determination of Variable Types

Creating Objects

Objects Only created from instance variables declared

in data declaration section or from other object types

Methods Provide operations that can be applied to

created objects or create general-purpose functions Independent of any one object

Creating Objects (continued)

Figure 2.6: The RoomType class

Creating Objects (continued)

Using dynamic memory allocation operator also called: Creating an instance Instantiating an object

Reference variable Reference location in memory where actual

object’s values located

Creating Objects (continued)

Private Once object is created, its private variables

can only be accessed by its class methods Safety feature provided by object-oriented

languages Cleansing Memory

Memory leak problem Objects keep track of who references them JVM cleans unused memory

Creating Objects (continued)

Figure 2.8: Instantiating an object

Specifying Storage Allocation

Declaring variables protects against typos Compiler catches errors

Each data type has its own storage requirements Compiler pre-allocates memory based on data

type Definition statements

Statements that cause variables to be created

Completing the Class: Methods Classes provide methods to:

Initialize values stored in each instance variable to user-selected values

Display values Modify values

Format of method header: public returnType methodName(parameter list)

Public Means method can be used in other classes

Constructor Methods

Method that has same name as class Automatically called each time object created Purpose:

Initialize new object’s instance variables Format:public ClassName(parameter list)

{

method body

}

Accessor Methods

Provide means for reading values stored in object’s variables

Referred to as get() method

Mutator Methods

Provide means for changing object’s values After object created

Also known as set() methods

Convenience

Can be convenient to place two classes in one file Second class’s main() method is placed

within first class’s methods section Both classes are stored in same file

public reserved word removed from class that does not contain main() method

Assignment Operations

Most basic statements for initializing variables

General syntax: variable = expression;

Example: length = 25;

Expression Any combination of constants and variables

that can be evaluated to yield a result

Assignment Operations (continued) All variables used in expression must

previously have been given valid values Must be a variable listed immediately to left of

equal sign Has lower precedence than any other

arithmetic operator

Multiple Declarations

Variables with same data type can be grouped Declared using single declaration statement

Frequently used in declaring method’s internal variables

Coercion Forced conversion based on data types

Assignment Variations

In an assignment expression: Variable to left of equal sign can also be used

to right of equal sign Shortcut assignment operators:

+= -= *= /= %=

Accumulating

Values added to program variable as program progresses

Uses assignment operator: sum = sum + 10,

Counting

Counting statement form: variable = variable + fixedNumber;

Example: i = i + 1;

Increment/decrement operators: ++ -- Example:

i++

Procedural versus Object Orientations Procedure-oriented programming

Emphasis on operations to be performed Object-oriented programming

Emphasis on attributes and behavior of objects

Common Programming Errors Forgetting to declare all variables used in

class Forgetting to assign or initialize values for all

variables before variables are used in expression

Mixing data types in same expression without clearly understanding effect produced

Defining more than one default constructor for class

Summary

Primitive data types: Numerical Boolean

Every variable must be declared as to type of value it can store

Class Programmer-defined data type

Summary (continued)

Classes contain methods: Constructor Accessor Mutator

Expressions evaluated according to precedence and associativity of operators used

Assignment symbol operator: =

Creating Objects

public class UseRoomType{ public static void main(String[] args) { RoomType roomOne; // declare a variable of type RoomType

roomOne = new RoomType(); // create and // initialize an object of type RoomType }}

RoomType roomOne; roomOne declared as a variable of type RoomType.Notice the capitalizations– what does that indicate?

roomOne is a programmer devised variableRoomType is a class

Why can’t we declareprivate RoomType roomOne; ?Ans: placed within a method and all variables declared

in a method are local and therefore privateThe contents of the memory storage of roomOne is

null because it does not yet refer to a valid object. It is a reference variable.

The RoomType class

public class RoomType{ // data declarations section private double length; // declare length as a double variable private double width; // declare width as a double variable

}

The process of creating a new object using the dynamic memory allocation operator is referred to as both creating an instance and instantiating an object.

Length and width – instance variables: an instance of them only comes into existence when an object is created.

Each created object will contain one instance of each instance variable

The variable is referenced using the object’s name – e.g.

roomOne.length or roomTwo.length

// File:DemoOperators.java// Description: Test program// This program will test the combination of integers and real numbers// and will explore the modulus operator// Programmer: M. Markel

// Date: 2/07

public class DemoOperators{ public static void main(String[] args) { System.out.println("9/2 = "+ 9/2); System.out.println("9%2 = "+ 9%2); System.out.println("9.0/2 = "+ 9.0/2);

System.out.println("9/2.0 = "+ 9/2.0); System.out.println("9.0%2 = "+ 9%2);System.out.println("9.0f/2 = "+ 9.0f/2);System.out.println("9.0/1.2 = "+ 9.0/1.2);System.out.println("9.0%1.2 = "+ 9.0%1.2);

414.54.514.57.50.600000000000003