Classes and Objects in Java

Java is object-oriented
Every definition is a class
Classes may hide representation-related components
Supports single inheritance
Supports polymorphism (via dynamic binding)
Also supports abstract classes and interfaces

Classes

A class defines a template for a set of objects
Classes include variables and methods
Variables store the state of an object

Methods define the behavior of an object or give access to it's state

class Circle {
  static final double PI = 3.14159;
  double x, y; // the center of the circle
  double radius;
  Circle(double nx, double ny, double nr) {x=nx; y=ny; r=nr;}
  Circle(double nr) {this(0.0; 0.0, nr);}
  double area() { return PI * radius * radius; }
  double circumference() { return 2 * PI * radius; }
  static double nTimesPI(int n) {return n * PI;}
}

Class Variables

Each instance of a class has its own variable data
Typically initialized by the constructor
final variables are constant (read only) - initialized in declaration

A static variable belong to the class - shared by all class instances

class Circle {
  static final double PI = 3.14159;
  double x, y; 
  double radius;
  ...
}

Class Methods

Each class has its own operations called `methods'
They may access all other class members
Each method has an implicit first parameter called `this'
Direct access to class members imply operation on this

static methods are like regular functions and have no `this' parameter

class Circle {

...
double area() { return PI * radius * radius; }
double circumference() { return nTimesPI(2) * radius; }
static double nTimesPI(int n) {return n * PI;}

}

Constructors

A constructor is called automatically whenever an object is created
It should initialize an object
Every object has a default (no arg) constructor

You may overload the constructor

class Circle {

...
Circle(double nx, double ny, double nr) {x=nx; y=ny; r=nr;}
Circle(double nr) {this(0.0; 0.0, nr);}
...

}

Object Creation and Member Access

All objects are created via new

After creation, each object is constructed

Circle c2 = new Circle(1.0, 2.0, 3.0);  // calls first constructor
Circle c1 = new Circle(1.9); // calls second constructor

Access to members is via dot operator

double aSum = c1.area() + c2.area();
double rSum = c1.radius + c2.radius;

prefix for static members may be an object or the class name
```
double fourPI = c1.nTimesPI(2) + Circle.nTimesPI(2);
```

Object Destruction

Java has garbage collection
You never need to free any storage
Collector is a low priority thread
When an object has no more references, it is returned to storage pool
No memory leaks or dangling pointers
Methods may return locally allocated objects safely

Finalization

Non-Java resources (files, sockets, windows) aren't handled by garbage collector
Classes may include a finalize method to release such resources
Finalizer is called before garbage collector frees storage
Exceptions raised by a finalizer are ignored

finalizers are rare

class FileWrapper
{

...
void finalize() throws IOException
{

  if (fd != null) close();


}

}

Subclasses and Inheritance

Class inheritance allows reuse and polymorphism
Parent class is called superclass, child is called subclass
Inheritance shows that child is a `kind of' its parent
Child inherits all members from parent
May add new ones or override parent methods

Child may access parent's public and protected members, not private members

class GraphicsCircle
  extends Circle
{
  GraphicsCircle(double nx, double ny, double nr) { super(nx,ny,nr); }
  boolean isOnScreen = false;
  void draw(DrawWindow w)
  {
    w.drawCircle(x, y, radius, outline, noFill);
  }
}

final classes may not be subclassed

Overriding Methods

