JAVA PROGRAMMING LAB

ABSTRACT In this Lab you will learn how to describe objects and

classes and how to define classes and create objects

Eng. Mustafa J. Dalloul Computer Programming Lab

27 November 2016

Islamic University of Gaza

Faculty of Engineering

Computer Engineering Dept.

Computer Programming Lab (ECOM 2114)

1

Object-oriented programming enables you to develop large-scale software and

GUIs effectively.

Object-oriented programming (OOP) involves programming using objects. An

object represents an entity in the real world that can be distinctly identified. For

example, a student, a desk, a circle, a button, and even a loan can all be viewed as

objects. An object has a unique identity, state, and behavior.

The state of an object (also known as its properties or attributes) is

represented by data fields with their current values.

The behavior of an object (also known as its actions) is defined by methods.

A Java class uses variables to define data fields and methods to define actions.

Next Figure shows an example of defining the class for Rectangle objects:

Class Name: Rectangle

Data Fields:

width is ______

Height is _____

Methods:

getArea

getPerimeter

setWidth

setHeight

Class Template

Rectangle Object 1

Data Fields:

width is 5

Height is 2

Rectangle Object 2

Data Fields:

width is 2.5

Height is 1

Rectangle Object 3

Data Fields:

width is 20

Height is 7

Objects of

Rectangle

Class

2

Example 1: Define a Rectangle class as a described states and behaviors from the

previous figure, then create a three objects and call the methods from the

Rectangle class.

public class Rectangle { double width = 1.0; double height = 1.0; Rectangle(){ } Rectangle(double w, double h){ width = w; height = h; } double getArea(){ return width*height; } double getPerimeter(){ return 2*(width+height); } }

Data Fields

Constructor

Methods

public class TestRectangle { public static void main(String[] args) { Rectangle r1 = new Rectangle(5.5,27); System.out.println("The area of Rectangle1 is: " +r1.getArea()); System.out.println("Perimeter of Rectangle1 is: " +r1.getPerimeter()+"\n"); Rectangle r2 = new Rectangle(10, 3); System.out.println("The area of Rectangle2 is: " +r2.getArea()); System.out.println("Perimeter of Rectangle2 is: " +r2.getPerimeter()+"\n"); Rectangle r3 = new Rectangle(10, 3); System.out.println("The area of Rectangle3 is: " +r3.getArea()); System.out.println("Perimeter of Rectangle3 is: " +r3.getPerimeter()); } }

Creating a three objects from the Rectangle class:

3

Constructors

A constructor is invoked to create an object using the new operator. Constructors

are a special kind of method. They have three peculiarities:

■ A constructor must have the same name as the class itself.

■ Constructors do not have a return type—not even void.

■ Constructors are invoked using the new operator when an object is created.

Constructors play the role of initializing objects.

A static variable is shared by all objects of the class. A static method cannot access

instance members of the class.

The data field width and height in the rectangle class is known as an instance

variable. An instance variable is tied to a specific instance of the class; it is not shared

among objects of the same class.

If you want all the instances of a class to share data, use static variables, also known

as class variables. Static variables store values for the variables in a common

memory location.

Let’s to modify the rectangle class and adding the numberOfObjects which is a static

variable that’s count the number of created objects from the rectangle class:

public class Rectangle { double width = 1.0; double height = 1.0; static int numberOfObjects = 0; // we are added this variable Rectangle(){ } Rectangle(double w, double h){ width = w; height = h; numberOfObjects ++; // at every object this will be incremented by one. } static int getNumberOfObjects(){ return numberOfObjects; }//static method to access the variable . . . .

4

Testing the new rectangle class:

Rectangle r1 = new Rectangle(5.5, 27); System.out.println("The number of Instances: " + r1.getNumberOfObjects()); Rectangle r2 = new Rectangle(10, 3); System.out.println("The number of Instances: " + r2.getNumberOfObjects());

The result after running the program:

Tip: Use Class Name

Use ClassName.methodName(arguments) to invoke a static method and

ClassName.staticVariable to access a static variable. This improves readability,

because this makes the static method and data easy to spot.

Recall that PI is a constant defined in Math, and Math.PI references the constant. So

r1.getNumberOfObjects() and r2.getNumberOfObjects() are better replaced by

Rectangle.getNumberOfObjects() or Rectangle.numberOfObjects.

Data Accessing

See this graphical diagram:

This mean that’s an instance method can invoke and access another instance

(method & data field) and static (method & data filed).

On other hand, a static method can only invoke and access a static (method & data

field).

5

See this code and read the comments:

public class A { int i = 5; static int k = 2; public static void main(String[] args) { int j = i; // Wrong because i is an instance variable m1(); // Wrong because m1() is an instance method } public void m1() { // Correct since instance and static variables and methods // can be used in an instance method i = i + k + m2(i, k); }

Visibility modifiers can be used to specify the visibility of a class and its

members:

- Default: The default modifier is accessible only within package

- Public: A public makes a modifier for classes, methods, and data fields

accessible from any other classes

- Private: by adding a private, this makes methods and data fields

accessible only from within its own class

- Protected: Later in java II .

See these examples:

Example 1:

C1: A nonpublic class has package-access.

6

Example 2:

Caution

The private modifier applies only to the members of a class. The public modifier

can apply to a class or members of a class. Using the modifiers public and private

on local variables would cause a compile error.

Making data fields private protects data and makes the class easy to maintain.

Return to the Rectangle class, we see that we can access the variables width

and height directly by writing r1.width and r1.height!

To prevent direct modifications of data fields, you should declare the data

fields private, using the private modifier. This is known as data field

encapsulation.

public class Rectangle { private double width = 1.0; private double height = 1.0; private static int numberOfObjects = 0; . . .

Now, How we can set the values of width and height from the rectangle

objects instances?

Okay, we need to create a public method that’s make a variables accessible

for reading and writing (Setters and Getters).

See the full modified rectangle class:

7

public class Rectangle { private double width = 1.0; private double height = 1.0; private static int numberOfObjects = 0; Rectangle(){ } Rectangle(double w, double h){ width = w; height = h; numberOfObjects ++; } static int getNumberOfObjects(){ return numberOfObjects; } double getArea(){ return width*height; } double getPerimeter(){ return 2*(width+height); } public double getWidth() { return width; } public void setWidth(double width) { this.width = width; } public double getHeight() { return height; } public void setHeight(double height) { this.height = height; } }

Creating an instances:

Rectangle r1 = new Rectangle(); r1.setWidth(50); r1.setHeight(70); System.out.println(r1.getArea());

8

this

The keyword this refers to the object itself. It can also be used inside a

constructor to invoke another constructor of the same class.

See this figure:

Using this to Reference Hidden Data Fields

Using this to Invoke a Constructor

public class Rectangle { private double width = 1.0; private double height = 1.0; private static int numberOfObjects = 0; Rectangle(){ this(1.0,1.0); this to invoke another constructor } Rectangle(double width, double height){ this.width = width; this to invoke private variables this.height = height; this to invoke private variables numberOfObjects ++; }

}

9

Design a class named Location for locating a maximal value and its location in

a two-dimensional array. The class contains public data fields row, column, and

maxValue that store the maximal value and its indices in a two-dimensional array

with row and column as int types and maxValue as a double type.

Write the following method that returns the location of the largest element in a

two-dimensional array:

public static Location locateLargest(double[][] a)

Sample Run:

Enter the number of rows and columns in the array: 3 4

Enter the array: 23.5 35 2 10

4.5 3 45 3.5

35 44 5.5 9.6

The location of the largest element is 45 at (1, 2)