The document defines classes and methods in Java. It discusses: 1) The syntax for defining a class with modifiers, data declarations, and method definitions. 2) How a class can contain data declarations and method declarations to store information and perform behaviors. 3) The structure of a method including the header, parameters, and body. 4) How to define constructors, static methods, and overload methods in a class.

1. DEFINING INSTANTIABLE
CLASSES
Chapter 6.6:

2. Syntax: Defining Class
 General syntax for defining a class is:
modifieropt class ClassIdentifier
{
classMembers:
data declarations
methods definitions
}
 Where
 modifier(s) are used to alter the
behavior of the class
 classMembers consist of data declarations
and/or methods definitions.

3. Class Definition
 A class can contain data declarations and method
declarations
int size, weight;
char category;
Data declarations
Method declarations

4. UML Design Specification
UML Class Diagram
Class Name
What data does it need?
What behaviors
will it perform?
Public
methods
Hidden
information
Instance variables -- memory locations
used for storing the information needed.
Methods -- blocks of code used
to perform a specific task.

5. Class Definition: An
Example
public class Rectangle
{
// data declarations
private double length;
private double width;
//methods definitions
public Rectangle(double l, double w) // Constructor method
{
length = l;
width = w;
} // Rectangle constructor
public double calculateArea()
{
return length * width;
} // calculateArea
} // Rectangle class

6. Method Definition
public void MethodName() // Method Header
{ // Start of method body
} // End of method body
 The Method Header
modifieropt ResultType MethodName (Formal ParameterList )
public static void main (String argv[ ] )
public void deposit (double amount)
public double calculateArea ( )

7. Method Header
 A method declaration begins with a method
header
int add (int num1, int num2)
method
name
return
type
Formal parameter
list
The parameter list specifies the type
and name of each parameter
The name of a parameter in the method
declaration is called a formal parameter

8. Method Body
 The method header is followed by the method
body
int add (int num1, int num2)
{
int sum = num1 + num2;
return sum;
}
The return expression
must be consistent with
the return type
sum is local data
Local data are
created each time
the method is
called, and are
destroyed when it
finishes executing

9. User-Defined Methods
 Methods can return zero or one value
 Value-returning methods
○ Methods that have a return type
 Void methods
○ Methods that do not have a return type

10. calculateArea Method.
public double calculateArea()
{
double area;
area = length * width;
return area;
}

11. Return statement
 Value-returning method uses a return
statement to return its value; it passes a
value outside the method.
 Syntax:return statement
return expr;
 Where expr can be:
 Variable, constant value or expression

12. User-Defined Methods
 Methods can have zero or >= 1
parameters
 No parameters
○ Nothing inside bracket in method header
 1 or more parameters
○ List the paramater/s inside bracket

13. Method Parameters
- as input/s to a method
public class Rectangle
{
. . .
public void setWidth(double w)
{
width = w;
}
public void setLength(double l)
{
length = l;
}
. . .
}

14. Syntax: Formal Parameter
List
 Note: it can be one or more dataType
 Eg.
 setWidth( double w )
 int add (int num1, int num2)
(dataType identifier, dataType identifier....)

15. Creating Rectangle
Instances
 Create, or instantiate, two instances of the
Rectangle class:
The objects (instances)
store actual values.
Rectangle rectangle1 = new Rectangle(30,10);
Rectangle rectangle2 = new Rectangle(25, 20);

16. Using Rectangle Instances
 We use a method call to ask each object to tell us
its area:
rectangle1 area 300
rectangle2 area 500Printed output:
System.out.println("rectangle1 area " + rectangle1.calculateArea());
System.out.println("rectangle2 area " + rectangle2.calculateArea());
References to
objects
Method calls

17. Syntax : Object
Construction
 new ClassName(parameters);
 Example:
 new Rectangle(30, 20);
 new Car("BMW 540ti", 2004);
 Purpose:
 To construct a new object, initialize it with
the construction parameters, and return a
reference to the constructed object.

