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 = 3;
        StringObject so = new StringObject("M");                     // Create a new StringObject passing a string to the constructor
        
        System.out.println(passingVariableObject(i, so));            // will display 5Hello, i is passed by value, so is passed by reference
        System.out.println(" " + i + so.toString());                 // will display 3Hello
    }

    static String passingVariableObject(int i, StringObject so){
        i = 5;                                                       // will not change the underlying variable as its passed by value 
        so.s = "Hello";                                              // will change the objects string to "Hello", as its passed by reference
        return " " + i + so;                                         // so Object will use the toString() to displays it's value
    }
}

class StringObject {
    public String s;

    public StringObject(String s) {
        this.s = s;
    }

    @Override
    public String toString() {
        return  s;
    }
}

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.

// Mostly commonly used main signature
public static void main(String[] args)
				
// Other valid main method signatures
public static void main(String args[])
public static void main(String []args)
public static void main(String ... vargs)                          // a variable-length argument called vargs
public static void main(Boolean ... vargs)                         // you can overload main, overloading the above
public static void main(String...vargs)
public static void main(int i, String...vargs)                     // the vargs must be the last argument
public static void main(final String[] args)

public static void main(String[] hello)                            // you can use whatever name you like, here I use hello
public static void main(String[] vars)

public static void main(String[] args) throws Exception
public static void main(String[] args) throws RunTimeException
public static void main(String[] args) throws Throwable
public static void main(String[] args) throws Error

public class commandLine {
   public static void main (String args[] ) {

     System.out.println("You passed " + args.length + " arguments");

     for(int i = 0; i < args.length; i++)
        System.out.println(args[i]);
   }
}

# Run the command line
c:\> java testCommandLine one two three

Note: arrays args is just like any other array.

public class VarArgs {

    public static void main(String ... vargs) {                 // notice the 3 periods, this means a varible-length argument is being passed
        for(String s : vargs){
            System.out.println(s);
        }
    }
}

Note: you can pass any number of string arguments, icluding passing no arguments

public class Football {
   private String team;                  // this is hidden to the outside world
   private int groundCapacity;           // this is hidden to the outside world

   public void setTeam(String t) { ... }
   public String getTeam() { ... }

   public void setGroundCapacity(int c) { ... }
   public int getGroundCapacity { ... }
}

Note: the only way to get to the instance variables is via the set and get methods

String getname() { return this.name; }

this();

class Test {
  Test() {}	           // no args constructor
  
  Test(String a) {
	this();		   // this() must be on the first line of the constructor
	// do something
  }
}

Object o = this;

Object returnObject() { return this; }

class myClass {

   private int hour, minute, second;     // access using this reference

   // Constructor
   myClass(int hour, int minute, int second) {
      this.hour = hour;                  // reference instance variable hour
      this.minute = minute;              // reference instance variable minute
      this.second = second;              // reference instance variable second
   }

   public void getTime() {
      System.out.println("Hour: " + hour + " Minute: " + minute + " Second: " + second);
   }

   public myClass getObject() {
      return this;                       // return this object
   }
}

String x = "hello have a nice day     ";

x = x.trim().concat(" and a jolly good evening").replace('hello'.'Hello');

Note: the statement is processed from left to right, so the trim method is called first, etc