Java Tutorial

1 of 16

http://www.learn-java-tutorial.com/InnerClasses.cfm

Search

In this lesson, you will learn how inner classes are used in Java.

About the creation and use of inner classes.

How to create and use enum classes.

1. Inner Classes, aka Nested Classes

2. Inner Class Syntax
3. Instantiating an Inner Class Instance from within the Enclosing Class
4. Inner Classes Referenced from Outside the Enclosing Class
5. Referencing the Outer Class Instance from the Inner Class Code
6. Better Practices for Working with Inner Classes
7. Enums

Java Introduction
(JavaIntroduction.cfm)
1. Conventions in These
Notes
2. The Java
Environment Overview
3. Writing a Java
Program

Inner classes, also known as nested classes are classes defined within another
class.
They may be defined as public, protected, private, or with package access.
They may only be used "in the context" of the containingclass (outer class, or
enclosing class), unless they are marked as static.

4. Obtaining the Java

Environment
5. Setting Up Your Java
Environment
6. Creating a Class that
Can Run as a
Program

The outer class can freely instantiate inner class objects within its code; they are

7/23/2013 9:58 PM

Java Tutorial

2 of 16

automatically associated with the outer class instance that created them.
Code in some other class can instantiate an inner class object associated with a
specific instance of the outer class if the inner class definition is public (and its
containing class is public as well).
If the inner class is static, then it can be instantiated without an outer class
instance, otherwise, the inner class object must be attached to an instance of the
outer class.

http://www.learn-java-tutorial.com/InnerClasses.cfm

7. Useful Stuff
Necessary to Go
Further
8. Using the Java
Documentation
Java Basics
(JavaBasics.cfm)

Inner classes are used to (these uses overlap to some extent):

1. Basic Java Syntax

Create a type of object that is only needed within one class, usually for some
short-term purpose.

2. Variables

Create a utility type of object that cannot be used elsewhere (which would allow
the programmer to change it without fear of repercussions in other classes).
Create one-of-a-kind interface implementations (such as individualized event
handlers).
Allow a sort of multiple inheritance, since the inner class may extend a different
class than the outer class extends, and an inner class instance would have
access to its private elements as well as the private elements of the outer class
object it is attached to
Implement one-to-many relationships where the classes are tightly coupled
(meaning that code for one or both of the classes needs access to many of the
private elements of the other class) - the outer class would be the "one" side of
the relationship, with the inner class being the "many" side.
Provide a specialized form of callback, with which a class may pass very limited
access to some of its internal components. Note that:
The collections classes provide an iterator, a class that implements the Iterator
interface to loop through the elements in the collection using hasNext and next
methods.

3. Data
4. Constants and the
final Keyword
5. Mathematics in Java
6. Creating and Using
Methods
7. Variable Scope
Java Objects
(JavaObjects.cfm)
1. Objects
2. Object-oriented
Languages
3. Object-oriented
Programs
4. Encapsulation

Given that the internal structure of the collection may be complex, implementing
the iterator as an inner class enables it to navigate the structure, while not
exposing any other aspects of the collection to the outside world.

5. References

Inner class code has free access to all elements of the outer class object that
contains it, by name (no matter what the access level of the elements is).

7. More on Access
Terms

Outer class code has free access to all elements in any of its inner classes, no
matter what their access term.

8. Adding Data
Members to a Class

An inner class compiles to its own class file, separate from that of the outer class
(the name of the file will be OuterClassName$InnerClassName.class, although
within your code the name of the class will be
OuterClassName.InnerClassName); you cannot use the dollar sign version of the
name in your code.

9. Standard Practices
for Fields and
Methods

An inner class occupies its own memory block, separate from the outer class
memory block.
An inner class may extend one class, which might be unrelated to the class the
outer class extends.

6. Defining a Class

10. Java Beans

11. Bean Properties
12. Constructors
13. Instantiating Objects
Revisited

7/23/2013 9:58 PM

Java Tutorial

3 of 16

http://www.learn-java-tutorial.com/InnerClasses.cfm

