Transcript CSE 120 9/8/05

Introduction to Programming
with Java, for Beginners
Intro OOP with Java
Java Program Structure
Object-Oriented Programming Model

Design problems/programs such that they
correspond to real world entities

Entity a.k.a Object is something that has real
existence


Objects: Model the parts of a problem. They
have:



Examples: person, dog, car, student, bank account
Data/State: information about that object
Behaviors: describe how the object behaves
Classes


Describes common features to all objects
Templates for creating objects
1
Example 1: Student Object
• Data: name, address, major, courseList
• Behavior: change major, add/drop a course
2
Example 3: Dog Objects
3
OOP in Java

A Java program is a collection of objects

A class is an abstract description of
objects

Classes contain

Data Fields that hold the data for each object
 Data is stored in instance variables

Methods that describe the actions/behaviors the
object can perform

Constructor(s) that tell how to create a new object of
this class
4
Class Structure
class Classname {
//Data Fields
…
//Constructor
..
//Methods
..
}

Classname and Filename
should be same
 i.e. Classname.java

Start and end of class
declaration is indicated by curly
braces i.e. { }
 Compiler complains if this is
missing
5
Classes contain Data Definitions

Classes describe the data held by each of
its objects

Also known as instance variables
class Dog {
Data usually goes first in a class
String name;
int age;
...rest of the class...
}
6
Classes contain Data Definitions (contd..)

Data can also describe the relationship
of the object to other objects

Example: a checkingAccount might have
An accountNumber (used as an ID number)
 A balance (the internal state of the account)
 An owner (some object representing a
person)

7
Classes always contain Constructors

A constructor is a piece of code that “constructs,”
or creates, a new object of that class

If you don’t write a constructor, Java defines one
for you (behind the scenes)


i.e. default constructor
Usually a constructor is written to initialize an
object’s state i.e. data fields

Default constructor initialize object’s state default value
for that type. E.g. for type int, the default value is zero
8
Constructor: Initialize Data Example
class Dog {
String name;
int age;
(This part is the constructor)
Dog(String Name, int Age) {
name = Name;
age = Age;
}
…
//rest of the class
}

Important: Constructor name is same as ClassName
9
Creating Objects

Declare a variable of appropriate type to hold
the object


E.g. For Dog object we a need a variable of type Dog
Use the constructor of Dog to create a Dog
instance and store it in the variable

Known as invoking the constructor
Dog d1;
d1 = new Dog();
make a new object
Dog d2;
d2 = new Dog(“Fido”, 5);
make a new object
10
Classes contain Methods

A class may contain methods that describe the
behavior of objects

Methods contain one or more statements that
describe a particular behavior


A block of code, which when used performs certain
instructions
Different from control block structures like if, while
Can receive inputs
Can return an output
11
Examples of Object Behavior

Query Methods: ask an object about its state
 What’s your name? Age? Favorite band?

Command Methods: change an object’s state

Withdraw $100 from my bank account my
bank balance changes
12
Example of Method
Methods usually go after the data & constructor
class Dog {
...
void bark() {
//instructions for barking
System.out.println(“Woof”);
}
}
Statement
13
Making object do something

To make a dog object bark, in Java we
write
d1.bark();
 d1 is dog object and we ask a this
particular dog to bark, it says “Woof”
 Terminology:

Sending message to dog object
Commanding or Asking the dog to something
14
General Method Declaration

return_type methodName(0+ parameters){..}
Input

Method Input
 receive 0 or more inputs. E.g. bark() has no inputs
 Inputs may be passed so that method can use these
values for some purpose
 A method specifies its expected inputs via a list of “formal
parameters” (type1 name1,type2 name2, …)
void bark(String barkSound){
System.out.println(barkSound);
}
15
General Method Declaration (contd..)

return_type methodName(0+ parameters){..}
Output

Method Output
A method may output nothing or one thing
 If it outputs nothing, then its return_type is
void
void setDogAge(int dogAge){
age = dogAge;
}

16
General Method Declaration (contd..)

Method Output

If it outputs one thing: Its return_type is nonvoid
i.e. must be of certain type


It then must have a return statement that returns
a value
The value returned must match return type
int getDogAge(){
return age;
}
age is of type
“int” and hence
return type is int
17
Calling/Invoking a Method on an Object

Calling/Invoking a method on an Object


Is a programming terminology for asking or
making an object to perform some behavior
In general
objectName.methodName(0 + parameters)
 In a method call, the number, order, and type of
