Java ShortCut

Object Oriented Programming Principles

2010-07-05T13:27:00.001-07:00

1. Encapsulation is the mechanism that binds together code and the data it manipulates, and keeps both safe from outside interference and misuse. Java implements this by the use of classes and objects.

Data hiding /abstraction: is the ability of objects to shield variables from external access. It is a useful consequence of the encapsulation principle. Java implements this by the use of access specifiers, namely public, private, protected, and default.

2. Inheritance is the process by which one object acquires the properties of another object. The concept of inheritance greatly enhances code reuse and makes hierarchical classification possible. Java implements this by the ability of classes to inherit methods and variables from parent classes and interfaces.

3. Polymorphism (from the Greek, meaning “many forms”) is the ability of a single entity to take multiple forms.

Java implements this by:

• Method Overloading (Methods with the same name but different signatures)

• Method Overriding (Methods with the same name & same signature but one in the parent class and the other in the child class)

• Dynamic Method Dispatch (The mechanism by which a call to an overridden method is resolved at run time, rather than compile time.)

Class Fundamentals

2010-07-05T13:25:00.003-07:00

Classes define a new data type that can be used as a template for creation of an object.

Objects are instances of a class.

Declaring Objects

2010-07-05T13:25:00.001-07:00

First, you must declare a variable of the class type. This variable does not define an object. Instead, it is simply a variable that can refer to an object. Second, you must acquire an actual, physical copy of the object and assign it to that variable. You can do this using the new operator. The new operator dynamically allocates memory for an object and returns a reference to it.

Assigning Object Reference Variables

2010-07-05T13:24:00.003-07:00

When you assign one object reference variable to another object reference variable, you are not creating a copy of the object; you are only making a copy of the reference.

Box b1 = new Box();
Box b2 = b1;

Constructors

2010-07-05T13:24:00.001-07:00

A constructor initializes an object immediately upon creation. It has the same name as the class in which it resides and is syntactically similar to a method. The return type of a class’ constructor is the class type itself. It is called immediately after the object is created, before the new operator completes.

The “this” Keyword

2010-07-05T13:22:00.001-07:00

“this” keyword is used by a method when it needs to refer to the object that invoked it. this can be used inside any method to refer to the current object.

Class Variable, Instance Variable, Local Variable

2010-07-05T13:20:00.001-07:00

Class Variable
Static variables declared inside a class are referred to as class variables. They are global to all objects created by the class.

Instance Variable
Instance variables are variables defined in a class body which are created when objects are instantiated. They take different values for each object.

Local Variable
Variables declared and used inside methods are called local variables.

Instance Variable Hiding

2010-07-05T13:18:00.003-07:00

When a local variable has the same name as an instance variable, the local variable hides the instance variable.

Garbage Collection

2010-07-05T13:18:00.001-07:00

Java provides auto garbage collection for unused objects. The garbage collector runs periodically, checking for objects that are no longer referenced by any running state or indirectly through other referenced objects.

The finalize( ) Method

2010-07-05T13:16:00.003-07:00

By using the finalize method, we can define specific actions that will occur when an object is just about to be reclaimed by the garbage collector. The Java run time calls this method whenever it is about to recycle an object of that class. Inside the finalize( ) method you will specify those actions that must be performed before an object is destroyed. The garbage collector runs periodically, checking for objects that are no longer referenced by any running state or indirectly through other referenced objects.

Overloading Methods

2010-07-05T13:16:00.001-07:00

Method overloading is one of the ways that Java implements polymorphism. When two or more methods within the same class share the same name but differ in the type and/or number of their parameters then those methods are said to be overloaded. While overloaded methods may have different return types, the return type alone is insufficient to distinguish two versions of a method. When Java encounters a call to an overloaded method, it simply executes the version of the method whose parameters match the arguments used in the call. Java uses the type and/or number of arguments as its guide to determine which version of the overloaded method to actually call.

Using Objects as Parameters

2010-07-05T13:15:00.005-07:00

It is both correct and common to pass objects to methods.

Argument Passing

2010-07-05T13:15:00.003-07:00

Call-by-value: This method copies the value of an argument into the formal parameter of the subroutine. Therefore, changes made to the parameter of the subroutine have no effect on the argument.

Call-by-reference: In this method, a reference to an argument (not the value of the argument) is passed to the parameter. Inside the subroutine, this reference is used to access the actual argument specified in the call. This means that changes made to the parameter will affect the argument used to call the subroutine.

When a simple type is passed to a method, it is done by use of call-by-value. Objects are passed by use of call-by-reference.

Returning Objects

2010-07-05T13:15:00.001-07:00

A method can return any type of data, including class types that you create.

Access Specifiers

2010-07-05T13:14:00.000-07:00

