Open Source Software · Technology

Java Fundamentals – Classes


It helps to look down from time to time and examine the very stuff we walk upon

I was reading code today (yes it would seem this is the only this I read these days), and I found something that puzzled me (and it should not have) :  “static class MyClass extends” – I know, I know! I should know what it means and I did take a good guess at it … “it means that the inner class is static and can be initiated from the top level class statically” – right?!  Well almost.  “okay ..”, I thought, “..what other unique ways of declaring a class do we have in Java? And why do we have them? How do we use them?!”

A little bit of googling let me to a great article on Java World [See JW Article On Static Classes] which talks in detail about the various way in Java Classes can be declared.

The JW Article Summary – Type of Java Class Declarations

There are 2 types of Java Class declarations – top level and inner. Inner classes can be Anonymous, Local, Member and Static Member.

  • Top-level Class:  The usual way of declaring a Java class, within a file which the name of the class.  Cannot declare this static. Class Name and Canonical class name are the same.
  • Inner Class: Classes defined within a top-level class
    • Anonymous Inner Class:
      • No name.
      • Instantiated only once.
      • You have seen these in Java Swing examples “new ActionListener(){…};” . You were implementing an interface using an anonymous class.
      • No class name
    • Local Class:
      • These are class declarations with a name, just like you would define a top-level class …except …
      • …they are declared within a “method block” in a top-level class
      • You can create as many instances but only within the method block
      • Outside the method you cannot access the class or instantiate it, just like a local var
      • Class Name and Canonical class name are the same
    • Member Class:
      • Just like member variables, these are classes declared within the top-level parent
      • …also just like member variables these are accessible through the instance of a parent
      • You cannot use the parent class to access these inner-classes, just like you cannot access non-static variables
      • Class Name is “Package.Parent.InnerClassName” and Canonical class name are of the form “Package.Parent$InnerClassName”
    • Static Member Class:
      • You use the static modifier when declaring the class
      • Declared within a parent class as an inner class
      • Accessible using the parent class or the parent instance (although this is discouraged)
      • Class Name is “Package.Parent.InnerClassName” and Canonical class name are of the form “Package.Parent$InnerClassName”

Hands-on Work

I created 5 top-level classes for each example and had the classes implement an interface which has a method called PrintDetails. I left the implementation of the print to the underlying inner classes and in a test harness I instantiated each of the five top-level classes and added them to a list.

After all the classes were added, I iterated through the list to invoke each interface’s print details.  Can you tell me what design pattern I have used here?

The examples and their implementation are given below. The readme.txt is a note that I keep for remember what I have learned about class declarations and static, member and local variables.  You can find this information on Sun/Oracle’s Java Fundamental tutorials.

Readme.txt

Implemented the examples for classes ... top-level, Anonymous Inner, Local, Member and Static Member.
Note: "static" does not do anything for the class like it does for the static variables
Class variables vs Object variables:
------------------------------------
-Static keyword makes a variable a Class variable
-It is then shared across all instances of the class
-Stored in one fixed memory location
-Any object can change the value, unless it is final
-Class variables can also be manipulated without creating an instance of the class
Static methods:
---------------
-to access Class variables or Static variables
-can be invoked using the ClassName or using the instance of the class (discouraged)
-cannot access instance variables
-cannot use 'this' keyword
Constants:
----------
-Variables declared using the "static" modifier and the "final" modifier are constants
-Their value cannot be reassigned in the program, compile time error results
-Compiler replaces the name of the variable with the value if a primitive type or a String is defined as a
constant. This is known as a compile time constant.

Sample Code


Advertisements

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s