import java.io.*;

import java.io.File;

java.io.File file = new java.io.File("/");

import java.io.File;
//[⋅⋅⋅]
File file = new File("/");

package org.example.game;

package org.example.game;
import org.example.game.*;

package superclass;
public class Superclass
{
    protected Superclass()
    {
        //[⋅⋅⋅]
    }
}

-------------------------------------

package subclass;
import superclass.*;
public class Subclass extends Superclass
{
    public Subclass()
    {
        super(); //Allowed "use" of superclass's protected constructor.
        Superclass superclass = new Superclass(); //Non-allowed use of the superclass's protected constructor.
    }
}

/**
 * Sets the the value of the ECHO flag; iff on the input to the terminal will be echoed back while typing.
 * This can be used to hide what the user is type, for example when a password is requested.
 *
 * @param   on           Whether the flag should be on.
 * @throws  IOException  Should not be thrown in GNU.
 */
public static void setEchoFlag(final boolean on) throws IOException
{
    (new ProcessBuilder("/bin/sh", "-c", "stty " + (on ? "echo" : "-echo") + " < " + TerminalMagick.tty + " > /dev/null")).start();
}

/**
 * Sets the the value of the ICANON flag; iff on the input will wait to be sent onto a line feed is given.
 * This can be used to read single characters instead of lines.
 *
 * @param   on           Whether the flag should be on.
 * @throws  IOException  Should not be thrown in GNU.
 */
public static void setBufferFlag(final boolean on) throws IOException
{
    (new ProcessBuilder("/bin/sh", "-c", "stty " + (on ? "icanon" : "-icanon") + " < " + TerminalMagick.tty + " > /dev/null")).start();
}

/**
 * Multiton constructor
 * 
 * @param   key  The key
 */
private ${enclosing_type}(final ${key_type} key)
{
    super();
}

/**
 * Gets (and may set) instance by key
 * 
 * @param   key  The key
 * @return       The instance
 */
public static ${enclosing_type} getInstance(final ${key_type} key)
{
    synchronized (instances)
    {
        ${enclosing_type} instance;

        if ((instance = instances.get(key)) == null)
        {
            instance = new ${enclosing_type}(key);
            instances.put(key, instance);
        }

        return instance;
    }
}

/**
 * The instances
 */
private static final ${hash_table_type}<${key_type}, ${enclosing_type}> instances = new ${hash_table_type}<${key_type}, ${enclosing_type}>();

public final class YourClass //final is not required, it changes nothing because the only constructor is private
{
    /**
     * Singleton constructor
     */
    private YourClass() //There is a recommendation to use protected when working with JUnit (so you can use the constructor)
    {
        //Implement construction here
    }

    /**
     * Gets the only instance of this class
     *
     * @return  The only instance of this class
     */
    public static YourClass getInstance() //Use this method to get the instance of the class, instead of the constructor
    {
        if (onlyInstance == null)
            synchronized (YourClass.class)
            {
                if (onlyInstance == null)
                    onlyInstance = new YourClass();
            }

        return onlyInstance;
    }

    /**
     * The only instance
     */
    private static volatile YourClass onlyInstance = null;
}

import java.io.*;

public class TerminalMagick
{
    /**
     * The stdout tty. This code assumes you have same stdin tty as stdout tty.
     */
    protected static String tty;

    /**
     * Class initialiser
     */
    static
    {
        //It is imported to use canonical path and not absolute path, otherwise it will change inode
        TerminalMagick.tty = (new File("/dev/stdout")).getCanonicalPath();
    }
}

import java.io.*;

public class TerminalMagick
{
    // [⋅⋅⋅], the old stuff

