�ݺ�ߣ

University Of Gondar
Edited
1
Basics of Object Oriented In
Java by Habitamu Asimare

Object-Oriented Nomenclature
Introduction to Object Oriented Programming2
“Class” means a category of things
A class name can be used in Java as the type of a field or local
variable or as the return type of a function (method)
“Object” means a particular item that belongs to a class
Also called an “instance”
For example, consider the following line:
String s1 = "Hello";
Here, String is the class, s1 is an instance variable of class
String, whose value is the String object "Hello"

Example 1: Instance Variables (“Fields”
or “Data Members”)
class Ship1 {
public double x, y, speed, direction;
public String name;
}
public class Test1 {
public static void main(String[] args) {
Ship1 s1 = new Ship1();
s1.x = 0.0;
s1.y = 0.0;
s1.speed = 1.0;
s1.direction = 0.0; // East
s1.name = "Ship1";
System.out.println(s1.name + " is initially at ("
+ s1.x + "," + s1.y + ").");
s1.x = s1.x + s1.speed
* Math.cos(s1.direction * Math.PI / 180.0);
s1.y = s1.y + s1.speed
* Math.sin(s1.direction * Math.PI / 180.0);
System.out.println(s1.name + " has moved to ("
+ s1.x + "," + s1.y + ").");
}
}

Instance Variables: Results
Compiling and Running:
javac Test1.java
java Test1
Output:
Ship1 is initially at (1,0).
Ship2 has moved to (-1.41421,1.41421).

Example 1: Major Points
Java naming convention
Format of class definitions
Creating classes with “new”
Accessing fields with “variableName.fieldName”

Java Naming Conventions
Leading uppercase letter in class name
public class MyClass {
...
}
Leading lowercase letter in field, local variable, and method
(function) names
myField, myVar, myMethod

First Look at Java Classes
 The general form of a simple class is
modifier class Classname {
modifier data-type field1;
modifier data-type field2;
...
modifier data-type fieldN;
modifier Return-Type methodName1(parameters) {
//statements
}
...
modifier Return-Type methodName2(parameters) {
//statements
}
}

Objects and References
Once a class is defined, you can easily declare a variable
(object reference) of the class
Ship s1, s2;
Point start;
Color blue;
Object references are initially null
The null value is a distinct type in Java and should not be
considered equal to zero
A primitive data type cannot be cast to an object (use wrapper
classes)
The new operator is required to explicitly create the object
that is referenced
ClassName variableName = new ClassName();

Accessing Instance Variables
Use a dot between the variable name and the field name, as
follows:
variableName.fieldName
For example, Java has a built-in class called Point that has
x and y fields
Point p = new Point(2, 3); // Build a Point object
int xSquared = p.x * p.x; // xSquared is 4
p.x = 7;
One major exception applies to the “access fields through
varName.fieldName” rule
Methods can access fields of current object without varName
This will be explained when methods (functions) are discussed

Example 2: Methods
class Ship2 {
public double x=0.0, y=0.0, speed=1.0, direction=0.0;
public String name = "UnnamedShip";
private double degreesToRadians(double degrees) {
return(degrees * Math.PI / 180.0);
}
public void move() {
double angle = degreesToRadians(direction);
x = x + speed * Math.cos(angle);
y = y + speed * Math.sin(angle);
}
public void printLocation() {
System.out.println(name + " is at ("
+ x + "," + y + ").");
}
}

Methods (Continued)
s1.name = "Ship1";
s2.direction = 135.0; // Northwest
s2.speed = 2.0;
s2.name = "Ship2";
s1.move();
s2.move();
s1.printLocation();
s2.printLocation();
}
}
javac Test2.java
java Test2
Output:
Ship1 is at (1,0).
Ship2 is at (-1.41421,1.41421).

Format of method definitions
Methods that access local fields
Calling methods
Static methods
Default values for fields
public/private distinction

Defining Methods
(Functions Inside Classes)
Basic method declaration:
public ReturnType methodName(type1 arg1,
type2 arg2, ...) {
...
return(something of ReturnType);
}
Exception to this format: if you declare the return type as
void
This special syntax that means “this method isn’t going to
return a value – it is just going to do some side effect like
printing on the screen”
In such a case you do not need (in fact, are not permitted), a
return statement that includes a value to be returned

