public class Bicycle {    // the Bicycle class has    // three fields    public int cadence;    public int gear;    public int speed;    // the Bicycle class has    // one constructor    public Bicycle(int startCadence, int startSpeed, int startGear) {        gear = startGear;        cadence = startCadence;        speed = startSpeed;    }    // the Bicycle class has    // four methods    public void setCadence(int newValue) {        cadence = newValue;    }    public void setGear(int newValue) {        gear = newValue;    }    public void applyBrake(int decrement) {        speed -= decrement;    }    public void speedUp(int increment) {        speed += increment;    }}

public class MountainBike extends Bicycle {    // the MountainBike subclass has    // one field    public int seatHeight;    // the MountainBike subclass has    // one constructor    public MountainBike(int startHeight, int startCadence,                        int startSpeed, int startGear) {        super(startCadence, startSpeed, startGear);        seatHeight = startHeight;    }
    // the MountainBike subclass has    // one method    public void setHeight(int newValue) {        seatHeight = newValue;    }
}

class MyClass {    // field, constructor, and    // method declarations}

class MyClass extends MySuperClass implements YourInterface {    // field, constructor, and    // method declarations}

public int cadence;public int gear;public int speed;

public class Bicycle {    private int cadence;    private int gear;    private int speed;    public Bicycle(int startCadence, int startSpeed, int startGear) {        gear = startGear;        cadence = startCadence;        speed = startSpeed;    }    public int getCadence() {        return cadence;    }    public void setCadence(int newValue) {        cadence = newValue;    }    public int getGear() {        return gear;    }    public void setGear(int newValue) {        gear = newValue;    }    public int getSpeed() {        return speed;    }    public void applyBrake(int decrement) {        speed -= decrement;    }    public void speedUp(int increment) {        speed += increment;    }}

public double calculateAnswer(double wingSpan, int numberOfEngines,                              double length, double grossTons) {    //do the calculation here}

calculateAnswer(double, int, double, double)

public class DataArtist {    ...    public void draw(String s) {        ...    }    public void draw(int i) {        ...    }    public void draw(double f) {        ...    }    public void draw(int i, double f) {        ...    }}

public Bicycle(int startCadence, int startSpeed, int startGear) {    gear = startGear;    cadence = startCadence;    speed = startSpeed;}

Bicycle myBike = new Bicycle(30, 0, 8);

public Bicycle() {    gear = 1;    cadence = 10;    speed = 0;}

public double computePayment(                  double loanAmt,                  double rate,                  double futureValue,                  int numPeriods) {    double interest = rate / 100.0;    double partial1 = Math.pow((1 + interest),
                    - numPeriods);    double denominator = (1 - partial1) / interest;    double answer = (-loanAmt / denominator)                    - ((futureValue * partial1) / denominator);    return answer;}

public Polygon polygonFrom(Point[] corners) {    // method body goes here}

public Polygon polygonFrom(Point... corners) {    int numberOfSides = corners.length;    double squareOfSide1, lengthOfSide1;    squareOfSide1 = (corners[1].x - corners[0].x)                     * (corners[1].x - corners[0].x)
                     + (corners[1].y - corners[0].y)                     * (corners[1].y - corners[0].y);    lengthOfSide1 = Math.sqrt(squareOfSide1);    // more method body code follows that creates and returns a    // polygon connecting the Points}

public PrintStream printf(String format, Object... args)

System.out.printf("%s: %d, %s%n", name, idnum, address);

System.out.printf("%s: %d, %s, %s, %s%n", name, idnum, address, phone, email);

public class Circle {    private int x, y, radius;    public void setOrigin(int x, int y) {        ...    }}

public class PassPrimitiveByValue {    public static void main(String[] args) {        int x = 3;        // invoke passMethod() with        // x as argument        passMethod(x);        // print x to see if its        // value has changed        System.out.println("After invoking passMethod, x = " + x);    }    // change parameter in passMethod()    public static void passMethod(int p) {        p = 10;    }}

After invoking passMethod, x = 3

public void moveCircle(Circle circle, int deltaX, int deltaY) {    // code to move origin of circle to x+deltaX, y+deltaY    circle.setX(circle.getX() + deltaX);    circle.setY(circle.getY() + deltaY);    // code to assign a new reference to circle    circle = new Circle(0, 0);}

moveCircle(myCircle, 23, 56)

public class CreateObjectDemo {    public static void main(String[] args) {        // Declare and create a point object and two rectangle objects.        Point originOne = new Point(23, 94);        Rectangle rectOne = new Rectangle(originOne, 100, 200);        Rectangle rectTwo = new Rectangle(50, 100);        // display rectOne's width, height, and area        System.out.println("Width of rectOne: " + rectOne.width);        System.out.println("Height of rectOne: " + rectOne.height);        System.out.println("Area of rectOne: " + rectOne.getArea());        // set rectTwo's position        rectTwo.origin = originOne;        // display rectTwo's position        System.out.println("X Position of rectTwo: " + rectTwo.origin.x);        System.out.println("Y Position of rectTwo: " + rectTwo.origin.y);        // move rectTwo and display its new position        rectTwo.move(40, 72);        System.out.println("X Position of rectTwo: " + rectTwo.origin.x);        System.out.println("Y Position of rectTwo: " + rectTwo.origin.y);    }}

Point originOne = new Point(23, 94);Rectangle rectOne = new Rectangle(originOne, 100, 200);Rectangle rectTwo = new Rectangle(50, 100);

type name;

Point originOne;

Point originOne = new Point(23, 94);

int height = new Rectangle().height;

public class Point {    public int x = 0;    public int y = 0;    //constructor    public Point(int a, int b) {        x = a;        y = b;    }}

Point originOne = new Point(23, 94);

public class Rectangle {    public int width = 0;    public int height = 0;    public Point origin;    // four constructors    public Rectangle() {        origin = new Point(0, 0);    }    public Rectangle(Point p) {        origin = p;    }    public Rectangle(int w, int h) {        origin = new Point(0, 0);        width = w;        height = h;    }    public Rectangle(Point p, int w, int h) {        origin = p;        width = w;        height = h;    }    // a method for moving the rectangle    public void move(int x, int y) {        origin.x = x;        origin.y = y;    }    // a method for computing the area of the rectangle    public int getArea() {        return width * height;    }}

Rectangle rectOne = new Rectangle(originOne, 100, 200);

Rectangle rectTwo = new Rectangle(50, 100);

Rectangle rect = new Rectangle();

System.out.println("Width and height are: " + width + ", " + height);

objectReference.fieldName

System.out.println("Width of rectOne: "  + rectOne.width);System.out.println("Height of rectOne: " + rectOne.height);

int height = new Rectangle().height;

objectReference.methodName(argumentList);

objectReference.methodName();

System.out.println("Area of rectOne: " + rectOne.getArea());...rectTwo.move(40, 72);

new Rectangle(100, 50).getArea()

int areaOfRectangle = new Rectangle(100, 50).getArea();

return;

return returnValue;

// a method for computing the area of the rectanglepublic int getArea() {  return width * height;}

public Bicycle seeWhosFastest(Bicycle myBike, Bicycle yourBike,                              Environment env) {    Bicycle fastest;    // code to calculate which bike is    // faster, given each bike's gear    // and cadence and given the    // environment (terrain and wind)    return fastest;}

public Number returnANumber() {    ...}

public ImaginaryNumber returnANumber() {    ...}

public class Point {    public int x = 0;    public int y = 0;    //constructor    public Point(int a, int b) {        x = a;        y = b;    }}

public class Point {    public int x = 0;    public int y = 0;    //constructor    public Point(int x, int y) {        this.x = x;        this.y = y;    }}

public class Rectangle {    private int x, y;    private int width, height;    public Rectangle() {        this(0, 0, 1, 1);    }    public Rectangle(int width, int height) {        this(0, 0, width, height);    }    public Rectangle(int x, int y, int width, int height) {        this.x = x;        this.y = y;        this.width = width;        this.height = height;    }    ...}

public class Bicycle {    private int cadence;    private int gear;    private int speed;    // add an instance variable for the object ID    private int id;    // add a class variable for the    // number of Bicycle objects instantiated    private static int numberOfBicycles = 0;        ...}

Bicycle.numberOfBicycles

public class Bicycle {    private int cadence;    private int gear;    private int speed;    private int id;    private static int numberOfBicycles = 0;    public Bicycle(int startCadence, int startSpeed, int startGear){        gear = startGear;        cadence = startCadence;        speed = startSpeed;        // increment number of Bicycles        // and assign ID number        id = ++numberOfBicycles;    }    // new method to return the ID instance variable    public int getID() {        return id;    }        ...}

ClassName.methodName(args)

public static int getNumberOfBicycles() {    return numberOfBicycles;}

static final double PI = 3.141592653589793;

public class Bicycle {    private int cadence;    private int gear;    private int speed;    private int id;    private static int numberOfBicycles = 0;    public Bicycle(int startCadence,                   int startSpeed,                   int startGear) {        gear = startGear;        cadence = startCadence;        speed = startSpeed;        id = ++numberOfBicycles;    }    public int getID() {        return id;    }    public static int getNumberOfBicycles() {        return numberOfBicycles;    }    public int getCadence() {        return cadence;    }    public void setCadence(int newValue) {        cadence = newValue;    }    public int getGear(){        return gear;    }    public void setGear(int newValue) {        gear = newValue;    }    public int getSpeed() {        return speed;    }    public void applyBrake(int decrement) {        speed -= decrement;    }    public void speedUp(int increment) {        speed += increment;    }}

public class BedAndBreakfast {    // initialize to 10    public static int capacity = 10;    // initialize to false    private boolean full = false;}

static {    // whatever code is needed for initialization goes here}

class Whatever {    public static varType myVar = initializeClassVariable();    private static varType initializeClassVariable() {        // initialization code goes here    }}

{    // 初始化所需的任何代码都在这里}

class Whatever {    private varType myVar = initializeInstanceVariable();    protected final varType initializeInstanceVariable() {        // initialization code goes here    }}

objectReference.variableName

objectReference.methodName(argumentList)

objectReference.methodName()

class OuterClass {    ...    class NestedClass {        ...    }}

class OuterClass {    ...    class InnerClass {        ...    }    static class StaticNestedClass {        ...    }}

class OuterClass {    ...    class InnerClass {        ...    }}

OuterClass outerObject = new OuterClass();OuterClass.InnerClass innerObject = outerObject.new InnerClass();

StaticNestedClass staticNestedObject = new StaticNestedClass();

public class OuterClass {    String outerField = "Outer field";    static String staticOuterField = "Static outer field";    class InnerClass {        void accessMembers() {            System.out.println(outerField);            System.out.println(staticOuterField);        }    }    static class StaticNestedClass {        void accessMembers(OuterClass outer) {            // Compiler error: Cannot make a static reference to the non-static            //     field outerField            // System.out.println(outerField);            System.out.println(outer.outerField);            System.out.println(staticOuterField);        }    }    public static void main(String[] args) {        System.out.println("Inner class:");        System.out.println("------------");        OuterClass outerObject = new OuterClass();        OuterClass.InnerClass innerObject = outerObject.new InnerClass();        innerObject.accessMembers();        System.out.println("\nStatic nested class:");        System.out.println("--------------------");        StaticNestedClass staticNestedObject = new StaticNestedClass();
        staticNestedObject.accessMembers(outerObject);        System.out.println("\nTop-level class:");        System.out.println("--------------------");        TopLevelClass topLevelObject = new TopLevelClass();
        topLevelObject.accessMembers(outerObject);
    }}

public class TopLevelClass {    void accessMembers(OuterClass outer) {
        // Compiler error: Cannot make a static reference to the non-static        //     field OuterClass.outerField        // System.out.println(OuterClass.outerField);        System.out.println(outer.outerField);        System.out.println(OuterClass.staticOuterField);    }
}

Inner class:------------Outer field
Static outer field
Static nested class:--------------------Outer field
Static outer field
Top-level class:--------------------Outer field
Static outer field

static class StaticNestedClass {    void accessMembers(OuterClass outer) {       // Compiler error: Cannot make a static reference to the non-static       //     field outerField       System.out.println(outerField);    }}

System.out.println(outer.outerField);

public class ShadowTest {    public int x = 0;    class FirstLevel {        public int x = 1;        void methodInFirstLevel(int x) {            System.out.println("x = " + x);            System.out.println("this.x = " + this.x);            System.out.println("ShadowTest.this.x = " + ShadowTest.this.x);        }    }    public static void main(String... args) {        ShadowTest st = new ShadowTest();        ShadowTest.FirstLevel fl = st.new FirstLevel();        fl.methodInFirstLevel(23);    }}

x = 23this.x = 1ShadowTest.this.x = 0

System.out.println("this.x = " + this.x);

System.out.println("ShadowTest.this.x = " + ShadowTest.this.x);

public class DataStructure {    // Create an array    private final static int SIZE = 15;    private int[] arrayOfInts = new int[SIZE];    public DataStructure() {        // fill the array with ascending integer values        for (int i = 0; i < SIZE; i++) {            arrayOfInts[i] = i;        }    }    public void printEven() {        // Print out values of even indices of the array        DataStructureIterator iterator = this.new EvenIterator();        while (iterator.hasNext()) {            System.out.print(iterator.next() + " ");        }        System.out.println();    }    interface DataStructureIterator extends java.util.Iterator<Integer> { }
    // Inner class implements the DataStructureIterator interface,    // which extends the Iterator<Integer> interface    private class EvenIterator implements DataStructureIterator {        // Start stepping through the array from the beginning        private int nextIndex = 0;        public boolean hasNext() {            // Check if the current element is the last in the array            return (nextIndex <= SIZE - 1);        }
        public Integer next() {            // Record a value of an even index of the array            Integer retValue = Integer.valueOf(arrayOfInts[nextIndex]);            // Get the next even element            nextIndex += 2;            return retValue;        }    }    public static void main(String s[]) {        // Fill the array with integer values and print out only        // values of even indices        DataStructure ds = new DataStructure();        ds.printEven();    }}

public class LocalClassExample {    static String regularExpression = "[^0-9]";    public static void validatePhoneNumber(        String phoneNumber1, String phoneNumber2) {        final int numberLength = 10;        // Valid in JDK 8 and later:        // int numberLength = 10;        class PhoneNumber {            String formattedPhoneNumber = null;            PhoneNumber(String phoneNumber){                // numberLength = 7;                String currentNumber = phoneNumber.replaceAll(                  regularExpression, "");                if (currentNumber.length() == numberLength)                    formattedPhoneNumber = currentNumber;                else                    formattedPhoneNumber = null;            }            public String getNumber() {                return formattedPhoneNumber;            }            // Valid in JDK 8 and later://            public void printOriginalNumbers() {//                System.out.println("Original numbers are " + phoneNumber1 +//                    " and " + phoneNumber2);//            }        }        PhoneNumber myNumber1 = new PhoneNumber(phoneNumber1);        PhoneNumber myNumber2 = new PhoneNumber(phoneNumber2);        // Valid in JDK 8 and later://        myNumber1.printOriginalNumbers();        if (myNumber1.getNumber() == null)
            System.out.println("First number is invalid");        else            System.out.println("First number is " + myNumber1.getNumber());        if (myNumber2.getNumber() == null)            System.out.println("Second number is invalid");        else            System.out.println("Second number is " + myNumber2.getNumber());    }    public static void main(String... args) {        validatePhoneNumber("123-456-7890", "456-7890");    }}

PhoneNumber(String phoneNumber) {    numberLength = 7;    String currentNumber = phoneNumber.replaceAll(        regularExpression, "");    if (currentNumber.length() == numberLength)        formattedPhoneNumber = currentNumber;    else        formattedPhoneNumber = null;}

if (currentNumber.length() == numberLength)

public void printOriginalNumbers() {    System.out.println("Original numbers are " + phoneNumber1 +        " and " + phoneNumber2);}

public void greetInEnglish() {  interface HelloThere {    public void greet();  }  class EnglishHelloThere implements HelloThere {    public void greet() {      System.out.println("Hello " + name);    }  }  HelloThere myGreeting = new EnglishHelloThere();  myGreeting.greet();}

public void sayGoodbyeInEnglish() {        class EnglishGoodbye {            public static void sayGoodbye() {                System.out.println("Bye bye");            }        }        EnglishGoodbye.sayGoodbye();    }

public void sayGoodbyeInEnglish() {        class EnglishGoodbye {            public static final String farewell = "Bye bye";            public void sayGoodbye() {                System.out.println(farewell);            }        }        EnglishGoodbye myEnglishGoodbye = new EnglishGoodbye();        myEnglishGoodbye.sayGoodbye();    }

public class HelloWorldAnonymousClasses {    interface HelloWorld {        public void greet();        public void greetSomeone(String someone);    }    public void sayHello() {        class EnglishGreeting implements HelloWorld {            String name = "world";            public void greet() {                greetSomeone("world");            }            public void greetSomeone(String someone) {                name = someone;                System.out.println("Hello " + name);            }        }        HelloWorld englishGreeting = new EnglishGreeting();        HelloWorld frenchGreeting = new HelloWorld() {            String name = "tout le monde";            public void greet() {                greetSomeone("tout le monde");            }            public void greetSomeone(String someone) {                name = someone;                System.out.println("Salut " + name);            }        };        HelloWorld spanishGreeting = new HelloWorld() {            String name = "mundo";            public void greet() {                greetSomeone("mundo");            }            public void greetSomeone(String someone) {                name = someone;                System.out.println("Hola, " + name);            }        };        englishGreeting.greet();        frenchGreeting.greetSomeone("Fred");        spanishGreeting.greet();    }    public static void main(String... args) {        HelloWorldAnonymousClasses myApp =            new HelloWorldAnonymousClasses();        myApp.sayHello();    }
}

HelloWorld frenchGreeting = new HelloWorld() {            String name = "tout le monde";            public void greet() {                greetSomeone("tout le monde");            }            public void greetSomeone(String someone) {                name = someone;                System.out.println("Salut " + name);            }        };

import javafx.event.ActionEvent;import javafx.event.EventHandler;import javafx.scene.Scene;import javafx.scene.control.Button;import javafx.scene.layout.StackPane;import javafx.stage.Stage;public class HelloWorld extends Application {    public static void main(String[] args) {        launch(args);    }    @Override    public void start(Stage primaryStage) {        primaryStage.setTitle("Hello World!");        Button btn = new Button();        btn.setText("Say 'Hello World'");        btn.setOnAction(new EventHandler<ActionEvent>() {            @Override            public void handle(ActionEvent event) {                System.out.println("Hello World!");            }        });        StackPane root = new StackPane();        root.getChildren().add(btn);        primaryStage.setScene(new Scene(root, 300, 250));        primaryStage.show();    }}

import javafx.application.Application;import javafx.event.ActionEvent;import javafx.event.EventHandler;import javafx.geometry.Insets;import javafx.scene.Group;import javafx.scene.Scene;import javafx.scene.control.*;import javafx.scene.layout.GridPane;import javafx.scene.layout.HBox;import javafx.stage.Stage;public class CustomTextFieldSample extends Application {    final static Label label = new Label();    @Override    public void start(Stage stage) {        Group root = new Group();        Scene scene = new Scene(root, 300, 150);        stage.setScene(scene);        stage.setTitle("Text Field Sample");        GridPane grid = new GridPane();        grid.setPadding(new Insets(10, 10, 10, 10));        grid.setVgap(5);        grid.setHgap(5);        scene.setRoot(grid);        final Label dollar = new Label("$");        GridPane.setConstraints(dollar, 0, 0);        grid.getChildren().add(dollar);        final TextField sum = new TextField() {            @Override            public void replaceText(int start, int end, String text) {                if (!text.matches("[a-z, A-Z]")) {                    super.replaceText(start, end, text);
                }                label.setText("Enter a numeric value");            }            @Override            public void replaceSelection(String text) {                if (!text.matches("[a-z, A-Z]")) {                    super.replaceSelection(text);                }            }        };        sum.setPromptText("Enter the total");        sum.setPrefColumnCount(10);        GridPane.setConstraints(sum, 1, 0);        grid.getChildren().add(sum);        Button submit = new Button("Submit");        GridPane.setConstraints(submit, 2, 0);        grid.getChildren().add(submit);        submit.setOnAction(new EventHandler<ActionEvent>() {            @Override            public void handle(ActionEvent e) {                label.setText(null);            }        });        GridPane.setConstraints(label, 0, 1);        GridPane.setColumnSpan(label, 3);        grid.getChildren().add(label);        scene.setRoot(grid);        stage.show();    }    public static void main(String[] args) {        launch(args);    }}

public class Person {    public enum Sex {        MALE, FEMALE
    }    String name;    LocalDate birthday;    Sex gender;    String emailAddress;    public int getAge() {        // ...    }    public void printPerson() {        // ...    }}

public static void printPersonsOlderThan(List<Person> roster, int age) {    for (Person p : roster) {        if (p.getAge() >= age) {            p.printPerson();        }    }}

public static void printPersonsWithinAgeRange(    List<Person> roster, int low, int high) {    for (Person p : roster) {        if (low <= p.getAge() && p.getAge() < high) {            p.printPerson();        }    }}

public static void printPersons(    List<Person> roster, CheckPerson tester) {    for (Person p : roster) {        if (tester.test(p)) {            p.printPerson();        }    }}

interface CheckPerson {    boolean test(Person p);}

class CheckPersonEligibleForSelectiveService implements CheckPerson {    public boolean test(Person p) {        return p.gender == Person.Sex.MALE &&            p.getAge() >= 18 &&            p.getAge() <= 25;    }}

printPersons(    roster, new CheckPersonEligibleForSelectiveService());

printPersons(    roster,    new CheckPerson() {        public boolean test(Person p) {            return p.getGender() == Person.Sex.MALE                && p.getAge() >= 18                && p.getAge() <= 25;        }    });

printPersons(    roster,    (Person p) -> p.getGender() == Person.Sex.MALE        && p.getAge() >= 18        && p.getAge() <= 25);

interface CheckPerson {    boolean test(Person p);}

interface Predicate<T> {    boolean test(T t);}

interface Predicate<Person> {    boolean test(Person t);}

public static void printPersonsWithPredicate(    List<Person> roster, Predicate<Person> tester) {    for (Person p : roster) {        if (tester.test(p)) {            p.printPerson();        }    }}

printPersonsWithPredicate(    roster,    p -> p.getGender() == Person.Sex.MALE        && p.getAge() >= 18        && p.getAge() <= 25);

public static void printPersonsWithPredicate(    List<Person> roster, Predicate<Person> tester) {    for (Person p : roster) {        if (tester.test(p)) {            p.printPerson();        }    }}

public static void processPersons(    List<Person> roster,    Predicate<Person> tester,    Consumer<Person> block) {        for (Person p : roster) {            if (tester.test(p)) {                block.accept(p);            }        }}

processPersons(     roster,     p -> p.getGender() == Person.Sex.MALE         && p.getAge() >= 18         && p.getAge() <= 25,     p -> p.printPerson());

public static void processPersonsWithFunction(    List<Person> roster,    Predicate<Person> tester,    Function<Person, String> mapper,    Consumer<String> block) {    for (Person p : roster) {        if (tester.test(p)) {            String data = mapper.apply(p);            block.accept(data);        }    }}

processPersonsWithFunction(    roster,    p -> p.getGender() == Person.Sex.MALE        && p.getAge() >= 18        && p.getAge() <= 25,    p -> p.getEmailAddress(),    email -> System.out.println(email));

public static <X, Y> void processElements(    Iterable<X> source,    Predicate<X> tester,    Function <X, Y> mapper,    Consumer<Y> block) {    for (X p : source) {        if (tester.test(p)) {            Y data = mapper.apply(p);            block.accept(data);        }    }}

processElements(    roster,    p -> p.getGender() == Person.Sex.MALE        && p.getAge() >= 18        && p.getAge() <= 25,    p -> p.getEmailAddress(),    email -> System.out.println(email));

roster
    .stream()    .filter(        p -> p.getGender() == Person.Sex.MALE            && p.getAge() >= 18            && p.getAge() <= 25)    .map(p -> p.getEmailAddress())    .forEach(email -> System.out.println(email));

btn.setOnAction(new EventHandler<ActionEvent>() {  @Override  public void handle(ActionEvent event) {    System.out.println("Hello World!");  }});

btn.setOnAction(  event -> System.out.println("Hello World!"));

p -> {    return p.getGender() == Person.Sex.MALE        && p.getAge() >= 18        && p.getAge() <= 25;}

email -> System.out.println(email)

public class Calculator {    interface IntegerMath {        int operation(int a, int b);
    }    public int operateBinary(int a, int b, IntegerMath op) {        return op.operation(a, b);    }    public static void main(String... args) {        Calculator myApp = new Calculator();        IntegerMath addition = (a, b) -> a + b;        IntegerMath subtraction = (a, b) -> a - b;        System.out.println("40 + 2 = " +            myApp.operateBinary(40, 2, addition));        System.out.println("20 - 10 = " +            myApp.operateBinary(20, 10, subtraction));
    }}

import java.util.function.Consumer;public class LambdaScopeTest {    public int x = 0;    class FirstLevel {        public int x = 1;        void methodInFirstLevel(int x) {            int z = 2;            Consumer<Integer> myConsumer = (y) ->
            {                // The following statement causes the compiler to generate                // the error "Local variable z defined in an enclosing scope                // must be final or effectively final"                //                // z = 99;                System.out.println("x = " + x);
                System.out.println("y = " + y);                System.out.println("z = " + z);                System.out.println("this.x = " + this.x);                System.out.println("LambdaScopeTest.this.x = " +                    LambdaScopeTest.this.x);            };            myConsumer.accept(x);        }    }    public static void main(String... args) {        LambdaScopeTest st = new LambdaScopeTest();        LambdaScopeTest.FirstLevel fl = st.new FirstLevel();        fl.methodInFirstLevel(23);    }}

Consumer<Integer> myConsumer = (x) -> {    // ...}

Consumer<Integer> myConsumer = (y) -> {    z = 99;    // ...}

p -> p.getGender() == Person.Sex.MALE    && p.getAge() >= 18    && p.getAge() <= 25

public interface Runnable {    void run();}public interface Callable<V> {    V call();}

void invoke(Runnable r) {    r.run();}<T> T invoke(Callable<T> c) {    return c.call();}

String s = invoke(() -> "done");

public class Person {    // ...    LocalDate birthday;    public int getAge() {        // ...    }    public LocalDate getBirthday() {        return birthday;    }
    public static int compareByAge(Person a, Person b) {        return a.birthday.compareTo(b.birthday);    }    // ...}

Person[] rosterAsArray = roster.toArray(new Person[roster.size()]);class PersonAgeComparator implements Comparator<Person> {    public int compare(Person a, Person b) {        return a.getBirthday().compareTo(b.getBirthday());    }}Arrays.sort(rosterAsArray, new PersonAgeComparator());

static <T> void sort(T[] a, Comparator<? super T> c)

Arrays.sort(rosterAsArray,    (Person a, Person b) -> {        return a.getBirthday().compareTo(b.getBirthday());    });

Arrays.sort(rosterAsArray,    (a, b) -> Person.compareByAge(a, b));

import java.util.function.BiFunction;public class MethodReferencesExamples {    public static <T> T mergeThings(T a, T b, BiFunction<T, T, T> merger) {        return merger.apply(a, b);    }    public static String appendStrings(String a, String b) {        return a + b;    }    public String appendStrings2(String a, String b) {        return a + b;    }    public static void main(String[] args) {        MethodReferencesExamples myApp = new MethodReferencesExamples();        // Calling the method mergeThings with a lambda expression        System.out.println(MethodReferencesExamples.            mergeThings("Hello ", "World!", (a, b) -> a + b));        // Reference to a static method        System.out.println(MethodReferencesExamples.            mergeThings("Hello ", "World!", MethodReferencesExamples::appendStrings));        // Reference to an instance method of a particular object        System.out.println(MethodReferencesExamples.            mergeThings("Hello ", "World!", myApp::appendStrings2));        // Reference to an instance method of an arbitrary object of a        // particular type        System.out.println(MethodReferencesExamples.            mergeThings("Hello ", "World!", String::concat));    }}

class ComparisonProvider {    public int compareByName(Person a, Person b) {        return a.getName().compareTo(b.getName());    }    public int compareByAge(Person a, Person b) {        return a.getBirthday().compareTo(b.getBirthday());    }}ComparisonProvider myComparisonProvider = new ComparisonProvider();Arrays.sort(rosterAsArray, myComparisonProvider::compareByName);

String[] stringArray = { "Barbara", "James", "Mary", "John",    "Patricia", "Robert", "Michael", "Linda" };Arrays.sort(stringArray, String::compareToIgnoreCase);

public static <T, SOURCE extends Collection<T>, DEST extends Collection<T>>    DEST transferElements(        SOURCE sourceCollection,        Supplier<DEST> collectionFactory) {    DEST result = collectionFactory.get();    for (T t : sourceCollection) {        result.add(t);    }    return result;}

Set<Person> rosterSetLambda =    transferElements(roster, () -> { return new HashSet<>(); });

Set<Person> rosterSet = transferElements(roster, HashSet::new);

Set<Person> rosterSet = transferElements(roster, HashSet<Person>::new);

public enum Day {    SUNDAY, MONDAY, TUESDAY, WEDNESDAY,    THURSDAY, FRIDAY, SATURDAY
}

public class EnumTest {    Day day;    public EnumTest(Day day) {        this.day = day;    }    public void tellItLikeItIs() {        switch (day) {            case MONDAY:                System.out.println("Mondays are bad.");                break;            case FRIDAY:                System.out.println("Fridays are better.");                break;            case SATURDAY: case SUNDAY:                System.out.println("Weekends are best.");                break;            default:                System.out.println("Midweek days are so-so.");                break;        }    }    public static void main(String[] args) {        EnumTest firstDay = new EnumTest(Day.MONDAY);        firstDay.tellItLikeItIs();        EnumTest thirdDay = new EnumTest(Day.WEDNESDAY);        thirdDay.tellItLikeItIs();        EnumTest fifthDay = new EnumTest(Day.FRIDAY);        fifthDay.tellItLikeItIs();        EnumTest sixthDay = new EnumTest(Day.SATURDAY);        sixthDay.tellItLikeItIs();        EnumTest seventhDay = new EnumTest(Day.SUNDAY);        seventhDay.tellItLikeItIs();    }}

for (Planet p : Planet.values()) {    System.out.printf("Your weight on %s is %f%n",                      p, p.surfaceWeight(mass));}

public enum Planet {    MERCURY (3.303e+23, 2.4397e6),    VENUS   (4.869e+24, 6.0518e6),    EARTH   (5.976e+24, 6.37814e6),    MARS    (6.421e+23, 3.3972e6),    JUPITER (1.9e+27,   7.1492e7),    SATURN  (5.688e+26, 6.0268e7),    URANUS  (8.686e+25, 2.5559e7),    NEPTUNE (1.024e+26, 2.4746e7);    private final double mass;   // in kilograms    private final double radius; // in meters    Planet(double mass, double radius) {        this.mass = mass;        this.radius = radius;    }    private double mass() { return mass; }    private double radius() { return radius; }    // universal gravitational constant  (m3 kg-1 s-2)    public static final double G = 6.67300E-11;    double surfaceGravity() {        return G * mass / (radius * radius);    }    double surfaceWeight(double otherMass) {        return otherMass * surfaceGravity();    }    public static void main(String[] args) {        if (args.length != 1) {            System.err.println("Usage: java Planet <earth_weight>");            System.exit(-1);        }        double earthWeight = Double.parseDouble(args[0]);        double mass = earthWeight/EARTH.surfaceGravity();        for (Planet p : Planet.values())           System.out.printf("Your weight on %s is %f%n",                             p, p.surfaceWeight(mass));    }}