JAVA_INTRODUCTION- History, Constructor, Inheritance

JAVA- History, OOPS Concept, FEATURES, CONSTRUCTOR, METHODS<INHERITANCE

1. By
Mrs. P. Usha., MCA., M.Phil., SET.,NET.,(Ph.D)
Assistant Professor,
Department of Information Technology, Bishop
Heber College (Autonomous), Trichy-17.
INTRODUCTION TO Java

2. Java was originally designed for interactive television, but it was too advanced technology for the
digital cable television industry at the time.
The history of Java starts with the Green Team. Java team members (also known as Green Team),
initiated this project to develop a language for digital devices such as set-top boxes, televisions,
etc. However, it was best suited for internet programming. Later, Java technology was
incorporated by Netscape.
The principles for creating Java programming were "Simple, Robust, Portable, Platform-
independent, Secured, High Performance, Multithreaded, Architecture Neutral, Object-Oriented,
Interpreted, and Dynamic". Java was developed by James Gosling, who is known as the father of
Java, in 1995. James Gosling and his team members started the project in the early '90s.
James Gosling - founder of java
Currently, Java is used in internet programming, mobile devices, games, e-business solutions, etc.
History of Java

3. 1)
 
James Gosling, Mike Sheridan, and
 
Patrick Naughton 
initiated the Java language project in June
1991. The small team of sun engineers called
 
Green Team.
2) Initially it was designed for small,
 
embedded systems 
in electronic appliances like set-top boxes.
3) Firstly, it was called
 
"Greentalk" 
by James Gosling, and the file extension was .gt.
4) After that, it was called
 
Oak 
and was developed as a part of the Green project.
Why Java was named as "Oak"?
5)
 
Why Oak? 
Oak is a symbol of strength and chosen as a national tree of many countries like the
U.S.A., France, Germany, Romania, etc.
6) In 1995, Oak was renamed as
 
"Java" 
because it was already a trademark by Oak Technologies.

4. According to James Gosling, "Java was one of the top choices along with
 
Silk". Since Java was so
unique, most of the team members preferred Java than other names.
8) Java is an island in Indonesia where the first coffee was produced (called Java coffee). It is a kind
of espresso bean. Java name was chosen by James Gosling while having a cup of coffee nearby his
office.
9) Notice that Java is just a name, not an acronym.
10) Initially developed by James Gosling at
 
Sun Microsystems 
(which is now a subsidiary of Oracle
Corporation) and released in 1995.
11) In 1995, Time magazine called
 
Java one of the Ten Best Products of 1995.
12) JDK 1.0 was released on January 23, 1996. After the first release of Java, there have been many
additional features added to the language. Now Java is being used in Windows applications, Web
applications, enterprise applications, mobile applications, cards, etc. Each new version adds new
features in Java.

5. Java Version History

6. Features of Java

7. How Java Program Works?

9. 4
 tools(JDK, JVM, JRE, JIT) that help us with the smooth working of our programs.

10. OOPs (Object Oriented Programming System)
Object 
means a real word entity such as pen, chair, table etc. 
Object-Oriented Programming 
is a methodology or paradigm to design a program using classes
and objects.
Object
Any entity that has state and behavior is known as an object.
For example: chair, pen, table, keyboard, bike etc. It can be physical and logical.
Object can be defined as an instance of a class.
An object contains an address and takes up some space in memory.
Objects can communicate without knowing details of each other's data or code, the only necessary
thing is that the type of message accepted and type of response returned by the objects.
Example: 
A dog is an object because it has states i.e. color, name, breed etc. as well as behaviors i.e.
wagging the tail, barking, eating etc.

11. Class
Collection of objects 
is called class.
It is a logical entity.
A class can also be defined as a blueprint from which you can create an individual object. Class
doesn?t store any space.
Inheritance
When one object acquires all the properties and behaviours of parent object, it is known as
inheritance.
It provides code reusability.
It is used to achieve runtime polymorphism.
Polymorphism
When
 
one task is performed by different ways 
i.e. known as polymorphism.
For example: to convince the customer differently, to draw something e.g. shape or rectangle
etc.
In java, we use method overloading and method overriding to achieve polymorphism.
Another example can be to speak something e.g. cat speaks meaw, dog barks woof etc.