Examples of Defining Methods
Here are two examples:
The first squares an integer
The second returns the faster of two Ship objects, assuming that a class
called Ship has been defined that has a field named speed
// Example function call:
// int val = square(7);
public int square(int x) {
return(x*x);
}
// Example function call:
// Ship faster = fasterShip(someShip, someOtherShip);
public Ship fasterShip(Ship ship1, Ship ship2) {
if (ship1.speed > ship2.speed) {
return(ship1);
} else {
return(ship2);
}
}

Exception to the “Field Access with
Dots” Rule
Normally access a field via: variableName.fieldName
but an exception is when a method of a class wants to access fields
of that same class
In that case, omit the variable name and the dot
For example, a move method within the Ship class might do:
x = x + speed * Math.cos(direction);
...
}
Here, x, speed, and direction are all fields within the class that the
move method belongs to, so move can refer to the fields directly
As we’ll see later, you still can use the variableName.fieldName
approach, and Java invents a variable called this that can be used for that
purpose

Static Methods
Static functions are like global functions in other languages
You can call a static method through the class name
ClassName.functionName(arguments);
For example, the Math class has a static method called cos that
expects a double precision number as an argument
So you can call Math.cos(3.5) without ever having any object
(instance) of the Math class

Method Visibility
public/private distinction
A declaration of private means that “outside” methods can’t call it --
only methods within the same class can
Thus, for example, the main method of the Test2 class could not have
done
double x = s1.degreesToRadians(2.2);
 Attempting to do so would have resulted in an error at compile time
Only say public for methods that you want to guarantee your class will
make available to users
You are free to change or eliminate private methods without telling
users of your class about

Example 3: Constructors
class Ship3 {
public double x, y, speed, direction;
public String name;
public Ship3(double x, double y,
double speed, double direction,
String name) {
this.x = x; // "this" differentiates instance vars
this.y = y; // from local vars.
this.speed = speed;
this.direction = direction;
this.name = name;
}
private double degreesToRadians(double degrees) {
return(degrees * Math.PI / 180.0);
}
...

Constructors (Continued)
double angle = degreesToRadians(direction);
x = x + speed * Math.cos(angle);
y = y + speed * Math.sin(angle);
}
public void printLocation() {
System.out.println(name + " is at ("
+ x + "," + y + ").");
}
}
Ship3 s1 = new Ship3(0.0, 0.0, 1.0, 0.0, "Ship1");
Ship3 s2 = new Ship3(0.0, 0.0, 2.0, 135.0, "Ship2");
s1.move();
s2.move();
s1.printLocation();
s2.printLocation();
}
}

Constructor Example: Results
javac Test3.java
java Test3
Output:
Ship1 is at (1,0).
Ship2 is at (-1.41421,1.41421).

Format of constructor definitions
The “this” reference
Destructors (not!)

Constructors
Constructors are special functions called when a class is
created with new
Constructors are especially useful for supplying values of fields
Constructors are declared through:
public ClassName(args) {
...
}
Notice that the constructor name must exactly match the class name
Constructors have no return type (not even void), unlike a regular
method
Java automatically provides a zero-argument constructor if and only if
the class doesn’t define it’s own constructor
That’s why you could say
in the first example, even though a constructor was never defined

The this Variable
 The this object reference can be used inside any non-static
method to refer to the current object
 The common uses of the this reference are:
1. To pass a reference to the current object as a parameter to other
methods
someMethod(this);
2. To resolve name conflicts
 Using this permits the use of instance variables in methods that have
local variables with the same name
 Note that it is only necessary to say this.fieldName when you
have a local variable and a class field with the same name; otherwise just
use fieldName with no this

Destructors
This Page Intentionally Left Blank

Summary
Class names should start with uppercase; method names with
lowercase
Methods must define a return type or void if no result is
returned
If a method accepts no arguments, the arg-list in the method
declaration is empty instead of void as in C
Static methods do not require an instance of the class; static
methods can be accessed through the class name
The this reference in a class refers to the current object
Class constructors do not declare a return type
Java performs its own memory management and requires no
destructors

�ݺ�ߣ

Java basic understand OOP

More Related Content

Java basic understand OOP