Assignment #3 on

OOPS

Submitted By: Pooja Prasad

MCA 2nd Sem
ID: CS16MCAGN006
KAZIRANGA UNIVERSITY
1. Write the importance of import statement in java. Explain it with proper java
code.

Ans: Import statement in java is used in java to import all the predefined classes
defined in a package and within that classes many methods are defined. Package is
just like the directory in the file system. Whenever we are writing any import
statement means we are telling compiler to load all the classes or any specific
class, it depends upon the import statement declaration.User can use any class or
that specific class at any moment of time in their programs. Now i will tell you
how to use import statement and how to import all the classes defined in different
packages or any particular classes from a package.

For example, the following line would ask the compiler to load all the classes
available in directory java_installation/java/io:

import java.io.*;
__________________________________________________________________

2. What do you mean by reference or object data type? What are its characteristics?

Ans: Reference variables are created using defined constructors of the classes.
They are used to access objects. These variables are declared to be of a specific
type that cannot be changed. For example, Employee, Puppy,etc.

Its characteristics are as follows:

A) Class objects and various type of array variables come under reference
datatype.

B) Default value of any reference variable is null.

C) A reference variable can be used to refer any object of the declared type or any
compatible type.

D) Example: Animal animal = new Animal("giraffe");

__________________________________________________________________
3. Write with examples about the various variables type avaible in java with proper
code. (Features)

Ans: A variable provides us with named storage that our programs can manipulate.
Each variable in Java has a specific type, which determines the size and layout of
the variable's memory; the range of values that can be stored within that memory;
and the set of operations that can be applied to the variable.

You must declare all variables before they can be used. Following is the basic form
of a variable declaration

data type variable [ = value][, variable [ = value] ...] ;

There are three kinds of variables in Java

Local variables

Instance variables

Class/Static variables

Local Variable:

Local variables are declared in methods, constructors, or blocks.

Local variables are created when the method, constructor or block is entered
and the variable will be destroyed once it exits the method, constructor, or
block.

Access modifiers cannot be used for local variables.

Local variables are visible only within the declared method, constructor, or
block.
 Local variables are implemented at stack level internally.

There is no default value for local variables, so local variables should be

declared and an initial value should be assigned before the first use.

Example:

Here, age is a local variable. This is defined inside pupAge() method and its
scope is limited to only this method.

public class Test

{
public void pupAge()
{
int age = 0;
age = age + 7;
System.out.println("Puppy age is : " + age);
}

public static void main(String args[]) {

Test test = new Test();
test.pupAge();
}
}

OUTPUT: Puppy age is: 7

Instance Variable:

Instance variables are declared in a class, but outside a method, constructor

or any block.

When a space is allocated for an object in the heap, a slot for each instance
variable value is created.
 Instance variables are created when an object is created with the use of the
keyword 'new' and destroyed when the object is destroyed.

Instance variables hold values that must be referenced by more than one
method, constructor or block, or essential parts of an object's state that must
be present throughout the class.

Instance variables can be declared in class level before or after use.

Access modifiers can be given for instance variables.

The instance variables are visible for all methods, constructors and block in
the class. Normally, it is recommended to make these variables private
(access level). However, visibility for subclasses can be given for these
variables with the use of access modifiers.

Instance variables have default values. For numbers, the default value is 0,
for Booleans it is false, and for object references it is null. Values can be
assigned during the declaration or within the constructor.

Instance variables can be accessed directly by calling the variable name

inside the class. However, within static methods (when instance variables are
given accessibility), they should be called using the fully qualified name.
ObjectReference.VariableName.

Example:

import java.io.*;
public class Employee
{

// this instance variable is visible for any child class.

public String name;

// salary variable is visible in Employee class only.

 private double salary;

// The name variable is assigned in the constructor.

public Employee (String empName)
{
name = empName;
}

// The salary variable is assigned a value.

public void setSalary(double empSal)
{
salary = empSal;
}

// This method prints the employee details.

public void printEmp() {
System.out.println("name : " + name );
System.out.println("salary :" + salary);
}

public static void main(String args[]) {

Employee empOne = new Employee("Ransika");
empOne.setSalary(1000);
empOne.printEmp();
}
}

Output:

name: Ransika
salary: 1000.0

Class/Static Variables:

Class variables also known as static variables are declared with the static
keyword in a class, but outside a method, constructor or a block.
 There would only be one copy of each class variable per class, regardless of
how many objects are created from it.

Static variables are rarely used other than being declared as constants.
Constants are variables that are declared as public/private, final, and static.
Constant variables never change from their initial value.

