Chapter –II Class and Object

 Class and object

 Define a class Compiled By: Daniel Tesfay

 Creating and using an object Master of Engineering in ICT Convergence

Senior Lecturer
 Modifiers Access and Non-Access
Department of Computer Science
 Method and constructor
Hawassa University

 Instantiating an object 2024

 Objective

At the end of this chapter, students will be able to

o understand the class and object
o demonstrate class definition
o create and use objects of a given class
o use method and constructor
o understand and use Instance fields
o Understand the modifiers/ Access Modifiers
Class

o A class is the template or blueprint from which objects are made

o It is a collection of identical objects

o A class is a means to logically group objects that shares some

common properties and behaviour.

o Many objects are of the same kind but have different identity.

o Class is an object’s type

 Class Conn…
o A class provides a method for packaging together a group of
logically related data items and function that operates on them
o Before we create a class, we must identify

₋ Class name

₋ Data items which are called fields

₋ Functions or methods/behavior of the object

 Class

o By convention, attributes’ name are suggested to be adjectives to describe

the object and the behaviors are the verbs or actions that shows action on
the object.

o For example, consider a car as an entity it would have the components:

₋ Class name/Entity Name: Car

₋ Attribute/ States : make, model, color, year, mpg

₋ Method/behaviors: moveForward(), moveBackward(), turnLeft(),

turnRight(), stop(), and honk() are methods or behaviors of a car object.
Define a class

o A class definition consists of

₋ Access modifier
₋ Class keyword
₋ Class Name
₋ State / data members
₋ Behaviour / method
₋ Constructors
Class definition Syntax
[Accesses Modifier ] <class> <ClassName> {

[Access Modifier] <Data Type> <DataMember1>;

[Access Modifier] <Data Type> <Data Member2 >;
[Access Modifier] <Return Type> <MrthodName1> ( [Para1, Para2 …]) {
//method body
}
[Access Modifier] <ClassName> ([optional Parameter lists]) {
// Constructors Body
}

} //end of the class

Class Definition Example
public class Account {
private int accountNo;
private float balance;

public Account(int accountNo, float balance) {

this.accountNo = accountNo;
this.balance = balance;
}

public int getAccountNo() { return accountNo;}

public float getBalance() { return balance;}

public void setAccountNo(int accountNo) { this.accountNo = accountNo;}

public void setBalance(float balance) { this.balance = balance;}

}
 Dog class definition Example