Happens when a subclass redefined a superclass' member function
New method may call overridden method via the `super' reference

final methods may not be overridden - implied for static and private methods

class FilledCircle
  extends GraphicsCircle
{
  void draw(DrawWindow w)
  {
    if (!do_fill)
      super.draw(w); // calls GraphicsCircle.draw() on this
    else
      w.drawCircle(x,y,radius, outline, fill);
  }
}

Dynamic Binding of Methods

Java calls method appropriate to run-time type of an object (dynamic binding)

Circle c = new FilledCircle();
c.draw(); // calls FilledCircle.draw()
c = new GraphicsCircle(...);
c.draw() // calls GraphicsCircle.draw()

Implicit (Automatic) Casting

char is converted to int (top 16 bits are zeroed)
byte and short are always promoted to int before applying operations
results of arithmetic are int unless one or both operands are long
mixed integer arguments are converted to largest (eg, short + int converts short to int first)
mixed floating arguments are converted to largest (eg, int + float converts int to float first)
numerics may be assigned to any more precise numeric
```
int i = 1; float f = i;
```
Beware potential loss of magnitude when assigning long to float
Casting an Object to String is automatic via toString method
Subclass objects are automatically cast to superclass when assigned or passed to method
```
FilledCircle fc = new FilledCircle(); Circle C = fc;  // always ok
```

Explicit Casting

Numerics must be cast to any less precise numeric
```
float f = 1.1; int i = (int)f;
```

Casts must be used to convert from superclass to subclass

Circle C = new FilledCircle();
FilledCircle f = (FilledCircle)C; // throws ClassCastException if C is not FilledCircle
if (C instanceof FilledCircle) // checking actual type is wise
  f = (FilledCircle)C;

Casts should be rarely used

Data Hiding and Encapsulation

Every class member has a visibility
Class methods can access any members defined within that class
The following modifiers have the following meanings:
- public - public to the world, for main(), applets, and libraries
- (default is package) - public within a package (i.e., a program)
- protected - public within package and to derived classes
- private protected - public to derived classes
- private - public to no one
Visibility must be the same when overriding

Abstract Classes

Some classes define abstractions for a set of specific classes
For example, class Widget in a GUI
A class is abstract if it has one or more abstract methods, or if it is declared abstract
You can't create instances of abstract classes
You can write routines that operate on them and all subclasses

Derived classes become concrete when definitions are provided for all the abstract methods

public abstract class Shape
{
  public abstract double area();
  public abstract double circumference(); 
} 
public class Circle
  extends Shape
{

...
public double area() { return ...;}
public double circumference() { return ...; }

}

Polymorphism

Inheritance and dynamic binding allow you to write polymorphic routines

public class Shape
{
  public abstract double area();
  public abstract double circumference(); 
  public static double sumArea(Shape[] a)
  {
    double total = 0.0;
    for (int i=0; i<a.length; i++)
      total += a[i].area();
    return total;
  }
}

Polymorphic operation sumArea works on anything derived from Shape

Shape[] a = {new Circle(...), new Square(...), new GraphicsCircle(...)};
double totalArea = Shape.sumArea(a);

Interfaces

Interfaces behave just like abstract classes with no data
Allows for one of the most common uses of multiple inheritance (and polymorphism)
Similar to defining a group of callback routines

A class can only extend one class, but it can (also) implement any number of interfaces

public interface Runable
{
  public void init();
  public void start();
  public void stop();
  public void destroy();
}

A class then implements methods required by it's interfaces

public Class RunningCircle
  extends Circle
  implements Runable
{
  public void init() { ... }
  ...
}

Instances may be passed to any routine expecting that interface

Extending Interfaces

interfaces may extend other interfaces by adding more abstract methods

public interface RunableCar
  extends Runable
{	// in addition to the abstract methods of Runable, add the following
  public void turnLeft();
  public void turnRight();
  public void break();
  public void accelerate();
}

Arrays

Are constructed with new

char s[] = new char[100];
char[] s1 = new char[50]; // brackets may go either place in declaration

length attribute is used to give the number of elements
```
for (int i=0; i<s.length; i++)