How a member can be accessed is determined by the access specifier that modifies its declaration. Java’s access specifiers are public, private, and protected. Java also defines a default access level. protected applies only when inheritance is involved.

• When a member of a class is modified by the public specifier, then that member can be accessed by any other code.

• When a member of a class is specified as private, then that member can only be accessed by other members of its class.

• When a member of a class is specified as protected, then that member of a class is public within its own package and in subclasses in other packages, but cannot be accessed by non-subclasses outside its package.
• When no access specifier is used, then by default the member of a class is public within its own package, but cannot be accessed outside of its package.

Anything declared public can be accessed from anywhere. Anything declared private cannot be seen outside of its class. When a member does not have an explicit access specification the default access is used, it is visible to subclasses as well as to other classes in the same package. If you want to allow an element to be seen outside your current package, but only to classes that subclass your class directly, then declare that element protected.

	Private	Default	Protected	Public
Same class	Yes	Yes	Yes	Yes
Same package subclass	No	Yes	Yes	Yes
Same package non-subclass	No	Yes	Yes	Yes
Different package subclass	No	No	Yes	Yes
Different package non-subclass	No	No	No	Yes

The “static” Keyword

2010-07-05T13:06:00.001-07:00

When a member is declared static, it can be accessed before any objects of its class are created, and without reference to any object. You can declare both methods and variables to be static. The most common example of a static member is main( ).

Variables

Instance variables declared as static are, essentially, global variables. When objects of its class are declared, no copy of a static variable is made. Instead, all instances of the class share the same static variable.

Methods

Methods declared as static have several restrictions:
• They can only call other static methods.
• They must only access static data. They can not to refer to any instance variables.
• They cannot refer to this or super in any way.

If you need to do computation in order to initialize your static variables, you can declare a static block which gets executed exactly once, when the class is first loaded.

Arrays Revisited

2010-07-05T13:05:00.001-07:00

Arrays are implemented as objects.

int a1[] = new int[10];
int a2[] = {3, 5, 7, 1, 8, 99, 44, -10};

Java Command-Line Arguments

2010-07-05T13:02:00.000-07:00

All command-line arguments are passed as strings.

javac prog.java
java prog this is test no 1

args[0]: this /* Arguments can be accessed by using args[i] */
args[1]: is
args[2]: test
args[3]: no
args[4]: 1 /* You must convert numeric values to their internal forms manually: Integer.parseInt(str) */

Inheritance Basics

2010-07-05T13:00:00.005-07:00

To inherit a class the extends keyword is used.

Subclass Object Referenced By Superclass Variable

2010-07-05T13:00:00.001-07:00

A reference variable of a superclass can be assigned a reference to any subclass derived from that superclass.

superclass_object=subclass_object

The “super” Keyword

2010-07-05T12:59:00.003-07:00

Whenever a subclass needs to refer to its immediate superclass, it can do so by use of the keyword super.super has two general forms. The first calls the superclass’ constructor. The second is used to access a member of the superclass that has been hidden by a member of a subclass.

super( ) must always be the first statement executed inside a subclass constructor.

1. super(parameter-list);
2. super.member

When Constructors Are Called

2010-07-05T12:59:00.001-07:00

In a class hierarchy, constructors are called in order of derivation, from superclass to subclass. Further, since super( ) must be the first statement executed in a subclass’ constructor, this order is the same whether or not super( ) is used. If super( ) is not used, then the default or parameterless constructor of each superclass will be executed.

Method Overriding

2010-07-05T12:58:00.006-07:00

In a class hierarchy, when a method in a subclass has the same name and type signature as a method in its superclass, then the method in the subclass is said to override the method in the superclass. When an overridden method is called from within a subclass, it will always refer to the version of that method defined by the subclass. The version of the method defined by the superclass will be hidden. If you wish to access the superclass version of an overridden function, you can do so by using super.

Method overriding occurs only when the names and the type signatures of the two methods are identical. If they are not, then the two methods are simply overloaded.

Dynamic Method Dispatch

2010-07-05T12:58:00.004-07:00

Dynamic method dispatch is the mechanism by which a call to an overridden method is resolved at run time, rather than compile time. Dynamic method dispatch is important because this is how Java implements run-time polymorphism.

Abstract Classes

2010-07-05T12:58:00.000-07:00

Abstract classes are classes which contain one or more abstract methods. To ensure that a subclass overrides all necessary methods the abstract type modifier is used. The following restrictions apply:
• An abstract class cannot be instantiated i.e. no objects can be created, because an abstract class is not fully defined.
• Constructors and static methods cannot be declared as abstract.
• Any subclass of an abstract class must either implement all of the abstract methods in the superclass, or be itself declared abstract.