A class contains two basic elements - state and behavior. The class must include a constructor to define these elements. A class definition specifies class statements and object constructors. A class can inherit properties from a superclass defined in its constructor. The code sample shows a class declaration that subclasses MySuperClass and implements MyInterface. It defines public and private state variables and a constructor that initializes them. Getter and setter methods allow modifying and accessing the class state through its objects.

1. A class contains two basic elements, state and behavior. With this being said a class
must contain some sort of constructor for these two elements. On top of this there are
class definition statements and object constructors for the objects that a class contains.
Also a class can become a subclass of another class, and this is done in the constructor
for the class itself. I will include a quick snippet of code that shows the different
members of a class definition then explain them.
//subclass declaration of MyClass from MySuperClass using the MyInterface interface
public class MyClass extends MySuperClass implements MyInterface
{ //body of class includes fields (states), methods (behavior),
and object declaration
public int myClassState1, myClassState2; //field declarations available to all
classes
private int myClassState3, myClassState4; //field declarations available to this
class only
public MyClass (int state1, int state2, int state3, int state4) { //object constructor
myClassState1 = state1;
myClassState2 = state2;
myClassState3 = state3;
myClassState4 = state4;
}
public void setState1 (int newValue) { //method used to update
myClassState1
myClassState1 = newValue;
}
public int getState1 () { //method used to return the value of myClassState1
return myClassState1;
}
}
In the beginning of this code snippet there is a class declaration that declares the class
as a sub class of MySuperClass and uses the MyInterface interface. This is the general
form of a class declaration, remembering that because the MyClass is a subclass of
MySuperClass, MyClass inherits the elements of MySuperClass.
Next are the variables that define the state of the class. These variables are the
myClassState1...2...3....4. These are the variables that are used to modify the contents
of the objects of that class. Two of these variable state are private meaning that the only

2. objects or classes that can use them are the MyClass.
The next lines declare the object of the class that uses all four of the variables. These
variable now become part of the object of the class and the object is then used to
modify these state variables using the methods of the class.
Next are the two methods, one is the setState1 which sets the state of the
myClassState1 of the objects of the class. The other method is the getState1 which
returns the value of the state of the variable myClassState1 of the object MyClass.
I am not 100% but to use the objects and methods later on in the program you need to
first declare an object of the class similar to this:
MyClass classObjectName = new MyClass(1, 2, 3, 4);
Then to use this object's methods it is done similar to this:
stateHandlerVariable = classObjectName.getState1();