arguments must match the corresponding
parameters
 Examples: d1.bark(); d1.bark(“Woof grrr”);

18
Methods can contain other methods

Example:
 class Dog {
...
void bark() {
System.out.println("Woof");
}
}

E.g. System.out.println(String s)


String s is the input to the method
Other programmer's wrote printing program and called it
class System
19
Reusing already written methods

Java is famous for reusing already written
programs


Benefits: Do not need to reinvent the wheel
Java provides a huge library of useful programs
that can be reused




Comes along with the JDK tool kit
Some libraries are part of the language and can be
simply used
Some libraries (utilities) need to specified with an
import statement
More on this later lectures
20
Methods may contain temporary data

Data described in a class exists in all objects of
that class


Example: Every Dog has its own name and age
A method may contain local temporary data that
exists only until the method finishes

E.g:
void wakeTheNeighbors( ) {
int i = 50;
// i is a temporary variable
while (i > 0) {
bark( ); //using its own class method
i = i – 1;
}
}
21
Temporary /Local vs. Instance
Variables

Temporary/local variables are known


From the point of declaration until the end curly brace of
the block in which they are declared
In contrast, instance variables are


Declared outside of any method
Known to all methods in the class in which they are
declared
22
Class Methods in General

Methods consist of statements (or
instructions) causes the object to do
something
Combination of literals and, operators
 Control Structures - e.g. while, if
 Temporary variables
 Methods from other classes
 Methods from its own class

23
Asking Object about its data directly

It may possible to ask a object about its data
without querying the object i.e. calling the
method

ObjectName.DataField;
>Dog d1 = new Dog(“Fido”,5);
>String dogName = d1.name;
>System.out.println(dogName);
Fido

But this depends on accessibility of the data

More on this in slide 28
24
Putting it all together

When you want to create standalone Java
application program one of the classes should
contain the main method

Method main is a special method, not part of any
object, that is executed in order to get things
started such as:


Creating Objects
Ask objects to do something or interact with another
object
25
Main Method
public static void main(String[ ] args) {
Dog fido = new Dog("Fido", 5); // creates a Dog
fido.bark();
fido.setAge(6);
}

Method main is of return type void
Will explain the keyword public (on slide 28)
 Learn about static and String [] args in later
lectures

26
OOP Recap
Class: a template for creating objects
 An object is an instance of a class
 Example:

One Dog class
 Multiple Dog objects
 Lord of the Rings Simulation

One Human class, multiple Human objects
One Elf class, multiple Elf objects
One Orc class, multiple Orc objects
27
A Counter class example
28
Complete Counter class
public class Counter {
private int count; Data field (instance variable)
public Counter () { count = 0; } constructor
public int currentCount () {
return count;
}
methods
query
public void incrementCount () {
count = count + 1;
}
command
public void reset () { count = 0; }
?
}
Counter class declaration
29
Counter Object Behaviors

Counter c= new Counter();

If you want to increment count value of object c


If you want see the count value of object c


c.incrementCount();
c.currentCount();
If you want to reset count value of object c

c.reset();
30
Accessibility Level

Data fields/instance variables of class and class
itself can also have accessibility_level

Examples: public void incrementCount(){ .. }, private
count ;

public: makes the method/data field accessible
from outside the class

Private:not accessible outside the class

In default case: accessible if within same directory

Accessibility_level appears before


the return type of method
the type of variable
31
Complete Counter Program
public class Counter {
private int count;
public Counter () {
count = 0;
}
public int getCount () {
return count;
}
public void incrementCount () {
count = count + 1;
}
public void reset () {
count = 0;
}
public static void main(String[ ] args) {
Counter c = new Counter();
int whatIsCount = 0;
c.incrementCount();
c.incrementCount();
whatIsCount = c.currentCount();
System.out.println(whatIsCount);
c.reset();
whatIsCount = c.currentCount();
System.out.println(whatIsCount);
}
} // ends the class
32
General Java Program
File
File
Class
File
Variables
Constructors
Variables
File
Statements
Methods
Variables
Statements


A program
consists of one or
more classes
Typically, each
class is in a
separate java file
33
Writing and Running Programs in OOP

When you write a program



You are writing classes and all the things that go into
classes
Your program typically contains commands to create
objects and make them do something
When you run a program

It creates objects, and those objects interact with one
another and do whatever they do to cause something to
happen
34
Advantages of OOP

OOP is conducive to good design and
efficient redesign

Most changes affect only a few classes
35