1. state
2. behavior

1. "What possible states can this object be in?"
2. "What possible behavior can this object perform?"

• Software objects are conceptually similar to real-world objects: they too consist of state and related behavior.
• An object stores its state in fields (variables in some programming languages) and exposes its behavior through methods (functions in some programming languages)
• Methods operate on an object's internal state and serve as the primary mechanism for object-to-object communication.
• Hiding internal state and requiring all interaction to be performed through an object's methods is known as data encapsulation — a fundamental principle of object-oriented programming.

• Object-oriented programming allows classes to inherit commonly used state and behavior from other classes.
• In this example, Bicycle now becomes the superclass of MountainBike, RoadBike, and TandemBike.
• In the Java programming language, each class is allowed to have one direct superclass, and each superclass has the potential for an unlimited number of subclasses:
  [Show the pic]
  
  
  

  [hide]

1. constructors for initializing new objects
2. declarations for the fields that provide the state of the class and its objects,
3. methods to implement the behavior of the class and its objects

1. Modifiers such as public, private, and a number of others that you will encounter later.
2. The class name, with the initial letter capitalized by convention.
3. The name of the class's parent (superclass), if any, preceded by the keyword extends. A class can only extend (subclass) one parent.
4. A comma-separated list of interfaces implemented by the class, if any, preceded by the keyword implements. A class can implement more than one interface.
5. The class body, surrounded by braces, {}.

Declare a Class

1. Zero or more modifiers, such as public or private.
2. The field's type.
3. The field's name.

method signature: Two of the components of a method declaration comprise the method signature—the method's name and the parameter types.

add parameter to the method

Set , Get Methods with each attributes

• primitive types
• reference types (sometimes called nonprimitive types)

A class contains constructors that are invoked to create objects from the class blueprint. Constructor declarations look like method declarations—except that they use the name of the class and have no return type

• Precede every field and method declaration with an access modifier. As a rule of thumb, instance variables should be declared private and methods should be declared public. (We will see that it is appropriate to declare certain methods private, if they will be accessed only by other methods of the class.)
• We prefer to list the fields of a class first, so that, as you read the code, you see the names and types of the variables before you see them used in the methods of the class. It is possible to list the class's fields anywhere in the class outside its method declarations, but scattering them tends to lead to hard-to-read code.
• Place a blank line between method declarations to separate the methods and enhance program readability.
• Unless default initialization of your class's instance variables is acceptable, provide a constructor to ensure that your class's instance variables are properly initialized with meaningful values when each new object of your class is created.

Static Methods and Satic Fields

Static Class

Class Constants
e.g. Math.PI

P S V M
public static void main (String args[]){}

Multiple Parameters in a method

Method Call Stack

Argument Promotion

Java API Packages
http://java.sun.com/javase/6/docs/api/

Method Overloading
The compiler distinguishes overloaded methods by their signaturea combination of the method's name and the number, types and order of its parameters

Intro to Enums

Declare Another Class

Access Control

this

Constructor Overloading

Default vs. No-Argument Constructors

Notes on Set and Get Methods
Set and Get Methods vs. public Data

Composition
A class can have references to objects of other classes as members. Such a capability is called composition and is sometimes referred to as a has-a relationship

Enumerations

[Show]

Each enum declaration declares an enum class with the following restrictions:

1. enum types are implicitly final, because they declare constants that should not be modified.
2. enum constants are implicitly static.
3. Any attempt to create an object of an enum type with operator new results in a compilation error.

[hide]

Garbage Collection and Method finalize()

static Class Members

[Show]

• Use a static variable when all objects of a class must use the same copy of the variable.
• Static class variables and methods exist, and can be used, even if no objects of that class have been instantiated
• Invoke every static method by using the class name and a dot (.) to emphasize that the method being called is a static method.
• A compilation error occurs if a static method calls an instance (non-static) method in the same class by using only the method name. Similarly, a compilation error occurs if a static method attempts to access an instance variable in the same class by using only the variable name.
• Referring to this in a static method is a syntax error.

[hide]

static Import

final Instance Variables

Data Abstraction and Encapsulation

about is_a relationaship

SuperClass and SubClass

protected Members

Constructors in a Subclass and super keyword

the Object class
[sun tutorial]

Overriding and Hiding Methods
[sun tutorial]

Hiding Fields
[sun tutorial]

Polymorphism enables us to "program in the general" rather than "program in the specific."

Polymorphism enables programmers to deal in generalities and let the execution-time environment handle the specifics. Programmers can command objects to behave in manners appropriate to those objects, without knowing the types of the objects

Demonstrating Polymorphic Behavior

Abstract Classes
an abstract class has no instance
several concrete subclass can inherit abstract class
concrete class can only has instances

