UNIT-2 I.

Program Structure in Java:

I. Program Structure in Java:

1. Classes and Objects: Introduction
1. Classes and Objects: Introduction Classes:
2. Class Declaration and Modifiers - A class is defined as collection of similar objects.
- Classes are user-defined data types and behave like the built-in types of a programming
3. Class Members language.
4. Declaration of Class Objects - In the real-world, classes are invisible only objects are visible.
Example:
5. Assigning One Object to Another - man is an object representing a class called Animal.
6. Access Control for Class Members - We can see the object called man but we cannot see the class called Animal.
Syntax:
7. Accessing Private Members of Class Animal man;
8. Constructor Methods for Class - It will create an object man belonging to the class Animal.

9. Overloaded Constructor Methods

Objects:
10. Nested Classes - Objects are basic run-time entities in an object-oriented system.
(or)
11. Final Class and Methods
Any real world entity is called an object.
12. Passing Arguments by Value and by Reference (or)
Objects are the combination of data and methods.
13. Keyword this.
Example: Person, Place, bank account, …., so on.
- In the real-world only objects are visible but classes are invisible.
- The most important benefits of an objects are
II. Methods: - Modularity
1. Introduction - Reusability
- The properties of objects are two types
2. Defining Methods - visible
3. Overloaded Methods - invisible
- Let man is an object, then visible properties are eyes, ears, hands, legs,…so on and
4. Overloaded Constructor Methods invisible properties are name, blood group,…. so on.
5. Class Objects as Parameters in Methods - Every object contains three basic elements
- Identity (name)
6. Access Control - State (variables)
7. Recursive Methods - Behavior (methods)

8. Nesting of Methods
Object = Data + Methods
9. Overriding Methods
10. Attributes Final and Static. 2. Class Declaration and Modifiers

A class declaration starts with the Access modifier. It is followed by keyword class,
which is followed by the name or identifier. The body of class is enclosed between a pair
of braces { }.
 Syntax:

Example:

 The class name starts with an upper-case letter, whereas variable names may start win
lower-case letters. Examples:
 In the case of names consisting of two or more words as in MyFarm, the other words for 1. A class without modifier.
with a capital letter for both classes and variables. In multiword identifiers, there is no class Student
blank space between the words {
 The class names should be simple and descriptive. /* class body*/
 Class names should start with an upper-case letter and should be nouns. For example, it }
could include names such as vehicles, books, and symbols. 2. A class with modifier
 It should have both upper and lower-case letters with the first letter capitalized public class Student
 Acronyms and abbreviations should be avoided {
/* class body*/
Class modifiers: }

 Class modifiers are used to control the access to class and its inheritance characteristics. (or)
 Java consists of packages and the packages consist of sub-packages and classes Packages
can also be used to control the accessibility of a class private class Student
 These modifiers can be grouped as (a) access modifiers and (b) non-access modifiers. {
Table 5.l gives a description of the various class modifiers. /* class body*/
}

(or)

protected class Student

{
/* class body*/
}

(or)
 Example:
final class Student
{ class CustomerId
/* class body*/ {
} static int count=0; // static variable
int id; // instance variable
(or) CustomerId() // Constructor
{
abstract class Student count++;
{ id = count ;
/* class body*/ }
} int getId() // Method
{
3. Class Members return id;
The class members are declared in the body of a class. These may comprise fields (variables in a }
class). methods, nested classes, and interfaces. The members of a class comprise the members int localVar()
declared in the class as well as the members inherited from a super class. The scope of all the {
members extends to the entire class body. int a=10; //Local variable
The fields comprise two types of variables
return a;
}
}
1. Non Static variables : These include instance and local variables and vanes in scope and
value.
class Application
(a) Instance variables: These variables are individual to an object and an object keeps a {
copy of these variables in its memory. public static void main(String[] args)
(b) Local variables: These are local in scope and not accessible outside their scope. {
CustomerId obj = new CustomerId();
System.out.println("Customer Id = " + obj.getId());
2. Class variables ( Static Variables) : These variables are also qualified as static variables.
System.out.println("Local Variable = " + obj.localVar());
The values of these variables are common to all the objects of the class. The class keeps
only one copy of these variables and all the objects share the same copy. As class }
variables belong to the whole class, these are also called class variables. }

