Java SE Specifications

https://docs.oracle.com/javase/specs
Admin
Java SE Specifications provides the official language and virtual machine specifications for Java...
Tokens:1,366,606
Snippets:6,878
Trust Score:9.7
Update:1 day ago
Show doc for...
Tokens:
Raw
### Incorrect Overriding because of throws - BadPointException and Point (Example 8.4.8.3-3)

Source: https://docs.oracle.com/javase/specs/jls/se27/html/jls-8.html

Declaration of BadPointException and class Point with move(int, int). This is the setup for the incorrect overriding example.

```java
class BadPointException extends Exception {
    BadPointException() { super(); }
    BadPointException(String s) { super(s); }
}
class Point {
    int x, y;
    void move(int dx, int dy) { x += dx; y += dy; }
}
```

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

### Binary Numeric Promotion Example (Example 5.6-2)

Source: https://docs.oracle.com/javase/specs/jls/se27/html/jls-5.html

Demonstrates binary numeric promotion in arithmetic, comparison, bitwise, and conditional expressions. The program outputs the results of these promotions.

```java
class Test {
    public static void main(String[] args) {
        int i    = 0;
        float f  = 1.0f;
        double d = 2.0;
        // First int*float is promoted to float*float, then
        // float==double is promoted to double==double:
        if (i * f == d) System.out.println("oops");

        // A char&byte is promoted to int&int:
        byte b = 0x1f;
        char c = 'G';
        int control = c & b;
        System.out.println(Integer.toHexString(control));

        // Here int:float is promoted to float:float:
        f = (b==0) ? i : 4.0f;
        System.out.println(1.0/f);
    }
}
```

```text
7
0.25
```

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

### TypeName.super method invocation example

Source: https://docs.oracle.com/javase/specs/jls/se27/html/jls-15.html

Shows how to use TypeName.super to invoke a superclass method from an anonymous inner class, bypassing the overriding method in the subclass. The example defines Superclass with foo(), Subclass1 overriding foo() to throw, and an anonymous Runnable that calls Subclass1.super.foo() to get the println behavior.

```java
class Superclass {
    void foo() { System.out.println("Hi"); }
}

class Subclass1 extends Superclass {
    public void foo() { throw new UnsupportedOperationException(); }

    Runnable tweak = new Runnable() {
        public void run() {
            Subclass1.super.foo();  // Gets the 'println' behavior
        }
    };
}
```

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

### Object Creation Example (Point and Test classes)

Source: https://docs.oracle.com/javase/specs/jls/se27/html/jls-4.html

This example shows explicit and implicit creation of class instances and arrays. It includes a Point class with constructors and a Test class that uses newInstance, array initializers, and array creation expressions. The program output is also shown.

```java
class Point {
    int x, y;
    Point() { System.out.println("default"); }
    Point(int x, int y) { this.x = x; this.y = y; }

    /* A Point instance is explicitly created at
       class initialization time: */
    static Point origin = new Point(0,0);

    /* A String can be implicitly created
       by a + operator: */
    public String toString() { return "(" + x + "," + y + ")"; }
}

class Test {
    public static void main(String[] args) {
        /* A Point is explicitly created
           using newInstance: */
        Point p = null;
        try {
            p = (Point)Class.forName("Point").newInstance();
        } catch (Exception e) {
            System.out.println(e);
        }

        /* An array is implicitly created
           by an array initializer: */
        Point[] a = { new Point(0,0), new Point(1,1) };

        /* Strings are implicitly created
           by + operators: */
        System.out.println("p: " + p);
        System.out.println("a: { " + a[0] + ", " + a[1] + " }");

        /* An array is explicitly created
           by an array creation expression: */
        String[] sa = new String[2];
        sa[0] = "he"; sa[1] = "llo";
        System.out.println(sa[0] + sa[1]);
    }
}
```

```text
default
p: (0,0)
a: { (0,0), (1,1) }
hello
```

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

### synchronized Methods: Box class for concurrent use

Source: https://docs.oracle.com/javase/specs/jls/se27/html/jls-8.html

Example 8.4.3.6-2 defines a Box class with synchronized get and put methods. It is designed for concurrent use; put returns false if the box is already full, and get returns null if the box is empty. Without synchronization, concurrent invocations could misbehave, e.g., lose track of an object.

```java
public class Box {
    private Object boxContents;
    public synchronized Object get() {
        Object contents = boxContents;
        boxContents = null;
        return contents;
    }
    public synchronized boolean put(Object contents) {
        if (boxContents != null) return false;
        boxContents = contents;
        return true;
    }
}
```

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

### Field Initialization Example (Point and Test classes)

Source: https://docs.oracle.com/javase/specs/jls/se27/html/jls-8.html

Shows a class Point with fields x and y initialized to 1 and 5, and a Test class that creates a Point and prints its fields. The output is '1, 5' because assignments occur each time a new Point is created.

```java
class Point {
    int x = 1, y = 5;
}
class Test {
    public static void main(String[] args) {
        Point p = new Point();
        System.out.println(p.x + ", " + p.y);
    }
}
```

```text
1, 5
```

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

### Transitive overriding example: class declarations in package P

