Cs1204: Important 16 mark question for Object oriented programming Oop’s | Important question for Oops : cs1204

1. What are the Features of Oop’s & how are they implemented in C++?
• • Objects.
• • Classes.
• • Data abstraction and Encapsulation.
• • Inheritance.
• • Polymorphism.
• • Dynamic binding.
• • Message passing.

2. Explain about inline function?
An inline function is a function that is expanded in line when it is invoked. That is compiler replaces the function call with the corresponding function code. The inline functions are defined as
Inline function-header
{
function body
}
The situations where inline expansion may not work are
• • for functions returning values, if loop, a switch, or a goto exists
• • for functions not returning values ,if a return statement exists
• • static if function contain variables
• • if inline functions are recursive

3. Explain Function Overloading?
Function overloading means we can use the same function name to create functions that perform a variety of different tasks.
Eg: An overloaded add ( ) function handles different data types as shown below.
// Declarations
iv. int add( int a, int b); //add function with 2 arguments of same type
v. int add( int a, int b, int c); //add function with 3 arguments of same type
vi. double add( int p, double q); //add function with 2 arguments of
different type
//Function calls
i. add (3 , 4);
ii. add (3, 4, 5);
iii. add (3 , 10.0);


4. Explain about Operator Overloading?
C++ has the ability to provide the operators with a special meaning for a data type. This mechanism of giving such special meanings to an operator is known as Operator overloading. It provides a flexible option for the creation of new definitions for C++ operators.
The operators that cannot be overloaded are.
• Class member access operator (. , . *)
• Scope resolution operator (::)
• Size operator ( size of )
• Conditional operator (?:)
The purpose of using operator function is to define an additional task to an operator, we must specify what it means in relation to the class to which the operator is applied. This is done by Operator function , which describes the task. Operator functions are either member functions or friend functions. The general form is
return type classname :: operator (op-arglist )
{
function body
}
where return type is the type of value returned by specified operation.
Op- operator being overloaded. The op is preceded by a keyword operator. operator op is
the function name. The rules for Operator overloading are
• Only the existing operators can be overloaded.
• The overloaded operator must have at least one operand that is of user
defined data type.
• The basic meaning of the operator should not be changed.
• Overloaded operators follow the syntax rules of the original operators.
They cannot be overridden.
5. Explain overloading Unary & Binary operator?
• When unary operators are overloaded using member functions it takes no explicit arguments and return no explicit values.
• When binary operators are overloaded using member functions, it takes one explicit argument. Also the left hand side operand must be an object of the relevant class.
• When unary operators are overloaded using friend function, it takes one reference argument (object of the relevant class)
• When binary operators are overloaded using friend function, it takes two explicit arguments. The operator can be invoked using member functions as follows
In case of Unary operators, overloaded operator can be invoked as op object_name or object_name op
In case of binary operators, it would be invoked as Object . operator op(y)
where op is the overloaded operator and y is the argument.
The overloaded operator can be invoked using Friend function as In case of unary operators, overloaded operator can be invoked as Operator op (x);
In case of binary operators, overloaded operator can be invoked as Operator op (x, y)
The operators that cannot be overloaded using Friend function.
• Assignment operator =
• Function call operator ( )
• Subscripting operator [ ]
• Class member access operator
6. Explain about Type conversions?
The three types of data conversion are
i. Conversion from basic type to class type.
ii. Conversion from class type to basic type.
iii. Conversion from one class type to another class type.
A casting operator is a function that satisfies the following conditions
• It must be a class member.
• It must not specify a return type.
• It must not have any arguments.
The general form of overloaded casting operator is
operator type name ( )
{
……….. // function statements
}
It is also known as conversion function.
i. Basic to class type conversion
Conversion from basic data type to class type can be done in destination class. Using constructors does it. Constructor takes a single argument whose type is to be converted.
Eg: Converting int type to class type
class time
{
int hrs,mins;
public:
………….
Time ( int t) //constructor
{
hours= t/60 ; //t in minutes
mins =t % 60;
}
};
Constructor will be called automatically while creating objects so that this conversion is done automatically.
ii. Basic type conversion with an example.
Using Type Casting operator, conversion from class to basic type conversion can be done. It is done in the source class itself.
Eg: vector : : operator double( )
{
double sum=0;
for(int I=0;I<size;I++)
sum=sum+v[ i ] *u[ i ] ;
return sqrt ( sum ) ;
}
This function converts a vector to the corresponding scalar magnitude.
iii. One class to another class conversion with an example.
Conversion from one class type to another is the combination of class to basic and
basic to class type conversion. Here constructor is used in destination class and casting
operator function is used in source class.
Eg: objX = objY
objX is the object of class X and objY is an object of class Y. The class Y type
data is converted into class X type data and the converted value is assigned to the obj X.
Here class Y is the source class and class X is the destination class.
7. Explain inheritance?
Inheritance is the process by which objects of one class acquire the properties of another class. It supports the concept of hierarchical classification. It provides the idea of reusability. We can add additional features to an existing class without modifying it by deriving a new class from it.
i. single inheritance
If a single class is derived from a single base class is called single inheritance.
Eg:
Base class
Derived class
Here class A is the base class from which the class D is derived. Class D is the
public derivation of class B hence it inherits all the public members of B. But D cannot
access private members of B.
ii. multiple inheritance
If a class is derived from more than one base class, it is called multiple inheritance.
Eg: Base classes
Derived class
Here class C is derived from two base classes A & B.
iii. Hierarchical inheritance
If a number of classes are derived from a single base class then it is called hierarchical inheritance.
Eg : Hierarchical classification of students in University
A
B
A
C
B
Student
Arts Engineering M e d i c a l
CSE ECE Civil
iv.Multilevel inheritance
If a class is derived from a class, which in turn is derived from another class, is called multilevel inheritance. This process can be extended to any number of levels.
Eg:
Base class Grand father
Intermediate
Base class Father
Derived class Child
v. Hybrid inheritance
It is the combination of one or more types of inheritance. The class result will have both the multilevel and multiple inheritances.
Multilevel
inheritance
Multiple
inheritance
8. Define constructor
A constructor is a special member function whose task is to initialize the objects of its class. It is special because its name is same as class name. The constructor is invoked whenever an object of its associated class is created. It is called constructor because it constructs the values of data members of the class
Eg:
integer Class
{
……
public:
integer( );//constructo r
………
}
A
B
C
Student
Test
Result
Sports
The different types of constructor are
i. default constructor
The constructor with no arguments is called default constructor
Eg:
Class integer
{
int m,n;
Public:
Integer( );
…….
};
integer::integer( )//default constructor
{
m=0;n=0;
}
the statement
integer a;
invokes the default constructor
ii. parameterized constructor
constructor with arguments is called parameterized constructor
Eg;
Class integer
{ int m,n;
public:
integer(int x,int y)
{ m=x;n=y;
}
To invoke parameterized constructor we must pass the initial values as arguments to the constructor function when an object is declared. This is done in two ways
1.By calling the constructor explicitly
eg:
integer int1=integer(10,10);
2.By calling the constructor implicitly
eg:
Integer int1(10,10);
iii. Default argument constructor
The constructor with default arguments are called default argument constructor
Eg:
Complex(float real,float imag=0);
The default value of the argument imag is 0
The statement
complex a(6.0)
assign real=6.0 and imag=0
the statement
complex a(2.3,9.0)
assign real=2.3 and imag=9.0
iv. Copy constructor
A copy constructor is used to declare and initialize an object from another object. It takes a reference to an object of the same class as an argument
Eg: integer i2(i1);
would define the object i2 at the same time initialize it to the values of i1.
Another form of this statement is
Eg: integer i2=i1;
The process of initializing through a copy constructor is known as copy initialization .
v.Dynamic constructor
Allocation of memory to objects at time of their construction is known as dynamic
constructor. The memory is allocated with the help of the NEW operator
Eg:
Class string
{
char *name;
int length;
public:
string( )
{
length=0;
name=new char[ length +1];
}
void main( )
{
string name1(“Louis”),name3(Lagrange);
}
use delete to free that memory.
9. Explain about Multiple constructors (constructor overloading)?
The class that has different types of constructor is called multiple constructors
Eg:
#include<iostream. h>
#include<conio.h>
class integer
{
int m,n;
public:
integer( ) //default constructor
{
m=0;n=0;
}
integer(int a,int b) //parameterized constructor
{
m=a; n=b;
}
integer(&i) //copy constructor
{
m=i. m;
n=i.n;
}
void main()
{
integer i1; //invokes default constructor
integer i2(45,67);//invokes parameterized constructor
integer i3(i2); //invokes copy constructor
}
The special characteristics of constructor are
• T hey should be declared in the public section
• They are invoked automatically when the objects are created
• They do not have return types, not even void and therefore, and they cannot
return values
• They cannot be inherited, though a derived class can call the base class
• They can have default arguments
• Constructors cannot be virtual f unction
10. Explain virtual functions
A function qualified by the ‘virtual’ keyword is called virtual function. When a
virtual function is called through a pointer, class of the object pointed to determine which
function definition will be used.
The rules for virtual functions are
• Virtual f unctions must be member of some class.
• They cannot be static members and they are accessed by using object pointers
• Virtual f unction in a base class must be defined.
• Prototypes of base class version of a virtual function and all the derived class
versions must be identical.
• If a virtual function is defined in the base class, it need not be redef ined in the
derived class.
Pure virtual functions
A pure virtual function is a function declared in a base class that has no definition relative to the base class. In such cases, the compiler requires each derived class to either define the function or redeclare it as a pure virtual function. A class containing pure virtual functions cannot be used to declare any object of its own. It is also known as “donothing” function.
The “do-nothing” function is defined as follows:
virtual void display ( ) =0;
11. Explain the features of Java?
• Compiled and Interpreted
• Platform-Independent and portable
• Object oriented
• Robust and Secure
• Distributed
• Familiar, simple and small
• Multithreaded and Interactive
• High Perf ormance
• Dynamic and Extensible
12. Describe the structure of Java program?
• Documentation section
• Package statement
• Import statements
• Interface statements
• Class definitions
• Main method class
13. Explain about Inheritance in Java?
• Defining a subclass
• Subclass constructor
• Single Inheritance
• Multilevel Inheritance
• Hierarchical Inheritance
Eg:
Class A
{
---------
---------
}
class B extends A
{
---------
---------
}
class C extends B
{
-------
--------
}
14. Explain about Interfaces in Java?
Java does not support multiple inheritances. It is achieved using interfaces in Java.
• Defining Interfaces
• Extending Interfaces
• Implementing Interfaces
• Accessing Interface variables
Eg :
Interface Area
{
final static flaot pi=3. 14f ;
float compute(float x,float y);
}
15. Explain about Packages?
Packages are java’s way of grouping variety of classes or interfaces together. Packages act as containers for classes
• Java API Packages
• Using System packages
• Creating Packages
• Accessing a package
• Using a package
Eg:
Package p1;
Public class A
{
public void display()
{
System. out,println(“Class A”);
}
}
16. Explain about Threads in Java?
A thread is a program that has a single flow of control
• Creating threads
• Extending the thread class
Eg:
Class Mythread extends Thread
{
------
------
}
• Using Runnable Interface
Eg:
Class MyThread implements Runnable
{
-------
-------
}
• Stopping and Blocking a thread
17. Explain about Strings in Java?
• • Strings can be created using
• String class
String s= new String(“Hello”);
• StringBuffer class
StringBuffer s= new StringBuff er(“Hello”);
• • String arrays
• String methods
18. Explain about Thread lifecycle?
• Newborn state
• Runnable state
• Running state
• Blocked state
• Dead state
19. Explain about Exception handling in Java?
• Exceptions
• Syntax of Exceptions handling state
• Multiple catch statements
• Using finally statement
Eg:
Class A
{
public static void main (String args[])
{
int a=10;
int b=5;
int c=5;
int x,y;
try
{
x=a/(b-c);
}
catch(ArithmeticException e)
{
System. out.println(“Division by zero”);
}
y=a/b+c;
System. out.println(“y=”+y);
}
}
20. Explain about Applet Lifecycle?
• Initialization state
• Running state
• Idle state or stopped state
• Dead state
• Display state
21. How Applets are prepared and executed?
• Writing Applets
Eg:
Import java.awt.*;
Import java.applet.*;
Public class A extends Applet
{
public void paint( Graphics g)
{
g.drawString(“Hello”,10,100);
}
}
• Building Applet code
• Designing a web page
<html>
<title>Applet</title>
<body>
<applet code= A.class width=400 height=200 </applet>
</body>
</html>
• Running the Applet
• Using appletviewer
• Using web browser
22. Explain about Visibility Controls?
• Public access
• Friendly access
• Protected access
• Private access
• Private protected access
23. Explain about Methods overriding and methods overloading?
Methods that have same name but different parameter lists and different definitions is called Method overloading.
Eg:
class Room
{
int width;
int length;
Room(int x,int y) // Constructor
{
length= x;
width = y;
}
Room(int x)
{
length=breadth=x;
}
}
When a method is called the method defined in the subclass is invoked and executed instead of the one in the superclass. This is called overriding.
Eg:
class superclass
{
void methodsuper()
{
System. out.println("superclass method");
}
}
class subclass extends superclass
{
void methodsuper()
{
System. out.println("overriding method of superclass");
} }
class override
{
public static void main(String args[])
{
subclass sb=new subclass();
sb.methodsuper();
} }
24 Explain about operators in Java?
• Arithmetic operators
• Integer arithmetic
• Real arithmetic
• Mixed mode arithmetic
• Relational operators
• Logical operators
• Assignment operators
• Increment and Decrement operators
• Conditional Operator
• Bitwise operator
• Special operators
• Instanceof operator
• Dot operator
25 Explain about Constructors in Java?
Constructors enable an object to initialize itself when it is created.
Eg: class Rect
{
int width;
int length;
Rect(int x,int y) // Constructor
{
length= x;
width = y;
}
int rectArea()
{
return(length *width);}
}
26. Explain the various Java tokens?
• Java character set
• Keywords
• Identifiers
• Literals
• Operators
• Separators
27. How will you implement a Java program?
• Creating the Java program
class sample
{
public static void main(String args[])
{
System. out.println(“Hello”);
} }
Save the program as sample.java
• Compiling the program
The program is compiled using the statement and it will create a class file named sample.class.
Javac sample.java
• Running the program
Java sample
This statement will execute the program and display the output.
28. What are the features of simple Java program?
• Class declaration
• Opening brace
• Main Line
• Output line
Eg:
class sample // Class declaration
{ // Opening brace
public static void main(String args[]) // Main Line
{
System. out.println(“Hello”); // Output line
} }

**********************************
*******************
***********


Related post