public class Dog {
₋ This class Dog has 3 methods and instance variables.
private String breed;
₋ Methods like:- barking(), hungry(), sleeping()
private int age
₋ States like:- breed, age, color.
private String color;
void barking() { //body …………………. }
void hungry() {//body ……………………}
void sleeping() {//body ................ }
}
Extended Class Definition
[Accesses Modifier ] <class> <ClassName> [extends] [Superclass]
[implements ] [interface1, Inteface2] {
[Access Modifier] <Data Type> <DataMember1>;
[Access Modifier] <Data Type> <Data Member2 >;
[Access Modifier] <Return Type> <MrthodName1> ( [Para1, Para2 …]) {
//method body
}
[Access Modifier] <ClassName> ([optional Parameter lists]) {
// Constructors Body
}

} //end of the class

Object

o An object is an instance of a given class

o It is a runtime entity of any class

o An object must be created using the class name and new keyword

o Syntax of Object creation

ClassName ObjectName = new CLassName();
o "new" is a keyword used to return the memory of the object.
Create an Object
o There are three steps when creating an object from a class

1. Declaration- a variable declaration with a variable name of an object type

2. Instantiation- the ‘new’ key word is used to create the object.

3. Initialization- the ‘new’ key word is followed by a constructor call. This call
initializes the new object.
Object Creation Example
Example Create an object of Car

o Crate an object of car class named tFord

Car TFord = new Car();
Instantiating and using objects

o Instance variables and methods are accessed via created objects.

o To access an instance variable the fully qualified path should be .
Accessing Instance Members
Access Modifiers
Access Modifiers

o Access modifiers are keywords used as a prefix with class, method and variables.

o Access modifies will change the meaning of certain statement

o That provides restriction of access /privilege

o In java the following access modifiers are supported

₋ Package private

₋ Public

₋ Private

₋ Protected
Package private

₋ No keyword is used to define a class or members of class as

package private.

₋ Package private access modifiers are package level

₋ So long the classes are in the same package, there is an access

privilege of members from one class to another class

₋ Classes, methods and variables can be defined as package private

Public

₋ Any class member which is defined as public would have an access privilege from
any other class regardless of the package specification

₋ It has higher access privilege than others

₋ It uses a keyword public as prefix to define a public members

₋ A class, variable, or method, interface can be defined public.

₋ By conversion, it is recommended to define methods and classes as public.

Protected

o Protected is a keyword used to define a protected member or

class
o Protected can be used with, class, method and data members
o A class members defined as a protected are accessible only by the
class which is inherited by the sub class
Protected

o The third relationship is between a class and its present and future subclasses.

o These subclasses are much closer to a parent class than to any other "outside"
classes for the following reasons:

₋ Subclasses are usually more intimately aware of the internals of a parent class

₋ Subclasses are often written by you or by someone to whom you’ve given your
source code.

₋ Subclasses frequently need to modify or enhance the representation of the data

within a parent class.
Private

o Private is the most narrowly visible, highest level of

protection that you can get.
o It is the diametric opposite of public. private methods
and variables cannot be seen by any class other than the
one in which they are defined .
o Any private data, internal state, or representations
unique to your implementation anything that shouldn’t
be directly shared with subclasses is private.
 Example
class Car {
private String make; The fields/data members are defined as
private String model; Private therefore, all the fields are
private int year;
private double mpg; accessible only with in this class
private String color;
private void moveForward() {/*body*/ }
private void moveBackward() {/*body*/}
private void stop() { /*body*/} Methods are defined as
private void turnLeft() {/*body*/ }
private void turnRight() { /*body */}
private and they are not
private void honk() { /*body*/ }
public static void main(String[] args) {
accessible outside of this class
Car myCar = new Car (); private
myCar.make = "Subaru";
myCar.model = "Outback";
myCar.year = 2017;
myCar.mpg = 28;
myCar.color = "red";
}
}
Summary of Access Modifiers

o The table below shows each type of modifier, it goes from least
restrictive (public) to most restrictive (private).
Modifier Class Package Subclass Everywhere

public Y Y Y Y

protected Y Y Y N

Package private Y Y N N

private Y N N N
Constructors and Methods
Constructors
o Constructors are a special methods that are used to
initialize the class and instance variables automatically
at the time of object is creation
o Constructors have the same name as the class name.
o No return type is specified for the constructor
o By default, constructors are public
o Constructors can be invoked only during object creation or from
other constructors using this keyword.
Defining constructor

o General Syntax
[public] <ClassName><([parameters]) >{
//body of the constructor
}
Types of Constructor

o Java provides three types of constructors

o Default constructor

₋ A constructor which is added automatically by the compiler when the program is

compiled

₋ If you declare any constructors for a class, the Java compiler will not create a
default constructor for that class.

₋ The body of the default contractor is empty

Default Constructor: Example
No Argument Constructor

o Constructor with no arguments is known as No-Argument

constructor.

o The signature is same as default constructor, how ever the body

can have any code given by the programmer
Example

public class DateTest{

String day;
String month;
int year;
/* This constructor provides an initial value for the members */
public DateTest() {
this.day="Monday";
this.month = "January"
this.year = 2011;
}
}
Parametrized Constructor

o Constructor with arguments/Parameters is known as

Parameterized constructor.

o The parametrized constructors will initialize the data members of

the given class in to its parameter values.

o The value must passed from the user when the object is created
 Constructor: Example

o Consider the Car as a class. Therefore, define a constructor with

no argument with in that class
class Car {

private String make; private String model; private int year;

private double mpg; private String color;

public Car() { No Argument Constructor

}
public Car(String make, String model, int year, double mpg, String color) {
this.make = make; this.model = model;
this.year = year; this.mpg = mpg;
this.color = color; Parametrized Constructor
}
}
Invoking a Constructor
o Constructor can be implicitly invoked when we are creating an object

o Explicitly called using this() keyword from another constructor.

o Class Car can be invoked this way

₋ Car carObj = new Car(); this line of statement will invoke the no argument
constructor

₋ It is also possible to invoke the No argument constructor from the parametrized

constructor in such a way

public Car(String make, String model, int year, double mpg, String color) {
this(); // this line will invoke the no argument constructor
}
Example
public class Student{ Invoking the
String firstName, lastName, sex;
int age;
paramconstructor using
public Student() { this() method from other
this("Dawit", "Tesfaye", 27, "Male"); constructor
}
public Student(String firstName, String lastName, int age, String sex) {
this.firstName = firstName;
this.lastName = lastName;
this.age = age;
this.sex = sex;
} Invoking the no argument
public static void main(String[] args) { constructor when the
Student stud1 = new Student();
} object is created
}
Methods
Method
o A method is a block of code that performs a specific task and can be called
(invoked) when needed. Methods help in:
₋ Organizing code
₋ Reusing code
₋ Making code more readable and maintainable
o Suppose you need to create a program to create a circle and color it. You can
create two methods to solve this problem:
₋ a method to draw the circle
₋ a method to color the circle
Types of Methods

o Types of Methods

₋ Standard Library Methods: These are built-in methods in Java that are
available to use.

₋ User-defined Methods: We can create our own method based on our

requirements.
Java Built-in methods

o Categories of Built-in Methods

₋ String Methods
₋ Number Methods
₋ Character Methods
₋ Array Methods etc.
String Methods

o compareTo(), str1.compareTo(str2), it returns 0 if equal, returns

positive if str1 > str2 else returns negative

o equals(): str1.equals(str2), returns either true or false

o concat(), str1.concat(str2)

o charAt(): Returns a character by index position

String Methods conn….

o equalsIgorecase() str1. equalsIgorecase(str2)

o toUpperCase () , str. toUpperCase () ;
o toLowerCase(), str. toLowerCase(),
o trim(), Removes spaces from both sides of a String, str.trim()
o endsWith() -Ends with specified suffix, str1.endsWith(str2)
o length() (returns string length) str.length()
Number Methods

o // Integer methods
₋ int num = Integer.parseInt("123"); // String to int
₋ String s = Integer.toString(456); // int to String
₋ int max = Integer.max(10, 20); // Maximum of two numbers
₋ int min = Integer.min(10, 20); // Minimum of two numbers
o // Double methods
₋ double d = Double.parseDouble("3.14"); // String to double
₋ boolean nan = Double.isNaN(d); // Checks if Not-a-Number
Character Methods

o char c = 'A';
₋ boolean isLetter = Character.isLetter(c); // Checks if character is letter
₋ boolean isDigit = Character.isDigit('7'); // Checks if digit
₋ boolean isWhitespace = Character.isWhitespace(' '); // Checks whitespace
₋ char lowerCase = Character.toLowerCase(c); // Converts to lowercase
₋ char upperCase = Character.toUpperCase('a'); // Converts to uppercase
Array Methods
o List<String> list = new ArrayList<>();
₋ list.add("Apple");
₋ list.add("Banana");
₋ Collections.sort(list); // Sorts list
₋ Collections.reverse(list); // Reverses list
₋ Collections.shuffle(list); // Randomly shuffles
₋ int freq = Collections.frequency(list, "Apple"); // Counts frequency
o // List methods
₋ String item = list.get(0); // Gets element by index
₋ list.set(1, "Orange"); // Replaces element
₋ int size = list.size(); // Gets size
User Defined Method : Syntax

ReturnType MethodName(DataType para1, DataType para2, ...) {

//Method body
}
o ReturnType - It specifies what type of value a method returns
₋ void return type: a method that returns nothing
₋ None void return type: a method that returns a value of its
return type
o methodName - It is an identifier that is used to refer to the
particular method in a program.
Method

o Method body - It includes the programming statements that are

used to perform some tasks.
o The method body is enclosed inside the curly braces { … }
o Example
int addNumbers() { Return type: int
// code Method Name: addNumbers
} Method Body: code
 Complex method Syntax

[Modifier] [static] <returnType> <methodName> ([Para1,

para2 .])
{
// method body
}
o Modifier - It defines access visibility (public, private, or protected)
o static
₋ none access modifier
₋ it can be accessed without creating objects.
Calling a method

o To let the method do what is specified inside the body, it has to

be called by another method or main method.

o calling Syntax for the None static method inside static method is
objectName.methodName(arguments); // if the method is void

Variable = objectName.methodName(arguments); // for none void method

System.out.print(objectName.methodName(arguments)); // none void method

 Calling a method

o Calling a none static method inside instance method of the same class and
o Calling a static method in any method of the same class
₋ is possible using its signature without object reference
₋ Syntax : methodName(arguments list..);
o In both the above cases, if the call is from different classes, it is must to
use object reference.
₋ Syntax : objectReference.methodName(arguments list..);
Reading assignment

o Parameter Passing
o Java Garbage collector
o enum (Enumerator)
Destroying Object

o Java uses automatic garbage collection.

o When new objects are created, the memory is automatically allocated

o Consequently, whenever the objects are not referenced anymore,

they are destroyed and their memory is reclaimed.

o Java garbage collection is an automatic process.

o The programmer does not need to explicitly mark objects to be deleted.
Enumerated Types

o An enumeration (enum) is a special data type which contains

a set of predefined constants.

o We use an enum, when dealing with values that aren't

required to change, like days of the week, seasons of the
year, colors, and so on.
Creating enum in java

o To create enum, we use enum keyword

o Syntax
<enum> <enumName>{ Example
VALUE1,
enum Colors{
VALUE2, RED,
BLUE,
VALUE3
YELLOW,
} GREEN
}
Example: using an enum
enum Colors {
RED,
BLUE,
YELLOW,
GREEN
}

public class EnumDemo {

public static void main(String[] args)

{
Colors red = Colors.RED;
System.out.println(red); // RED
}
}
Reading Assignment

o Encapsulation
End of Chapter –II Class and Object
 Class and object
 Define a class Compiled By: Daniel Tesfay

Master of Engineering in ICT Convergence

 Creating and using an object Senior Lecturer

 Modifiers Access and Non-Access Department of Computer Science

Hawassa University
 Method and constructor 2022

 Instantiating an object
CHAPTER III