class Classname {
 ....
}

class Student {

   String lastname;
   String firstname;


   void printName() {
      System.out.println("Student's Name: " + firstname + " " + lastname);
   }

}

Student s = new Student();

• If a class is not defined as a subclass of another it is automatically a subclass of the Java class called Object. 
• Java only allows for a class to have one superclass (single inheritance). 
• A subclass inherits all of its parent's (as well as its superclasses') methods and variables. The subclass may overwrite (create its own version) these methods. To access such an overwritten parent method you can type: super.method_name(...); 

Example:

class GradStudent extends Student {
....
}

• Variables 
• See here for details. 
• Constructors (optional) 
• Special Kind of method called when creating an instance of a class that may perform a any variety of operations including initializing variables, creating other objects, etc. 
• Always have the same name as the class. 
• Can have multiple constructors that take different inputs and can perform different operations. 
• If you do not define a constructor for a class, the default constructor is invoked that does nothing. 
• Has NO return type. 
• If you write a class with a constructor with parameters and you intend to possibly use it as a Paretn class you need to make sure you also write a constructor with NO paramters. This is needed because: If the child class is defined with no concstructors, it will automatically call super() which is the Parent's constructor with No arguments. 
• Finalize Method (optional) 
• Called just before the object is garbage-collected and its memory reclaimed. 
• Must be defined as follows: 

protected void finalize() throws Throwable { ...}

• The default finalize() does nothing. 
• Methods 
• Details 

class Car {
    
  /*VARIABLES*/
  String model;
  String manufacturer;
  float Engine_Size;

  /*CONSTRUCTORS*/
  Car(String m, String man) {
      model = m;
      manufacturer = man;
  }
  Car(String m, String man, float e) {
      model = m;
      manufacturer = man;
      Engine_Size = e;
  } 


  /*METHODS*/
  void PrintInfo() {
      System.out.println("Model:" + model);
      System.out.println("Make: " + make);
      System.out.println("EngineSize: " + Engine_Size);
  }

}
       
  

• See your book for more details. 
• It is the way that a set of method names, without definitions. By this I mean the method's interface is presented but not implemented. This will allow similar behavior to be duplicated acrros different parts of the class hierarchy which is achievable in C++ through multiple inheritance which Java does not allow. 
• Can not declare an object of this class....must create a new class that extends this and implements all of the unimplemented methods. 
• Can not contain the main() method. 

• See book for more details. 
• Unlike an Interface Class, some methods may be implemented and the others only the interface is declared. To declare an interface method you must preceed it with the special keyword abstract as shown in the following example:

abstract void  PrintInfo();

• Can not declare objects of this class...must create a new class that extends this and implements all of the unimplemented methods. 
• Declare class and each method inside that is not implemented as abstract by preceeding it with the term abstract 
• Can not contain the main() method. 

• super Refers to the parent class. Example: super.mmm() calls the method named mmm in the parent class. 
• this Refers to the object itself. Example: this.mmm() calls the method named mmm in the object itself. 

• Finalizing a class means that it can not be used to create subclasses. 
• Declare by preceeding the definition with the word final