Output:
C:\>javac Application.java

C:\>java Application
Customer Id = 1
Local Variable = 10
4. Declaration of Class Objects 5. Assigning One Object to Another
Creating an object is also referred to as instantiating an object. Java provides the facility to assign one object to another
- Objects in java are created dynamically using the new operator. object
- The new operator creates an object of the specified class and returns a reference to that
object. Syntax:
Syntax: (creating an object)
new_Object = old_object;
className objectReference=new className();
all the properties of old_object will be copied to new object.

Example:

class Farm
{
double length;
double width;
double area()
{
return length*width;
}
}
public class FarmExel
{
public static void main (String args[])
{
Farm farm1 = new Farm(); //defining an object of Farm
Farm farm2 = new Farm(); //defining new object of Farm

farm1.length = 20.0;
farm1.width = 40.0;
Example:
System.out.println("Area of form1= " + farm1.area());
Farm myFarm = new Farm();
farm2 = farm1; // Object Assignment

System.out.println("Area of form2 = " + farm2.area());

}
}
Output:
C:\>javac FarmExel.java

C:\>java FarmExel
Area of form1= 800.0
Area of form2 = 800.0
 class FarmExe3
6. Access Control for Class Members {
In Java, There are three access specifiers are permitted: public static void main (String args[])
{
• public
• protected Farm farm1 =new Farm();
• private double farmArea;
The coding with access specifiers for variables is illustrated as
farm1.setSides(50.0,20.0);
Access_specifier type identifier; farmArea = farm1.area();
Detials of Access specifiers are as follows.
System.out.println("Area of farm1 = "+ farmArea);
System.out.println("Length of farm1 = "+ farm1.getLength());
System.out.println("Length of farm1 = "+ farm1.getWidth());

}
}

Output
C:\>javac PrivateMembers.java

C:\>java FarmExe3
Area of farm1 = 1000.0
7. Accessing Private Members of Class Length of farm1 = 50.0
Length of farm1 = 20.0
 Private members of a class, whether they are instance variables or methods, can only be
accessed by other members of the same class In the above program, the two object variables length and width are declared private. The
 Any outside code cannot directly access them because they are private. However, first thing is to assign values to these variables for an object. This is done by defining a public
interface public method members may be defined to access the private members method setSides(), which is invoked by the class object for entering values that are passed
 The code other than class members can access the interface public members that pass on to length and width variables The method setsides may be defined as
the values. public void setsides (int 1, int w){length = 1; width = w;}

Example: The class also defines another method area() to which the values are passed for calculation
of area when the method area() is invoked by the object. For obtaining values of length and
public class Farm width by outside code, two public methods are defined as
{
private double length; // private member data public double getLength(){return length;} //Function for getting length
private double width; // private member data public double getWidth(){return width;} // Function for getting width

//definition of public methods

public double area() {return length*width;} These methods may be invoked by objects of the class to obtain the values of variables as
public void setSides(double l, double w) follows:
{ length=l; width = w; }
public double getLength(){return length;} farm1.getLength()
public double getWidth(){return width;}
} farm1.getWidth()
8. Constructor Methods for Class
9. Overloaded Constructor Methods
- A constructor is a special method of the class and it is used to initialize an object whenever Like other methods, the constructors may also be overloaded. The name of all the
the object is created. overloaded constructor methods same as the name of the class, but parameters have to
- A Constructor is a special method because, be different either in number of type a order of parameters in each definition.
 Class name and Constructor name both must be same
Example:
 Doesn’t contain any return type
 Automatically executed when object is created. class Perimeter
