Java Classes
A class in Java is a set of objects that share common characteristics and common properties. It is a
user-defined blueprint or prototype from which objects are created. For example, Student is a class
while a particular student named Ravi is an object.
Properties of Java Classes
• Class is not a real-world entity. It is just a template or blueprint, or a prototype from which
objects are created.
• Class does not occupy memory.
• A class is a group of variables of different data types and a group of methods.
• A Class in Java can contain:
o Data member
o Method
o Constructor
o Nested Class
o Interface
Class Declaration in Java
access_modifier class <class_name>
data member;
method;
constructor;
nested class;
interface;
Components of Java Classes
In general, class declarations can include these components, in order:
• Modifiers: A class can be public or has default access (Refer this for details).
• Class keyword: Class keyword is used to create a class.
• Class name: The name should begin with an initial letter (capitalized by convention).
• Superclass (if any): The name of the class’s parent (superclass), if any, preceded by the
keyword extends. A class can only extend (subclass) one parent.
• Interfaces(if any): A comma-separated list of interfaces implemented by the class, if any,
preceded by the keyword implements. A class can implement more than one interface.
• Body: The class body is surrounded by braces, { }.
Java Constructors
Java constructors or constructors in Java is a terminology used to construct something in our
programs. A constructor in Java is a special method that is used to initialize objects when they are
created. It is automatically called when an object is instantiated using the new keyword. It can be
used to set initial values for object attributes.
Key Features of Constructors:
• Same Name as the Class: A constructor has the same name as the class in which it is defined.
• No Return Type: Constructors do not have any return type, not even void. The main purpose
of a constructor is to initialize the object, not to return a value.
• Automatically Called on Object Creation: When an object of a class is created, the constructor
is called automatically to initialize the object’s attributes.
• Used to Set Initial Values for Object Attributes: Constructors are primarily used to set the
initial state or values of an object’s attributes when it is created.
Example: This program demonstrates how a constructor is automatically called when an object is
created in Java.
// Java Program to demonstrate
// Constructor
import java.io.*;
// Driver Class
class A {
// Constructor
Geeks()
super();
System.out.println("Constructor Called");
// main function
public static void main(String[] args)
A a1 = new A();
Output
Constructor Called
Note: It is not necessary to write a constructor for a class. It is because the java compiler creates a
default constructor (constructor with no arguments) if your class doesn’t have any.
How Java Constructors are Different From Java Methods?
The below table demonstrates the key difference between Java Constructor and Java Methods.
Features Constructor Method
Constructors must have the same name as the Methods can have any valid
Name class name name
Methods have the return type or
Constructors do not return any type
void if does not return any value.
Return Type
Constructors are called automatically with new
Methods are called explicitly
Invocation keyword
Methods are used to perform
Constructors are used to initialize objects
Purpose operations
Now let us come up with the syntax for the constructor being invoked at the time of object or
instance creation.
class A{
…….
// A Constructor
A() {
…….
// We can create an object of the above class
// using the below statement. This statement
// calls above constructor.
A obj = new A();
The first line of a constructor is a call to super() or this(), (a call to a constructor of a super-class or an
overloaded constructor), if you don’t type in the call to super in your constructor the compiler will
provide you with a non-argument call to super at the first line of your code, the super constructor must
be called to create an object:
Note: If you think your class is not a subclass it actually is, every class in Java is the subclass of a
class object even if you don’t say extends object in your class definition.
Why Do We Need Constructors in Java
Constructors play a very important role, it ensures that an object is properly initialized before use.
What happens when we don’t use constructors:
Without constructors:
• Objects might have undefined or default values.
• Extra initialization methods would be required.
• Risk of improper object state
When Java Constructor is called?
Each time an object is created using a new() keyword, at least one constructor (it could be the default
constructor) is invoked to assign initial values to the data members of the same class. Rules for writing
constructors are as follows:
• The constructor(s) of a class must have the same name as the class name in which it resides.
• A constructor in Java can not be abstract, final, static, or Synchronized.
• Access modifiers can be used in constructor declaration to control its access i.e which other
class can call the constructor.
Types of Constructors in Java
Now is the correct time to discuss the types of the constructor, so primarily there are three types of
constructors in Java are mentioned below:
• Default Constructor
• Parameterized Constructor
• Copy Constructor
1. Default Constructor in Java
A constructor that has no parameters is known as default constructor. A default constructor is
invisible. And if we write a constructor with no arguments, the compiler does not create a default
constructor. It is taken out. It is being overloaded and called a parameterized constructor. The default
constructor changed into the parameterized constructor. But Parameterized constructor can’t change
the default constructor. The default constructor can be implicit or explicit.
• Implicit Default Constructor: If no constructor is defined in a class, the Java compiler
automatically provides a default constructor. This constructor doesn’t take any parameters and
initializes the object with default values, such as 0 for numbers, null for objects.
• Explicit Default Constructor: If we define a constructor that takes no parameters, it’s called an
explicit default constructor. This constructor replaces the one the compiler would normally
create automatically. Once you define any constructor (with or without parameters), the
compiler no longer provides the default constructor for you.
Example: This program demonstrates the use of a default constructor, which is automatically called
when an object is created.
// Java Program to demonstrate
// Default Constructor
import java.io.*;
// Driver class
class A {
// Default Constructor
A() {
System.out.println("Default constructor"); }
// Driver function
public static void main(String[] args)
A a1 = new A();
Output
Default constructor
Note: Default constructor provides the default values to the object like 0, null, false etc. depending on
the type.
2. Parameterized Constructor in Java
A constructor that has parameters is known as parameterized constructor. If we want to initialize
fields of the class with our own values, then use a parameterized constructor.
Example: This program demonstrates the use of a parameterized constructor to initialize an object’s
attributes with specific values.
// Java Program for Parameterized Constructor
import java.io.*;
class A {
// data members of the class.
String name;
int id;
A(String name, int id) {
this.name = name;
this.id = id;
class B
public static void main(String[] args)
// This would invoke the parameterized constructor.
A a1 = new A("Avinash", 68);
System.out.println("AName :" +a1.name
+ " and AId :" + a1.id);
Output
AName :Avinash and BId :68
Remember: Does constructor return any value?
There are no “return value” statements in the constructor, but the constructor returns the current class
instance. We can write ‘return’ inside a constructor.
3. Copy Constructor in Java
Unlike other constructors copy constructor is passed with another object which copies the data
available from the passed object to the newly created object.
Note: In Java,there is no such inbuilt copy constructor available like in other programming languages
such as C++, instead we can create our own copy constructor by passing the object of the same class
to the other instance(object) of the class.
Example: This example, demonstrates how a copy constructor can be used to create a new object by
copying the values of another object’s attributes.
// Java Program for Copy Constructor
import java.io.*;
class A {
// data members of the class.
String name;
int id;
// Parameterized Constructor
A(String name, int id)
this.name = name;
this.id = id;
// Copy Constructor
A(A obj2)
this.name = obj2.name;
this.id = obj2.id;
class A {
public static void main(String[] args)
// This would invoke the parameterized constructor.
System.out.println("First Object");
A a1 = new A("Avinash", 68);
System.out.println("AName :" + a1.name
+ " and AId :" + a1.id);
System.out.println();
// This would invoke the copy constructor.
A a2 = new A(a1);
System.out.println(
"Copy Constructor used Second Object");
System.out.println("AName :" + a2.name
+ " and AId :" + a2.id);
Output
First Object
AName :Avinash and AId :68
Copy Constructor used Second Object
AName :Avinash and AId :68
Constructor Overloading
When we create more than one constructors in same class provided they have different umber of
arguments / different type of argument.
package contructor;
public class B {
B(){
System.out.println(1);
B(int x){
System.out.println(10);
public static void main(String[] args) {
B b1=new B();
B b2=new B(100);
}
}
Output
Constructor Chaining
Constructor chaining is the process of calling one constructor from another constructor with respect
to current object.
One of the main use of constructor chaining is to avoid duplicate codes while having multiple
constructor (by means of constructor overloading) and make code more readable.
Prerequisite - Constructors in Java
Constructor chaining can be done in two ways:
• Within same class: It can be done using this() keyword for constructors in the same class
• From base class: by using super() keyword to call the constructor from the base class.
Constructor chaining occurs through inheritance. A sub-class constructor’s task is to call super class’s
constructor first. This ensures that the creation of sub class’s object starts with the initialization of the
data members of the superclass. There could be any number of classes in the inheritance chain. Every
constructor calls up the chain till the class at the top is reached.
Why do we need constructor chaining?
This process is used when we want to perform multiple tasks in a single constructor rather than
creating a code for each task in a single constructor we create a separate constructor for each task and
make their chain which makes the program more readable.
Example:
package constructor_chaining;
// Here we call one constructor from
//another constructor
public class A {
A(int x, int y){
System.out.println(x);
System.out.println(y);
}
A(int x){
this(1000,2000);
A(){
this(100);
public static void main(String[] args) {
A a1=new A();
Java Methods
A method is a block of code which only runs when it is called.
You can pass data, known as parameters, into a method.
Methods are used to perform certain actions, and they are also known as functions.
Why use methods? To reuse code: define the code once, and use it many times.
Create a Method
A method must be declared within a class. It is defined with the name of the method, followed by
parentheses (). Java provides some pre-defined methods, such as System.out.println(), but you can
also create your own methods to perform certain actions:
Example
public class Main {
static void myMethod() {
// code to be executed
Example Explained
• myMethod() is the name of the method
• static means that the method belongs to the Main class and not an object of the Main class.
You will learn more about objects and how to access methods through objects later in this
tutorial.
• void means that this method does not have a return value. You will learn more about return
values later in this chapter
• Call a Method
• To call a method in Java, write the method's name followed by two
parentheses () and a semicolon;
• In the following example, myMethod() is used to print a text (the action),
when it is called:
Example
Inside main, call the myMethod() method:
public class Main {
static void myMethod() {
System.out.println("I just got executed!");
public static void main(String[] args) {
myMethod();
// Outputs "I just got executed!"
Java Modifiers / Access specifiers
Modifiers
Access Specifier / Access Modifiers
1. private
2. default
3. protected
4. public
private default protected public
Same class yes Yes yes yes
Same package
subclass NO Yes yes yes
Same package
non subclass NO Yes yes yes
different
package No No yes yes
subclass
different
package non No No No yes
subclass
Private:
a. private members are the class are accessible in the same class
Example 1:
package p1;
public class A {
private int i = 10;
private void test(){
System.out.println("From test");
public static void main(String[] args) {
A a1 = new A();
System.out.println(a1.i);
a1.test();
Output:
10
From test
Example 2:
private members cannot be accesses in same package sub class
package p1;
public class A {
private int i = 10;
private void test(){
System.out.println("From test");
package p1;
public class B extends A{
public static void main(String[] args) {
B b1 = new B();
System.out.println(b1.i);
b1.test();
Output:
error
Note: private members cannot be accessed in different non subclass same
package
Example 3:
package p1;
public class A {
private int i = 10;
private void test(){
System.out.println("From test");
package p1;
public class B {
public static void main(String[] args) {
A a1 = new A();
System.out.println(a1.i);
a1.test();
Output:
error
Note: private members cannot be accessed in different package sub class
Example 4:
package p1;
public class A {
private int i = 10;
private void test(){
System.out.println("From test");
package p2;
import p1.A;
public class C extends A{
public static void main(String[] args) {
C c1 = new C();
System.out.println(c1.i);
c1.test();
Output:
Error
Note: private members cannot be accessed in different package non sub class
Example 5:
package p1;
public class A {
private int i = 10;
private void test(){
System.out.println("From test");
package p2;
import p1.A;
public class C {
public static void main(String[] args) {
A a1 = new A();
System.out.println(a1.i);
a1.test();
}
}
Output:
Error
Important Note:
Private members are accessible only in same class, outside that class
private members cannot be used
default access specifier:
These members are accessible only in same package, outside the package tese
members cannot be accessed
Example 1:
package p1;
public class A {
int i = 10;
void test(){
System.out.println("From Test");
public static void main(String[] args) {
A a1 = new A();
System.out.println(a1.i);
a1.test();
Output:
10
From Test
Example 2:
package p1;
public class A {
int i = 10;
void test(){
System.out.println("From Test");
package p1;
public class B extends A{
public static void main(String[] args) {
B b1 = new B();
System.out.println(b1.i);
b1.test();
Output:
10
From Test
Example 3:
package p1;
public class A {
int i = 10;
void test(){
System.out.println("From Test");
package p1;
public class B {
public static void main(String[] args) {
A a1 = new A();
System.out.println(a1.i);
a1.test();
Output:
10
From Test
Example 4:
package p1;
public class A {
int i = 10;
void test(){
System.out.println("From Test");
package p1;
public class A {
int i = 10;
void test(){
System.out.println("From Test");
Example 5:
package p1;
public class A {
int i = 10;
void test(){
System.out.println("From Test");
package p2;
import p1.A;
public class C {
public static void main(String[] args) {
A a1 = new A();
System.out.println(a1.i);
a1.test();
Protected Access Specifier:
protected members can be accessed in same package and in different package
onlythrough inheritance
Example 1:
package p1;
public class A {
protected int i = 10;
protected void test(){
System.out.println("From Test");
public static void main(String[] args) {
A a1 = new A();
System.out.println(a1.i);
a1.test();
Output:
10
From Test
Example 2:
package p1;
public class A {
protected int i = 10;
protected void test(){
System.out.println("From Test");
package p1;
public class B extends A{
public static void main(String[] args) {
B b1 = new B();
System.out.println(b1.i);
b1.test();
Example 3:
package p1;
public class A {
protected int i = 10;
protected void test(){
System.out.println("From Test");
package p1;
public class B {
public static void main(String[] args) {
A a1 = new A();
System.out.println(a1.i);
a1.test();
Example 4:
package p1;
public class A {
protected int i = 10;
protected void test(){
System.out.println("From Test");
package p2;
import p1.A;
public class C extends A{
public static void main(String[] args) {
C c1 = new C();
System.out.println(c1.i);
c1.test();
Output:
10
From Test
Example 5:
package p1;
public class A {
protected int i = 10;
protected void test(){
System.out.println("From Test");
package p2;
import p1.A;
public class C{
public static void main(String[] args) {
A a1 = new A();
System.out.println(a1.i);
a1.test();
Output:
Error
Public access specifier:
Public access specifier can be accessed anywhere in the project
Note: A class in java can be public or default. It cannot be private or
protected
Example 1:
In the below example we get an error because default class cannot be
accessed in different package
package p1;
class A {
}
package p2;
import p1.A;
public class B extends A{
Output: Error
Note:
1. If a constructor is made public then its object can be created anywhere
in the project
2. If a constructor is made default then its object cannot be created in
different package
3. If a constructor is made private then its object can be created in same
class
4. If a constructor is made protected then its object can be created in
same package only just like default constructor