Abstract Methods
signature of abstract method is declared in abstract class
inheriting concrete subclass must override and implement the abstract class

instanceof operator

final Methods and Classes
A method that is declared final in a superclass cannot be overridden in a subclass. Methods that are declared private are implicitly final
A class that is declared final cannot be a superclass (i.e., a class cannot extend a final class). All methods in a final class are implicitly final. Class String is an example of a final class.

Interfaces
There are a number of situations in software engineering when it is important for disparate groups of programmers to agree to a "contract" that spells out how their software interacts. Each group should be able to write their code without any knowledge of how the other group's code is written. Generally speaking, interfaces are such contracts.

Interfaces in Java
In the Java programming language, an interface is a reference type, similar to a class, that can contain only constants, method signatures, and nested types. There are no method bodies. Interfaces cannot be instantiated—they can only be implemented by classes or extended by other interfaces

an example
public interface Implementable {
// constant declarations, if any
// method signatures
returnType methodName(pType param, pType param,..,pType param);
//... }

Interfaces and Multiple Inheritance
The Java programming language does not permit multiple inheritance (inheritance is discussed later in this lesson), but interfaces provide an alternative. In Java, a class can inherit from only one class but it can implement more than one interface. Therefore, objects can have multiple types: the type of their own class and the types of all the interfaces that they implement.

The Interface Body
The interface body contains method declarations for all the methods included in the interface. A method declaration within an interface is followed by a semicolon, but no braces, because an interface does not provide implementations for the methods declared within it. All methods declared in an interface are implicitly public, so the public modifier can be omitted. An interface can contain constant declarations in addition to method declarations. All constant values defined in an interface are implicitly public, static, and final. Once again, these modifiers can be omitted.

Implementing an Interface
public class MyClass implements Implementable {
// method implementations
returnType methodName(pType param, pType param,..,pType param) {
//do something
//return the thing
}
//...
}


Using an Interface as a Type
[sun tutorial]

Rewriting Interfaces
[sun tutorial]

Summary of Interfaces
An interface defines a protocol of communication between two objects.

An interface declaration contains signatures, but no implementations, for a set of methods, and might also contain constant definitions.

A class that implements an interface must implement all the methods declared in the interface.

An interface name can be used anywhere a type can be used.

Summary of Creating and Using Classes and Objects
A class declaration names the class and encloses the class body between braces. The class name can be preceded by modifiers. The class body contains fields, methods, and constructors for the class. A class uses fields to contain state information and uses methods to implement behavior. Constructors that initialize a new instance of a class use the name of the class and look like methods without a return type.

You control access to classes and members in the same way: by using an access modifier such as public in their declaration.

You specify a class variable or a class method by using the static keyword in the member's declaration. A member that is not declared as static is implicitly an instance member. Class variables are shared by all instances of a class and can be accessed through the class name as well as an instance reference. Instances of a class get their own copy of each instance variable, which must be accessed through an instance reference.

You create an object from a class by using the new operator and a constructor. The new operator returns a reference to the object that was created. You can assign the reference to a variable or use it directly.

Instance variables and methods that are accessible to code outside of the class that they are declared in can be referred to by using a qualified name. The qualified name of an instance variable looks like this:

objectReference.variableName
                                

The qualified name of a method looks like this:

objectReference.methodName(argumentList) or 
objectReference.methodName()
                                

The garbage collector automatically cleans up unused objects. An object is unused if the program holds no more references to it. You can explicitly drop a reference by setting the variable holding the reference to null.

Summary of Inheritance
Except for the Object class, a class has exactly one direct superclass. A class inherits fields and methods from all its superclasses, whether direct or indirect. A subclass can override methods that it inherits, or it can hide fields or methods that it inherits. (Note that hiding fields is generally bad programming practice.)

The table in Overriding and Hiding Methods section shows the effect of declaring a method with the same signature as a method in the superclass.

The Object class is the top of the class hierarchy. All classes are descendants from this class and inherit methods from it. Useful methods inherited from Object include toString(), equals(), clone(), and getClass().

You can prevent a class from being subclassed by using the final keyword in the class's declaration. Similarly, you can prevent a method from being overridden by subclasses by declaring it as a final method.

An abstract class can only be subclassed; it cannot be instantiated. An abstract class can contain abstract methods—methods that are declared but not implemented. Subclasses then provide the implementations for the abstract methods.

Summary of Interfaces
An interface defines a protocol of communication between two objects.

An interface declaration contains signatures, but no implementations, for a set of methods, and might also contain constant definitions.

A class that implements an interface must implement all the methods declared in the interface.

An interface name can be used anywhere a type can be used.