- Constructors are two types {
i. Default Constructor (without arguments) Perimeter()
ii. Parameterized Constructor (with arguments) {
System.out.println("No parameters");
Example: }
Perimeter(double r) //Constructor Overloading
class Perimeter
{
{
System.out.println("Perimeter of the Circle="+(2*3.14*r));
Perimeter() // default Constructor
}
{
Perimeter(int l, int b) // Constructor Overloading
System.out.println("No parameters");
{
}
System.out.println("Perimeter of the Rectangle="+(2*(l+b)));
Perimeter(double r) // Parameterized Constructor
}
{
}
System.out.println("Perimeter of the Circle="+(2*3.14*r));
class ConstructorDemo
}
{
Perimeter(int l, int b) // Parameterized constructor
public static void main(String args[])
{
{
System.out.println("Perimeter of the Rectangle="+(2*(l+b)));
Perimeter p1=new Perimeter();
}
Perimeter p2=new Perimeter(10);
}
Perimeter p3=new Perimeter(10,20);
class ConstructorDemo
}
{
}
public static void main(String args[])
Output
{
C:\>javac ConstructorDemo.java
Perimeter p1=new Perimeter();
Perimeter p2=new Perimeter(10); C:\>java ConstructorDemo
Perimeter p3=new Perimeter(10,20); No parameters
} Perimeter of the Circle=62.800000000000004
} Perimeter of the Rectangle=60
Output
E:\>javac ConstructorDemo.java

E:\>java ConstructorDemo
No parameters
Perimeter of the Circle=62.800000000000004
Perimeter of the Rectangle=60
 class NestedClassDemo
10. Nested Classes {
A nested class is one that is declared entirely in the body of another class or interface. The public static void main (String args[])
{
class, which is nested, exists only long as the enveloping class exists. Therefore, the scope of
Outer obj =new Outer(10,20);
inner class is limited to the scope of enveloping class. There are four types of nested class. obj.outer_display();
}
Nested static class is like any other static member of the enveloping class. }
i. Member Inner Class.
ii. Anonymous Class Output:
iii. Local Class C:\>javac NestedClassDemo.java
iv. Static Nested Class
C:\>java NestedClassDemo
x+y = 30.0
i. Member Inner Class.
A class which is declared within class is called Member inner class.
The inner class has access to all the members of the enveloping class including the
members declared public, protected or private.

Example:
class Outer
{
double outer_x;
double outer_y;
Outer (double a, double b)
{
outer_x = a;
outer_y = b;
}
double outer_add()
{
return outer_x+outer_y;
}
void outer_display()
{
Inner in = new Inner();
in.inner_display();
}

class Inner // Inner Class

{
void inner_display()
{
System.out.println("x+y = "+ outer_add());
}
}
}
 ii. Anonymous Class iii. Local Class
 Anonymous classes are inner classes without a name.  A local class is declared in a block or a method, and hence, their scope is limited to the
 It is defined inside another class. Because class has no name it cannot have a constructor block of method. The general properties of such classes are as follows
method and its objects cannot be declared outside the class. o These classes can refer to local variables or parameters, which are declared final
 Therefore, an anonymous class must be defined and initialized in a single expression. o These are not visible outside the block in which they are declared and hence, the
 An anonymous class may be used where the class has to be used only once. access modifiers such as public, private, or protected do not apply to local
 An anonymous class extends a super class or implements an interface, but keywords extend classes.
or implements do not appear in its definition. On the other hand, the names of super class and Example:
interface do appear. Example:
 An anonymous class is defined by operator new followed by class name it extends, argument class LocalClassDemo
{
list for the constructor of super class, and then the anonymous class body.
public static void main (String args[])
{
Example: class Local // Local class defined
abstract class Person {
{ int x;
abstract void display(); //abstract method Local(int a) { x =a; }
} public void display()
{
class AnonymousClass System.out.println("x = "+ x);
{ }
public static void main (String args[]) }
{
Local localObj = new Local(10);
Person obj = new Person() { // Creating an object of Anonymous class
localObj.display();
void display() }
{ }
System.out.println("In display() method ");
} Output
}; // anonymous class closes
C:\>javac LocalClassDemo.java
obj.display(); // Calling anonymous class method
C:\>java LocalClassDemo
}
x = 10
}