    /**
     * Sets the the value of the ISIG flag; iff on signals may be cued from the TTY when the user presses special key combinations,
     * like ^C and ^\ (also know as ^4). The to 'false' to allow ^C (otherwise abort signal) and ^\(otherwise process dump (should actually be quit) signal).
     *
     * @param   on           Whether the flag should be on.
     * @throws  IOException  Should not be thrown in GNU.
     */
    public static void setInterruptionSignalFlag(final boolean on) throws IOException
    {
        (new ProcessBuilder("/bin/sh", "-c", "stty " + (on ? "isig" : "-isig") + " < " + TerminalMagick.tty + " > /dev/null")).start();
    }
}

public static void main(final String... args)
{
    try
    {
        TerminalMagick.setInterruptionSignalFlag(false); //Lets you use ^C and ^\.

        //Do your normal stuff here…
    }
    finally //Runs when the try (and its catches) is complete, even if the method have returned
    {
        TerminalMagick.setInterruptionSignalFlag(true); //Resets ^C and ^\ to send signals (abort and quit).
    }
}

public class MyClass
{
    private static void print(final String prefix, final int... lines)
    {
        for (final int line : lines)
            System.out.println(prefix + String.valueOf(line));
    }

    private static void print(final String prefix, final String... lines) // (*)
    {
        for (final String line : lines)
            System.out.println(prefix + line);
    }



    public static void main(final String... args)
    {
        print(":", 1, 2, 3, 4, 5);
        print(":", new int[] {1, 2, 3, 4, 5});
        //print(":"); //Would compile if we remove (*)
        print(":", "a", "b", "c");
    }

}

public class MyClass
{
    private static void print(final Strings... lines, final SomeOtherClass... moreLines)
    {
        for (final String line : lines)
            System.out.println(line);

        for (final SomeOtherClass line : moreLines)
            System.out.println(line.toString());
    }
}

public class MyClass
{
    public static class Subclass extends MyClass
    {
        {
            System.out.println("Subclass Initialiser 1");
        }
        public Subclass()
        {
            System.out.println("Subclass Constructor");
        }
        {
            System.out.println("Subclass Initialiser 2");
        }
    }

    {
        System.out.println("Initialiser 1");
    }
    public MyClass()
    {
        System.out.println("Constructor");
    }
    {
        System.out.println("Initialiser 2");
    }



    public static void main(final String... args)
    {
        new Subclass();
        System.out.println("----");
        new Subclass();
    }

}

public class YourClass
{
    public static final int YOUR_CONSTANT = constantValue();

    private static int constantValue()
    {
        int value1 = 0, value2 = 1;
        int value = 0;
        for (int i = 0; i < 10; i++)
        {
            value = value1 + value2;
            value2 = value1;
            value1 = value;
        }
        return value:
    }
}

public class YourClass
{
    private static final Void IM_A_DUMMY = printHello();

    private static Void printHello()
    {
        System.out.println("Hello");
        return null;
    }
}

public class MyClass
{
    private static final Void DUMMY = dummysCode();
    public static final int VALUE;

    /**
     * Class initialiser
     */
    static
    {
        System.out.println("Hello");
        VALUE = 10;
    }

    private static final Void ANOTHER_DUMMY = anotherDummysCode();

    static
    {
        System.out.println("Initialised!");
    }



    private static Void dummysCode()
    {
        System.out.println("Dummy's code");
        return null;
    }

    private static Void anotherDummysCode()
    {
        System.out.println("Another dummy's code");
        return null;
    }



    public static void main(final String... arg)
    {
        System.out.println(VALUE);
    }

}

public class YetAnotherClass
{
    //public static final int YET_ANOTHER_CONSTANT = YET_ANOTHER_CONSTANT; //Compile-time error: illegal forward reference
    public static final int ANOTHER_CONSTANT = YetAnotherClass.ANOTHER_CONSTANT; //OK!

    //public int yetAnotherVariable = yetAnotherVariable; //Compile-time error: illegal forward reference
    public int anotherVariable = this.anotherVariable + 1; //OK!


    public static void main(final String... args)
    {
        System.out.println(ANOTHER_CONSTANT);
        System.out.println(new YetAnotherClass().anotherVariable);
    }
}