12. Java Platforms / Editions
There are 4 platforms or editions of Java:
1) Java SE (Java Standard Edition)
It is a java programming platform. It includes Java programming APIs such as java.lang, java.io,
java.net, java.util, java.sql, java.math etc. It includes core topics like OOPs,
 
String, Regex,
Exception, Inner classes, Multithreading, I/O Stream, Networking, AWT, Swing, Reflection,
Collection etc.
2) Java EE (Java Enterprise Edition)
It is an enterprise platform which is mainly used to develop web and enterprise applications. It is
built on the top of Java SE platform. It includes topics like Servlet, JSP, Web Services, EJB,
 
JPA
 
etc.
3) Java ME (Java Micro Edition)
It is a micro platform which is mainly used to develop mobile applications.
4) JavaFx
It is used to develop rich internet applications. It uses light-weight user interface API.

13. An object has three characteristics:
state: 
represents data (value) of an object.
behavior: 
represents the behavior (functionality) of an object such as deposit, withdraw etc.
identity: 
Object identity is typically implemented via a unique ID. The value of the ID is not visible to
the external user. But, it is used internally by the JVM to identify each object uniquely.
For Example: Pen is an object. Its name is Reynolds, color is white etc. known as its state. It is used to
write, so writing is its behavior.
Object is an instance of a class. 
Class is a template or blueprint from which objects are created. So
object is the instance(result) of a class.
Object Definitions:
Object is
 
a real world entity.
Object is
 
a run time entity.
Object is
 
an entity which has state and behavior.
Object is
 
an instance of a class.

14. Class in Java
A class is a group of objects which have common properties. It is a template or
blueprint from which objects are created. It is a logical entity. It can't be physical.
A class in Java can contain:
fields
methods
constructors
blocks
nested class and interface
Syntax to declare a class:
class
 <class_name>
{
  
 
   
field;
  
 
   
method;
  
}
  

15. Instance variable in Java
A variable which is created inside the class but outside the method, is known as instance
variable.
 Instance variable doesn't get memory at compile time.
It gets memory at run time when object(instance) is created.
That is why, it is known as instance variable.
Object and Class Example: main within class
class
 
Student{
  
 int
 id;//field or data member or instance variable  
 String
 name;  
 
 
 public
 static void main(String args[])
{
  
 
 
Student
 s1=new Student();//creating an object of Student  
 
 
System.out.println(s1.id);//accessing
 member through reference variable  
 
 
System.out.println(s1.name);
  
 }
  
}
  

16. Object and Class Example: main outside class
class
 Student
{
  
 int
 id;  
 String
 name;  
}
  
class
 TestStudent1
{
  
 public
 static void main(String args[])
{
  
 
 
Student
 s1=new Student();  
 
 
System.out.println(s1.id);
  
 
 
System.out.println(s1.name);
  
 }
  
}
  

17. 3 Ways to initialize object
There are 3 ways to initialize object in java.
By reference variable
By method
By constructor
Object and Class Example: Initialization through reference
class
 Student
{
  
 int
 id;  
 String
 name;  
}
  