iv. Static Nested Class

Output:
-------  The main benefit of Static Nested classes is that their reference is not attached to outer
C:\>javac AnonymousClass.java class reference.
 Object may be accessed directly.
C:\>java AnonymousClass  These classes cannot access non-static variables and methods. They can access only static
In display() method variables and methods
 Static nested class can be referred by its class name.
Example: 11. Final Class and Methods
class Outer  A final class is a class that is declared as a final which cannot have a subclass
{
static double outer_x;
static double outer_y; Example:
Outer (double a, double b) final class A
{ {
outer_x = a; int a;
outer_y = b; A(int x) {a=x;}
} void display()
static double outer_add() {
{ System.out.println("a = "+ a);
return outer_x+outer_y; }
} }
static void outer_display()
{ class B extends A
Inner in = new Inner(); {
in.inner_display(); int b;
} B(int x,int y)
{
static class Inner // Static Inner Class super(x);
{ this.b=y;
void inner_display() }
{ void display()
System.out.println("x+y = "+ outer_add()); {
} System.out.println("b = "+ b);
} }
} }

class StaticNestedClass class FinalClass

{ {
public static void main (String args[]) public static void main (String args[])
{ {
Outer obj =new Outer(10,20); A objA= new A(10);
obj.outer_display(); B objB= new B(100,200);
}
} objA.display();
objB.display();
Output: }
}
C:\>javac StaticNestedClass.java Output:

C:\>java StaticNestedClass C:\>javac FinalClass.java

x+y = 30.0 FinalClass.java:11: error: cannot inherit from final A
class B extends A
^
1 error
12. Passing Arguments by Value and by Reference }
class CallByValue
{
Arguments are the variables which are declared in the method prototype to receive the
public static void main (String args[])
values as a input to the Method( Function). {
Example: int x=10,y=20;
System.out.println("Before Swap : x= "+x+ " y="+y);
int add(int a, int b) // method prototype Swap obj =new Swap();
obj.setValues(x,y);
{
obj.swapping();
//Body of the method add
obj.display();
return a+b; System.out.println("After Swap : x= "+x+ " y="+y);
} }
}
Here a and b are called as arguments. ( also called as formal arguments)
Output:
Arguments are passed to the method from the method calling C:\>javac CallByValue.java
Ex:
int x=10,y=20; C:\>java CallByValue
Before Swap : x= 10 y=20
add( x , y); // method calling In Swap Class: a= 20 b= 10
After Swap : x= 10 y=20
Here x and y are actual arguments.
ii. Call by reference
Arguments can be passed in two ways In call by reference the object will be passed to the method as an argument. At that time the
i. Call by value actual and formal arguments are same.
ii. Call by reference That means any occurs in actual arguments will be reflected in the formal arguments.

i. Call by value Example:

In call by value actual arguments are copied in to formal arguments.
Example: class Swap
class Swap {
{ int a,b;
int a,b; void setValues(Swap objSwap)
void setValues(int p, int q) {
{ a = objSwap.a;
a=p; b = objSwap.b;
b=q; }
} void swapping()
void swapping() {
{ int temp;
int temp; temp =a;
temp =a; a=b;
a=b; b=temp;
b=temp; }
} void display()
void display() {
{ System.out.println("In Swap Class: a= "+a+" b= "+b);
System.out.println("In Swap Class: a= "+a+" b= "+b); }
} }
class CallByReference Add obj= new Add();
{ obj.setValues(10,20);
public static void main (String args[]) obj.add();
{
}
Swap obj =new Swap();
obj.a=10; }
obj.b=20;
System.out.println("Before Swap : obj.a = "+ obj.a+" obj.b="+ obj.b); Output:
C:\ >javac ThisKeyword.java
obj.setValues(obj); // call by reference
obj.swapping();
C:\ >java ThisKeyword
obj.display();
System.out.println("After Swap: obj.a = "+ obj.a+ " obj.b="+ obj.b); Sum = 30
}
}