Source: https://docs.oracle.com/javase/specs/jvms/se27/html/jvms-5.html

Three class declarations in package P showing a default-access method m() in A, a public override in B, and a default-access override in C. This setup demonstrates how C.m can override B.m and A.m.

```java
public class A           {        void m() {} }
public class B extends A { public void m() {} }
public class C extends B {        void m() {} }
```

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

### Bytecode: example() and silly() compiled to JVM instructions

Source: https://docs.oracle.com/javase/specs/jvms/se27/html/jvms-3.html

JVM bytecode for the example() and silly() methods, showing new, dup, invokespecial, astore, aload, invokevirtual, areturn, ifnull, and other instructions. Comments indicate the class and method references.

```bytecode
Method MyObj example()
0   new #2              // Class MyObj
3   dup
4   invokespecial #5    // Method MyObj.<init>()V
7   astore_1
8   aload_0
9   aload_1
10  invokevirtual #4    // Method Example.silly(LMyObj;)LMyObj;
13  areturn

Method MyObj silly(MyObj)
0   aload_1
1   ifnull 6
4   aload_1
5   areturn
6   aload_1
7   areturn
```

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

### Unary Numeric Promotion Example (Example 5.6-1)

Source: https://docs.oracle.com/javase/specs/jls/se27/html/jls-5.html

Demonstrates unary numeric promotion in dimension expressions, index expressions, unary minus, bitwise complement, and shift operations. The program outputs the results of these promotions.

```java
class Test {
    public static void main(String[] args) {
        byte  b = 2;
        int[] a = new int[b];  // dimension expression promotion
        char  c = '\u0001';
        a[c] = 1;              // index expression promotion
        a[0] = -c;             // unary - promotion
        System.out.println("a: " + a[0] + "," + a[1]);
        b = -1;
        int i = ~b;            // bitwise complement promotion
        System.out.println("~0x" + Integer.toHexString(b)
                           + "==0x" + Integer.toHexString(i));
        i = b << 4L;           // shift promotion (left operand)
        System.out.println("0x" + Integer.toHexString(b)
                           + "<<4L==0x" + Integer.toHexString(i));
    }
}
```

```text
a: -1,1
~0xffffffff==0x0
0xffffffff<<4L==0xfffffff0
```

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

### Abstract/Abstract Method Overriding (Example 8.4.3.1-1)

Source: https://docs.oracle.com/javase/specs/jls/se27/html/jls-8.html

Shows an abstract method 'get' in interface Buffer being overridden by an abstract method in abstract class InfiniteBuffer, narrowing the throws clause to only BufferError. The overriding declaration states that subclasses never throw BufferEmpty.

```java
class BufferEmpty extends Exception {
    BufferEmpty() { super(); }
    BufferEmpty(String s) { super(s); }
}
class BufferError extends Exception {
    BufferError() { super(); }
    BufferError(String s) { super(s); }
}
interface Buffer {
    char get() throws BufferEmpty, BufferError;
}
abstract class InfiniteBuffer implements Buffer {
    public abstract char get() throws BufferError;
}
```

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

### Invoking a superinterface default method with Superinterface.super.foo()

Source: https://docs.oracle.com/javase/specs/jls/se27/html/jls-15.html

Shows how to invoke a default method from a direct superinterface using the qualified super invocation form. The example defines a Superinterface with a default foo() method, a Subclass2 that overrides foo() to throw an exception, and a tweak() method that calls Superinterface.super.foo() to get the default behavior.

```java
interface Superinterface {
    default void foo() { System.out.println("Hi"); }
}

class Subclass2 implements Superinterface {
    public void foo() { throw new UnsupportedOperationException(); }

    void tweak() {
        Superinterface.super.foo();  // Gets the 'println' behavior
    }
}
```

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

### Object Creation Example (Example 4.3.1-1)

Source: https://docs.oracle.com/javase/specs/jls/se27/jls27.pdf

Shows explicit and implicit creation of objects, arrays, and strings. The output demonstrates the default constructor call and string concatenation behavior.

```java
class Point {
int x, y;
Point() { System.out.println("default"); }
Point(int x, int y) { this.x = x; this.y = y; }
/* A Point instance is explicitly created at
class initialization time: */
static Point origin = new Point(0,0);
/* A String can be implicitly created
by a + operator: */
public String toString() { return "(" + x + "," + y + ")"; }
}
class Test {
public static void main(String[] args) {
/* A Point is explicitly created
using newInstance: */
Point p = null;
try {
p = (Point)Class.forName("Point").newInstance();
} catch (Exception e) {
System.out.println(e);
}
/* An array is implicitly created
by an array initializer: */
Point[] a = { new Point(0,0), new Point(1,1) };
/* Strings are implicitly created
by + operators: */
System.out.println("p: " + p);
System.out.println("a: { " + a[0] + ", " + a[1] + " }");
/* An array is explicitly created
by an array creation expression: */
String[] sa = new String[2];
sa[0] = "he"; sa[1] = "llo";
System.out.println(sa[0] + sa[1]);
}
}
```

```text
default
p: (0,0)
a: { (0,0), (1,1) }
hello
```
Tokens:
Raw