Anatomy of a class

CIS-260 Home http://www.c-jump.com/bcc/

Anatomy of a class

Anatomy of a class
No concepts exist in isolation
Class Name
Java comments
Attributes
Static Attributes
Constructors revisited
Constructor Examples
Accessor Operations
Private Operations

1. Anatomy of a class

Name
Comments
Attributes
Constructors
Accessors
public and private operations.

2. No concepts exist in isolation

When objects are instantiated, they interact with other objects.
Objects may contain other objects, or they can inherit from other objects:

3. Class Name

A class name should reflect that a class represents a concept from the application domain.
A UML diagram shows classes drawn as rectangles
Relationships among classes are drawn as paths connecting class rectangles.
A ticket system for a theater has concepts such as
- tickets, reservations, subscription plans, seat assignment algorithms, and interactive web pages for ordering.

Class diagram of a ticket-selling application:

4. Java comments

Multiline comment /**/
Single are comment //

5. Attributes

Attributes represent the state of an object.
Attributes store object data.
Attributes can be static, public, and private.
- Anything public becomes part of the interface.
- Anything private is part of object implementation.
Conservative design means keeping private as much as possible.

6. Static Attributes

Static attributes are shared by all objects instantiated for a given class.

This means that only a single copy of static attribute is allocated in memory.


    public class ClassicSingleton {

        private static ClassicSingleton instance = null;

        protected ClassicSingleton() {
            // Exists only to defeat instantiation.
        }

        public static ClassicSingleton getInstance() {
            if( instance == null ) {
                instance = new ClassicSingleton();
            }
            return instance;
        }
    }

7. Constructors revisited

Class definitions can have multiple constructors.
Constructors are operations that aide object creation.
Constructors are primarily responsible for initialization of object attributes.
Default constructor has no parameters.
Other constructors have parameter lists (see next slide).
Default constructors are provided for free unless explicitly defined.

8. Constructor Examples


public class Point {
    int x;
    int y;
    public Point() {
        x = 0;
        y = 0;
    }
    public Point ( int x, int y ) {
        this.x = x;
        this.y = y;
    }
    public String toString() {
        return x + " " + y;
    }
    public static void main( String[] args )  {
        Point pt = new Point();
        Point pt2 = new Point( 10, 20 );
        System.out.println( pt.toString() );
        System.out.println( pt2.toString() );
    }
}

To run this example, type command:
```
    Point.main( null );
```
or simply
```
    java Point
```

9. Accessor Operations

Normally, all object attributes are declared private.
This prevents objects from accessing other object attributes directly.
Such arrangement is dictated by the rules of encapsulation.
Accessor operations, known as setters and getters allow sharing appropriate information between objects.

For example,


public class Point {
    int x;
    int y;
    public void setX( int x ) {
        this.x = x;
    }
    public  int getX() {
        return x;
    }
    public void setY( int y ) {
        this.y = y;
    }
    public  int getY() {
        return y;
    }
}

Note: Encapsulation preserves data integrity.

10. Private Operations

Similar to private data attributes, operations can also be private.
Private operations are part of object implementation.
Implementation is hidden from other classes.
Private operations can be used only inside the scope of the class.