OBJECT-ORIENTED

PROGRAMMINGLECTURE # 18-22

Content

Method Overloading

Constructor Overloading

Encapsulation and Access Specifiers

static Keyword

static block

Introducing Math class

final keyword

Nested and Inner Classes

Method Overloading

Method overloading is one of the ways that Java supports

polymorphism.

Defining two or more methods with the same name in a class is

called method overloading.

The compiler is able to distinguish between the methods

because of their method signatures.

The name of a method together with the types and sequence

of the parameters form the signature of the method.

Method Overloading

Examples:

System.out.println(“hello”);

System.out.println(23);

System.out.println(58.25);

System.out.println(‘a’);

Method Overloading

class OverloadDemo {

void test() { System.out.println("No parameters");

}

// Overload test for one integer parameter. void test(int a) { System.out.println("a: " + a);

}

// Overload test for two integer parameters. void test(int a, int b) { System.out.println("a and b: " + a + " " + b);

}

// overload test for a double parameter double test(double a) { System.out.println("double a: " + a);

return a*a; }

}

Method Overloading

class Overload {

public static void main(String args[]) {

OverloadDemo ob = new OverloadDemo(); double result; ob.test();

ob.test(10);

ob.test(10, 20); result = ob.test(123.2);

System.out.println("Result of ob.test(123.2): " + result);

}

}

Constructor Overloading

Constructors are methods that can be overloaded, just like

any other method in a class.

When you want to generate objects of a class from different

sets of initial defining data.

Constructor Overloading

class Student { String name;String rollno;int age;

Student(){System.out.println(“no information provided”);name = “”;rollno = “”; age = 0;}

Student(String n, String r, int a){name = n;rollno = r; age = a;}

void getStudentInfo(){System.out.println(“name = ”+name+”\n roll no. = rollno+”\n age =

”+age);

}}

Constructor Overloading

class UseStudentClass{

public static void main(){

Student std1 = new Student();Student std2 = new Student(“Al”, “19SW09”, 21);

std1.getStudentInfo();std2.getStudentsInfo();

}}

Encapsulation and Access Specifiers

Java’s access specifiers are public, private, and protected.

Java also defines a default access level.

Encapsulation, you can control what parts of a program can

access the members of a class.

By controlling access, you can prevent misuse.

Encapsulation and Access Specifiers

Java provides the following access specifiers:

Encapsulation and Access Specifiers

class Test {

int a; // default accesspublic int b; // public access

private int c;

void setc(int i) { c = i;

}

int getc() { return c;

}

}

Encapsulation and Access Specifiers

class AccessTest {

public static void main(String args[]) {

Test ob = new Test();ob.a = 10;ob.b = 20;

// ob.c = 100; // Error!

ob.setc(100); // OKSystem.out.println("a, b, and c: " + ob.a + " " +ob.b + " " + ob.getc());

}

}

static Keyword

A static class member can be accessed without creating an

object.

You can declare both methods and variables to be static.

main() is a common example.

static Keyword

Methods declared as static have several restrictions:

They can only call other static methods.

They must only access static data.

They cannot refer to this or super in any way.

static Keyword

class StaticDemo {

static String name;static int age;

static void getInfo(){System.out.println(“name ”+name);System.out.println(“age ”+age);}

}class UseStaticDemo{public static void main(String args[]){

StaticDemo.getInfo();

}}

static block

Static blocks are also called Static initialization

blocks .

A static initialization block is a normal block of code

enclosed in braces, { }, and preceded by the static

keyword.

static{

//whatever code is needed for initialization goes here

}

Introducing Math Class

The java.lang.Math class contains methods for performing basic

numeric operations such as the elementary exponential, logarithm,

square root, and trigonometric functions.

Access these functions without making the object as they are all

declared static.

E.g. Math.method(arg)

Code it now!

Consider a right-angle triangle like this one. Write a

java class with three instance variables hypotenuse,

perpendicular and base. Create two overloaded

constructor for initializing these lengths including a

default constructor that gives default values.

Create three functions,

getHyp(double , double) returns hyp after calculation,

getPerp(double, double) returns perp after calculation,

getBase(double, double) returns base after calculation.

Code it now!

Overload the functions in the previous slides:

getHyp(double length, double angle)

getBase(double length, double angle)

getPerp(double length, double angle)

Each function must return the side after taking

length and angle

final Keyword

Doing so prevents its contents from being modified.

This means that you must initialize a final variable

when it is declared.

It is a common coding convention to choose all

uppercase identifiers for final variables

final double PI = 3.142;

Nested and Inner Classes

You can put the definition of one class inside the definition of another class.

The inside class is called a nested class.

Syntax:

public class Outside {

// Nested class

public class Inside {

// Details of Inside class...

}

// More members of Outside class...

}

Nested and Inner Classes

A top-level class is a class that contains a nested

class but is not itself a nested class.

Nested and Inner Classes

class Outer {int outer_x = 100;void test() {Inner inner = new Inner();inner.display();}// this is an inner classclass Inner {void display() {System.out.println("display: outer_x = " + outer_x);}}}class InnerClassDemo { public static void main(String args[]) {Outer outer = new Outer();outer.test();

} }