object oriented programming using java, second sem BCA,UoM

Constructors
 A special type of method that enables an object to initialize itself when it is
created
 Constructors have the same name as the class itself
 They do not specify a return type, not even void because they return the
instance of the class itself.
 It is called constructor because it constructs the values at the time of object
creation

Example:
class Rectangle
{
int length;
int width;
Rectangle (int x, int y) // Defining constructor
{
length=x;
width=y;
}
int rectArea()
{
return (length * width);
}
}

Class RectangleArea
{
public static void main(string a[ ])
{
Rectangle rect1=new Rectangle(15,10); //calling constructors
int area1=rect1.rectArea( );
System.out.println(“Area1= ” +area1);
}
}

Types of Constructor
 In Java, constructors can be divided into three types:
1. No-Arg Constructor
 If a constructor does not accept any parameters, it is known as
a no-argument constructor.
 Ex: class Data
{
Data()
{
System.out.println("No-Args Constructor");
}
public static void main(String[] args)
{
Data d = new Data();
}
}

2. Parameterized Constructor
 A Java constructor can also accept one or more parameters. Such
constructors are known as parameterized constructors (constructors
with parameters).
class Data
{
int num1, num2;
Data(int m,int n)
{
num1=m;
num2=n;
}
{
Data d = new Data(10,20)
}
}

3. Default Constructor
 If we do not create any constructor, the Java compiler automatically creates a no-arg
constructor during the execution of the program.
 This constructor is called the default constructor.
 Ex: class Data
{
{
Data d = new Data();
}
}
 Default constructor only role is to initialize the object and return it to the calling code.
 Default constructor is always without argument and provided by java compiler only
when there is no existing constructor defined.

Overloaded constructor
 Two or more constructors having different parameters is called overloaded
constructor.
 Ex:
class Demo
{
int a,b,c;
Demo()
{
a=1; b=2; c=3;
}
Demo(int x, int y)
{
a=x; b=y; c=20;
}

Demo(int x, int y, int z)
{
a=x; b=y; c=z;
}
}
class Main
{
public static void main(String args[])
{
Demo obj1=new Demo();
Demo obj2=new Demo(10,20);
Demo obj3=new Demo(10,20,30);
}
}

Java Garbage Collection
 Java garbage collection is the process by which Java programs perform
automatic memory management.
 Java programs compile to bytecode that can be run on a Java Virtual
Machine, or JVM for short.
 When Java programs run on the JVM, objects are created on the heap,
which is a portion of memory dedicated to the program.
 Eventually, some objects will no longer be needed. The garbage collector
finds these unused objects and deletes them to free up memory.

Finalizer
• Finalizer methods are almost the opposite of constructor methods.
• A constructor method is used to initialize an object, while finalizer methods
are called just before the object is garbage-collected and its memory
reclaimed.
• The syntax of the finalizer method is simply finalize().
• The Object class defines a default finalizer method.
• To create a finalizer method, override the finalize() method using the
following signature:

 The body of finalize() method can include several objects including
super.finalize(). This object allows the parent class to finalize an object, if
necessary.
 The finalize() method can be called at any time; however, calling finalize()
does not trigger an object to be garbage-collected. Only removing all
references to an object will cause it to be marked for deleting.
 Finalizer methods are best used for optimizing the removal of an object
(for example, by removing references to other objects) by releasing
external resources that have been acquired (for example, external files), or
for other behaviors that may make it easier for that object to be removed .

Visibility modifiers
 Java provides entities called “Access Modifiers or access specifiers” that help
us to restrict the scope or visibility of a package, class, constructor, methods,
variables, or other data members. These access modifiers are also
called “Visibility Specifiers”.
 The access specifiers also determine which data members (methods or fields)
of a class can be accessed by other data members of classes or packages etc.
 To ensure encapsulation and reusability, these access specifiers/modifiers are
an integral part of object-oriented programming.

Visibility modifiers in Java
1. Default: Whenever a specific access level is not specified, then it is assumed
to be ‘default’. The scope of the default level is within the package.
2. Public: This is the most common access level and whenever the public
access specifier is used with an entity, that particular entity is accessible
throughout from within or outside the class, within or outside the package,
etc.
3. Protected: The protected access level has a scope that is within the package.
A protected entity is also accessible outside the package through inherited
class or child class.
4. Private: When an entity is private, then this entity cannot be accessed
outside the class. A private entity can only be accessible from within the class.

Inbuilt classes - String
 The String is a built-in class in Java to store a sequence of characters between
double-quotes.
 It’s under java.lang package so we don’t have to import, it will be imported
automatically for every class.
 Example: class Main
{
{
String str = "apple";
System.out.println(str); // apple
String name = new String("John");
System.out.println(name); // John
}
}

 The strings are objects in java of the class ‘String’.
System.out.println(“Welcome to java”);
The string “welcome to java” is automatically converted into a string
object by java.
 A string in java is not a character array and it is not terminated with
“NULL”.

object oriented programming using java, second sem BCA,UoM

More Related Content

Similar to object oriented programming using java, second sem BCA,UoM (20)

More from ambikavenkatesh2 (19)

Recently uploaded (20)

object oriented programming using java, second sem BCA,UoM