Advanced Class Features

Session Objectives

Class Variables, Constants and Methods (Static)

Inheritance

Declare and use final classes, methods, and variables

Use inner classes

Reflection API
Class Variable/Static Variables

 static  method or a variable is not attached to a particular object, but rather

to the class as a whole.

 They are allocated when the class is loaded. Remember, each time you call
the instance the new value of the variable is provided to you.
 Class Variable/Static Variables
public class Employee {
static String companyName="GTT";
int empNo;
String empName;
public static void main(String[] args) {

Employee sam=new Employee();

sam.empNo=101;
sam.empName="Sam Dsouza";

Employee tom=new Employee();

tom.empNo=102;
tom.empName=“Tom Francis";

System.out.println(sam.companyName);
System.out.println(tom.companyName);
System.out.println(Employee.companyName);
}
}
 Class Variable/Static Variables

public class Employee {

static String companyname="GTT";

int empNo;
String empName;
static void dispAddress(){
System.out.println("GTT Pvt”);
System.out.println(“GigaSpace Viman Nagar Pune");
}
public static void main(String[] args) {

Employee.dispAddress();
}

}
 Inheritance

 Inheritance allows a software developer to derive a new class from an existing

one
 The existing class is called the parent class or superclass
 The derived class is called the child class or subclass.

 Super class – Book

 Sub Class - Dictionary
 Inheritance

 The child class inherits the methods and data defined for the parent class
 To tailor a derived class, the programmer can add new variables or methods, or
can modify the inherited ones
 Software reuse is at the heart of inheritance
 By using existing software components to create new ones, we capitalize on all
the effort that went into the design, implementation, and testing of the existing
software
Deriving Subclasses using extends

 In Java, we use the reserved word extends to establish an inheritance

relationship

class Dictionary extends Book {

// class contents
}
public class Book {
protected int pages = 1500;
public String message() {
System.out.println(“Number of pages: ” + pages);
}
}

public class Dictionary extends Book {

private int definitions = 52500;
public void defMessage() {
System.out.println(“Number of definitions” +
definitions);
System.out.println(“Definitions per page: ” +
(definitions/pages));
}
}

Dictionary webster = new Dictionary();

webster.message();
webster.defMessage();
Some Inheritance Details

An instance of a child class does not rely on an instance of a parent

class
Hence we could create a Dictionary object
without having to create a Book object first

Inheritance is a one-way street

The Book class cannot use variables or methods
declared explicitly in the Dictionary class
Protected

Visibility modifiers determine which class members are inherited and

which are not
Variables and methods declared with public visibility are inherited;
those with private visibility are not
But public variables violate the principle of encapsulation
There is a third visibility modifier that helps in inheritance situations:
protected
Protected

 The protected modifier allows a member of a base class to be inherited into

a child
 Protected visibility provides
 more encapsulation than public visibility does
 the best possible encapsulation that permits inheritance
Protected Vs Default

 Default: Default access modifier is no-modifier.

 Default access also means “package-level” access.
 That means a default member can be accessed only inside the same
package in which the member is declared.
 Protected: Protected members are same as the default members as far as
the access in the same package is concerned.
 The difference is that, the protected members are also accessible to the
subclasses of the class in which the member is declared which are outside
the package in which the parent class is present.
 But these protected members are “accessible outside the package only
through inheritance“. i.e you can access a protected member of a class in
its subclass present in some other package directly as if the member is
present in the subclass itself.
The super Reference

 Constructors are not inherited, even though they have public visibility
 Yet we often want to use the parent's constructor to set up the "parent's part"
of the object
 The super reference can be used to refer to the parent class, and often is used
to invoke the parent's constructor
 A child’s constructor is responsible for calling the parent’s constructor
 The first line of a child’s constructor should use the super reference to call the
parent’s constructor
 The super reference can also be used to reference other variables and
methods defined in the parent’s class
 The super Reference
public class Book {

protected int pages;

Book(int numPages) {
pages = numPages;
}
}

public class Dictionary extends Book{

private int definitions;

Dictionary(int numPages, int numDefinitions) {

super(numPages);

definitions = numDefinitions;
}
}
Multiple Inheritance

 Java supports single inheritance, meaning that a derived class can have only
one parent class
 Multiple inheritance allows a class to be derived from two or more classes,
inheriting the members of all parents
 Collisions, such as the same variable name in two parents, have to be
resolved
 Java does not support multiple inheritance
In most cases, the use of interfaces gives us aspects of multiple inheritance
without the overhead (will discuss later)
Overriding Methods

 When a child class defines a method with the same name and signature as a
method in the parent class, we say that the child’s version overrides the
parent’s version in favor of its own.
 Signature: method’s name along with number, type, and order of its
parameters
 The new method must have the same signature as the parent's method, but
can have a different body
 The type of the object executing the method determines which version of
the method is invoked
Overriding

 A parent method can be invoked explicitly using the super reference

 If a method is declared with the final modifier, it cannot be overridden
 The concept of overriding can be applied to data and is called shadowing
variables
 Shadowing variables should be avoided because it tends to cause
unnecessarily confusing code
public class Book {
protected int pages;
Book(int numPages) {
pages = numPages;
}
public void message() {
System.out.println(“Number of pages:
” + pages);
} public class Dictionary {
}
protected int definitions;
Dictionary(int numPages, int numDefinitions) {
super(numPages);
definitions = numDefinitions;
}
public void message() {
System.out.println(“Number of definitions” +
definitions);
System.out.println(“Definitions per page: ” +
(definitions/pages));
super.message();
}
}
Overloading vs. Overriding

 Don't confuse the concepts of overloading and overriding

 Overloading deals with multiple methods with the same name in the same
class, but with different signatures
 Overriding deals with two methods, one in a parent class and one in a child
class, that have the same signature
 Overloading lets you define a similar operation in different ways for
different data
Overriding lets you define a similar operation in different ways for different
object types
The Object Class

 A class called Object is defined in the java.lang package of the Java

standard class library
All classes are derived from the Object class
If a class is not explicitly defined to be the child of an existing class, it is
assumed to be the child of the Object class
 Therefore, the Object class is the ultimate root of all class hierarchies
The Object Class

 The Object class contains a few useful methods, which are inherited by all
classes
 For example, the toString method is defined in the Object class
 Every time we have defined toString, we have actually been overriding an
existing definition
 The toString method in the Object class is defined to return a string that
contains the name of the object’s class together along with some other
information
The Object Class

 The equals method of the Object class returns true if two references are
aliases

 We can override equals in any class to define equality in some more

appropriate way

 The String class (as we've seen) defines the equals method to return true if
two String objects contain the same characters

 Therefore the String class has overridden the equals method inherited from
Object in favor of its own version
Final Classes

Final Classes cannot be Inherited

Security:
 One mechanism that hackers use to subvert systems is to create
subclasses of a class and then substitute their class for the original.
The subclass looks and feels like the original class but does vastly
different things possibly causing damage or getting into private
information.
To prevent this kind of subversion, you can declare your class to be
final and prevent any subclasses from being created

Design:
Another reason you may wish to declare a class as final are for object-
oriented design reasons.
You may think that your class is "perfect" or that, conceptually, your
class should have no subclasses.
Final Classes

To specify that your class is a final class, use the keyword final before the
class keyword in your class declaration.

For example, if you wanted to declare your (perfect) ChessAlgorithm class

as final, its declaration would look like this:

final class ChessAlgorithm { . . . }

Final Methods

You can use the final keyword in a method declaration to indicate to the
compiler that the method cannot be overridden by subclasses.

You might wish to make a method final if the method has an

implementation that should not be changed and is critical to the consistent
state of the object.
Final Methods

For example, instead of making your ChessAlgorithm class final, you might
just want to make the nextMove method final:

class ChessAlgorithm {

. . final void nextMove(ChessPiece pieceMoved, BoardLocation newLocation)

{}...

}
Final instance variables

Final instance variables cannot be changed

public class Student {

final String schoolName="Humes";

public static void main(String[] args) {

Student s1=new Student();

s1. schoolName =“Xaviers"; //Error Cannot be modified
}
}
 Use inner classes

Inner classes nest within other classes. A normal class is a direct member of
a package, a top-level class. Inner classes, which became available with Java
1.1, come in following flavors:

Static member classes

Member classes
Local classes
Anonymous classes
Use inner classes

Static member class is a static member of a class.

Like any other static method, a static member class has access to all static
methods of the parent, or top-level, class.

Member class is also defined as a member of a class.

Unlike the static variety, the member class is instance specific and has
access to any and all methods and members, even the parent's this reference.
Use inner classes

Local classes are declared within a block of code and are visible only
within that block, just as any other method variable.

Anonymous classes are those who do not have names:-

E.g

new Thread(new Runnable() {

public void run() {
try {
while (true) { }
}
catch(InterruptedException ex) {}
}
}).start();
Use inner classes

public class Info{

static String compName=“Sun-Oracle";
public static class Company
{
int time=10;
void showinfo(){
System.out.println("Our Company
Name :
"+compName);
System.out.println("The time of the
company :
"+time);
}
}
public static void main(String[] args)
{
Info.Company object = new Info.Company();
object.showinfo();
System.out.println(object.time);
}
}
Reflection API

Reflection API is a powerful technique (that provides the facility) to

find-out its environment as well as to inspect the class itself.

Reflection API was included in Java 1.1.

Here is an example that provides the usage of the getInterfaces()

method in more detail.
Example-1

import java.lang.reflect.*;

public class UseReflect1 {
   public static void main(String str[]){
   Class cls = java.util.List.class;
   Class[] intfs = cls.getInterfaces();
   int len = intfs.length;
   for (int i =0; i < len; i++)
   {
   System.out.println(intfs[i]);
   }

   }
}
Example-2

import java.lang.reflect.*;

public class  UseReflect2{
  public static void main(String[] args){
     Class cls = java.lang.Integer.class;
     String info;
     info = cls.getName();     // It will show java.lang.Integer
     System.out.println(info);
  }
}
Example-3
import java.lang.reflect.*;
class Animal{

}
class Horse extends Animal{

}
public class checkSuper {
static void printName(Object objct){

Class temp=objct.getClass();
Class sup = temp.getSuperclass();
System.out.println(sup);
}

public static void main(String[] args) {

Horse big = new Horse();
printName(big);
}