... s[i] ...
```

Indices range from 0 to length-1 and are always checked

int i = -1, j = 100;
char c = s[i] + s[j] ; // either will throw IndexOutOfBoundsException

Allocating an array of objects does not allocate element objects
```
Circle[] ca = new Circle[100]; // elements are all null
```

Array literals via curly braces

Circle[] ca1 = {new Circle(1.0), new Circle(2.0), new Circle(3.0)};
char[] s2 = {'a', 'b', 'c'};

class Object

All classes are implicitly derived from class Object

class Object {
  Object()
  Object clone () // component copy
  boolean equals(Object o) // component equality
  String toString() // gives String image of object
  void finalize() // done when object is freed
  Class getClass() // gives run-time class of an object
  int hashCode() // allows use in a Hashtable
  void  wait() wait(long) wait(long, int) // thread wait-for-notify
  void notify() notifyAll() // unblocks waiting threads
}

Strings

String is a predefined class - not an array of characters
Literals may be defined with double-quote notation
```
String s = "Hello there";
```

Equivalent to

char[] a = {'H','e','l','l','o',' ','t','h','e','r','e'};
String s = new String(a);

Strings are read-only

They may be concatenated with + or +=

String s2 = s + " everyone";
s2 += " here";
s2 = s2.concat(" and now");

Public methods and constructors

class String {
  String () // same as ""
  String(String)
  String(char[])
  String(char[], int start, int end)
  String(byte[], int, int, int)
  String(byte[], int)
  String(StringBuffer)
  int length() // number of chars in String
  char charAt (int index)
  boolean equals(Object o)
  boolean equalsIgnoreCase(String s)
  boolean compareTo(String s) // like C's strcmp
  String concat(String s) // called by + operator
  int indexOf(int ch)
  int indexOf(int ch, int start)
  int indexOf(String s)
  int indexOf(String s, int start)
  int lastIndexOf(int ch)
  int lastIndexOf(int ch, int start)
  int lastIndexOf(String s)
  int lastIndexOf(String s, int start)
  bolean regionMatches(int start, String s, int sstart, int len)
  boolean regionMatches(boolean ignoreCase, int start, String s, int sstart, int len)
  String replace(char ch, char replacement)
  boolean startsWith(String s, int skip)
  boolean startsWith(String s)
  boolean endsWith(String s)
  String substring(int len)
  String substring(int start, int len)
  String toLowerCase()
  String toString()
  String toUpperCase()
  String trim() // trims leading and trailing whitespace
  String valueOf(Object o)
  String valueOf(char[] s)
  String valueOf(char[] s, int start, int len)
  String valueOf(boolean b)
  String valueOf(char c)
  String valueOf(int i)
  String valueOf(long l)
  String valueOf(float f)
  String valueOf(double d)
  char[] toCharArray()
  void getBytes(int start, int end, byte[] b, int bStart)
  void getChars(int start, int end, char[] b, int bStart)
  String copyValueOf(char[] b, int start, int end)
  String copyValueOf(char[] b)
  int hashCode()
  int intern() // allows faster equals comparison with ==
}

StringBuffers

Like String, but also writable

StringBuffer b = new StringBuffer("Hello");
b.append(" there");
b.setCharAt(0, 'M');
b.setLength(b.length()-3); // chops off last three characters
String s = b.toString(); // converts b to a String

Initial length can be specified at construction

StringBuffer b1(100); // initial value is ""
b1.capacity() // returns 100
StringBuffers are reallocated if more space is necessary

Cloning (copying) Objects

All objects (including array) have clone() method
Classes must implement interface Cloneable (note misspelling)
Default clone method makes shallow copy
Classes can override default to make deep copy
Class can raise CloneNotSupportedException to forbid clone

Analogous to C++ copy constructor, but not called automatically

IntegerStack first = new IntegerStack();
first.push(10); first.push(20);
IntegerStack second = first.clone();
second.push(30); first.push(40);

Note default clone will not work here

Define clone for IntegerStack

Object clone()
{
  IntegerStack copy = (IntegerStack)super.clone();
  copy.buffer = (int[])buffer.clone();
  return copy;
}

Inner Classes

Java allows definition of classes within other classes
each instance of an inner class has a reference to it's creator
thus it may access data members of it's parent (creator)