Title: Defining Classes and Methods
1Defining Classes and Methods
2Object-Oriented Programming
- Our world consists of objects (people, trees,
cars, cities, airline reservations, etc.). - Objects can perform actions which effect
themselves and other objects in the world. - Object-oriented programming (OOP) treats a
program as a collection of objects that interact
by means of actions.
3OOP Design Principles
- OOP adheres to three primary design principles
- encapsulation
- polymorphism
- inheritance.
4Introduction to Encapsulation
- The data and methods associated with any
particular class are encapsulated (put together
in a capsule), but only part of the contents is
made accessible. - Encapsulation provides a means of using the
class, but it omits the details of how the class
works. - Encapsulation often is called information hiding.
5Accessibility Example
- An automobile consists of several parts and
pieces and is capable of doing many useful
things. - Awareness of the accelerator pedal, the brake
pedal, and the steering wheel is important to the
driver. - Awareness of the fuel injectors, the automatic
braking control system, and the power steering
pump is not important to the driver.
6Introduction to Inheritance
- Classes can be organized using inheritance.
7Introduction to Inheritance, cont.
- A class at lower levels inherits all the
characteristics of classes above it in the
hierarchy. - At each level, classifications become more
specialized by adding other characteristics. - Higher classes are more inclusive lower classes
are less inclusive.
8Introduction to Polymorphism
- from the Greek meaning many forms
- The same program instruction adapts to mean
different things in different contexts. - A method name, used as an instruction, produces
results that depend on the class of the object
that used the method. - everyday analogy take time to recreate causes
different people to do different activities - more about polymorphism in Chapter 7
9Outline
- Class and Method Definitions
- Information Hiding and Encapsulation
- Objects and Reference
10Class and Method Definitions Outline
- Class Files and Separate Compilation
- Instance Variables
- Using Methods
- void Method Definitions
- Methods that Return a Value
- Accessing Instance Variables
- Local Variables
- Blocks
- Parameters of a Primitive Type
- Class and Method Definition Syntax
11Basic Terminology
- Objects can represent almost anything.
- A class defines a kind of object.
- It specifies the kinds of data an object of the
class can have. - It provides methods specifying the actions an
object of the class can take. - An object satisfying the class definition
instantiates the class and is an instance of the
class.
12Basic Terminology, cont.
- The data items and the methods are referred to as
members of the class. - We will call the data items associated with an
object the instance variables of that object
(i.e. that instance of the class).
13A Class as an Outline
14Class and Method Definition Syntax
- public class Class_Name
-
- Instance_Variable_Declaration_1
- Instance_Variable_Declaration_2
-
- Method_Definition_1
- Method_Definition_2
- ...
-
15Class and Method Definition Syntax, cont.
- public Type_Name_Or_void Method_Name(Parameter_Lis
t) - where Parameter_List consists of
- a list of one or more formal parameter names,
each preceded by a type and separated by commas
or - no formal parameters at all
16Example
- The modifier public associated with the instance
variables should be replaced with the modifier
private, as we will do later in the chapter.
17Class Files and Separate Compilation
- Each Java class definition should be in a file by
itself. - The name of the file should be the same as the
name of the class. - The file name should end in .java
- A Java class can be compiled before it is used in
a program - The compiled byte code is stored in a file with
the same name, but ending in .class
18Class Files and Separate Compilation, cont.
- If all the classes used in a program are in the
same directory as the program file, you do not
need to import them.
19Using Methods
- two kinds of methods
- methods that return a single value (e.g. nextInt)
- methods that perform some action other than
returning a single value (e.g println), called
void methods
20Methods That Return a Value
- example
- int next keyboard.nextInt()
- keyboard is the calling object.
- You can use the method invocation any place that
it is valid to use of value of the type returned
by the method.
21Methods That Do Not Return a Value
- example
- System.out.println(Enter data)
- System.out is the calling object.
- The method invocation is a Java statement that
produces the action(s) specified in the method
definition. - It is as if the method invocation were replaced
by the statements and declarations in the method
definition.
22void Method Definitions
- example
- public void writeOuput()
-
- System.out.println(Name name)
- System.out.println(Age age)
-
- Such methods are called void methods.
23Method Definitions
- All method definitions belong to some class.
- All method definitions are given inside the
definition of the class to which they belong. - If the definition of the method begins with
public void, it does not return a value. - public indicates that use is unrestricted.
- void indicates that the method does not return a
value.
24Method Definitions, cont.
- The parentheses following the method name contain
any information the method needs. - The first part of the method definition is called
the heading. - The remainder of the method is called the body,
and is enclosed in braces . - Statements or declarations are placed in the body.
25The Method main
- A program is a class that has a method named
main. - The programs we have seen so far have no instance
variables and no methods other than method main. - Programs can have instance variables and other
methods.
26Defining Methods That Return a Value
- example
- public int fiveFactorial()
-
- int factorial 54321
- return factorial
-
- As before, the method definition consists of the
method heading and the method body. - The return type replaces void.
27Defining Methods That Return a Value, cont.
- The body of the method definition must contain
- return Expression
- This is called a return statement.
- The Expression must produce a value of the type
specified in the heading. - The body can contain multiple return statements,
but a single return statement makes for better
code.
28Using return in a void Method
- form
- return
- use
- to end the invocation of the method, usually
prematurely, to deal with some problem - caution
- Almost always, there are better ways to deal with
a potential problem.
29public Method Definitions
- syntax for a void method
- public void Method_Name(Parameters)
-
- ltstatement(s)gt
-
- syntax for methods that return a value
- public Return_Type Method_Name(Parameters)
-
- ltstatement(s), including a
- return statementgt
-
30Accessing Instance Variables
- Outside the class definition, a public instance
variable is accessed with - the name of an object of the class
- a dot (.)
- the name of the instance variable.
- Example myBestFriend.name Lara
- Inside the definition of the same class only the
name of the instance variable is used. - Example name keyboard.nextLine()
31Accessing Instance Variables, cont.
- equivalent assignment statements
- name keyboard.nextLine()
- and
- this.name keyboard.nextLine()
- The keyword this stands for the calling object -
the object that invokes the method.
32Local Variables
- A variable declared within a method is called a
local variable. - Its meaning is local to (confined to) the
method definition. - Variables with the same name declared within
different methods are different variables. - A local variable exists only as long as the
method is active.
33Local Variables, cont.
- class BankAccount
- class LocalVariablesDemoProgram
34Blocks
- The terms block and compound statement both refer
to a set of Java statements enclosed in braces
. - A variable declared within a block is local to
the block. - When the block ends, the variable disappears.
- If you intend to use the variable both inside and
outside the block, declare it outside the block.
35Variables in for Statements
- The loop control variable can be declared outside
the for statement - int n
- for (n 1 n lt10, n)
- in which case the variable n still exists when
the for statement ends - or
36Variables in for Statements, cont.
- The loop control variable can be declared inside
the for statement - for (int n 1 n lt10, n)
- in which case the variable n ceases to exist when
the for statement ends
37Parameters of a Primitive Type
- Often it is convenient to pass one or more values
into a method and to have the method perform its
actions using those values. - The values are passed in as arguments (or actual
parameters) associated with the method invocation.
38Parameters of a Primitive Type, cont.
- The method receives the values and stores them in
its formal parameters (or simply parameters). - A method invocation assigns the values of the
arguments (actual parameters) to the
corresponding formal parameters (parameters). - This is known as the call-by-value mechanism.
- The formal parameters exist as long as the method
is active.
39Parameters of a Primitive Type, cont.
- Generally, the type of each argument must be the
same as the type of the corresponding formal
parameter. - Java will perform automatic type conversion for
an argument that appears to the left of a formal
parameter it needs to match - byte --gt short --gt int --gt long --gt float --gt
double
40Parameters of a Primitive Type, cont.
- An argument in a method invocation can be
- a literal such as 2 or A
- a variable
- any expression that yields a value of the
appropriate type. - A method invocation can include any number of
arguments the method definition contains a
corresponding number of formal parameters, each
preceded by its type.
41Parameters of a Primitive Type, cont.
- anObject.doStuff(42, 100, 9.99, Z)
- public void doStuff(int n1, int n2, double d1,
char c1) - arguments and formal parameters are matched by
position - Everything said about arguments and formal
parameters applies to methods that return a value
as well as to void methods.
42Method with a Parameter
43Information Hiding and Encapsulation Outline
- Information Hiding
- Precondition and Postcondition Comments
- The public and private Modifiers
- Encapsulation
- Automatic Documentation with javadoc
- UML Class Diagrams
44Information Hiding
- Information overload is avoided by suppressing
or hiding certain kinds of information, making
the programmers job simpler and the code easier
to understand. - A programmer can use a method defined by someone
else without knowing the details of how it works
(e.g. the println method) - He needs to know what the method does, but not
how it does it.
45Information Hiding, cont.
- What the method contains is not secret, and maybe
not even interesting. - Viewing the code does not help you use the method
and may distract you from the task at hand. - Designing a method so that it can be used how it
performs its task is called information hiding or
abstraction.
46The public and private Modifiers
- The instance variables of a class should not be
declared public. - Typically, instance variables are declared
private. - An instance variable declared public can be
accessed and changed directly, with potentially
serious integrity consequences. - Declaring an instance variable private protects
its integrity.
47The public and private Modifiers, cont.
- Analogy An ATM permits deposits and withdrawals,
both of which affect the account balance, but it
does not permit an account balance to be accessed
and changed directly. If an account balance
could be accessed and changed directly, a bank
would be at the mercy of ignorant and
unscrupulous users.
48The private Modifier
- The private modifier makes an instance variable
inaccessible outside the class definition. - But within the class definition, the instance
variable remains accessible and changeable. - This means that the instance variable can be
accessed and changed only via the methods
accompanying the class.
49Accessor and Mutator Methods
- Appropriate access to an instance variable
declared private is provided by an accessor
method which is declared public. - Typically, accessor methods begin with the word
get, as in getName. - Mutator methods should be written to guard
against inappropriate changes.
50Encapsulation
- Encapsulation is the process of hiding details of
a class definition that are not needed to use
objects of the class. - Encapsulation is a form of information hiding.
51Encapsulation, cont.
- When done correctly, encapsulation neatly divides
a class definition into two parts - the user interface which communicates everything
needed to use the class - the implementation consisting of all the members
of the class. - A class defined this way is said to be well
encapsulated.
52The User Interface
- The user interface consists of
- the headings for the public methods
- the defined public constants
- comments telling the programmer how to use the
public methods and the defined public constants. - The user interface contains everything needed to
use the class.
53The Implementation
- The implementation consists of
- the private instance variables
- the private defined constants
- the definitions of public and private methods.
- The Java code contains both the user interface
and the implementation. - Imagine a wall between the user interface and the
implementation.
54Encapsulation
55Encapsulation Guidelines
- Precede the class definition with a comment that
shapes the programmers view of the class. - Declare all the instance variables in the class
private. - Provide appropriate public accessor and mutator
methods.
56Encapsulation Guidelines, cont.
- Provide public methods to permit the programmer
to use the class appropriately. - Precede each public method with a comment
specifying how to use the method. - Declare methods invoked only by other methods in
the class private. - Use /.../ or /.../ for user interface
comments and // for implementation comments.
57Encapsulation Characteristics
- Encapsulation should permit implementation
changes (improvements, modifications,
simplifications, etc.) without requiring changes
in any program or class that uses the class. - Encapsulation combines the data and the methods
into a single entity, hiding the details of the
implementation.
58Objects and Reference Outline
- Variables of a Class Type and Objects
- Boolean-Valued Methods
- Class Parameters
- Comparing Class Parameters and Primitive-Type
Parameters
59Variables
- Variables of a class type name objects, which is
different from how primitive variables store
values. - All variables are implemented as memory
locations. - The value of a variable of a primitive type is
stored in the assigned location. - The value of a variable of a class type is the
address where a named object of that class is
stored.
60Variables, cont.
- A value of any particular primitive type always
requires the same amount of storage. - example a variable of type int always requires 4
bytes. - An object of a class type might be arbitrarily
large. - An object of type String might be empty, or might
contain 1, 120, 5280, or more characters.
61Variables, cont.
- However, there is always a limit on the size of
an address. - The memory address where an object is stored is
called a reference to the object. - Variables of a class type behave differently from
variables of a primitive type.
62Variables of a Primitive Type
- Only one variable of a primitive type is
associated with the memory location where the
value of the variable is stored.
63Variables of a Class Type
- However, multiple variables of a class type can
contain the memory location where an object is
stored. - The object can be accessed and potentially
changed using any of these variables. - All these variables contain the same reference
and name the same object. - Variables of a class type referencing the same
memory location are called aliases.
64Variables of a Class Type, cont.
- When one variable of a class type is assigned to
another variable of a compatible class type, the
memory address is copied from one variable to
another and the two variables become aliases of
one another. - The numeric values of these memory addresses
generally are not available to the programmer nor
are they needed by the programmer.
65Allocating Memory for a Reference and an Object
- A declaration such as
- SpeciesFourthTry s
- creates a variable s that can hold a memory
address. - A statement such as
- s new SpeciesFourthTry()
- allocates memory for an object of type
SpeciesFourthTry.
66 with Variables of a Class Type
67 with Variables of a Class Type, cont.
- When used with variables of a class type,
tests if the variables are aliases of each other,
not if they reference objects with identical
data. - To test for equality of objects in the intuitive
sense, define and use an appropriate equals
method.
68Method equals
- The definition of method equals depends on the
circumstances. - In some cases, two objects may be equal when
the values of only one particular instance
variable match. - In other cases, two objects may be equal only
when the values of all instance variables match. - Always name the method equals.
69Class Parameters
- Recall
- When the assignment operator is used with objects
of a class type, a memory address is copied,
creating an alias. - When the assignment operator is used with a
primitive type, a copy of the primitive type is
created.
70Class Parameters, cont.
- When a parameter in a method invocation is a
primitive type, the corresponding formal
parameter is a copy of the primitive type.
71Class Parameters, cont.
- When a parameter in a method invocation is a
reference to a class type (i.e. a named object),
the corresponding formal parameter is a copy of
that reference (i.e. an identically valued
reference to the same memory location).
72Class Parameters, cont.
- Example
- if (s1.equals(s2))
-
- public boolean equals (Species otherObject)
- causes otherObject to become an alias of s2,
referring to the same memory location, which is
equivalent to - otherObject s2
73Class Parameters, cont.
- Any changes made to the object named otherObject
will be done to the object named s2, and vice
versa, because they are the same object. - If otherObject is a formal parameter of a method,
the otherObject name exists only as long as the
method is active.
74Comparing Class Parameters and Primitive-Type
Parameters
- A method cannot change the value of a variable of
a primitive type passed into the method. - A method can change the value(s) of the instance
variable(s) of a class type passed into the
method.
75Comparing Class Parameters and Primitive-Type
Parameters, cont.
76Comparing Class Parameters and Primitive-Type
Parameters, cont.
77Summary
- You have become familiar with the concept of a
class and an object that instantiates the class. - You have learned how to define classes in Java.
- You have learned how to define and use methods in
Java. - You have learned how to create objects in Java
78Summary, cont.
- You have learned how parameters work in Java.
- You have learned about information hiding and
encapsulation. - You have become familiar with the notion of a
reference (to understand class variables and
class parameters).