public class myclass{ /* any code that you want */ }

Note: you can have only one public class in a source file

public void coolMethod { /* any code that you want */ }

public abstract int coolMethod();

Note: No curly braces at the end, code for this method must be in a sub-class

public synchronized Record getUserInfo() { /* any code that you want */ }

Note: synchronized can never be used with abstract but you can use the other access modifiers

int bonus = 1.1;

Note: a local variable must be initialized

final int bonus = 1.1;

Note: the final non-access modifier is the only option for a local variable

public class VariableExample {
   private static int classCounter = 0;  // Will get incremented everytime a new class is created
   private int instanceCounter = 0;      // will get incremented when the method increment is called

   public void increment() {
      int localCounter = 0;
      classCounter++;
      instanceCounter++;
      localCounter++;

      System.out.println(
         "classCounter:\t\t" + classCounter + "\n" +
         "instanceCounter:\t\t" + instanceCounter + "\n" +
         "localCounter:\t\t" + localCounter + "\n"
      );
   }

   public static void main(String args[]) {
      VariableExample var1 = new VariableExample();
      VariableExample var2 = new VariableExample();
      VariableExample var3 = new VariableExample();

      var1.increment();
      var2.increment();
      var3.increment();
      var2.increment();
   }
}

# This Java program will increase the static variable classCounter everytime a new class is created, the instanceCounter will only get affect everytime we call the increment method of that instance, the localCounter gets reset everytime we call the increment method

public class myTestClass {
   private static int count;                // must come before the static block to allow access

   public static void main(String[] args) {
      // nothing here
   }

   // static initializer block, this will execute even though it is not called
   static {
      System.out.println(" This is a static initializer block");
      count++;                                      // will access the above static instance variable
      System.out.println("Count: " + count);
   }

   static {
      System.out.println("You can have more than one static block");   // this will execute last
   }
}

Note: static objects are initialized in order of appearance

class test1 extends test2{
   int count = 10;                // instance variable

   void testMethod() {            // body of the testMethod to satisify the abstraction
      int count = 5;              // local variable

      System.out.println("local testMethod variable count = " + count);                 // local variable
      System.out.println("test1 instance variable count = " + this.count);              // instance variable
      System.out.println("test2 instance variable count = " + super.count);             // super class variable
      //System.out.println("test3 instance variable count = " + super.super.count);     // illegal super super class variable, use below
      System.out.println("test3 instance variable count = " + super.getSuperCount() );  // get super super count variable
   }
}

abstract class test2 extend test3{            // the abstract class
   int count = 15;                            // super class variable

   abstract void testMethod();                // the abstract method, must at some point provide the body

   void testMethod2(){                        // plain old method, you can mix and match abstract and non-abstract
      System.out.println("testMethod2");
   }

   int getSuperCount() {
      return super.count;                     // return super class test3 count's variable
   }
}

class test3 {
   int count = 20;                            // super super class - getting a bit silly but explains it's possible
}

Note: there is lots going on in this program buts its a good refresher and not a difficult program to work out. By the way there is no such thing as super.super you must get the super class to access the so called super.super class.

package uk.co.datadisk;   // this directory structure will contain your classes.

Note:the directory structure will be uk/co/datadisk and will contain the compiled classes

package uk.co.datadisk;
package com.javaguru;     // Only one package allowed, compiler error

Note: only one package declaration per source code file

import java.util.*;                // Using wildcard, import all classes
import uk.co.datadisk.fooClass;    // a specific class

Note: import statements must be below package declaration and above the class declaration, you can have as many as you want. Import statements have no performance hits and they do not increase the file size.

public class fooClass { /* any code that you want */ }

Note: you can only have one public class declaration, the order of the public class makes no difference, the filename should match the public class name. It is possible to have a file with no public classes.

public static void main(String args[]) { ... }

Note: Main must be public and static, must have a void return and have a single String array argument (the name of the String argument does not have to be args)

public interface Bounceable {
   public abstract void bounce();
   void setBounceFactor();
}

Note: you do not need to specify the public abstract modifiers (now redundant), so both above methods are acceptable, all methods are public and abstract no matter what you see.

public interface Bounceable {
   public final static int LOW_BOUNCE = 1;
   int HIGH_BOUNCE = 10;                      # HIGH_BOUNCE will be implicity be defined as public final static
}

Note: by putting constants in an interface you are guaranteeing that any class implementing the interface will have access to the same constant. They are also used to associate values with easy names to remember. as with the same with methods you do not need to specify the public final static modifiers (now redundant), so both above declarations are acceptable, all constants are public final static no matter what you see.

public class rubberBall implements Bounceable {
   public void bounce() { ... }               # must supply the code for the implemented interfaces method
}

Note: you are binded by a contract to supply the code for any of the interfaces methods, otherwise the compiler will complain. The signature of the method must be same as in the interface.

Also a abstract class can implement a interface but at somepoint the interface methods code must be implemented to honour the binding contract.

public class rubberBall implements Bounceable, Serializable, Runnable { ... }

class test implements inter1 {                        // enter into the interfaces contract, abstraction rules now apply

   public void methodA() {                            // method body for abstract methodA
      System.out.println("interface inter1 - methodA");
      count = 50;                                     // illegal - count has been marked public, static and final by the interface
      System.out.println("count" + count);
   }
}

interface inter1 {                                    // 100% abstract class - all methods are abstract
   int count = 20;                                    // implicity marked public, static and final - even if not stated

   public void methodA();                             // implicity marked public and abstract - even if not stated

   public void methodB() {                            // illegal - must be abstract method - no curly braces
      System.out.println("class test - methodB");
   }
}

Note: this program will not compile as there are a number of errors.