Output:
C:\1. JAVA\PPT Programs>javac CallByReference.java

C:\1. JAVA\PPT Programs>java CallByReference

Before Swap : obj.a = 10 obj.b=20
In Swap Class: a= 20 b= 10
After Swap : obj.a = 20 obj.b=10

13. Keyword this.

The keyword this provides reference to the current object.

Example:

class Add
{
int a,b;
void setValues(int a, int b)
{
this.a = a;
this.b = b;
}

void add()
{
System.out.println("Sum = "+ (a+b) );
}
}
class ThisKeyword
{
public static void main (String args[])
{
 Modifier description is as follows.
II. Methods

1. Introduction
A method in Java represents an action on data or behaviour of an object. In other
programming languages, the methods are called functions or procedures.

A method is an encapsulation of declarations and executable statements meant to execute

desired operations.

A few types of actions and behaviour of Methods are as follows.

1. It could involve carrying out computation on data presented to method.
2. The action may simply be rearranging the elements of an object. for example, sorting
arrays.
3. The action may comprise finding or searching elements in the list.
4. The action may simply be the initialization of an object.
5. Methods may create images, voice, and multimedia as well as display.
6. Methods may define how an object will communicate with other objects. Example:
7. It may simply answer an enquiry. class Add
8. A method may tell whether an action is permissible or not. {
int a,b;
 In Java, a method must be defined inside a class and an interface. void setValues(int x, int y) // method with two arguments
{
 An interface represents an encapsulation of constants, classes, interfaces, and one or more
abstract methods that are implemented by a class. a = x;
b = y;
 A method cannot be defined inside another method, but it can be defined inside a local
class }

2. Defining Methods void add() // method without arguments

A method definition comprises two components: {
1. Header that includes modifier, type, identifier, or name of method and a list of System.out.println("Sum = "+ (a+b) );
parameters. }
• The parameter list is placed in a pair of parentheses. }
2. Body that is placed in braces ({ }) and consists of declarations and executable class MethodDemo
statement and other expressions. {
public static void main (String args[])
Method definition: {
Modifier return_type method_name (datatype Parameter_Name,…) Add obj= new Add();
{ obj.setValues(10,20); // method calling
/*Statements -- obj.add();
Body of the method*/ }
} }

Output:
C:\ >javac MethodDemo.java

C:\ >java MethodDemo

Sum = 30
 3. Overloaded Methods Example:
Methods with the same name and scope are permitted provided they have different
signatures that include the following: class Add
i. Number of parameters {
ii. Data types of parameters int a,b;
iii. Their order in the parameter list void setValues(int a, int b) // method with two arguments
The compiler executes the version of the method whose parameters match with the {
arguments. For example, the following types of declarations in the scope are permissible: this.a = a;
this.b = b;
}
void add() // method without arguments
{
System.out.println("In add() method Sum = "+ (a+b) );
}
//Method overloding - integer datatype arguments
void add(int a, int b)
{
System.out.println("In add(int, int) Method- sum= "+ (a+b) );
}

//Method overloding - double datatype arguments

void add(double a, double b)
{
System.out.println("In add(double, double) MethodSum = "+ (a+b) );
}
}

class MethodOverload
{
public static void main (String args[])
{
Add obj= new Add();
obj.setValues(10,20); // method calling
obj.add(); // calling method without arguments
obj.add(15,30);// calling method with integer datatype arguments
obj.add(10.3, 30.4); // calling method with double datatype arguments
}
}

C:\>javac MethodOverload.java

C:\>java MethodOverload
In add() method Sum = 30
In add(int, int) Method- sum= 45
 In add(double, double) MethodSum = 40.7 Example:

class AddDemo
4. Overloaded ConstructorMethods {
A constructor method is automatically called whenever a new object of the class is int a,b;
constructed. It creates and initializes the Object. AddDemo() // Constructor without arguments
{
A constructor method has the same name as the name of class to which it belongs. It has a=10;
no type and it does not return any value. It only initializes the object. b=20;
}
The constructor method may also be overloaded by changing the number of default values.
Therefore, constructors with different parameters may be declared. For the remaining // Constructor Overloading with arguments
parameters, it will pick up default values when these are not specified in the object definition. AddDemo(int x, int y)
{
a = x;
b = y;
}

void add() // method without arguments

{
System.out.println("a = " + a + ", b = "+ b+ ": Sum = "+ (a+b) );
}
}

class ConstructorOverload
{
public static void main (String args[])
{
AddDemo obj1= new AddDemo(); //calling constructor without arguments
obj1.add();

AddDemo obj2= new AddDemo(150,60); //calling constructor with arguments

obj2.add();
}
}

Output:

C:\>javac ConstructorOverload.java

C:\>java ConstructorOverload
a = 10, b = 20: Sum = 30
a = 150, b = 60: Sum = 210
 5. Class Objects as Parameters in Methods iii. public
Objects can be passed as parameters to the Methods just like iv. default case-no modifier specified
primit ive data types. It is called as Call by Reference.
i. private : The private members can only be accessed by the other members
Example: (methods) of the same class. No other code outside the class can access them.
class AddDemo Ex:
{ private int x;
int a,b; private int getx()
{
void add(AddDemo obj2) // method with Object as an return x;
argument
}
{
System.out.println("Sum = "+ (obj2.a + obj2.b)
); ii. protected : The protected members can accessed by own class and derived class
} only.
} protected int x;
class ObjectAsParameters protected int getx()
{ {
public static void main (String args[])
return x;
{
AddDemo obj1= new AddDemo(); }
obj1.a=180;
obj1.b=50;
obj1.add(obj1); iii. public : The public members can accessed by all the classes.
} Ex:
} public int x;
public int getx()
Output: {
C:\>javac ObjectAsParameter.java return x;
}
C:\>java ObjectAsParameter
Sum = 230
iv. default case ( no modifier specified ): The default members can accessed by all the
classes within the package only.
6. Access Control
Java supports access control at the class level and at the level of class members. At the class
int x;
level, the following two categories are generally used:
int getx()
i. default case no modifier applied : In the default case, when no access specifier is {
applied, the class can be accessed by other classes only in the same package return x;
ii. public : A class declared public may be accessed by any other class in any package. }

In a class, Java supports the information hiding mechanism so that the user of a class does not
get to know how the process is taking place. A class contains data members and method
members or a nested class.
To access any of the members data method, or nested class-can be controlled by the
following modifiers.
i. private
ii. protected
 7. Recursive Methods 8. Nesting of Methods
A Method which is calling itself is called as Recursive Method. A method calling in another method with in the class is called as Nesting of
Example: Recursive method to find factorial of a given number. Methods.
class Fact
{ Example:
int factorial (int n) class Rectangle
{ {
if(n<2) void perimeter(int l, int w)
return n; {
else System.out.println("Length ="+l+", Width= "+w);
return n*(factorial(n-1)); System.out.println("Perimeter = " + (l+w));
} }
} void area(int l, int w)
{
class FactDemo perimeter(l,w); // Nesting of Method
{ System.out.println("Area = " + (l*w));
public static void main(String[] args) }
{ }
Fact obj =new Fact();
int n=5; class RectangleDemo
int res = obj.factorial(n); {
System.out.println("Factorial of " + n + " = " +res); public static void main(String[] args)
} {
} Rectangle obj = new Rectangle();
Output: obj.area(5,4);
C:\>javac FactDemo.java }
}
C:\>java FactDemo
Factorial of 5 = 120 Output:
C:\ >javac RectangleDemo.java

C:\ >java RectangleDemo

Length =5, Width= 4
Perimeter = 9
Area = 20

9. Overriding Methods
See this topic in Inheritance.

10. Attributes Final and Static

See Attribute Final from UNIT-1: Section II – Topic - 8
See Static Variable and Method from UNIT-1 : Section II – Topic -7