Static variables are stored in the static memory. It is rare to use static
variables other than declared final and used as either public or private
constants.

Static variables are created when the program starts and destroyed when the
program stops.

Visibility is similar to instance variables. However, most static variables are

declared public since they must be available for users of the class.

Default values are same as instance variables. For numbers, the default value
is 0; for Booleans, it is false; and for object references, it is null. Values can
be assigned during the declaration or within the constructor. Additionally,
values can be assigned in special static initializer blocks.

Static variables can be accessed by calling with the class name

ClassName.VariableName.

When declaring class variables as public static final, then variable names
(constants) are all in upper case. If the static variables are not public and
final, the naming syntax is the same as instance and local variables.

Example:

import java.io.*;
public class Employee
{
 // salary variable is a private static variable
private static double salary;

// DEPARTMENT is a constant
public static final String DEPARTMENT = "Development ";

public static void main(String args[])

{
salary = 1000;
System.out.println(DEPARTMENT + "average salary:" + salary);
}
}

Output:

Development average salary:1000

__________________________________________________________________

4. What is a constructor? How many types of constructor are available in java.

Explain each of the constructor with suitable java code.

Ans: Java constructors are special methods that are called when an object is
instantiated. In other words, when you use the new keyword. The constructor
initializes the newly created object. When discussing about classes, one of the most
important sub topic would be constructors. Every class has a constructor. If we do
not explicitly write a constructor for a class, the Java compiler builds a default
constructor for that class. Each time a new object is created, at least one
constructor will be invoked. The main rule of constructors is that they should have
the same name as the class. A class can have more than one constructor.

Example:

public class Puppy

{
public Puppy()
{
}

public Puppy(String name)

{
// This constructor has one parameter, name.
}
}

Types of constructors:

a) Default Constructor:- Default Constructor is also called as Empty Constructor

which has no arguments and It is Automatically called when we creates the object
of class but Remember name of Constructor is same as name of class and
Constructor never declared with the help of Return Type. Means we cant Declare a
Constructor with the help of void Return Type. , if we never Pass or Declare any
Arguments then this called as the Copy Constructors.

b) Parameterized Constructor :- This is Another type Constructor which has

some Arguments and same name as class name but it uses some Arguments So For
this We have to create object of Class by passing some Arguments at the time of
creating object with the name of class. When we pass some Arguments to the
Constructor then this will automatically pass the Arguments to the Constructor and
the values will retrieve by the Respective Data Members of the Class.

c) Copy Constructor:- This is also Another type of Constructor. In this

Constructor we pass the object of class into the Another Object of Same Class. As
name Suggests you Copy, means Copy the values of one Object into the another
Object of Class .This is used for Copying the values of class object into an another
object of class So we call them as Copy Constructor and For Copying the values
We have to pass the name of object whose values we wants to Copying and When
we are using or passing an Object to a Constructor then we must have to use the &
Ampersand or Address Operator.
5. What is the importance of singleton class? Which kind of constructor is best
suited for implementing a singleton class and why? Write a java program to
implement a singleton class and explain its characteristics.

Ans: As the name implies, a class is said to be singleton if it limits the number of
objects of that class to one. We cant have more than a single object for such
classes. Singleton classes are employed extensively in concepts like Networking
and Database Connectivity.

The easiest implementation consists of a private constructor and a field to hold its
result, and a static accessor method with a name like getInstance().

The private field can be assigned from within a static initializer block or, more
simply, using an initializer. The getInstance( ) method (which must be public) then
simply returns this instance

// File Name: Singleton.java

public class Singleton
{

private static Singleton singleton = new Singleton( );

/* A private Constructor prevents any other

* class from instantiating.
*/
private Singleton() { }

/* Static 'instance' method */

public static Singleton getInstance( )
{
return singleton;
}

/* Other methods protected by singleton-ness */

protected static void demoMethod( ) {
System.out.println("demoMethod for singleton");
}
}

Here is the main program file where we will create a singleton object

// File Name: SingletonDemo.java

public class SingletonDemo
{

public static void main(String[] args)

{
Singleton tmp = Singleton.getInstance( );
tmp.demoMethod( );
}
}
Output: demoMethod for singleton
__________________________________________________________________

6. Write a code in java for accessing instance variable and methods.

Ans: Instance Variable:

Instance variables are declared in a class, but outside a method, constructor

or any block.

When a space is allocated for an object in the heap, a slot for each instance
variable value is created.

Instance variables are created when an object is created with the use of the
keyword 'new' and destroyed when the object is destroyed.

