Quick Java — Code Section Inventory

package examples.shapes;

public class Circle {
    private int radius;

    public Circle(int r) {
        radius = r;
    }

    public double area() {
        return Math.PI * Math.pow(radius, 2);
    }
}

package examples.shapes;

public class CircleApp {

    public static void main(String[] args) {
        int size = 10;
        Circle c = new Circle(size);
        double area = c.area();
        System.out.printf(
            "The area of a circle " +
            "with radius %d is %7.2f",
            size, area);
    }
}

int count;     // declaration
count = 0;     // definition
int count = 0; // declaration + definition

int[] numbers = new int[100];

package teamMaker;
import java.util.HashSet;

public static double Avogadro = 6.0221409e+23;

if (2 + 2 == 4) {
    System.out.println("All is well.");
} else {
    System.out.println("What??");
}

int count = 10;
while (count > 0) {
    System.out.println(count);
    count = count - 1;
}
System.out.println("Blast off!");

for (int i = 10; i > 0; i = i - 1) {
    System.out.println(i);
}
System.out.println("Blast off!");

public static void main(String[] args) {

public class MyClass {
    String hello = "Hello World";

    public static void main(String[] args) {
        new MyClass().doSomething();
    }

    void doSomething() {
        System.out.println(hello);
    }
}

/**
 * Returns the sum of two numbers.
 * @param a The first number.
 * @param b The second number. Cannot be negative.
 * @return the sum of the two numbers.
 * @throws AssertionError if b is negative.
 */
int add(int a, int b) {
    assert b >= 0; // ignored unless -ea is set
    while (b > 0) {
        // Move a 1 from b into a
        b -= 1;
        a += 1;
    }
    return a;
}

int[] scores;

int[] ary = new int[] {3, 1, 4, 1, 6};

int[] ary2 = {3, 1, 4, 1, 6};

double elevation[][]; // declaration

elevation = new double[50][75]; // definition

elevation[49][74] = 123.45;

int[] triangle = new int[10];
for (int i = 0; i < triangle.length; i++) {
    triangle[i] = new int[i + 1];
}

""       // an empty string
"hello"  // a string containing five characters

"He said, \"Don't go.\""

String name = "We're doing Java";

String fullName = firstName + " " + lastName;

String message = "There are " + count + " errors.";

int i = 0;
double d = 2.71828;
i = (int)d;
System.out.println(i);  // prints 2

char ch = (char)('a' + 1); // result is 'b'

final int DAYS_IN_A_WEEK = 7;

final int TWELVE = 12;

/**
 * A leap year is a year divisible by 4 but not
 * by 100, unless it is also divisible by 400.
 */
boolean isLeapYear(int year) {
    if (year % 4 != 0) return false;
    if (year % 100 != 0) return true;
    return year % 400 == 0;
}

int count = 0;

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

public void printLengthOfYear(int year) {
    int days = 365;
    if (isLeapYear(year)) { // "this." omitted
        days = 366;
    }
    System.out.println(year + " has " +
                       days + " days.");
}

public class MyClass {
    int x = 5;
    int y = x + 1; // can use x here
    int z = w + 1; // but this is illegal
    // now we can use x, y, and z
    int w = 3;
    // now we can also use w
    ...
}

public double average(double x, double y) {
    double sum = x + y;
    return sum / 2;
}

{
    x = 1; // illegal!
    int x; // scope of "x" starts here
    x = 2; // legal
} // scope of "x" ends here
x = 3; // illegal!

x = 5;

x = 10;

public double average(double... args) {
     double sum = 0;
     for (double arg : args) {
         sum += arg;
     }
     return sum / args.length;
}

if (x < 0) {
    x = 0;
}

if (x % 2 == 0) {
    x = x / 2;
}
else {
    x = 3 * x + 1
}

if (x % 2 == 0) x = x / 2;
else x = 3 * x + 1;

 if (x < 0) {
     System.out.println("x is negative");
 } else if (x > 0) {
     System.out.println("x is positive");
 } else {
     System.out.println("x is zero");
 }

int countDigits(int number) {
    int count = 0;
    while (number != 0) {
        number = number / 10;
        count += 1;
    }
    return count;
}

Random rand = new Random();
int x;
do {
    x = rand.nextInt(1000);
} while (x % 7 != 0);

do {
    int x = rand.nextInt(1000);
} while (x % 7 != 0); // error

int[] ary = {3, 1, 4, 1, 6};
for (int i = 0; i < ary.length; i += 1) {
    System.out.println(ary[i]);
}

for (int i = 1, j = 100; i < j; i = 2 * i, j -= 1) {
    System.out.println("i = " + i + ", j = " + j);
}

for (String name : names) {
    System.out.println(name);
}

int i = 3;
String s;

switch (i) {
    case 1:
        s = "one";
        break;
    case 2:
        s = "two";
        break;
    default:
        s = "many";
}

int i, j = 0;
int[] ary = {7, 30, 9, 20, 3, 5};
id: for (i = 0; i < ary.length; i += 1) {
    for (j = 0; j < ary.length; j += 1) {
        if (i != j && ary[i] == 10 * ary[j]) {
            break id;
        }
    }
}
System.out.println(ary[i] + ", " + ary[j]);

int[] ary = {10, 20, 5, -1, 30, -12, 50};
double sum = 0;
int count = 0;

for (int i = 0; i < ary.length; i += 1) {
    if (ary[i] <= 0) continue;
    sum += ary[i];
    count += 1;
}
double average = sum / count;

int add(int a, int b) {
    return a + b;
}

void print(int x) {
    System.out.println(x);
    return; // superfluous
}

return;

for (n = 1; n < 1000; n = 2 * n) {}

for (n = 1; n < 1000; n = 2 * n);

assert i >= 0 && i < myArray.length :
    "Bad array index: " + i;

System.out.println("The sum is " + sum);

long nonsense = switch (i) {
    case 1 -> 1000000000000L;
    case 2 -> 17 * x;
    case 3, 4 -> 'a';
    case 5 -> {
        System.out.println("Five!");
        yield 55;
    }
    case 6 -> throw new RuntimeException();
    default -> -1;
};
System.out.println(nonsense);

String s = switch (shape) {
    case Rectangle r && r.width == r.height ->
        "It's a square";
    case Rectangle r ->
        "It's a rectangle";
    case Triangle t ->
        "It's a " + t.width + " by " +
        t.height + " triangle.";
    default -> "It's a shape.";
};
System.out.println(s);

if (b < 0) {
    throw new Exception("b is negative");
}

int myMethod(int a, int b) throws Exception {
    if (b < 0) {
        throw new Exception("b is negative");
    }
    // other stuff
}

try (FileReader fr = new FileReader("/Users/dave/test.txt");
    BufferedReader br = new BufferedReader(fr);) {
    String line = br.readLine();
    System.out.println(line);
}
catch (IOException e) { }

try (br; fr) {
    line = br.readLine();
    System.out.println(line);
}
catch (IOException e) { }

try (FileWriter fw = new FileWriter(
           "/Users/dave/test2.txt")) {
    fw.write("Hello\n");
    fw.write("Goodbye");
} catch (IOException e) {}

String language = "Java";

int numChars = language.length();

StringBuilder builder = new StringBuilder("Java");

builder.append("Script");

language = builder.toString(); // now "JavaScript"

import java.util.Scanner;

Scanner scanner = new Scanner(System.in);

Stack stuff = new Stack();
stuff.push("abracadabra");
stuff.push(new File("abc.txt"));
File foo = (File)stuff.pop();
String spell = (String)stuff.pop();

Stack<String> words = new Stack<String>();
words.push("abracadabra");
words.push(new File("abc.txt")); // not legal

Stack<String> words = new Stack<>();

String word = words.pop();

int find(String target,
         Stack<String> words) {...}

HashMap<String, Integer> phones = new HashMap<>();
phones.put("Joan", 555_1212);

public class Password {
    private String password;

    public Password(String password) {
        this.password = password;
    }

    public boolean matches(String attempt) {
        return attempt.equals(password);
    }

    boolean reset(String oldPassword,
                  String newPassword) {
        if (matches(oldPassword)) {
            password = newPassword;
        }
        return password.equals(newPassword);
    }
}

String name;
double length = 22.75;
private int count = 0;

public class Customer {
    String name;
    String address;
    double amountOwed = 0;

    /** Here is the constructor */
    Customer(String name, String address) {
        this.name = name;
        this.address = address;
    }
}

Customer c = new Customer("Jane", "jane@aol");

int count = 0;

public class Account {
    private int funds = 0;

    void deposit(int amount) {
        if (amount > 0) {
            funds += amount;
        }
    }

    void withdraw(int amount) throws Exception {
        if (funds >= amount) {
            funds -= amount;
        } else {
            throw new Exception("Insufficient funds");
        }
    }

    int getBalance() {
        return funds;
    }

    void transferFrom(Account other, int amount)
            throws Exception {
        other.withdraw(amount);
        deposit(amount);
    }

    public static void main(String[] args)
            throws Exception {
        Account john = new Account();
        Account mary = new Account();
        john.deposit(100);
        mary.transferFrom(john, 75);
        System.out.println(john.getBalance());
    }
}

john.funds = 1_000_000;

public class Customer extends Person {
    private double amountOwed = 0;
    private String otherInfo;

    /** Here is the constructor */
    Customer(String name, String address,
             String otherInfo) {
        super(name, address); // required
        this.otherInfo = otherInfo;
    }
}

public class Customer {
    private String name;
    private String address;
    private double amountOwed = 0;
    private static int howMany = 0;

    Customer(String name, String address) {
        this.name = name;
        this.address = address;
        howMany += 1;
    }
}

static int getHowMany() {
    return howMany;
}
...
int customers;
// All of the following lines are equivalent
customers = Customer.getHowMany();
customers = richGuy.getHowMany();
customers = poorGuy.getHowMany();

static double feetToMiles(double feet) {
    return feet / 5280.0;
}

public class MyClass {
    public static void main(String[] args) {
        new MyClass().run();
    }
    void run() {
        System.out.println("Hello World");
    }
}

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

package myPackage;

public class MyClass {
    public static void main(String[] args) {
        System.out.println(args[0] + args[1]);
    }
}

javac myPackage/MyClass.java

java myPackage/MyClass abc 123

package tools;

/**
 * A simple counter class
 */
public class Counter {
    private int count; // a field

    /** Constructor to make a Counter
     * object with an initial value.
     */
    public Counter(int initial) {
        count = initial;
    }

    /** increments the counter by n. */
    public void bump(int n) {
        count += n;
    }


    /** increments the counter by 1. */
    public void bump() {
        bump(1);
    }

    /** returns the value of the counter. */
    public int getCount() {
        return count;
    }
}

package toolUser;
import tools.*;

public class CounterTest {
    public static void main(String[] args) {
        Counter c1 = new Counter(0);
        Counter c2 = new Counter(100);
        c1.bump(2);
        c1.bump(8);
        c2.bump(100);
        c2.bump();
        System.out.println(c1.getCount() + ", " +
                           c2.getCount());
    }
}

class Person {...}
class Person extends Object {...}

BirthdayCake myCake = new BirthdayCake();
Cake cake = myCake;
Object obj = myCake;

myCake = (BirthdayCake)cake;
myCake = (BirthdayCake)obj;
cake = (Cake)obj;

myCake instanceof BirthdayCake // true
myCake instanceof Cake   // true
myCake instanceof Object // true

if (obj instanceof BirthdayCake) {
    BirthdayCake bc = (BirthdayCake) obj;
    ... use bc here
}

if (obj instanceof BirthdayCake bc) {
    ... use bc here
}

@Override
public String toString() {
    return "My count is " + count;
}

@Override
public boolean equals(Object obj) {
    if (obj == this) return true;
    if (! (obj instanceof Counter)) return false;
    Counter that = (Counter)obj;
    return this.count == that.count;
}

@Override
public int hashCode() {
    return count;
}

@Override
public int hashCode() {
    return name.hashCode();
}

public int getWeight() {
    return weight;
}

public void setWeight(int weight)
            throws IllegalArgumentException {
    if (weight < 0) {
        throw new IllegalArgumentException();
    }
    this.weight = weight;
}

public double getPounds() {
    return kilograms / 2.2;
}

public class OneScanner {

    static Scanner scanner = null;

    private OneScanner() { } // constructor

    static Scanner instanceOf() {
        if (scanner == null) {
            scanner = new Scanner(System.in);
        }
        return scanner;
    }

    void close() {
        scanner.close();
        scanner = null;
    }
}
...
Scanner myScanner = OneScanner.instanceOf();

{
    x = 1; // not legal here
    int x;
    x = 2; // legal here
}
x = 3;     // not legal here

int[] numbers = new int[100];

var numbers = new int[100];

System.out.println("1234567");
String textBlock = """
            First line
        Middle line
            Last line
      """;
System.out.println(textBlock);

1234567
      First line
  Middle line
      Last line

Formatter f = new Formatter();
f.format("The value of %s is %7.4f", "pi", Math.PI);
f.format(" and %s is %6.4f.", "e", Math.E);
System.out.println(f);
f.close();

Set<Item> items = new HashSet<>();

List list = new LinkedList();
list.add("one");
list.add("two");
list.add("three");

Iterator iter = list.iterator();

while (iter.hasNext()) {
    System.out.println(iter.next());
}

larger = a > b ? a : b;

String s = "n is " + (n % 2 == 0 ? "even" : "odd");

x = x++;

import java.util.*;

public class Box<T> {
    private List<T> contents;

    public Box() {
        contents = new ArrayList<T>();
    }

    public void add(T thing) {
        contents.add(thing);
    }

    public T grab() {
        if (contents.size() > 0) {
            return contents.remove(0);
        }
        else return null;
    }
}

Box<String> box = new Box<String>();

List<String> names = new ArrayList<String>();

List<String> names = new Stack<String>();

interface Storage<T> {
    public void add(T thing); // no body
    public T grab(); // no body
}

class Box<T> implements Storage<T> {...}
class Shelf<T> implements Storage<T> {...}
class Cabinet<T> implements Storage<T> {...}

void method rearrange(Storage<T> storage) {
    // code that uses add and grab
}

public void clear() {
    T thing;
    do {
        thing = grab();
    } while (thing != null);
}

abstract class Storage<T> {

    public abstract void add(T thing); // no body

    public abstract T grab(); // no body

    public void clear() {
        T thing;
        do {
            thing = grab();
        } while (thing != null);
    }
}

class Box<T> extends Storage<T> {...}
class Shelf<T> extends Storage<T> {...}
class Cabinet<T> extends Storage<T> {...}

public final class Human {
    final String species = "Homo sapiens";
    final String getSpecies() {
        return species;
    }
    // other methods...
}

public sealed class Thing
    permits Animal, Vegetable, Mineral {…}

final class Animal extends Thing {…}

sealed class Vegetable extends Thing
    permits Carrot {…}
final class Carrot extends Vegetable {…}

non-sealed class Mineral extends Thing {…}
class Quartz extends Mineral {…}

public class OuterClass {
    int outerVariable = 0;

    public OuterClass(int number) { // constructor
        outerVariable = number;
    }

    class MemberClass {
        int innerVariable = 20;

        int getSum(int parameter) {
            return outerVariable + innerVariable +
                   parameter;
        }
    }

    public static void main(String[] args) {
        OuterClass outer = new OuterClass(100);
        MemberClass inner = outer.new MemberClass();
        System.out.println(inner.getSum(3));
        outer.run();
    }

    void run() {
        MemberClass localInner = new MemberClass();
        System.out.println(localInner.getSum(4));
    }
}

public class OuterClass {
    int outerVariable = 100;
    static int staticOuterVariable = 200;

    static class StaticMemberClass {
        int innerVariable = 20;

        int getSum(int parameter) {
            // Cannot access outerVariable here
            return innerVariable +
                   staticOuterVariable + parameter;
        }
    }

    public static void main(String[] args) {
        OuterClass outer = new OuterClass();
        StaticMemberClass inner =
            new StaticMemberClass();
        System.out.println(inner.getSum(3));
        outer.run();
    }

    void run() {
        StaticMemberClass localInner =
            new StaticMemberClass();
        System.out.println(localInner.getSum(5));
    }
}

public class OuterClass {
    int outerVariable = 10000;
    static int staticOuterVariable = 2000;

    public static void main(String[] args) {
        OuterClass outer = new OuterClass();
        System.out.println(outer.run());
    }

    Object run() {
        int localVariable = 666;
        final int finalLocalVariable = 300;

        class LocalClass {
            int innerVariable = 40;

            int getSum(int parameter) {
                // Cannot access localVariable here
                return outerVariable +
                       staticOuterVariable +
                       finalLocalVariable +
                       innerVariable + parameter;
            }

            @Override
            public String toString() {
                return "I'm an instance of LocalClass";
            }
        }
        LocalClass local = new LocalClass();
        System.out.println(local.getSum(5));
        return local;
    }
}

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.*;

public class OuterClass extends JFrame {

    public static void main(String[] args) {
        OuterClass outer = new OuterClass();
        JButton button =
            new JButton("Don't click me!");
        button.addActionListener(
            new ActionListener() {
                public void actionPerformed(
                    ActionEvent event) {
                        System.out.println("Ouch!");
                }
        });
        outer.add(button);
        outer.pack();
        outer.setVisible(true);
    }
}

enum Weekday { SUN, MON, TUE, WED, THU, FRI, SAT }

public enum Coin {
    private final int value;
    PENNY(1), NICKEL(5), DIME(10), QUARTER(25);
    Coin(int value) { this.value = value; }
    public int value() { return value; }
}

record Range(int min, int max) { }

public Range {
    assert min <= max;
}

module giveModule {
	exports com.xyz.giver;
	exports com.xyz.secret to takeModule;
}

module takeModule {
	requires transitive giveModule;
}

void run(IntUnaryOperator fun, int n) {
    System.out.println(fun.applyAsInt(1n));
}

import java.util.function.IntUnaryOperator;
import java.util.Arrays;

public class FunctionTest {

    public static void main(String[] args) {
        FunctionTest test = new FunctionTest();
        int[] a = new int[] {1, 2, 3, 4, 5};
        Mapper map = new Mapper();
        int[] b = map.apply(a, x -> x * x);
        System.out.println(Arrays.toString(b));
    }
}

@FunctionalInterface
interface ForEach {
    int[] apply(int[] a, IntUnaryOperator f);
}

class Mapper implements ForEach {
    public int[] apply(int[] a, IntUnaryOperator f) {
        int[] b = new int[a.length];
        for (int i = 0; i < a.length; i += 1) {
            b[i] = f.applyAsInt(a[i]);
        }
        return b;
    }
}

myButton.addActionListener(new ActionListener() {
    @Override
    public void actionPerformed(ActionEvent e) {
        doSomething();
}});

myButton.addActionListener(e -> doSomething());

import org.junit.jupiter.api.*;
import static org.junit.jupiter.api.Assertions.*;
import static org.junit.jupiter.api.Assumptions.*;

assertThrows(ArithmeticException.class,
             () -> divide(0, 0));

try {
    divide(0, 0);
    Assertions.fail();
}
catch (ArithmeticException e) { }

package account;

import org.junit.jupiter.api.*;
import static org.junit.jupiter.api.Assertions.*;

public class AccountTest {
    Account account; // must be global

    @BeforeEach
    public void setup() {
        this.account = new Account(); // global
    }

    @Test
    public void openAnAccount() {
        assertEquals(0, account.getBalance());
    }

    @Test
    public void testDeposit() {
        account.deposit(100);
        assertEquals(100, account.getBalance());
        account.deposit(70);
        assertEquals(170, account.getBalance());;
    }

    @Test
    public void testIllegalDeposit() {
        account.deposit(-10000);
        assertEquals(0, account.getBalance());
    }

    @Test
    public void goodWithdrawal() throws Exception {
        account.deposit(100);
        account.withdraw(35);
        assertEquals(65, account.getBalance());
    }

    @Test
    @DisplayName("Exception test, old style")
    public void badWithdrawal() {
        try {
            account.withdraw(35);
            fail("Did not throw exception");
        }
        catch (Exception e) { }
    }

    @Test
    @DisplayName("Exception test, new style")
    public void badWithdrawal2() {
         assertThrows(Exception.class,
             () -> account.withdraw(35));
    }
}

JOptionPane.showMessageDialog(parent,
        "This is a message dialog.");

int yesNo = JOptionPane.showConfirmDialog(
        parent,
        "Do you really want to do that?");
if (yesNo == JOptionPane.YES_OPTION) {
      System.out.println("Action confirmed");
}

String userName =
    JOptionPane.showInputDialog(
        parent, "What is your name?");

Object[] options = new String[] {
    "Java", "Python", "C++"
};
int option = JOptionPane.showOptionDialog(
     parent,
     "Choose an option:",  // message
     "Option Dialog",      // title
     JOptionPane.YES_NO_OPTION,    // option type
     JOptionPane.QUESTION_MESSAGE, // message type
     null,     // icon
     options,  // array of strings or components
     options[0]); // initial selection

JColorChooser colorChooser = new JColorChooser();
Color chosenColor =
    colorChooser.showDialog(parent,
                            "Choose a color:",
                            Color.WHITE);

JFileChooser chooser = new JFileChooser();
chooser.setDialogTitle("Load which file?");

BufferedReader br = null;
int result = chooser.showOpenDialog(parent);
if (result == JFileChooser.APPROVE_OPTION) {
    File file = chooser.getSelectedFile();
    try {
        if (file != null) {
            String fileName = file.getCanonicalPath();
            FileReader fr = new FileReader(fileName);
            br = new BufferedReader(fr);
        }
    }
    catch (IOException e) { }
}

String line = "";
try { line = br.readLine(); }
catch (IOException e) { }

JFileChooser chooser = new JFileChooser();
chooser.setDialogTitle("Save file as?");

int result = chooser.showSaveDialog(parent);
PrintWriter pr = null;
if (result == JFileChooser.APPROVE_OPTION) {
    File file = chooser.getSelectedFile();
    String fileName;
    try {
        if (file != null) {
            fileName = file.getCanonicalPath();
            FileOutputStream stream =
                new FileOutputStream(fileName);
            pr = new PrintWriter(stream, true);
        }
    }
    catch (IOException e) { }
}

pr.println("Test line");
pr.close();

JFrame parent = null;
boolean isModal = true;
JDialog myDialog =
    new JDialog(parent, isModal);

myDialog.add(new JLabel(" Your text "),
             BorderLayout.CENTER);
JButton closeButton = new JButton("Close");
myDialog.add(closeButton, BorderLayout.SOUTH);

closeButton.addActionListener(new ActionListener() {
    public void actionPerformed(ActionEvent e) {
        myDialog.setVisible(false);
    }
});

myDialog.pack();
myDialog.setVisible(true);

import javax.swing.SwingUtilities;
import javax.swing.JFrame;

public class MyGUI extends JFrame implements Runnable {

    public static void main(String[] args) {
        SwingUtilities.invokeLater(new MyGUI());
    }

    public void run() {
        // add components to this JFrame
        pack();
        setVisible(true);
    }
}

JFrame frame = new JFrame(); // or
JFrame frame = new JFrame("Text for title bar");

public class Examples extends JFrame {...}

JFrame myFrame = new JFrame();

setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

addWindowListener(new Closer());
private class Closer extends WindowAdapter {
   public void windowClosing(WindowEvent we) {
        update(); // your method
   }
}

setLayout(new BorderLayout());

add(controlPanel, BorderLayout.NORTH);

pack();
setVisible(true);

JEditorPane editor = new JEditorPane();

JPanel content = new JPanel();

JScrollPane scroller = new JScrollPane(editor);

EditorKit kit =
	 JEditorPane.createEditorKitForContentType(
	     "text/html");
editor.setEditorKit(kit);

content.setLayout(new BorderLayout());
content.add(scroller, BorderLayout.CENTER);

editor.setText("This is <i>Sample</i> text");
String myText = editor.getText();

JPanel content = new JPanel();

JScrollPane scroller = new JScrollPane(content);

scroller.setPreferredSize(new Dimension(600, 600));

content.setLayout(new BorderLayout());
content.add(editor, BorderLayout.CENTER);
add(scroller); // to the JFrame

editor.setCaretPosition(0);

JTabbedPane tabbedPane = new JTabbedPane();
tabbedPane.setPreferredSize(
    new Dimension(300, 150));

ImageIcon smiley =
   new ImageIcon("Resources Root/smiley.png");

ImageIcon frowny =
   new ImageIcon("Resources Root/frowny.png");

tabbedPane.addTab("Smile", smiley,
                  panel0, "Tooltip 0");

tabbedPane.addTab("Tab 1", null,
                  panel1, "Tooltip 1");

tabbedPane.addTab(null, frowny,
                  panel2, null);

private JButton myJButton =
    new JButton("This is a JButton");

someJPanel.add(myJButton);

myJButton.addActionListener(event ->
    handleEvent("JButton"));

private JTextField myJTextField =
    new JTextField("Example JTextField");

someJPanel.add(myJTextField);

myJTextField.setToolTipText("My tooltip");

myJTextField.setText("This is new text");

String myText = myJTextField.getText();

myJTextField.addActionListener(event ->
    handleEvent("JTextField"));

private JTextArea myJTextArea =
    new JTextArea(rows, columns);

someJPanel.add(myJTextArea);

myJTextArea.setText(
    "New text for the JTextArea,\n" +
    "and it may contain newlines.");

myJTextArea.append("Ehh...that's all, folks!");

String myText = myJTextArea.getText();

myJTextArea.getDocument().addDocumentListener(
        new MyJTextAreaListener());

public class MyJTextAreaListener
    implements DocumentListener {
        public void insertUpdate(
            DocumentEvent arg0) {
                handleEvent("JTextArea");
        }
        public void removeUpdate(
            DocumentEvent arg0) {
                handleEvent("JTextArea");
            }
        public void changedUpdate(
            DocumentEvent arg0) {
                handleEvent("JTextArea");
            }
    }

private JCheckBox myJCheckBox =
    new JCheckBox("This is a JCheckBox");

someJPanel.add(myJCheckBox);

boolean checked = myJCheckBox.isSelected();

myJCheckBox.addItemListener(event ->
    handleEvent("JCheckBox"));

private JRadioButton myJRadioButton1 =
    new JRadioButton("radio 1");
private JRadioButton myJRadioButton2 =
    new JRadioButton("radio 2");

private ButtonGroup myButtonGroup = new ButtonGroup();

myButtonGroup.add(myJRadioButton1);
myButtonGroup.add(myJRadioButton2);

someJPanel.setLayout(new GridLayout(2, 1));
someJPanel.add(myJRadioButton1);
someJPanel.add(myJRadioButton2);

    myJRadioButton1.setSelected(true);

boolean selected1 = myJRadioButton1.isSelected();
boolean selected2 = myJRadioButton2.isSelected();

 myJRadioButton1.addItemListener(event ->
     handleEvent("JRadioButton1"));
myJRadioButton2.addItemListener(event ->
     handleEvent("JRadioButton2"));

JLabel myJLabel = new JLabel("This is a JLabel");

labelPanel.add(myJLabel);

labelPanel.addMouseListener(
    new MouseAdapter() {
        @Override
        public void mouseClicked(
            MouseEvent e) {
                handleEvent("JLabel");
        }
    });

private JComboBox myJComboBox =
    new JComboBox(
        new String[]{"Java", "Python",
                     "JavaScript"} );

someJPanel.add(myJComboBox);

myJComboBox.addActionListener(event -> {
    String selection =
        (String) myJComboBox.getSelectedItem();
    handleEvent(selection);
});

private JSlider myJSlider =
    new JSlider(SwingConstants.HORIZONTAL,
                0, 50, 20);

someJPanel.add(myJSlider);

myJSlider.setMajorTickSpacing(10);
myJSlider.setMinorTickSpacing(2);
myJSlider.setPaintTicks(true);
myJSlider.setPaintLabels(true);

myJSlider.setValue(45);

int temp = myJSlider.getValue();

myJSlider.addChangeListener(event ->
    handleEvent("JSlider"));

int min = 10, max = 30, step = 2, initValue = 20;
SpinnerModel model =
    new SpinnerNumberModel(initValue, min,
                           max, step);
private JSpinner myJSpinner = new JSpinner(model);

someJPanel.add(myJSpinner);

myJSpinner.setValue(20);

int value = (int)myJSpinner.getValue();

myJSpinner.addChangeListener(event ->
    handleEvent("JSpinner"));

JProgressBar myProgressBar =
        new JProgressBar(min, max);

JProgressBar myProgressBar =
        new JProgressBar(); // 0 to 100

myProgressBar.setStringPainted(true);

someJPanel.add(myProgressBar);

myProgressBar.setValue(20);

int value = myProgressBar.getValue();

JMenuBar myJMenuBar = new JMenuBar();
JMenu myJMenu = new JMenu("Menu");
JMenuItem myJMenuItem = new JMenuItem("Menu Item");

myJMenuBar.add(myJMenu);
myJMenu.add(myJMenuItem);

this.setJMenuBar(myJMenuBar);

myJMenuItem.addActionListener(event ->
    handleEvent("JMenuItem"));

JPanel panel = new JPanel();
panel.setPreferredSize(new Dimension(300, 200));
JLabel label = new JLabel("Type here");
panel.add(label);
add(panel, BorderLayout.CENTER); // to JFrame

KeyListener listener = new KeyListener() {
    @Override
    public void keyPressed(KeyEvent e) {
        System.out.println(
            "Pressed " + e.getKeyCode());
    }
    @Override
    public void keyTyped(KeyEvent e) {
        System.out.println(
            " Typed: " + e.getKeyChar());
    }
    @Override
    public void keyReleased(KeyEvent e) {
        System.out.println(
            "  Released: " + e.getKeyCode());
    }
};
panel.setFocusable(true);
panel.addKeyListener(listener);

import javax.swing.*;
import javax.swing.event.*;
import java.awt.*;
import java.awt.event.*;
import java.util.Random;

public class DiceRoller extends JFrame {
    static Random rand = new Random();
    JButton rollButton;
    JTextField result;

    public static void main(String[] args) {
        SwingUtilities.invokeLater(new Runnable() {
            public void run() {
                new DiceRoller().createAndShowGUI();
            }
        });
    }

    void createAndShowGUI() {
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        rollButton = new JButton("Roll 'em!");
        getContentPane().add(rollButton, BorderLayout.NORTH);
        result = new JTextField("You haven't rolled yet.");
        getContentPane().add(result, BorderLayout.SOUTH);
        pack();
        setVisible(true);
        rollButton.addActionListener(event -> {
                int number = rand.nextInt(6) + 1;
                result.setText("You rolled a " + number);
            });
    }
}

try { Thread.sleep(1000); }
catch (InterruptedException e) { }

boolean okToRun = true;
secondThread.start();

public void run() {
    while (firstThread.okToRun) {...}
}

Timer timer = new Timer(40, event -> doSomething());

import java.math.BigInteger;
import javax.swing.SwingWorker;

class Worker extends SwingWorker<BigInteger, Void> {
    private BigInteger big;

    Worker(BigInteger big) { // constructor
        this.big = big;
    }

    @Override
    public BigInteger doInBackground() {
        return findFactor(big);
    }

    // Here is our long-running process
    BigInteger findFactor(BigInteger big) {
        if (big.mod(BigInteger.TWO).equals
           (BigInteger.ZERO)) {
            return BigInteger.TWO; // 2 is a factor
        }
        BigInteger divisor = new BigInteger("3");
        while (big.divide(divisor).compareTo(divisor) >= 0) {
            if (big.mod(divisor).equals(BigInteger.ZERO)) {
                return divisor;
             }
            divisor = divisor.add(BigInteger.TWO);
        }
        return BigInteger.ZERO;
    }
}

import java.math.BigInteger;

public class FactorFinder {

    public static void main(String[] args) {
        new FactorFinder(args[0]);
    }

    public FactorFinder(String bignum) {
        BigInteger factor = BigInteger.ZERO;
        BigInteger big = new BigInteger(bignum);
        System.out.println("Trying to factor " + big);

        // Use the SwingWorker
        Worker worker = new Worker(big);
        worker.execute();
        while (!worker.isDone()) {
            twiddleThumbs();
        }
        try { factor = worker.get(); }
        catch (Exception e) { }

        // Show the results
        if (factor.equals(BigInteger.ZERO))
            System.out.println("\n" + big +
                               " is prime");
        else
            System.out.println("\n" + big + " = " +
                               factor +" x " +
                               big.divide(factor));
    }

    public void twiddleThumbs() {
        try { Thread.sleep(1000); }
        catch(InterruptedException e) {}
        System.out.print('.');
    }
}

model = new Model();
view = new View(model);

this.addComponentListener(new ComponentAdapter() {
    @Override
    public void componentResized(ComponentEvent e) {
        model.setLimits(view.getWidth(),
                        view.getHeight());
    }
});

private Point position = new Point(0, 0);
private int dx = 6; // change in x
private int dy = 4; // change in y

timer = new Timer(40, new ActionListener() {
    @Override
    public void actionPerformed(ActionEvent e) {
        makeOneStep();
    }
});

position.x += dx;
if (position.x < 0 || position.x >= xLimit) {
    dx = -dx;
    position.x += dx;
}

public PropertyChangeSupport pcs;

this.pcs.firePropertyChange("position", null,
                            position);

public class View extends JPanel
    implements PropertyChangeListener {…}

@Override
public void propertyChange(
        PropertyChangeEvent event) {
    position = (Point) event.getNewValue();
    repaint();
}

model.pcs.addPropertyChangeListener(this);

/**
 * This is an example of the basic "Bouncing
 * Ball" animation, making use of the Model-
 * View-Controller design pattern and the
 * Timer and PropertyChangeSupport classes.
 */

import java.awt.BorderLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.ComponentAdapter;
import java.awt.event.ComponentEvent;
import java.util.Timer;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;

/**
 * The Controller sets up the GUI and handles
 * the controls (in this case, buttons).
 * @author David Matuszek
 */
public class Controller extends JFrame {
    JPanel buttonPanel = new JPanel();
    JButton runButton = new JButton("Run");
    JButton stopButton = new JButton("Stop");
    Timer timer;

    /**
     * The Model is the object that does all
     * the computations. It is independent
     * of the Controller and View objects.
     */
    Model model;

    /**
     * The View object displays what is
     * happening in the Model.
     */
    View view;

    /**
     * Runs the bouncing ball program.
     * @param args Ignored.
     */
    public static void main(String[] args) {
        Controller c = new Controller();
        c.init();
        c.display();
    }

    /**
     * Sets up communication between the
     * Model and the View.
     */
    private void init() {
        model = new Model();
        view = new View(model);
    }

    /**
     * Displays the GUI.
     */
    private void display() {
        layOutComponents();
        attachListenersToComponents();
        setSize(300, 300);
        setVisible(true);
        setDefaultCloseOperation(
                JFrame.EXIT_ON_CLOSE);
    }

    /**
     * Arranges the components in the GUI.
     */
    private void layOutComponents() {
        setLayout(new BorderLayout());
        this.add(BorderLayout.SOUTH, buttonPanel);
        buttonPanel.add(runButton);
        buttonPanel.add(stopButton);
        stopButton.setEnabled(false);
        this.add(BorderLayout.CENTER, view);
    }

    /**
     * Attaches listeners to the components
     * and schedules a Timer.
     */
    private void attachListenersToComponents() {
        // The Run button starts the Model
        runButton.addActionListener( event -> {
             runButton.setEnabled(false);
             stopButton.setEnabled(true);
             model.start();
        });
        // The Stop button pauses the Model
        stopButton.addActionListener(event -> {
            runButton.setEnabled(true);
            stopButton.setEnabled(false);
            model.pause();
        });
        // When the window is resized,
        // the Model is given the new limits
        this.addComponentListener(
                new ComponentAdapter() {
            @Override
            public void componentResized(
                    ComponentEvent arg0) {
                model.setLimits(view.getWidth(),
                               view.getHeight());
            }
        });
    }
}

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.Point;
import javax.swing.Timer;
import java.beans.*;

/**
 * This is the Model class for a bouncing ball.
 * It defines a PropertyChangeSupport object.
 * @author David Matuszek
 */
public class Model {
    private Point position = new Point(0, 0);
    private int xLimit, yLimit;
    private int dx = 6;
    private int dy = 4;
    private Timer timer;
    public PropertyChangeSupport pcs;

    public Model() {
        pcs = new PropertyChangeSupport(this);
        position = new Point(0, 0);
        timer = new Timer(
                40, new ActionListener() {
            @Override
            public void actionPerformed(
                ActionEvent e) {
                    makeOneStep();
                }
        });
        timer.stop();
    }

    /**
     * Sets the "walls" that the ball should
     * bounce off from.
     * @param xLimit The right wall (in pixels).
     * @param yLimit The floor (in pixels).
     */
    public void setLimits(int xLimit,
                          int yLimit) {
        this.xLimit = xLimit - 20;
        this.yLimit = yLimit - 20;
        position =
           new Point(Math.min(position.x, xLimit),
                     Math.min(position.y, yLimit));
    }

    /**
     * @return The balls X position.
     */
    public Point getPosition() {
        return position;
    }

    /**
     * Tells the ball to start moving. This is
     * done by starting a Timer that periodically
     * tells the ball to make one "step."
     */
    public void start() {
        timer.start();
    }

    /**
     * Tells the ball to stop where it is.
     */
    public void pause() {
        timer.stop();
    }

    /**
     * Tells the ball to advance one step
     * in the direction that it is moving.
     * If it hits a wall, its direction
     * of movement changes. The method
     * then fires a PropertyChange event.
     */
    public void makeOneStep() {
        // Do the work
        position.x += dx;
        if (position.x < 0 ||
            position.x >= xLimit) {
          dx = -dx;
          position.x += dx;
        }
        position.y += dy;
        if (position.y < 0 ||
            position.y >= yLimit) {
          dy = -dy;
          position.y += dy;
        }
        this.pcs.firePropertyChange(
                "position", null, position);
    }
}

import java.awt.Color;
import java.awt.Graphics;
import java.awt.Point;
import java.beans.*;
import javax.swing.JPanel;

/**
 * The View displays what is going on in
 * the Model. In this example, the Model
 * is only a single bouncing ball.
 * @author David Matuszek
 */
public class View extends JPanel
        implements PropertyChangeListener {
    Point position = new Point(0, 0);
    /** This is what we will be viewing. */
    Model model;

    /**
     * Constructor. Adds a listener for
     * PropertyChange events.
     * @param model The Model whose working
     *              is to be displayed.
     */
    View(Model model) {
        this.model = model;
        model.pcs.addPropertyChangeListener(this);
    }

    /**
     * Displays what is going on in the Model.
     * Note: This method should NEVER be
     * called directly; call repaint() instead.
     * @param g The Graphics on which to paint.
     * @see javax.swing.JComponent#paint(
     *      java.awt.Graphics)
     */
    @Override
    public void paint(Graphics g) {
        g.setColor(Color.WHITE);
        g.fillRect(0, 0, getWidth(), getHeight());
        g.setColor(Color.RED);
        position = model.getPosition();
        g.fillOval(position.x, position.y, 20, 20);
    }

    /**
     * Repaints the JPanel when a
     * PropertyChangeEvents is received.
     * @param evt Contains the ball's position.
     */
    @Override
    public void propertyChange(
            PropertyChangeEvent evt) {
        position = (Point) evt.getNewValue();
        repaint();
    }
}