Classes, Methods and Objects
Class Fundamentals
A class is a template for an object.
An object is an instance of a class.
Define a new data type.
Once define this new data type is used
to create an object of that type.
The Structure of a class
class classname {
type instance-variable1;
type instance-variable1;
//...
type instance-variableN;
type methodname1(parameter-list){
//body of the method
}
type methodnameN(parameter-list){
//body of the method
}
}
The data/variable within the class is called
instance variable.
Each object has its own copy of variable.
The code is contained within the method.
The method and instance variable is defined
within the class is called member of the
class. that is, things that you access with .
The variable of one object is separate and
unique from the variable of the other object.
class Box {
double width;
double height;
double depth;
}
To create an object of type Box:
Box mybox = new Box();
Now mybox will be an instance of Box.
To access the member of the mybox object
outside the class
mybox.width=100;
// This class declares an object of type Box.
class BoxDemo {
public static void main(String args[]) {
Box mybox = new Box();
double vol;
// assign values to mybox's instance variables
mybox.width = 10;
mybox.height = 20;
mybox.depth = 15;
// compute volume of box
vol = mybox.width * mybox.height * mybox.depth;
System.out.println("Volume is " + vol);
}
}
Here two class file are created
1.BoxDemo
2.Box
These two class may contain in two different
files.
javac Box.java BoxDemo.java
There can only be one public class per file. The filename should also match the name of this public class (e.g., MyClass.java for a class named MyClass).
This class is accessible from other packages. You can have multiple classes declared without the public keyword.
These classes are considered package-private and can only be accessed by other classes within the same package.
Declaring Objects
Creating an object is a two steps process:
Declare a variable of the class type
It is simple a variable that can refer to an object
Acquire an actual copy of the object and assign it to that
variable.
Keyword
new operator is used to allocate the memory for an
object and return a reference to it.
reference means the address of the object allocated by
new.
Box b1 = new Box(); you create a new instance of the Box class in memory and assign its reference to the variable b1.
This means b1 now refers to the actual Box object.
Box b2 = b1; copy the reference of b1 to b2
.......
b1 = null; b1 no longer refers to any specific object. It becomes a reference that doesn't point anywhere.
The original Box object itself might still exist in memory until it's garbage collected, but you can't access it through b1 anymore.
When you assign one object reference
variable, you are not creating a copy of the
object, you only making a copy of the
reference.
class Box {
double width;
double height;
double depth;
// display volume of a box
void calculateVolume() {
System.out.println("Volume is “ +width * height * depth);
}
}
class BoxDemo3 {
public static void main(String args[]) {
Box mybox1 = new Box();
Box mybox2 = new Box();
// assign values to mybox1's instance variables
mybox1.width = 10;
mybox1.height = 20;
mybox1.depth = 15;
/* assign different values to mybox2's instance variables */
mybox2.width = 3;
mybox2.height = 6;
mybox2.depth = 9;
// display volume of first box
mybox1.calculateVolume();
Volume is 3000.0
// display volume of second box Volume is 162.0
mybox2.calculateVolume();
}
}
Constructor
Using Constructor is a must to while creating an object
A constructor initializes an object
immediately upon creation.
It has the same name as the class in whice it
resides.
Automatically called after the object is
created.
class Box {
double width;
double height;
double depth;
// This is the constructor for Box.
Box() {
System.out.println("Constructing Box"); Printing inside a constructor
width = 10;
height = 10;
depth = 10;
}
// compute and return volume
double volume() {
return width * height * depth;
}
}
class BoxDemo6 {
public static void main(String args[]) {
// declare, allocate, and initialize Box objects
Box mybox1 = new Box();
Box mybox2 = new Box();
double vol;
// get volume of first box
vol = mybox1.volume();
System.out.println("Volume is " + vol);
Output:
// get volume of second box Whenever a object is crated
construtor gets called and prints
Constructing Box
(executes the printing method)
vol = mybox2.volume();
Constructing Box
System.out.println("Volume is " + vol);
Volume is 1000.0
}
Volume is 1000.0
}
Box mybox1 = new Box();
The constructor is the class Box is being
called.
When no constructor is defined, java creates
a default constructor and initialized all the
instance variable to zero.
Therefore, In the previous example, the volume will be 0.0 (code saved)
Parameterized Constructor
/* Here, Box uses a parameterized constructor to initialize the dimensions of a box.*/
class Box {
double width;
double height;
double depth;
// This is the constructor for Box.
Box(double w, double h, double d) {
width = w;
height = h;
depth = d;
}
// compute and return volume
double volume() {
return width * height * depth;
}
}
class BoxDemo7 {
public static void main(String args[]) {
// declare, allocate, and initialize Box objects
Box mybox1 = new Box(10, 20, 15);
Box mybox2 = new Box(3, 6, 9);
double vol;
// get volume of first box
vol = mybox1.volume();
System.out.println("Volume is " + vol);
// get volume of second box
vol = mybox2.volume();
System.out.println("Volume is " + vol);
}
}
The this Keyword
This keyword can be used inside any method to
refer the current object.
Every object can access a reference to itself with
this.
Use this to resolve name-space collisions.
Box(double width, double height, double depth) {
this.width = width;
this.height = height;
this.depth = depth;
Local variable/
} formal parameter
Garbage Collection
Handle de-allocation of memory that is
occupied by object.
exists
When no references to an object exits the
memory is automatically be freed.
The Finalize Method Built-in
If an object is holding some non-java resources such
as file handler.
You want to make sure these resources must be freed
before an object is destroyed.
Define specific actions that will occur when an object is
just about to be reclaimed by garbage collection.
The structure of finalize method is:
protected void finalize() Key points:
1. Not guaranteed
2. Unpredictable timing
{ 3. Not an alternative to proper resource management
//finalization code
}
Prevents access to finalize() by code outside of the
class.
Arrays
An array is a group of like-typed variables
that are referenced by a common name.
A specific element of an array is accessed by
its index.
One dimensional Arrays
The general form of one dimensional array
declaration is:
type var_name[];
Example:
int month_days[];
Actually no array is exists.
This is a reference variable that can hold the address
of the integer type array.
month_days = new int[12];
Allocates a 12 element array of integer and link
them to the month_days.
Array can be initialized when they are declared
Like C
class AutoArray {
public static void main(String args[]) {
Size can't be writen (we could do this in C)
int month_days[] = { 31, 28, 31, 30, 31, 30, 31, 31,
30, 31, 30, 31 };
System.out.println("April has " + month_days[3] + "
days.");
}
}
Multidimensional Arrays
int twoD[][] = new int[4][5];
This allocates a 4 by 5 array and assigns it to twoD.
In Multidimensional array
you only need to the first dimension (leftmost). (Row)
You can allocate the remaining dimension separately.
int twoD[][] = new int[4][];
twoD[0] = new int[1];
twoD[1] = new int[2];
twoD[2] = new int[3];
twoD[3] = new int[4];
Alternative array declaration syntax
int a1[] = new int[3];
int [] a2 = new int [3];
Array are implemented as objects
Using length instance variable we can found the
number of element that an array hold.
For 2D array, length will be number of rows
class Length { To get number of columns, we need to write => array_name[index_of_row]
public static void main(String args[]) {
int a1[] = new int[10];
int a2[] = {3, 5, 7, 1, 8, 99, 44, -10};
int a3[] = {4, 3, 2, 1};
Not a method, so not length() but length
System.out.println("length of a1 is " + a1.length);
System.out.println("length of a2 is " + a2.length);
System.out.println("length of a3 is " + a3.length);
}
}
Strings
Probably the most common used class.
Every string you created is actually an object of
String class.
Strings can be constructed a variety of ways:
String myString;
myString= "this is a test";
or
String myString = "this is a test";
System.out.println(myString);
Using “+”, two strings can be concatenated
String myString = "I" + " like " + "Java.";
Or, String myString= aString+bString;
// Demonstrating Strings.
class StringDemo {
public static void main(String args[]) {
String strOb1 = "First String";
String strOb2 = "Second String";
String strOb3 = strOb1 + " and " + strOb2;
System.out.println(strOb1);
System.out.println(strOb2);
System.out.println(strOb3);
}
}
Also Compare => Directly using == [BE AWARE, there is no > / < / >= /..... for string (but != is available)]
Some methods of String class:
boolean equals(String object)
int length() Not an instance variable like that of Array,
so not length but length()
char charAt(int index) [Index starts from 0]
// Demonstrating some String methods.
class StringDemo2 {
public static void main(String args[]) {
String strOb1 = "First String";
String strOb2 = "Second String";
String strOb3 = strOb1;
System.out.println("Length of strOb1: " + strOb1.length());
System.out.println("Char at index 3 in strOb1: " + strOb1.charAt(3));
if(strOb1.equals(strOb2))
System.out.println("strOb1 == strOb2");
else
Length of strOb1: 12
System.out.println("strOb1 != strOb2"); Index starts from 0
Char at index 3 in strOb1: s
if(strOb1.equals(strOb3)) strOb1 != strOb2
System.out.println("strOb1 == strOb3"); strOb1 == strOb3
else
System.out.println("strOb1 != strOb3");
}
}
Array of Strings
// Demonstrate String arrays.
class StringDemo3 {
public static void main(String args[]) {
String str[] = { "one", "two", "three" };
length of the array
for(int i=0; i<str.length; i++)
System.out.println("str[" + i + "]: " + str[i]);
}
}
Overloading Methods
In Method overloading
Two or more method within the same class share
the same name.
But their parameter declarations are different.
Overloaded methods must differ in the type or
the number of parameters.
Methods may have different return type, but it is
not sufficient for method overloading.
// Demonstrate method overloading.
class OverloadDemo {
void test() {
System.out.println("No parameters");
}
// Overload test for one integer parameter.
void test(int a) {
System.out.println("a: " + a);
}
// Overload test for two integer parameters.
void test(int a, int b) {
System.out.println("a and b: " + a + " " + b);
}
// overload test for a double parameter
double test(double a) {
System.out.println("double a: " + a);
return a*a;
}
}
class Overload {
public static void main(String args[]) {
OverloadDemo ob = new OverloadDemo();
double result;
// call all versions of test()
ob.test();
ob.test(10);
ob.test(10, 20);
result = ob.test(123.2);
System.out.println("Result of ob.test(123.2): " + result);
}
}
Output:
No parameters
a: 10
a and b: 10 20
double a: 123.2
Result of ob.test(123.2): 15178.24
Automatic Type Conversion
// Automatic type conversions apply to overloading.
class OverloadDemo {
void test() {
System.out.println("No parameters");
}
// Overload test for two integer parameters.
void test(int a, int b) {
System.out.println("a and b: " + a + " " + b);
}
// overload test for a double parameter and return type
void test(double a) {
System.out.println("Inside test(double) a: " + a);
}
}
class Overload { One Interface, Multiple
public static void main(String args[]) { methods
OverloadDemo ob = new OverloadDemo(); In c, there are abs(), fabs(),
int i = 88; labs() which return the absolute
value of integer, float and long.
But in java abs() method of Math
ob.test(); class can return absolute value
ob.test(10, 20); of all data type using method
overloading.
ob.test(i); // this will invoke test(double)
ob.test(123.2); // this will invoke test(double)
}
}
Output:
No parameters
a and b: 10 20
Inside Test( double) a :88
Inside Test (double) a: 123.2
Overloading Constructor
/* Here, Box defines three constructors to initialize
the dimensions of a box various ways.*/
class Box {
double width;
double height;
double depth;
// constructor used when all dimensions specified
Box(double w, double h, double d) {
width = w; // constructor used when cube is
height = h; created
depth = d; Box(double len) {
} width = height = depth = len;
}
// constructor used when no dimensions specified
Box() { // compute and return volume
width = -1; // use -1 to indicate double volume() {
height = -1; // an uninitialized return width * height * depth;
depth = -1; // box }
} }
class OverloadCons { Output:
public static void main(String args[]) {
Volume of mybox1 is 3000.0
// create boxes using the various constructors
Volume of mybox2 is –1.0
Box mybox1 = new Box(10, 20, 15);
Volume of mycube is 343.0
Box mybox2 = new Box();
Box mycube = new Box(7);
double vol;
// get volume of first box
vol = mybox1.volume();
System.out.println("Volume of mybox1 is " + vol);
// get volume of second box
vol = mybox2.volume();
System.out.println("Volume of mybox2 is " + vol);
// get volume of cube
vol = mycube.volume();
System.out.println("Volume of mycube is " + vol);
}
}
Objects as Parameter
// Objects may be passed to methods.
class Test {
int a, b;
Test(int i, int j) {
a = i;
b = j;
}
// return true if o is equal to the invoking object
boolean equals(Test o) {
if(o.a == a && o.b == b) return true;
else return false;
}
}
class PassOb {
public static void main(String args[]) {
Test ob1 = new Test(100, 22);
Test ob2 = new Test(100, 22);
Test ob3 = new Test(-1, -1);
System.out.println("ob1 == ob2: " + ob1.equals(ob2));
System.out.println("ob1 == ob3: " + ob1.equals(ob3));
}
}
Output:
ob1 == ob2: true
ob1 == ob3: false
Call-by-Reference
A reference to an argument is passed to the parameter.
Used to access the actual argument specified in the call
In Java
This is done by passing an object
Object are passed by reference
Primitive data types are always passed by value.
class Test { Objects, arrays, and strings are passed by reference (a copy of the reference, not the object itself).
Modifications made through the reference variable within the method affect the original object.
int a, b; Java doesn't have direct pointers for primitive data types.
Wrapper classes and modifying objects passed by reference can simulate call by reference
behavior for primitives, but with limitations.
Test(int i, int j) {
a = i;
b = j;
}
// pass an object
Don't get confused; you can pass an object of the same class as where (class) it's written
void meth(Test o) {
o.a *= 2;
o.b /= 2;
}
}
class CallByRef {
public static void main(String args[]) {
Test ob = new Test(15, 20);
System.out.println("ob.a and ob.b before call: " +
ob.a + " " + ob.b);
ob.meth(ob);
System.out.println("ob.a and ob.b after call: " +
ob.a + " " + ob.b);
}
}
Output:
When a simple type is passed to
Ob.a and ob.b before call: 15 20 a method, it is done by use of
Ob.a and ob.b after call: 30 10 call-by-value. Objects are passed
by use of call-by-reference.
Returning Objects
// Returning an object.
class Test {
int a;
Test(int i) {
a = i;
}
Test incrByTen() {
Test temp = new Test(a+10);
return temp;
}
}
class RetOb {
Output:
public static void main(String args[]) {
Ob1.a: 2
Test ob1 = new Test(2);
Ob2.a: 12
Test ob2;
Ob2.a after second increase: 22
ob2 = ob1.incrByTen();
System.out.println("ob1.a: " + ob1.a);
System.out.println("ob2.a: " + ob2.a);
ob2 = ob2.incrByTen();
System.out.println("ob2.a after second increase: "
+ ob2.a);
}
}
Each time incrByTen() is invoked, a new object is
created and a reference to it is returned to the
calling routine.
Access Control
Control what parts of a program can access the
member of a class. aka Access Modifier
Three access specifier: public, private, protected.
When a member is declared as public
The member is accessed by any other code in your
program
When a member is declared as private
The member is only access by the other member of that
class
When no access specifier is declared, It is by
default declared as public.
/* This program demonstrates the difference between public and private.*/
class Test { // This is not OK and will cause an error
int a; // default access // ob.c = 100; // Error!
public int b; // public access
private int c; // private access // You must access c through its methods
ob.setc(100); // OK
// methods to access c
void setc(int i) { // set c's value System.out.println("a, b, and c: " + ob.a + " " +
c = i; ob.b + " " + ob.getc());
} }
int getc() { // get c's value }
return c;
}
}
class AccessTest {
public static void main(String args[]) {
Test ob = new Test();
// These are OK, a and b may be accessed directly
ob.a = 10;
ob.b = 20;
Static Keyword
A class member is only accessed when the
object or instance the class is created.
It is possible to create a class member
without reference to a specific instance.
When a member is declared as static it is
possible to access those member without
creating any object of that class.
Instance variable which are declared as static
is behaved like global variable.
block
Static have several restrictions:
They can only call other static methods.
They must only access static data.
They cannot refer to this or super in any way.
// Demonstrate static variables, methods, and blocks.
class UseStatic {
static int a = 3;
public static void main(String args[])
static int b; {
static void meth(int x) { meth(42);
}
System.out.println("x = " + x);
System.out.println("a = " + a); }
System.out.println("b = " + b); Execute exactly once, when the class is
} loaded. Generally used to initializing static
variabls.
static {
System.out.println("Static block initialized."); Static block initialized.
x = 42
b = a * 4; a=3
} b = 12
If you call a static method from outside its class
then use the following general form
classname.method() When you are insited that class, you don't need to write
classname.method() ; instead write method() only
class StaticDemo {
static int a = 42;
static int b = 99;
static void callme() {
System.out.println("a = " + a);
}
}
class StaticByName {
public static void main(String args[]) {
StaticDemo.callme();
Output:
System.out.println("b = " + StaticDemo.b);
a = 42
}
b = 99
}
Final Keyword
Just the same as const in C
A variable can declared as final.
Prevents its content from being modified.
Behave like a constant
Lowercase, not uppercase
final int FILE_NEW = 1;
final int FILE_OPEN = 2;
final int FILE_SAVE = 3;
final int FILE_SAVEAS = 4;
final int FILE_QUIT = 5;
Problem
Create a class Employee that include three pieces
of information as instance variables- a first name
(type String), a last name (type String) and a
monthly salary (double). Your class should have a
constructor that initializes the three instance
variables. Provide a set and a get method for each
instance variable. If the monthly salary is not
positive, set it to 0.0. Write a test application
named EmployeeTest that demonstrate class Main Class
Employee’s capabilities. Create two Employee
objects and display each object’s yearly
salary.Then give each Employee a 10% raise and
display each Employee’s yearly salary again.
Problem
Create a class Invoice that a hardware store might use to
represent an invoice for an item sold at the store. An
invoice should include four piece of information as
instance variables- a part number (type String), a part
description (type String), a quantity of an item being
purchased (type int) and a price per item (double). Your
class should have a constructor that initialized four
instance variables. Provide a get and set method for each
instance variable. In addition, provide a method name
getInvoiceAmount that calculate the invoice amount, then
return the amount as double value. If the quantity is not
positive, it should be set 0. If the price of per item is not
positive, it should be set 0.0. Write a test application
name InvoiceTest that demonstrate class Invoice’s
capabilities.
Problem
Create a class called Date that include three
pieces of information as instance variable – a
month (type int), a day (type int) and a year
(type int). your class should have a
constructor that initializes the three instance
variables. Provided a set and a get method
for each instance variable. Provide a method
displayDate that displays the month, day and
year separated by forward slash(/). Write a
test application DateTest that demonstrate the
class’s capabilities.