An inner class can implement one of more interfaces, and, if treated as an

instance of one of its interfaces, external code may have no knowledge that the
object actually comes from an inner class.

14. Important Note on

Constructors
15. Method Overloading
16. The this Keyword

Like this Java tutorial? Try our self-paced online Java

course (http://www.remotecourse.com/java/index.cfm),
which includes videos and exercises in addition to the
content in this Java tutorial. Not sure if you want to pay
for that? Register for a free demo of the course
(http://www.webucator.com/self-paced-courses
/demo.cfm).

17. Using this to Call

Another Constructor
18. static Elements
19. The main Method
20. Garbage Collection
21. Java Packages
22. Compiling and
Executing with
Packages

1
2
3
4
5

[modifiers]classOuterClassName{
code
[modifiers]classInnerClassName[extendsBaseClassToIn
fieldsandmethods
}

The definition of the inner class is always available for the outer class to use.
Note that:
No inner class objects are automatically instantiated with an outer class object.
Outer class code may instantiate any number of inner class objects - none, one,
or many.

Java-InnerClasses/Demos/MyOuter.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

publicclassMyOuter{
privateintx;
MyOuter(intx,inty){
this.x=x;
newMyInner(y).privateDisplay();
}
publicclassMyInner{
privateinty;
MyInner(inty){
this.y=y;
}
privatevoidprivateDisplay(){
System.out.println("privateDisplayx="+x+"and
}
publicvoidpublicDisplay(){
System.out.println("publicDisplayx="+x+"and
}
}
}

This is a simple example of an inner class

MyOuter has one property, x; the inner class MyInner has one property, y.

23. Working with

Packages
24. String, StringBuffer,
and StringBuilder
25. Creating
Documentation
Comments and Using
javadoc
26. Primitives and
Wrapper Classes
Comparisons and Flow
Control Structures
(ComparisonsandFlowCon
1. Boolean-valued
Expressions
2. Comparison
Operators
3. Comparing Objects
4. Conditional
Expression Examples
5. Complex boolean
Expressions
6. The if Statement
7. if Statement
Examples
8. Two Mutually
Exclusive Branches

7/23/2013 9:58 PM

Java Tutorial

4 of 16

http://www.learn-java-tutorial.com/InnerClasses.cfm

The MyOuter constructor accepts two parameters; the first is used to populate x.
It creates one MyInner object, whose y property is populated with the second
parameter.

9. Comparing a Number
of Mutually Exclusive
options - The switch
Statement

Note that the inner class has free access to the private outer class x element.

10. Comparing Objects

The outer class has free access to the private inner class privateDisplay()
method.

11. Conditional
Expression

The connection between the two classes is handled automatically.

12. Additional Loop

Control: break and
continue

The following diagram maps out the memory used by the example.

13. Continuing a Loop

14. Classpath, Code
Libraries, and Jar
Files
15. Compiling to a
Different Directory
Arrays (Arrays.cfm)
1. Defining and
Declaring Arrays
2. Instantiating Arrays
3. Initializing Arrays
4. Working With Arrays
5. Array Variables
6. Copying Arrays
7. Arrays of Objects
8. Enhanced for Loops the For-Each Loop
9. Multi-Dimensional
Arrays

Like this Java tutorial? Try our self-paced online Java

courses (http://www.remotecourse.com/java/index.cfm),
which includes videos and exercises in addition to the
content in this Java tutorial. Not sure if you want to pay
for that? Register for a free demo of the course
(http://www.webucator.com/self-paced-courses
/demo.cfm).

10. Multidimensional
Arrays in Memory
11. Example - Printing a
Picture
12. Typecasting with
Arrays of Primitives
Inheritance
(Inheritance.cfm)
1. Inheritance
2. Inheritance Examples

7/23/2013 9:58 PM

Java Tutorial

5 of 16

http://www.learn-java-tutorial.com/InnerClasses.cfm

3. Payroll with
Inheritance
4. Derived Class
Objects
5. Polymorphism
6. Creating a Derived
Class
An inner class instance may be directly instantiated from code in the enclosing
class, without any special syntax:
1
2
3
4
5
6
7
8
9

[modifiers]classOuterClassName{
code
[modifiers]classInnerClassName{
code
}
publicvoidsomeMethod(){
InnerClassNamevariable=newInnerClassName();
}
}

Such an instance is automatically associated with the enclosing class instance

that instantiated it.

7. Inheritance Example A Derived Class

8. Inheritance and
Access
9. Inheritance and
Constructors - the
super Keyword
10. Derived Class
Methods that
Override Base Class
Methods
11. Inheritance and
Default Base Class
Constructors

Java-InnerClasses/Demos/Inner1.java
1
2
3
4
5

publicclassInner1{
publicstaticvoidmain(String[]args){
newMyOuter(1,2);
}
}

This code simply creates an instance of the outer class, MyOuter.

The MyOuter constructor creates an instance of MyInner as mentioned earlier.

12. The Instantiation

Process at Runtime
13. Example - Factoring
Person Out of
Employee
14. Typecasting with
Object References
15. More on Overriding

Like this Java tutorial? Try our self-paced online Java

course (http://www.remotecourse.com/java/index.cfm),
which includes videos and exercises in addition to the
content in this Java tutorial. Not sure if you want to pay
for that? Register for a free demo of the course
(http://www.webucator.com/self-paced-courses
/demo.cfm).

16. Object Typecasting

Example
17. Checking an Object's
Type: Using
instanceof
18. Typecasting with
Arrays of Objects
19. Methods Inherited
from Object
20. Other Inheritancerelated Keywords
Interfaces
(Interfaces.cfm)

7/23/2013 9:58 PM

Java Tutorial

6 of 16

http://www.learn-java-tutorial.com/InnerClasses.cfm

1. Interfaces
2. Creating an Interface
Definition
3. Implementing
Interfaces
If the access term for the inner class definition is public (or the element is
accessible at package access or protected level to the other class), then other
classes can hold references to one or more of these inner class objects
If the inner class is static, then it can exist without an outer class object,
otherwise any inner class object must belong to an outer class instance.
For code that is not in the outer class, a reference to a static or non-static inner
class object must use the outer class name, a dot, then the inner class name:
1

OuterClassName.InnerClassNameinnerClassVariable

If the inner class has an accessible constructor, you can you instantiate one from
outside of the enclosing class, although the syntax is ugly, and there is rarely a
need for this capability.

Like this Java tutorial? Try our self-paced online Java

course (http://www.remotecourse.com/java/index.cfm),
which includes videos and exercises in addition to the
content in this Java tutorial. Not sure if you want to pay
for that? Register for a free demo of the course
(http://www.webucator.com/self-paced-courses
/demo.cfm).

4. Reference Variables
and Interfaces
5. Interfaces and
Inheritance
6. Some Uses for
Interfaces
7. Annotations
8. Annotation Details
9. Using Annotations
Exceptions
(Exceptions.cfm)
1. Exceptions
2. Handling Exceptions
3. Exception Objects
4. Attempting Risky
Code - try and catch
5. Guaranteeing
Execution of Code The finally Block
6. Letting an Exception
be Thrown to the
Method Caller
7. Throwing an
Exception
8. Exceptions and
Inheritance
9. Creating and Using
Your Own Exception
Classes

If inner class code needs a reference to the outer class instance that it is
attached to, use the name of the outer class, a dot, and this. Remember that if
there is no name conflict, there is no need for any special syntax.

10. Rethrowing
Exceptions

For code in MyInner to obtain a reference to its MyOuter:

11. Initializer Blocks

MyOuter.this

12. Assertions
Collections
(Collections.cfm)

7/23/2013 9:58 PM

Java Tutorial

7 of 16

http://www.learn-java-tutorial.com/InnerClasses.cfm

1. Collections

An inner class may be marked as static.

2. Using the Collection

Classes

A static inner class my be instantiated without an instance of the outer class.

Note that:

3. Using the Iterator

Interface

static members of the outer class are visible to the inner class, no matter what
their access level.
Non-static members of the outer class are not available, since there is not
instance of the outer class to retrieve them from.

4. Creating Collectible
Classes
5. Collections in Java
5.0: Generics
6. Bounded Types

To create a static inner class object from outside the enclosing class, you must
still reference the outer class name
1

newOuterClassName.InnerClassName(arguments)

An inner class may not have static members unless the inner class is itself
marked as static.

7. Extending Generic
Classes and
Implementing Generic
Interfaces
8. Generic Methods
9. Variations on
Generics - Wildcards

Java-InnerClasses/Demos/StaticInnerTest.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

classStaticOuter{
publicStaticInnercreateInner(){
returnnewStaticInner();
}

staticclassStaticInner{
publicvoiddisplay(){
System.out.println("StaticOuter.Innerdisplaymethod
}
}
}

classStaticInnerTest{
publicstaticvoidmain(String[]args){

newStaticOuter.StaticInner().display();

StaticOuterso=newStaticOuter();

//so.newStaticInner().display();

so.createInner().display();

}
}

We have a class StaticOuter that declares a static inner class StaticInner.

StaticOuter has a method that will create instances of StaticInner. But,
StaticInner also has a public constructor. Note that:

Inner Classes
(InnerClasses.cfm)
1. Inner Classes, aka
Nested Classes
2. Inner Class Syntax
3. Instantiating an Inner
Class Instance from
within the Enclosing
Class
4. Inner Classes
Referenced from
Outside the Enclosing
Class
5. Referencing the
Outer Class Instance
from the Inner Class
Code
6. Better Practices for
Working with Inner
Classes
7. Enums

We can directly instantiate a StaticOuter.StaticInner object without an outer class

instance.
Code for a StaticOuter can create a StaticInner, but the inner class object has no
attachment to the outer class object that created it.

7/23/2013 9:58 PM

Java Tutorial

8 of 16

http://www.learn-java-tutorial.com/InnerClasses.cfm

Note the commented out line; you cannot create a static inner class instance
attached to an instance of its enclosing class.

Advanced CSS Training

Tutorial
Advanced Flash CS5
Training Tutorial

Like this Java tutorial? Try our self-paced online Java

course (http://www.remotecourse.com/java/index.cfm),
which includes videos and exercises in addition to the
content in this Java tutorial. Not sure if you want to pay
for that? Register for a free demo of the course
(http://www.webucator.com/self-paced-courses
/demo.cfm).

Advanced Google
AdWords Training Tutorial
Advanced Google
Analytics Tutorial
Advanced JavaScript
Programming Tutorial
Advanced Microsoft Excel
2010 Training Tutorial
Advanced Microsoft Word
2010 Training Tutorial
Ajax Training Tutorial
Business Writing Training
Tutorial

It is easiest if inner class objects can always be instantiated from the enclosing
class object. You can create a factory method to accomplish this.

Java-InnerClasses/Demos/FactoryInnerOuter.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

classFactoryOuter{
FactoryInner[]fi=newFactoryInner[3];
protectedintlastIndex=0;
privateintx=0;
publicFactoryOuter(intx){
this.x=x;
}
publicintgetX(){
returnx;
}
publicvoidaddInner(inty){
if(lastIndex<fi.length){
fi[lastIndex++]=newFactoryInner(y);
}
elsethrownewRuntimeException("FactoryInnerarrayfu
}
publicvoidlist(){
for(inti=0;i<fi.length;i++){
System.out.print("Icanseeintotheinnerclasswhe
fi[i].y+"orcalldisplay:");
fi[i].display();
}
}
publicclassFactoryInner{
privateinty;
protectedFactoryInner(inty){
this.y=y;
}
publicvoiddisplay(){

Customer Service Training

Tutorial
Diversity Training for
Employees and Managers
Tutorial
Goal Setting and Time
Management Training
Tutorial
HTML5 Training for Web
Developers Tutorial
Intermediate Microsoft
Excel 2010 Training
Tutorial
Intermediate Microsoft
Word 2010 Training
Tutorial
Introduction to CSS
Training Tutorial
Introduction to
Dreamweaver CS5
Training Tutorial
Introduction to Flash CS5
Training Tutorial
Introduction to Google
AdWords Tutorial

7/23/2013 9:58 PM

Java Tutorial

9 of 16

http://www.learn-java-tutorial.com/InnerClasses.cfm

30
31
32
33
34
35
36
37
38
39
40
41
42
43

System.out.println("FactoryInnerx="+x+"and
}
}
}
publicclassFactoryInnerOuter{
publicstaticvoidmain(String[]args){
FactoryOuterfo=newFactoryOuter(1);
fo.addInner(101);
fo.addInner(102);
fo.addInner(103);
fo.list();
//fo.addInner(104);
}
}

For convenience, this file contains both the main class and the FactoryOuter
class (with package access). Note that:
An instance of FactoryOuter contains a three element array of FactoryInner
objects.
The addInner method instantiates a FactoryInner object and adds it to the array
(note that is still automatically associated with the FactoryOuter instance by the
JVM, but we need our own mechanism for keeping track of the inner class
instances we create).
A better approach would be to use one of the collections classes instead of an
array, to avoid running out of room in the array
This is exactly the sort of thing that happens when you obtain an iterator from a
collection class. In order to successfully navigate what is most likely a complex
internal structure, the object will need access to the private elements. So, an
inner class is used, but all you need to know about the object is that it
implements the Iterator interface.

Introduction to Google
Analytics Training Tutorial
Introduction to HTML
Training Tutorial
Introduction to Java
Training Tutorial
Introduction to JavaScript
Training Tutorial
Introduction to Microsoft
Excel 2010 Training
Tutorial
Introduction to Microsoft
Word 2010 Training
Tutorial
Introduction to PHP
Training Tutorial
Introduction to PowerPoint
2010 Training Tutorial
Introduction to SQL
Training Tutorial
Introduction to XML
Training Tutorial
jQuery Fundamentals
Training Tutorial

Java-InnerClasses/Demos/PayrollInnerClass/employees/Employee.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

packageemployees;
importfinance.TransactionException;

publicclassEmployee{

CODEOMITTED
privatedoubleytdPay;
privatePayment[]payments=newPayment[12];
privateintpaymentCount=0;

CODEOMITTED
publicdoublegetYtdPay(){returnytdPay;}

publicPaymentcreatePayment(){
Paymentp=newPayment(payRate);
payments[paymentCount++]=p;
returnp;
}

publicvoidprintPaymentHistory(){
for(Paymentp:payments){
System.out.println(p);
}
}

publicclassPayment{

Microsoft Outlook 2010

Training Tutorial
Sexual Harassment
Awareness for Employees
and Managers Tutorial
SharePoint 2010 End User
Training Tutorial
SharePoint 2010 Power
User Training Tutorial
Upgrading to Microsoft
Excel 2010 Tutorial
Upgrading to Microsoft
Outlook 2010 Tutorial
Upgrading to Microsoft
PowerPoint 2010 Tutorial
Upgrading to Microsoft
Word 2010 Tutorial
Working with Difficult

7/23/2013 9:58 PM

Java Tutorial

10 of 16

http://www.learn-java-tutorial.com/InnerClasses.cfm

27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

privatedoubleamount;
privatebooleanposted;

publicPayment(doubleamount){
this.amount=amount;
}

publicbooleanprocess()throwsTransactionException{
if(!posted){
ytdPay+=amount;
posted=true;
System.out.println(getFullName()+"paid"+amou
returntrue;
}else{
thrownewTransactionException("Transactionalread
}
}

publicStringtoString(){
returngetFullName()+"paymentof"+amount;
}

}
}

Payment is an inner class to a simplified Employee, and, as an inner class, has

free access to all private elements of Employee. Unlike a standalone payment
class, this class can retrieve the employee name from the outer class instance.
We also use this access to defer updating the year-to-date amounts until the
payment is posted, via the process method.
To get this degree of interaction between two separate classes would be difficult,
since it would mean that either:

People Tutorial

Flash CS5 Courses

AdWords Courses
Google and SEO Courses
Google Analytics Courses
Excel 2010 Courses
Word 2010 Courses
Best Selling Live Online
Courses
HTML5 Courses
Mobile Web Development
Courses
Dreamweaver CS5
Courses
PowerPoint 2010 Courses

1. The ability to update ytdPay would have to be publicly available.

SharePoint 2010 Courses

2. Employee and Payment would have to be in the same package, with

updating ytdPay achieved by using package access.

SharePoint End User

Courses

Note that we have also separated the concepts of creating a payment from
actually posting it. This gives us better control over transactions - note that a
payment cannot be processed twice.

Java-InnerClasses/Demos/PayrollInnerClass/Payroll.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

importemployees.*;
importfinance.*;

publicclassPayroll{
publicstaticvoidmain(String[]args){

Employee.setNextId(22);
Employeee=newEmployee("John","Doe",6000.0);

//looptopayeachmonth
for(intmonth=0;month<12;month++){
Employee.Paymentp=e.createPayment();
try{
p.process();

//HRerrorcausesattempttoprocessJunepaychec
if(month==5)p.process();
}

Office 2010 Upgrade

Courses

CSS Training
Flash Training
Marketing Training
Google Training
Social Media Training
Google AdWords Training
Google Analytics Training
JavaScript Training
Microsoft Office Training

7/23/2013 9:58 PM

Java Tutorial

11 of 16

http://www.learn-java-tutorial.com/InnerClasses.cfm

19
20
21
22
23
24
25
26
27
28
29
30

catch(TransactionExceptionte){
System.out.println(te.getMessage());
}
System.out.println("Ytdpay:"+e.getYtdPay());
}

System.out.println("EmployeePaymentHistory:");

e.printPaymentHistory();
}

We have only one employee for simplicity. As we loop for each month, a
payment is created for each. We try to process the June payment twice
(remember that the array is zero-based, so January is month 0; this matches the
behavior of the java.util.Date class) . The second attempt to process the
payment should throw an exception which our catch block handles.
We retrieve and print the year-to-date pay each time we process a payment.
At the end, we have the Employee object print the entire payment history created
by our calls to the inner class' process method..

Microsoft Excel Training

Microsoft Word Training
Ajax Training
Writing Training
Customer Service Training
HR Training
Business Management
Training
HTML Training
Mobile Web Development
Training
Dreamweaver Training
Java Fundamentals
Training
PHP Training

Java-InnerClasses/Demos/PayrollInnerClassInterface/employees/Employee.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

packageemployees;
importfinance.*;

publicclassEmployee{

CODEOMITTED
publicclassPaymentimplementsPayable{
privatedoubleamount;
privatebooleanposted;

publicPayment(doubleamount){
this.amount=amount;
}

publicbooleanprocess()throwsTransactionException{
if(!posted){
ytdPay+=amount;
posted=true;
System.out.println(getFullName()+"paid"+amou
returntrue;
}else{
thrownewTransactionException("Transactionalread
}
}

publicStringtoString(){
returngetFullName()+"paymentof"+amount;
}

}
}

Microsoft PowerPoint
Training
SQL Training
XML Training
jQuery Training
Microsoft Outlook Training
SharePoint Training

Check out our self-paced

Java courses!

This code goes one step further to create a Payment inner class that implements
the Payable interface.

7/23/2013 9:58 PM

Java Tutorial

12 of 16

http://www.learn-java-tutorial.com/InnerClasses.cfm

Java-InnerClasses/Demos/PayrollInnerClassInterface/Payroll.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

importemployees.*;
importfinance.*;

publicclassPayroll{
publicstaticvoidmain(String[]args){

Employee.setNextId(22);
Employeee=newEmployee("John","Doe",6000.0);

//looptopayeachmonth
for(intmonth=0;month<12;month++){
Payablep=e.createPayment();
try{
p.process();

//HRerrorcausesattempttoprocessJunepaychec
if(month==5)p.process();
}
catch(TransactionExceptionte){
System.out.println(te.getMessage());
}
System.out.println("Ytdpay:"+e.getYtdPay());
}

System.out.println("EmployeePaymentHistory:");

e.printPaymentHistory();
}

The only difference here is that we declare the variable holding the payments as
Payable, hiding the fact that it is an inner class.

Like this Java tutorial? Try our self-paced online Java

courses (http://www.remotecourse.com/java/index.cfm),
which includes videos and exercises in addition to the
content in this Java tutorial. Not sure if you want to pay
for that? Register for a free demo of the course
(http://www.webucator.com/self-paced-courses
/demo.cfm).

In Java 5, the enum element was introduced. Long sought by the C/C++ part of
the Java community, enums provide a set of predefined constants for indicating a
small set of mutually exclusive values or states.

7/23/2013 9:58 PM

Java Tutorial

13 of 16

http://www.learn-java-tutorial.com/InnerClasses.cfm

The other approaches all have some sort of flaw, particularly as involves
type-safety.
Interfaces defining only constants were commonly used, and several are
grandfathered into the API, like SwingConstants. But, there is a minor problem
that if you implement an interface in order to gain the constants, you then have
additional public elements in that class that you wouldn't really want to provide to
the outside world.
1
2
3
4

publicclassMyFrameextendsJFrameimplementsSwingConstan

MyFrameframe=newMyFrame();
//frame.HORIZONTALisnowpubliclyavailable

While not terrible, there isn't any real meaning to frame.HORIZONTAL, or any
reason we would want to make it available to the outside world.
Using plain old integers seems straightforward enough, but, if you perhaps have
a method that requires one of that set of values to be passed in, the parameter
would be typed as int. A caller could supply any int value, including ones you
wouldn't expect.
1
2
3
4
5
6
7
8

privateintLEFT=0;
privateintRIGHT=1;
privateintCENTER=2;

publicvoidsetAlignment(intalign){...}

//compilerwouldallow:
setAlignment(99);

Java enums provide a type-safe way of creating a set of constants, since they
are defined as a class, and therefore are a type of data.
A disadvantage to this approach is that the set of values is written into the code.
For sets of values that may change, this would require recompiling the code, and
would invalidate any serialized instances of the enum class. For example, if we
offered a choice of benefits plans to our employees, the set of available plans
would not be a good candidate for an enum, since it is likely that the set of
available plans would eventually change.

To create a simple enum class:

1. Declare like an ordinary class, except using the keyword enum instead of
class.
2. Within the curly braces, supply a comma-separated list of names, ending in
a semicolon.
One instance of the enum class will be created to represent each item you listed,
available as a static field of the class, using the name you supplied which will be
the individual values. Each instance can provide an integral value, with sequential

7/23/2013 9:58 PM

Java Tutorial

14 of 16

http://www.learn-java-tutorial.com/InnerClasses.cfm

indexes starting at 0, in the order that the names were defined - there is no way
to change this, but there is a route to get specific values which have a complex
internal state.
1
2
3

publicenumEnumName{
value1,value2,value3,...;
}

publicenumAlignment{left,right,center;}

There will be three instances of the class created, Alignment.left, Alignment.right,

and Alignment.center. An Alignment type variable can hold any of these three
values.
Enums automatically extend the Enum class from the API, and they inherit
several useful methods:
Each object has a name method that returns the name of that instance (as does
the toString method).
The ordinal method returns that enum object's position in the set, the integer
index mentioned above.
There are also several other methods that will be present, although they are not
listed in the documentation for Enum.
A public static EnumName[] values() method that returns an array containing all
the values, in order (so that the array index would match the ordinal value for that
object). This method is not inherited, but is built specifically for each enum class.
A public EnumName valueOf(String name) method that returns the instance
whose name matches the specified name (this is not the uglier method you will
see in the documentation, but another built specifically for each instance - the one
listed in the documentation is actually used internally by the simpler form).
The reason for the last two methods not being in the documentation has to do
with generics and type erasure - the methods cannot be declared in the Enum
base class in a way that would allow the use of the as-yet unknown subclass.
Individual values from the set may be accessed as static elements of the enum
class. The JVM will instantiate exactly one instance of each value from the set.
Therefore, they can be used in comparisons with ==, or in switch statements
(using the equals method is preferred to ==, since it will serve as a reminder that
you are dealing with true objects, not integers).
Although enums may be top-level classes, they are often created as inner
classes, as in the following example, where the concept of the enum is an
integral part of a new BookWithEnum class. When used as an inner class, they
are automatically static, so that an instance of an inner enum does not have
access to instance elements of the enclosing class.

Java-InnerClasses/Demos/BookWithEnum.java
1
2
3
4
5

publicclassBookWithEnum{
privateintitemCode;
privateStringtitle;
privatedoubleprice;
privateCategorycategory;

7/23/2013 9:58 PM

Java Tutorial

15 of 16

http://www.learn-java-tutorial.com/InnerClasses.cfm

6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

publicenumCategory{required,supplemental,optional,

publicBookWithEnum(
intitemCode,Stringtitle,
doubleprice,Categorycategory){
setItemCode(itemCode);
setTitle(title);
setPrice(price);
setCategory(category);
}
publicBookWithEnum(Stringtitle){
setItemCode(0);
setTitle(title);
setPrice(0.0);
setCategory(Category.unknown);
}
publicintgetItemCode(){
returnitemCode;
}
publicvoidsetItemCode(intitemCode){
if(itemCode>0)this.itemCode=itemCode;
}
publicStringgetTitle(){
returntitle;
}
publicvoidsetTitle(Stringtitle){
this.title=title;
}
publicvoidsetPrice(doubleprice){
this.price=price;
}
publicdoublegetPrice(){
returnprice;
}
publicvoidsetCategory(Categorycategory){
this.category=category;
}
publicvoidsetCategory(StringcategoryName){
this.category=Category.valueOf(categoryName);
}
publicCategorygetCategory(){
returncategory;
}
publicvoiddisplay(){
System.out.println(itemCode+""+title+":"+cat
",Price:$"+price);
}
}

The Category enum is defined as an inner class to BookWithEnum. The full

names of the complete set of values are: BookWithEnum.Category.required,
BookWithEnum.Category.supplemental, BookWithEnum.Category.optional, and
BookWithEnum.Category.unknown. From within the BookWithEnum class, they
may be accessed as: Category.required, Category.supplemental,
Category.optional, and Category.unknown.
We set the category for a book constructed without one as Category.unknown,
and provide methods to get the value, and to set it with either an enum object or
from a string.
Note that enums may be used in switch statements - for the cases you use only
the short name for the value.

7/23/2013 9:58 PM

Java Tutorial

16 of 16

http://www.learn-java-tutorial.com/InnerClasses.cfm

Enums are more than just a set of integer constants. They are actually a set of
unique object instances, and, as objects, can have multiple fields. So, an enum is
a class with a fixed number of possible instances, each with it's own unique
state, and each of the possible instances is created automatically and stored as
static field under the same name. (In design pattern terms, an enum is a
Flyweight - a class where only a limited number of fixed states exist.)
To create a more complex enum class:
1. Declare as before.
2. Declare any additional fields and accessor methods as with a regular class.
While you can actually write mutator methods to create what is called a
mutable enum, this practice is strongly discouraged.
3. Write one constructor.
4. Within the curly braces, again supply a comma-separated list of names,
which will be the individual values, but this time with a parameter list. The
enum values will be constructed with the data you provide.

Like this Java tutorial? Try our self-paced online Java

course (http://www.remotecourse.com/java/index.cfm),
which includes videos and exercises in addition to the
content in this Java tutorial. Not sure if you want to pay
for that? Register for a free demo of the course
(http://www.webucator.com/self-paced-courses
/demo.cfm).

This page was last updated on 2013-01-03

All pages and graphics in this Java Tutorial is copyright 2013 and are the property of Webucator, Inc.
(http://www.webucator.com) unless otherwise specified. The purpose of this website is to help you learn Java on your own
and use of the website implies your agreement to our Terms of Service (tos.cfm).

7/23/2013 9:58 PM