3140705 - Object Oriented Programming 1
Unit -4
Objects and Classes
• Java is an object-oriented programming language.
• Everything in Java is associated with classes and
objects, along with its attributes and methods.
• For example: in real life, a car is an object. The car
has attributes, such as weight and color, and
methods, such as drive and brake.
Create an Object
• In Java, an object is created from a class.
• To create an object of Class, specify the class name,
followed by the object name, and use the keyword new:
public class Main
{
int x = 5;
public static void main(String[] args)
{
Main myObj = new Main();
System.out.println(myObj.x);
}
}
Multiple Objects
You can create multiple objects of one class:
public class Main
{
int x = 5;
public static void main(String[] args)
{
Main myObj1 = new Main(); // Object 1
Main myObj2 = new Main(); // Object 2
System.out.println(myObj1.x);
System.out.println(myObj2.x);
}
}
Using Multiple Classes
• You can also create an object of a class and access it
in another class.
• This is often used for better organization of classes
(one class has all the attributes and methods, while
the other class holds the main() method (code to be
executed)).
• Remember that the name of the java file should
match the class name.
• In this example, we have created two files in the
same directory/folder:
public class Main
{
int x = 5;
}
class Second
{
public static void main(String[] args)
{
Main myObj = new Main();
System.out.println(myObj.x);
}
}
When both files have been compiled:
C:\Users\Your Name>javac Main.java
C:\Users\Your Name>javac Second.java
Run the Second.java file:
C:\Users\Your Name>java Second
And the output will be:
5
Java Class Methods
• You learned that methods are declared within a class, and that
they are used to perform certain actions:
public class Main
{
static void myMethod()
{
System.out.println("Hello World!");
}
public static void main(String[] args)
{
myMethod();
}
}
// Outputs "Hello World!"
Static vs. Non-Static
• You will often see Java programs that have either
static or public attributes and methods.
• In the example above, we created a static
method, which means that it can be accessed
without creating an object of the class, unlike
public, which can only be accessed by objects:
• An example to demonstrate the differences
between static and public methods:
public class Main
{
static void myStaticMethod()
{
System.out.println("Static methods can be called without creating objects");
}
public void myPublicMethod()
{
System.out.println("Public methods must be called by creating objects");
}
public static void main(String[] args)
{
myStaticMethod(); // Call the static method
// myPublicMethod(); This would compile an error
Main myObj = new Main(); // Create an object of Main
myObj.myPublicMethod(); // Call the public method on the object
}
}
Output
Static methods can be called without creating objects
Public methods must be called by creating objects
Access Methods With an Object
public class Main
{
public void fullThrottle()
{
System.out.println("The car is going as fast as it can!");
}
public void speed(int maxSpeed)
{
System.out.println("Max speed is: " + maxSpeed);
}
public static void main(String[] args)
{
Main myCar = new Main(); // Create a myCar object
myCar.fullThrottle(); // Call the fullThrottle() method
myCar.speed(200); // Call the speed() method
}
}
Output
The car is going as fast as it can!
Max speed is: 200
Constructors
• A constructor in Java is a special method that is used
to initialize objects.
• The constructor is called when an object of a class is
created. It can be used to set initial values for object
attributes.
• Every time an object is created using the new()
keyword, at least one constructor is called.
• It calls a default constructor if there is no constructor
available in the class.
Rules for creating Java constructor
• There are two rules defined for the constructor.
• Constructor name must be the same as its class name
• A Constructor must have no explicit return type
• A Java constructor cannot be abstract, static, final, and
synchronized
Types of Java constructors
There are two types of constructors in Java:
– Default constructor (no-arg constructor)
– Parameterized constructor
Java Default Constructor
A constructor is called "Default Constructor" when it doesn't have any parameter.
Syntax of default constructor: class_name( ){ }
class Bike1
{
Bike1()
{
System.out.println("Bike is created");
}
public static void main(String args[])
{
Bike1 b=new Bike1();
}
}
Output: Bike is created
Rule: If there is no constructor in a class, compiler automatically creates a default
constructor.
What is the purpose of a default constructor?
The default constructor is used to provide the default values to the object like 0, null, etc.,
depending on the type.
class Student
{
int id;
String name;
void display()
{
System.out.println(id+" "+name);
}
public static void main(String args[])
{
Student s1=new Student();
Student s2=new Student();
s1.display();
s2.display();
}
}
Output:
0 null
0 null
Java Parameterized Constructor
• A constructor which has a specific number of
parameters is called a parameterized constructor.
Why use the parameterized constructor?
The parameterized constructor is used to provide
different values to distinct objects. However, you
can provide the same values also.
//Java Program to demonstrate the use of the parameterized constructor.
class Student
{
int id;
String name;
Student(int i,String n)
{
id = i;
name = n;
}
void display()
{
System.out.println(id+" "+name);
}
public static void main(String args[])
{
Student s1 = new Student(111,"Karan");
Student s2 = new Student(222,"Aryan");
s1.display();
s2.display();
}
}
Output:
111 Karan
222 Aryan
Constructor Overloading in Java
• In Java, a constructor is just like a method but without
return type.
• It can also be overloaded like Java methods.
• Constructor overloading in Java is a technique of having
more than one constructor with different parameter lists.
• They are arranged in a way that each constructor performs
a different task.
• They are differentiated by the compiler by the number of
parameters in the list and their types.
Example of Constructor Overloading
//Java program to overload constructors
class Student5{
int id;
String name;
int age;
//creating two arg constructor
Student5(int i,String n){
id = i;
name = n;
}
//creating three arg constructor
Student5(int i,String n,int a){
id = i;
name = n;
age=a;
}
void display(){System.out.println(id+" "+name+" "+age);}
public static void main(String args[]){
Student5 s1 = new Student5(111,"Karan");
Student5 s2 = new Student5(222,"Aryan",25);
s1.display();
s2.display();
}
}
Output:
111 Karan 0
222 Aryan 25
