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: the default modifier is local to the block of code

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

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.

Number getNumber(){ return Integer.valueOf(1); }

Number getNumber(){ return null; }

long getNumber() { 
  int myInt =2;
  return myInt;
}

long getNumber(){ return Long.valueOf(1); }

long getNumber(){ return Integer.valueOf(1); }

public void returnNothing() { return; }

public class Test {

    public static void main(String[] args) {

        int i = 1;
        Long l = 2L;
        char c = 3;

        T1 t1 = new T1(i);        // int test, will use int constructor
        T1 t2 = new T1(l);        // Long test, will use long constructor
        T1 t3 = new T1(c);        // char test, will use int constructor

        byte b = 4;
        long l2 = 5;
        short s = 6;
        float f = 5.6f;
        double d = 5.6;
        Character c2 = 7;

        T1 t4 = new T1(b);        // byte test, will use int constructor
        T1 t5 = new T1(l2);       // long test, will use long constructor
        T1 t6 = new T1(s);        // short test, will use int constructor
        // T1 t7 = new T1(f);     // No Constructor for float, compile error
        T1 t8 = new T1(d);        // double test, will use Double constructor
        T1 t9 = new T1(c2);       // Character test, will use char constructor
    }
}

class T1 {

    T1(int a){ System.out.println("int constructor"); }

    T1(long a){ System.out.println("long constructor"); }

    T1(char a){ System.out.println("char constructor"); }

    T1(Character a){ System.out.println("char constructor"); }

    T1(Double d) {  System.out.println("Double constructor"); }
}

public class Animal {                            // This will be the super class
   public void eat() {
      System.out.println("Generic Animal food");

   public void printAnimal {
      System.out.println("This is the Animal class");
   }
}

class Horse extends Animal {                     // Horse is a sub-class of Animal
   public void eat() {                           // override the Animal eat method
      System.out.println("I like oats, hay");

   public void printAnimal {
      super.printAnimal();                // Invoke the Animal super class code, then come back here
   }
}

class Lion extends Animal {                      // Lion is a sub-class of Animal
   public void eat() {                           // override the Animal eat method
      System.out.println("I like to eat Horses ");
}

Note: to call methods from the superclass use the super keyword.