class
 TestStudent2
{
  
 public
 static void main(String args[])
{
  
 
 
Student
 s1=new Student();  
 
 
s1.id=101;
  
 
 
s1.name="Sonoo";
  
 
 
System.out.println(s1.id+"
 "+s1.name);//printing members with a white space  
 }
  
}
  

18. create multiple objects
class
 Student
{
  
 int
 id;  
 String
 name;  
}
  
class
 TestStudent3
{
  
 public
 static void main(String args[])
{
  
 
 
//Creating
 objects  
 
 
Student
 s1=new Student();  
 
 
Student
 s2=new Student();  
 
 
//Initializing
 objects  
 
 
s1.id=101;
  
 
 
s1.name="Sonoo";
  
 
 
s2.id=102;
  
 
 
s2.name="Amit";
  
 
 
//Printing
 data  
 
 
System.out.println(s1.id+"
 "+s1.name);  
 
 
System.out.println(s2.id+"
 "+s2.name);  
 }
  
}
  

19. Method in Java
Object and Class Example: Initialization through method
class
 Student
{
  
 int
 rollno;   String name;  
 void
 insertRecord(int r, String n)
{
  
 
 
rollno=r;
  
 
 
name=n;
  
 }
  
 void
 displayInformation()
{
System.out.println(rollno+"
 "+name);
}
  
}
  
class
 TestStudent4
{
  
 public
 static void main(String args[])
{
  
 
 
Student
 s1=new Student();  
 
 
Student
 s2=new Student();  
 
 
s1.insertRecord(111,"Karan");
  
 
 
s2.insertRecord(222,"Aryan");
  
 
 
s1.displayInformation();
  
 
 
s2.displayInformation();
  
 }
  
}

20. Constructor in Java
In Java, constructor is a block of codes similar to method. It is called when an instance of object is
created and memory is allocated for the object.
It is a special type of method which is used to initialize the object.
When is a constructor called
Everytime an object is created using new() keyword, atleast one constructor is called. It is called a
default constructor.
Note: 
It is called constructor because it constructs the values at the time of object creation. It is not
necessary to write a constructor for a class. It is because java compiler creates a default constructor if your
class doesn't have any.
 Rules for creating java constructor
There are basically two rules defined for the constructor.
Constructor name must be same as its class name
Constructor must have no explicit return type
 Types of java constructors
1.Default constructor (no-arg constructor)
2.Parameterized constructor

21. Rules for creating Java constructor
The constructor name must be the same as its class name
A Constructor must have no explicit return type
A Java constructor cannot be abstract, static, final, and synchronized
•Default constructor: These constructors do not accept any parameters.
•Parameterized constructor: These constructors accept a specific number of parameters.

22. Syntax of default constructor:
class Test
{
Test()
{
// constructor body
}
} 
Example of default constructor
class Bike1
{ 
 
Bike1()
{
System.out.println("Bike is created");
} 
 
public static void main(String args[])
{ 
 
Bike1 b=new Bike1(); 
 
} 
 
} 
  
Rule: If there is no constructor in a class,
compiler automatically creates a default
constructor.

23. class Main
{
private String name;
// constructor
Main()
{
System.out.println("Constructor Called:");
name = "Programiz";
}
public static void main(String[] args)
{
// constructor is invoked while
// creating an object of the Main class
Main obj = new Main();
System.out.println("The name is " + obj.name);
}
}
Output:
Constructor Called:
The name is Programiz

24. class Main {
int i;
// constructor with no parameter
private Main() {
i = 5;
System.out.println("Constructor is called");
}
public static void main(String[] args) {
// calling the constructor without any
parameter
Main obj = new Main();
System.out.println("Value of i: " + obj.i);
}
}
Private No-arg Constructor
Output:
Constructor is called
Value of i: 5
Once a constructor is declared
 private, it cannot be
accessed from outside the class.
So, creating objects from outside the class is
prohibited using the private constructor.
Here, we are creating the object inside the same
class.

25. class Company {
String name;
// public constructor
public Company() {
name = "Programiz";
}
}
class Main {
public static void main(String[] args) {
// object is created in another class
Company obj = new Company();
System.out.println("Company name = " +
obj.name);
}
}
Public no-arg Constructors
Output
Company name = Programiz

26. class Main {
String languages;
// constructor accepting single value
Main(String lang) {
languages = lang;
System.out.println(languages + " Programming
Language");
}
public static void main(String[] args) {
// call constructor by passing a single value
Main obj1 = new Main("Java");
Main obj2 = new Main("Python");
Main obj3 = new Main("C");
}
}
Parameterized Constructor
Output
Java Programming Language
Python Programming Language
C Programming Language

27. class Main {
int a;
boolean b;
public static void main(String[] args) {
// calls default constructor
Main obj = new Main();
System.out.println("Default Value:");
System.out.println("a = " + obj.a);
System.out.println("b = " + obj.b);
}
}
Default Constructor
Run Code
Output
Default Value:
a = 0
b = false

28. class Main {
String language;
// constructor with no parameter
Main() {
this.language = "Java";
}
// constructor with a single parameter
Main(String language) {
this.language = language;
}
public void getName() {
System.out.println("Programming Language: " + this.language);
}
public static void main(String[] args) {
// call constructor with no parameter
Main obj1 = new Main();
// call constructor with a single parameter
Main obj2 = new Main("Python");
obj1.getName();
obj2.getName();
}
}
Constructor Overloading
Run Code
Output
Programming Language: Java
Programming Language: Python

29. Example of parameterized constructor
class
 Student4
{
  
 
   
int
 id;  
 
   
String
 name;  
 
  
Student4(int
 i,String n)
{
  
 
   
id
 = i;  
 
   
name
 = n;  
 }
  
 
   
void
 display()
{
System.out.println(id+"
 "+name);
}
  
 
  
 
   
public
 static void main(String args[])
{
  
 
   
Student4
 s1 = new Student4(111,"Karan");  
 
   
Student4
 s2 = new Student4(222,"Aryan");  
 
   
s1.display();
  
 
   
s2.display();
  
 
  
}
  
}
  

30. Syntax
public static int methodName(int a, int b)
{ // body
}
JAVA METHOD
Here,
public static 
− modifier
int 
− return type
methodName 
− name of the method
a, b 
− formal parameters
int a, int b 
− list of parameters
public static int minFunction(int n1,int n2)
{
int min;
if(n1 > n2)
min= n2;
Else
min= n1;
return min;
}

31. Passing Parameters by Value
publicclassswappingExample
{
publicstaticvoid main(String[]args)
{
int a =30;
int b =45;
System.out.println("Before swapping, a = "+ a +" and b = "+ b);// Invoke the swap method
swapFunction(a, b);
System.out.println
("\n**Now, Before and After swapping values will be same here**:");
System.out.println("After swapping, a = "+ a +" and b is "+ b);
}
publicstaticvoidswapFunction(int a,int b)
{
System.out.println("Before swapping(Inside), a = "+ a +" b = "+ b);// Swap n1 with n2
int c = a;
a = b;
b = c;
System.out.println("After swapping(Inside), a = "+ a +" b = "+ b);
}
}

32. Method Overloading
If a class has multiple methods having same name but different in parameters, it is known as Method
Overloading.
ways to overload the method
There are two ways to overload the method in java
1.By changing number of arguments
2.By changing the data type

33. Method Overloading: changing no. of arguments
class 
Adder
{
  
static int 
add(
int 
a,
int 
b)
{
return 
a+b;
}
  
static int 
add(
int 
a,
int 
b,
int 
c)
{
return 
a+b+c;
}
  
}
  
class 
TestOverloading1
{
  
public static void 
main(String[] args)
{
  
System.out.println(Adder.add(11,11));
  
System.out.println(Adder.add(11,11,11));
  
}
}
  

34. Method Overloading: changing data type of arguments
class 
Adder
{
  
static int 
add(
int 
a, 
int 
b)
{
return 
a+b;
}
  
static double 
add(
double 
a, 
double 
b)
{
return 
a+b;
}
  
}
  
 
 
class 
TestOverloading2
{
  
public static void 
main(String[] args)
{
  
System.out.println(Adder.add(11,11));
  
System.out.println(Adder.add(12.3,12.6));
  
}
}

36. Inheritance in Java 
is a mechanism in which one object acquires all the properties and
behaviors of a parent object.
Terms used in Inheritance
Class: 
A class is a group of objects which have common properties. It is a template or blueprint
from which objects are created.
Sub Class/Child Class: 
Subclass is a class which inherits the other class. It is also called a derived
class, extended class, or child class.
Super Class/Parent Class: 
Superclass is the class from where a subclass inherits the features. It is
also called a base class or a parent class.
Inheritance

37. class Super {
.....
.....
}
class Sub extends Super {
.....
.....
}
Syntax to implement inheritance

38. class Calculation {
int z;
public void addition(int x, int y) {
z = x + y;
System.out.println("The sum of the given numbers:"+z);
}
public void Subtraction(int x, int y) {
z = x - y;
System.out.println("The difference between the given numbers:"+z);
}
}
public class My_Calculation extends Calculation {
public void multiplication(int x, int y) {
z = x * y;
System.out.println("The product of the given numbers:"+z);
}
public static void main(String args[]) {
int a = 20, b = 10;
My_Calculation demo = new My_Calculation();
demo.addition(a, b);
demo.Subtraction(a, b);
demo.multiplication(a, b);
}
}

39. Types of Java Inheritance

40. class Student{
void Fee() {
System.out.println("Student Fee= 20000");
}
}
class Student_Name extends Student{
void Name() {
System.out.println("Student Name=Jayanti");
}
}
class College {
public static void main(String args[]) {
Student_Name p = new Student_Name();
p.Fee();
p.Name();
}
}
Output:
Student Fee= 20000
Student Name=Jayanti

41. // Superclass
class Company {
void CompanyName() {
System.out.println("Company name is Dotnettricks.");
}
}
// Subclass 1
class Employee1 extends Company {
void EmployeeName1() {
System.out.println("EmployeeName1 is Sakshi.");
}
}
// Subclass 2
class Employee2 extends Company {
void EmployeeName2() {
System.out.println("EmployeeName2 is Sourav.");
}
}
// Main class
public class Main {
public static void main(String[] args) {
Employee1 E1 = new Employee1();
E1.CompanyName();
E1.EmployeeName1();
Employee2 E2 = new Employee2();
E2.CompanyName();
E2.EmployeeName2();
}
}
Hierarchical Inheritance

42. public class Son extends
Mother
{
public void showS()
{
System.out.println("He is
Son.");
}
public static void main(String
args[])
{
Daughter obj = new
Daughter();
obj.showD();
obj.showM();
obj.showG();
Son obj2 = new Son();
obj2.showS();
obj2.showM();
obj2.showG();
}
}
class GrandMother
{
public void showG()
{
System.out.println("She is
grandmother.");
}
}
class Mother extends GrandMother
{
public void showM()
{
System.out.println("She is mother.");
}
}
class Daughter extends Mother
{
public void showD()
{
System.out.println("She is daughter.");
}
}
Using Single and Hierarchical Inheritance in hybrid inheritance

43. Multilevel Inheritance

44. //Superclass box...
class Box {
private double width;
private double height;
private double depth;
// Constructor of the superclass
Box(double w, double h, double d)
{
width = w;
height = h;
depth = d;
}
// Volume calculation...
double volume() {
return width * height * depth;
}
}
// Sub class - 1
// BoxWeight class extending the box class...
class BoxWeight extends Box
{
double weight; // weight of box
// Sub class -1 constructor
BoxWeight(double w, double h, double d, double m) {
super(w, h, d); // calling superclass constructor
weight = m;
}
}
// Sub class - 2
// Shipment class extending BoxWeight class...
class Shipment extends BoxWeight {
double cost;
// Sub class - 2 constructor
Shipment(double w, double h, double d, double m, double c) {
super(w, h, d, m); // calling superclass constructor
cost = c;
}
}
public class TestMultilevel
{
public static void main(String args[])
{
Shipment shipment1 = new Shipment(1, 2, 3, 5, 3.41);
Shipment shipment2 = new Shipment(2, 4, 6, 10, 1.28);
double vol;
vol = shipment1.volume();
System.out.println("The volume of shipment1 is " + vol);
System.out.println("The weight of shipment1 is " + shipment1.weight);
System.out.println("Shipping cost: Rs." + shipment1.cost);
System.out.println();
vol = shipment2.volume();
System.out.println("The volume of shipment2 is " + vol);
System.out.println("The weight of shipment2 is " + shipment2.weight);
System.out.println("Shipping cost: Rs." + shipment2.cost);
}
}

45. Output
The volume of shipment1 is 6.0
The weight of shipment1 is 5.0
Shipping cost: Rs.3.41
The volume of shipment2 is 48.0
The weight of shipment2 is 10.0
Shipping cost: Rs.1.28

46. An
 
interface in Java 
is a blueprint of a class.
 It has static constants and abstract methods.
The interface in Java is
 
a mechanism to achieve
 abstraction
.
There can be only abstract methods in the Java interface, not method body.
It is used to achieve abstraction and multiple
 inheritance in Java.
In other words, you can say that interfaces can have abstract methods and variables.
It cannot have a method body.
Interface
Syntax:
interface <interface_name>{

// declare constant fields
// declare methods that abstract
// by default.
}

48. interface Polygon {
void getArea(int length, int breadth);
}
// implement the Polygon interface
class Rectangle implements Polygon {
// implementation of abstract method
public void getArea(int length, int breadth) {
System.out.println("The area of the rectangle is
" + (length * breadth));
}
}
class Main {
public static void main(String[] args) {
Rectangle r1 = new Rectangle();
r1.getArea(5, 6);
}
}

49. Suppose we have two classes Mother and Uncle which have the same method feature().
If multiple inheritance is possible then the Grandchild class can inherit data members
(properties) and methods (behavior) of both Mother and Uncle classes. Now, the
Grandchild class has two feature() methods inherited from Mother and Uncle. The
problem occurs in a method call, when the feature() method is called with the
Grandchild class object which method will be called, will it be of Mother or Uncle? This is
an ambiguty problem because of which multiple inheritance is not supported in Java.
Why is Multiple Inheritance Not Supported
 

50. interface Parent1 {
void mother();
}
interface Parent2 {
void father();
}
class Family implements Parent1, Parent2 {
public void mother() {
System.out.println("Mothers Feature");
}
public void father() {
System.out.println("Fathers Feature");
}
}
public class Demo {
public static void main(String args[]) {
Family a = new Family();
a.mother();
a.father();
}
}

52. public interface Area
{
public void Square();
public void Circle();
public void Rectangle();
public void Triangle();
}
//Class
package simplilearn;
import java.util.Scanner;
public class shapeArea implements Area
{
public void Circle()
{
Scanner kb = new Scanner(System.in);
System.out.println("Enter the radius of the
circle");
double r = kb.nextInt();
double areaOfCircle = 3.142 * r * r;
System.out.println("Area of the circle is " +
areaOfCircle);
}
@Override
public void Square()
{
// TODO Auto-generated method stub
Scanner kb2 = new Scanner(System.in);
System.out.println("Enter the length of the side of the
square");
double s = kb2.nextInt();
double areaOfSquare = s * s;
System.out.println("Area of the square is " +
areaOfSquare);
}
@Override
public void Rectangle()
{
// TODO Auto-generated method stub
Scanner kb3 = new Scanner(System.in);
System.out.println("Enter the length of the Rectangle");
double l = kb3.nextInt();
System.out.println("Enter the breadth of the
Rectangle");
double b = kb3.nextInt();
double areaOfRectangle = l * b;
System.out.println("Area of the Rectangle is " +
areaOfRectangle);
}

53. @Override
public void Triangle()
{
// TODO Auto-generated method stub
Scanner kb4 = new Scanner(System.in);
System.out.println("Enter the base of the Triangle");
double base = kb4.nextInt();
System.out.println("Enter the height of the Triangle");
double h = kb4.nextInt();
double areaOfTriangle = 0.5 * base * h;
System.out.println("Area of the Triangle is " + areaOfTriangle);
}
public static void main(String[] args)
{
shapeArea geometry = new shapeArea();
geometry.Circle();
geometry.Square();
geometry.Rectangle();
geometry.Triangle();
}
}

54. set of classes and interfaces grouped together are known as Packages in
JAVA
Built-in Packages (packages from the Java API)
User-defined Packages (create your own packages)
Syntax
import package.name.Class; // Import a single class
import package.name.*; // Import the whole package
BENEFITS
The packages organize the group of classes into a single API unit
It will control the naming conflicts
The access protection will be easier. Protected and default are the access
level control to the package
Easy to locate the related classes
Reuse the existing classes in packages
Packages

55. built-in packages
Java.lang–Bundles the fundamental classes
Java.io - Bundle of input and output function classes
Java.awt–Bundle of abstract window toolkit classes
Java.swing–Bundle of windows application GUI toolkit classes
Java.net–Bundle of network infrastructure classes
Java.util–Bundle of collection framework classes
Java.applet–Bundle of creating applet classes
Java.sql -Bundle of related data processing classes
Extension packages
Extension packages start with javax.
This is for all the Java languages, which have lightweight component classes.
Javax.swing
Javax.servlet
Javax.sql

56. Define a class within another class. Such class is known as nested class.
Syntax
class OuterClass {
// ...
class NestedClass {
// ...
}
}
There are two types of nested classes you can create in Java.
1.Non-static nested class (inner class)
2.Static nested class
Nested and Inner Class

57. Advantage
•Nested classes represent a particular type of relationship that is
 
it can access all the
members (data members and methods) of the outer class, 
including private.
•Nested classes are used
 
to develop more readable and maintainable code 
because
it logically group classes and interfaces in one place only.
•Code Optimization: It requires less code to write.
Type Description
Member Inner Class A class created within class and outside
method.
Anonymous Inner Class A class created for implementing an interface or
extending class. The java compiler decides its
name.
Local Inner Class A class was created within the method.
Static Nested Class A static class was created within the class.
Nested Interface An interface created within class or interface.

58. Types of Inner Class
 in Java
The inner class is divided into four types based on position and behavior.
•Normal or Regular Inner Class
•Method local inner class
•Anonymous inner class
•Static Nested class
Normal or Regular Inner Classes
If we are declaring a named class inside another class without static modifier, such type of class
in normal or regular inner class.
Code:

59. //outer class
public class University {


private int courseId;


// regular inner class
class Department{

// inner class method
public void computer(){

System.out.println("We are Learning Java");

//accessing private variable of outer class University
courseId=1001;

System.out.println("Course Id for Java is:"+ courseId);

}

}

public static void main(String[] args) {
//creating outer class instance
University university=new University();

//creating instance of regular inner class
University.Department depart=university.new Department();

//calling inner class method
depart.computer();
}
}

60. Method Local Inner Class
•Declaring the class inside the method of the outer class, then that class is considered
as method local inner class.
•The scope of this class is limited to that particular method inside which it is declared.
•The method’s local inner class can be instantiated only within the method where the
inner class is declared.
 

61. //outer class
public class University {


private int courseId;
private static double courseFee;

public void getDepartment() {

// method local inner class
class Department{

// inner class method
public void computer(){

double TutionFee=20000.00;

int extraFee=1000;

System.out.println("We are Learning Java");

//accessing private variable of outer class University
courseId=1001;

System.out.println("Course Id for Java is:"+ courseId);

//accessing the static variable of outer class
courseFee=TutionFee+extraFee;

System.out.println("CourseFee:"+ courseFee);

}
}
//creating instance of inner class in inside the method of outer class
Department depart=new Department();

//calling method of inner class
depart.computer();

}

public static void main(String[] args) {
//creating outer class instance
University university=new University();

//calling outer class method
university.getDepartment();
}
}

62. Anonymous Inner Class
The inner class without a name is considered an Anonymous inner class, and
only a single object is created for the Anonymous inner class.
We use the Anonymous inner class when we need to override the method of
a class or interface method.
The main purpose of the anonymous inner class is just for instant use (one-
time use).
There are three types of anonymous inner class.
1.The anonymous inner class that extends a class
2.An anonymous inner class that implements an interface
3.An anonymous inner class that defines inside arguments

63. Anonymous Inner Class that Extends a Class
abstract class Player{

abstract void play();

}
public class Main {


public static void main(String[] args) {

// object of anonymous class is created with parent reference Player
Player p=new Player() {

//implementation of play() method
void play() {

System.out.println("Playing Football !");
}
};

p.play();

}
}

64. The Anonymous Inner Class that Defines Inside Interface
•In the program below, we created an interface Player and declared a method play.
•An anonymous class is created inside a main method, but the compiler decides its
name.
•This anonymous class implements the interface Player and provides the
implementation of the play() method.
interface Player{

void play();

}
public class Main {

public static void main(String[] args) {

// object of anonymous class is created with parent reference Player
Player p=new Player() {

//implementation of play() method
public void play() {

System.out.println("Playing Football !");
}
};

p.play();

}
}

65. Anonymous Inner Class that Define Inside Arguments
Anonymous Inner can be defined inside as an argument in the method or the
constructor;
public class Main {


public static void main(String[] args) {

//anonymous inner class that define inside the argument
Thread thread=new Thread(new Runnable() {

public void run() {

System.out.println(" child Thread running");
}

});

thread.start();

System.out.println(" Main Thread running");

}
}

66. Static Nested Class
•We use the keyword static to make the nested class static.
•In Java, only nested classes are allowed to be static.
•Static nested classes are technically not an inner class.
We have two cases in the static nested class:
1.Static nested class with instance member
2.Static nested class with static member

67. Instance Member
•When instance methods or variables are present inside the static nested class, we
must create the object of the static nested class.
•We do not have to create an object of the outer class because the nested class is static
and static properties and members are accessed without an object.
•The below program, instance method display() is accessed with the help of an Inner
class object.
public class Main {

static int value=500;

static class Inner{

public void display() {

System.out.println("The value is:"+ value);
}
}
public static void main(String[] args) {
//creating object of static nested Inner class
Main.Inner obj= new Main.Inner();

obj.display();
}
}

68. Static Member
When we have static methods or variables inside the static nested class, there is no need to
create the object of the static class.
public class Main {

static int value=500;

static class Inner{

public static void display() {

System.out.println("The value is:"+ value);
}
}


public static void main(String[] args) {
// no need to create the object of static nested
class Inner
Main.Inner.display(); }
}