Instance variables hold values that must be referenced by more than one
method, constructor or block, or essential parts of an object's state that must
be present throughout the class.

Instance variables can be declared in class level before or after use.

Access modifiers can be given for instance variables.

The instance variables are visible for all methods, constructors and block in
the class. Normally, it is recommended to make these variables private
(access level). However, visibility for subclasses can be given for these
variables with the use of access modifiers.
 Instance variables have default values. For numbers, the default value is 0,
for Booleans it is false, and for object references it is null. Values can be
assigned during the declaration or within the constructor.

Instance variables can be accessed directly by calling the variable name

inside the class. However, within static methods (when instance variables are
given accessibility), they should be called using the fully qualified name.
ObjectReference.VariableName.

Example:

import java.io.*;
public class Employee
{

// this instance variable is visible for any child class.

public String name;

// salary variable is visible in Employee class only.

private double salary;

// The name variable is assigned in the constructor.

public Employee (String empName)
{
name = empName;
}

// The salary variable is assigned a value.

public void setSalary(double empSal)
{
salary = empSal;
}

// This method prints the employee details.

public void printEmp() {
System.out.println("name : " + name );
System.out.println("salary :" + salary);
 }

public static void main(String args[]) {

Employee empOne = new Employee("Ransika");
empOne.setSalary(1000);
empOne.printEmp();
}
}

Output:

name: Ransika
salary: 1000.0
__________________________________________________________________

7. What are the different access modifiers in java.

Ans: Java provides a number of access modifiers to set access levels for classes,
variables, methods, and constructors. The four access levels are

1. Visible to the package, the default. No modifiers are needed.

2. Visible to the class only (private).
3. Visible to the world (public).
4. Visible to the package and all subclasses (protected).

__________________________________________________________________

8. Write a java program to show the implementation and explain the usage of

1. The Public Modifier

2. The Private Modifier

3. The Protected Modifier

4. The Default Modifier

Ans:

1. Public Access Modifier Public:

A class, method, constructor, interface, etc. declared public can be accessed from
any other class. Therefore, fields, methods, blocks declared inside a public class
can be accessed from any class belonging to the Java Universe.

However, if the public class we are trying to access is in a different package, then
the public class still needs to be imported. Because of class inheritance, all public
methods and variables of a class are inherited by its subclasses.

Example: The following function uses public access control

public static void main(String[] arguments)

{
// ...
}

The main() method of an application has to be public. Otherwise, it could not be

called by a Java interpreter (such as java) to run the class.

2. Private Access Modifier Private:

Methods, variables, and constructors that are declared private can only be accessed
within the declared class itself.

Private access modifier is the most restrictive access level. Class and interfaces
cannot be private.

Variables that are declared private can be accessed outside the class, if public getter
methods are present in the class.

Using the private modifier is the main way that an object encapsulates itself and
hides data from the outside world.
Example: The following class uses private access control

public class Logger

{
private String format;

public String getFormat()

{
return this.format;
}

public void setFormat(String format) {

this.format = format;
}
}

Here, the format variable of the Logger class is private, so there's no way for other
classes to retrieve or set its value directly.

So, to make this variable available to the outside world, we defined two public
methods: getFormat(), which returns the value of format, and setFormat(String),
which sets its value.

3.Protected Access Modifier Protected:

Variables, methods, and constructors, which are declared protected in a superclass

can be accessed only by the subclasses in other package or any class within the
package of the protected members' class.

The protected access modifier cannot be applied to class and interfaces. Methods,
fields can be declared protected, however methods and fields in a interface cannot
be declared protected.

Protected access gives the subclass a chance to use the helper method or variable,
while preventing a nonrelated class from trying to use it.
Example: The following parent class uses protected access
control, to allow its child class override openSpeaker() method

class AudioPlayer {
protected boolean openSpeaker(Speaker sp)
{
// implementation details
}
}

class StreamingAudioPlayer
{
boolean openSpeaker(Speaker sp)
{
// implementation details
}
}

Here, if we define openSpeaker() method as private, then it would not be

accessible from any other class other than AudioPlayer. If we define it as public,
then it would become accessible to all the outside world. But our intention is to
expose this method to its subclass only, thats why we have used protected
modifier.

4.Default Access Modifier - No Keyword:

Default access modifier means we do not explicitly declare an access modifier for
a class, field, method, etc.

A variable or method declared without any access control modifier is available to

any other class in the same package. The fields in an interface are implicitly public
static final and the methods in an interface are by default public.

Example: Variables and methods can be declared without any modifiers, as in the
following examples

String version = "1.5.1";

boolean processOrder()
{
return true;
}