18. The RectangleUser Class Definition
public class RectangleUser
{
public static void main(String argv[])
{
Rectangle rectangle1 = new Rectangle(30,10);
Rectangle rectangle2 = new Rectangle(25,20);
System.out.println("rectangle1 area " +
rectangle1.calculateArea());
System.out.println("rectangle2 area " +
rectangle2.calculateArea());
} // main()
} // RectangleUser
An application must
have a main() method
Object
Use
Object
Creation
Class
Definition

19. Method Call
 Syntax to call a method
methodName(actual parameter list);
Eg.
segi4.setWidth(20.5);
obj.add (25, count);

20. Formal vs Actual
Parameters
 When a method is called, the actual parameters in
the invocation are copied into the formal
parameters in the method header
int add (int num1, int num2)
{
int sum = num1 + num2;
return sum;
}
total = obj.add(25, count);

21. Formal vs Actual
Parameters
public class RectangleUser
{
public static void main(String argv[])
{
Rectangle rectangle1 = new Rectangle(30.0,10.0);
System.out.println("rectangle1 area " +
rectangle1.calculateArea());
rectangle1.setWidth(20.0);
System.out.println("rectangle1 area " +
rectangle1.calculateArea());
}
}

22. Method Overloading
 In Java, within a class, several methods
can have the same name. We called
method overloading
 Two methods are said to have different
formal parameter lists:
 If both methods have a different number of
formal parameters
 If the number of formal parameters is the
same in both methods, the data type of the
formal parameters in the order we list must
differ in at least one position

23. Method Overloading
 Example:
public void methodABC()
public void methodABC(int x)
public void methodABC(int x, double y)
public void methodABC(double x, int y)
public void methodABC(char x, double y)
public void methodABC(String x,int y)

24. Java code for overloading
public class Exam
{
public static void main (String [] args)
{
int test1=75, test2=68, total_test1, total_test2;
Exam midsem=new Exam();
total_test1 = midsem.result(test1);
System.out.println("Total test 1 : "+ total_test1);
total_test2 = midsem.result(test1,test2);
System.out.println("Total test 2 : "+ total_test2);
}
int result (int i)
{
return i++;
}
int result (int i, int j)
{
return ++i + j;
}
}

25.  Output
Total test 1 : 75
Total test 2 : 144

26. Constructors Revisited
 Properties of constructors:
 Name of constructor same as the name of class
 A constructor,even though it is a method, it has no
type
 Constructors are automatically executed when a
class object is instantiated
 A class can have more than one constructors –
“constructor overloading”
○ which constructor executes depends on the type of
value passed to the constructor when the object is
instantiated

27. Java code (constructor overloading)
public class Student
{ String name;
int age;
Student(String n, int a)
{ name = n; age = a;
System.out.println ("Name1 :" + name);
System.out.println ("Age1 :" + age);
}
Student(String n)
{
name = n; age = 18;
System.out.println ("Name2 :" + name);
System.out.println ("Age2 :" + age);
}
public static void main (String args[])
{
Student myStudent1=new Student("Adam",22);
Student myStudent2=new Student("Adlin");
}
}

28. Output:
Name1 :Adam
Age1 :22
Name2 :Adlin
Age2 :18

29. Object Methods & Class Methods
 Object/Instance methods belong to
objects and can only be applied after the
objects are created.
 They called by the following :
objectName.methodName();
 Class can have its own methods known
as class methods or static methods

30. Static Methods
 Java supports static methods as well as static variables.
 Static Method:-
 Belongs to class (NOT to objects created from the class)
 Can be called without creating an object/instance of the
class
 To define a static method, put the modifier static in the
method declaration:
 Static methods are called by :
ClassName.methodName();

31. Java Code (static method)
public class Fish
{
public static void main (String args[])
{
System.out.println ("Flower Horn");
Fish.colour();
}
static void colour ()
{
System.out.println ("Beautiful Colour");
}
}

32. Output:
Flower Horn
Beautiful Colour