Значения целочисленных типов находятся в следующих диапазонах:

Язык программирования Java предоставляет ряд операторов, которые действуют над целочисленными значениями:

Другие полезные конструкторы, методы и константы определены в классах Byte, Short, Integer, Long и Character.

Если оператор целых чисел, кроме оператора сдвига, имеет хотя бы один операнд типа long, то операция выполняется с точностью 64 бита, и результат числового оператора имеет тип long. Если другой операнд не long, он сначала расширяется (§5.1.5) до типа long с помощью числового повышения (§5.6).

В противном случае операция выполняется с точностью 32 бита, и результат числового оператора имеет тип int. Если ни один из операндов не является int, он сначала расширяется до типа int с помощью числового повышения.

Любое значение любого целочисленного типа может быть приведено к любому числовому типу или из него. Нет приведений между целочисленными типами и типом boolean.

См. §4.2.5 для образца преобразования целочисленных выражений в boolean.

Операторы целых чисел никак не указывают переполнение или недополнение.

Оператор целых чисел может выбросить исключение (§11 (Исключения)) по следующим причинам:

class Test {
    public static void main(String[] args) {
        int i = 1000000;
        System.out.println(i * i);
        long l = i;
        System.out.println(l * l);
        System.out.println(20296 / (l - i));
    }
}

-727379968
1000000000000

Язык программирования Java предоставляет ряд операторов, действующих над значениями с плавающей точкой:

Другие полезные конструкторы, методы и константы определены в классах Float, Double и Math.

Если хотя бы один из операндов бинарного оператора имеет тип с плавающей точкой, то операция является операцией с плавающей точкой, даже если другой — целочисленный.

Если хотя бы один из операндов числового оператора имеет тип double, то операция выполняется с использованием 64-битной арифметики с плавающей точкой, и результат числового оператора является значением типа double. Если другой операнд не является double, он сначала расширяется (§5.1.5) до типа double с помощью числового продвижения (§5.6).

В противном случае операция выполняется с использованием 32-битной арифметики с плавающей точкой, и результат числового оператора является значением типа float. (Если другой операнд не является float, он сначала расширяется до типа float с помощью числового продвижения.)

Любое значение типа с плавающей точкой может быть приведено к любому числовому типу или из него. Преобразования между типами с плавающей точкой и типом boolean отсутствуют.

См. §4.2.5 для примера преобразования выражений с плавающей точкой в boolean.

Операторы над числами с плавающей точкой ведут себя так, как указано в стандарте IEEE 754 (за исключением оператора остатка (§15.17.3)). В частности, язык программирования Java требует поддержки стандарта IEEE 754 денормализованных чисел с плавающей точкой и постепенного уменьшения, что облегчает доказательство желаемых свойств определенных численных алгоритмов. Операции с плавающей точкой не «сбрасывают к нулю» результат, если полученное значение является денормализованным числом.

Язык программирования Java требует, чтобы арифметика с плавающей точкой вела себя так, как будто каждый оператор с плавающей точкой округлял свой результат до точности результата. Неточные результаты должны быть округлены до ближайшего представимого значения к бесконечно точному результату; если два ближайших представимых значения одинаково близки, выбирается то, у которого младший бит равен нулю. Это стандартный режим округления IEEE 754, известный как округление до ближайшего.

Язык программирования Java использует округление к нулю при преобразовании значения с плавающей точкой в целое число (§5.1.3), который в этом случае действует так, как если бы число было усечено, отбрасывая биты мантиссы. Округление к нулю выбирает в качестве результата значение формата, наиболее близкое к бесконечно точному результату и не большее по величине.

Операция с плавающей точкой, которая переполняется, даёт результат бесконечности соответствующего знака.

Операция с плавающей точкой, которая недополняется, даёт денормализованное значение или нуль соответствующего знака.

Операция с плавающей точкой, у которой нет математически определенного результата, даёт NaN.

Все числовые операции с NaN в качестве операнда дают NaN в качестве результата.

Оператор с плавающей точкой может выбросить исключение (§11 (Исключения)) по следующим причинам:

class Test {
    public static void main(String[] args) {
        // An example of overflow:
        double d = 1e308;
        System.out.print("overflow produces infinity: ");
        System.out.println(d + "*10==" + d*10);
        // An example of gradual underflow:
        d = 1e-305 * Math.PI;
        System.out.print("gradual underflow: " + d + "\n   ");
        for (int i = 0; i < 4; i++)
            System.out.print(" " + (d /= 100000));
        System.out.println();
        // An example of NaN:
        System.out.print("0.0/0.0 is Not-a-Number: ");
        d = 0.0/0.0;
        System.out.println(d);
        // An example of inexact results and rounding:
        System.out.print("inexact results with float:");
        for (int i = 0; i < 100; i++) {
            float z = 1.0f / i;
            if (z * i != 1.0f)
                System.out.print(" " + i);
        }
        System.out.println();
        // Another example of inexact results and rounding:
        System.out.print("inexact results with double:");
        for (int i = 0; i < 100; i++) {
            double z = 1.0 / i;
            if (z * i != 1.0)
                System.out.print(" " + i);
        }
        System.out.println();
        // An example of cast to integer rounding:
        System.out.print("cast to int rounds toward 0: ");
        d = 12345.6;
        System.out.println((int)d + " " + (int)(-d));
    }
}

overflow produces infinity: 1.0E308*10==Infinity
gradual underflow: 3.141592653589793E-305
    3.1415926535898E-310 3.141592653E-315 3.142E-320 0.0
0.0/0.0 is Not-a-Number: NaN
inexact results with float: 0 41 47 55 61 82 83 94 97
inexact results with double: 0 49 98
cast to int rounds toward 0: 12345 -12345

Тип boolean представляет логическую величину с двумя возможными значениями, обозначаемыми литералами true и false (§3.10.3).

Операторы для boolean:

Булевы выражения определяют поток управления в нескольких типах операторов:

Выражение boolean также определяет, какое подвыражение вычисляется в условном ? : операторе (§15.25).

Только boolean и Boolean выражения могут быть использованы в операторах управления потоком и в качестве первого операнда условного оператора ? :.

Целочисленное или дробное выражение x может быть преобразовано в значение boolean, следуя соглашению языка C, где любое ненулевое значение является true, при помощи выражения x!=0.

Ссылка на объект obj может быть преобразована в значение boolean, следуя соглашению языка C, где любая ссылка, отличная от null, является true, при помощи выражения obj!=null.

Значение boolean может быть преобразовано в String путём преобразования в строку (§5.4).

Значение boolean может быть приведено к типу boolean, Boolean или Object (§5.5). Другие приведения к типу boolean не допускаются.

Объект — это экземпляр класса или массив.

Значения ссылок (часто просто ссылки) — это указатели на эти объекты, и специальная ссылка null, которая не ссылается на какой-либо объект.

Экземпляр класса явно создаётся выражением создания экземпляра класса (§15.9).

Массив явно создаётся выражением создания массива (§15.10.1).

Другие выражения могут неявно создавать экземпляр класса (§12.5) или массив (§10.6).

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 constructor: */
        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]);
    }
}

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

Операции над ссылками на объекты:

Может быть множество ссылок на один и тот же объект. Большинство объектов имеют состояние, хранящееся в полях объектов, которые являются экземплярами классов, или в переменных, которые являются компонентами объекта массива. Если две переменные содержат ссылки на один и тот же объект, состояние объекта может быть изменено с помощью ссылки одной переменной на объект, а затем изменённое состояние может быть наблюдаемо через ссылку в другой переменной.

class Value { int val; }

class Test {
    public static void main(String[] args) {
        int i1 = 3;
        int i2 = i1;
        i2 = 4;
        System.out.print("i1==" + i1);
        System.out.println(" but i2==" + i2);
        Value v1 = new Value();
        v1.val = 5;
        Value v2 = v1;
        v2.val = 6;
        System.out.print("v1.val==" + v1.val);
        System.out.println(" and v2.val==" + v2.val);
    }
}

i1==3 but i2==4
v1.val==6 and v2.val==6

Каждый объект связан с монитором (§17.1), который используется методами synchronized (§8.4.3) и оператором synchronized (§14.19) для управления одновременным доступом к состоянию несколькими потоками (§17 (Потоки и блокировки)).

Класс Object является суперклассом (§8.1.4) всех остальных классов.

Все типы классов и массивов наследуют (§8.4.8) методы класса Object, которые обобщаются следующим образом:

Экземпляры класса String представляют собой последовательности точек кода Юникода.

Объект String имеет постоянное (не изменяемое) значение.

Строковые литералы (§3.10.5) являются ссылками на экземпляры класса String.

Оператор конкатенации строк + (§15.18.1) неявно создаёт новый объект String, когда результат не является константным выражением (§15.28).

Два типа ссылок являются одним типом на этапе компиляции, если они объявлены в модулях компиляции, связанных с одним и тем же модулем (§7.3), имеют одинаковое бинарное имя (§13.1), и их аргументы типа, если таковые имеются, идентичны, применяя это определение рекурсивно.

Когда два типа ссылок совпадают, их иногда называют одним классом или одним интерфейсом.

Во время выполнения несколько типов ссылок с одинаковым бинарным именем могут быть загружены одновременно различными загрузчиками классов. Эти типы могут или не могут представлять один и тот же тип объявления. Даже если два таких типа представляют одно и то же объявление типа, они считаются отличными.

Два типа ссылок являются одним типом на этапе выполнения, если:

Аргументы типа могут быть либо типами ссылок, либо джойлд-символами. Джойлд-символы полезны в ситуациях, когда требуется лишь частичное знание о параметре типа.

Джойлд-символам можно задать явные границы, подобно обычным объявлениям переменных типа. Верхняя граница обозначается следующим синтаксисом, где B — граница:

? extends B

В отличие от обычных переменных типа, объявленных в сигнатуре метода, при использовании джойлд-символа не требуется вывод типа. Поэтому разрешается объявлять нижние границы джойлд-символа, используя следующий синтаксис, где B — нижняя граница:

? super B

Джойлд-символ ? extends Object эквивалентен неограниченному джойлд-символу ?.

Два аргумента типа доказательно различны, если выполняется одно из следующих условий:

Говорят, что аргумент типа T₁ содержит другой аргумент типа T₂, записываемое как T₂ <= T₁, если множество типов, обозначаемое T₂, является доказательно подмножеством множества типов, обозначаемых T₁, в соответствии с рефлексивным и транзитивным замыканием следующих правил (где <: обозначает подтипизацию (§4.10)):

Связь джойлд-символов с установленной теорией типов интересная, что мы кратко упомянули здесь. Джойлд-символы — это ограниченная форма экзистенциальных типов. Учитывая общее объявление типа G<T extends B>, G<?> примерно соответствует Some X <: B. G<X>.

Исторически джойлд-символы являются прямым потомком работ Ацуси Игараси и Мирко Вироли. Читатели, заинтересованные в более подробном обсуждении, должны обратиться к работе «On Variance-Based Subtyping for Parametric Types» Ацуси Игараси и Мирко Вироли в «Proceedings of the 16th European Conference on Object Oriented Programming (ECOOP 2002)». Эта работа сама по себе основана на более ранних работах Крстен Торупа и Мадса Торгерсена («Unifying Genericity», ECOOP 99), а также на длительной традиции работ по вариации, основанной на объявлении, которая восходит к работе Пьера Америки над POOL (OOPSLA 89).

Джойлд-символы отличаются в некоторых деталях от конструкций, описанных в упомянутой статье, в частности, в использовании преобразования захвата (§5.1.10) вместо операции close, описанной Игараси и Вироли. Для формального описания джойлд-символов см. «Wild FJ» Мадса Торгерсена, Эрика Эрнста и Кристиана Плеснера Хансена в 12-м семинаре по основам объектно-ориентированного программирования (FOOL 2005).

import java.util.Collection;
import java.util.ArrayList;

class Test {
    static void printCollection(Collection<?> c) {
                                // a wildcard collection
        for (Object o : c) {
            System.out.println(o);
        }
    }

    public static void main(String[] args) {
        Collection<String> cs = new ArrayList<String>();
        cs.add("hello");
        cs.add("world");
        printCollection(cs);
    }
}

public Method getMethod(Class<?>[] parameterTypes) { ... }

boolean addAll(Collection<? extends E> c)

<T> boolean addAll(Collection<T> c)

Reference(T referent, ReferenceQueue<? super T> queue)

Пусть C — это объявление обобщённого класса или интерфейса с параметрами типа A₁,...,A_n, и пусть C<T₁,...,T_n> — это параметризация C, где для 1 ≤ i ≤ n, T_i — это тип (а не подстановочный знак). Тогда:

Если какие-либо аргументы типа в параметризации C являются подстановочными знаками, то:

Это не имеет значения, так как невозможно получить доступ к члену параметризованного типа без выполнения преобразования захвата, и невозможно использовать подстановочный знак после ключевого слова new в выражении создания экземпляра класса (§15.9).

Единственное исключение из предыдущего абзаца — это когда вложенный параметризованный тип используется в качестве выражения в операторе instanceof (§15.20.2), где преобразование захвата не применяется.

Член static, объявленный в обобщённом объявлении типа, должен быть указан с использованием необобщённого типа, который соответствует обобщённому типу (§6.1, §6.5.5.2, §6.5.6.2), иначе произойдёт ошибка компиляции.

Другими словами, недопустимо ссылаться на член static, объявленный в обобщённом объявлении типа, используя параметризованный тип.

Следующие правила определяют отношение прямого надтипа между примитивными типами:

Учитывая объявление не обобщенного типа C, прямыми супертипами типа C являются все следующие:

Учитывая объявление обобщенного типа C<F₁,...,F_n> (n > 0), прямыми супертипами необработанного типа C (§4.8) являются все следующие:

Учитывая объявление обобщенного типа C<F₁,...,F_n> (n > 0), прямыми супертипами обобщенного типа C<F₁,...,F_n> являются все следующие:

Учитывая объявление обобщенного типа C<F₁,...,F_n> (n > 0), прямыми супертипами параметризованного типа C<T₁,...,T_n>, где T_i (1 ≤ i ≤ n) - это тип, являются все следующие:

Учитывая объявление обобщенного типа C<F₁,...,F_n> (n > 0), прямыми супертипами параметризованного типа C<R₁,...,R_n> где по крайней мере один из R_i (1 ≤ i ≤ n) является аргументом типа wildcard, являются прямыми супертипами параметризованного типа C<X₁,...,X_n>, который является результатом применения преобразования захвата к C<R₁,...,R_n> (§5.1.10).

Прямыми супертипами типа пересечения T₁ & ... & T_n являются T_i (1 ≤ i ≤ n).

Прямыми супертипами переменной типа являются типы, перечисленные в ее границе.

Переменная типа является прямым супертипом своей нижней границы.

Прямыми супертипами нулевого типа являются все ссылочные типы, кроме самого нулевого типа.

Следующие правила определяют отношение прямого супертипа среди типов массивов:

Синтетическая переменная типа — это переменная типа, введенная компилятором во время преобразования захвата (§5.1.10) или разрешения переменной вывода (§18.4).

Иногда необходимо найти близкий супертип типа, где этот супертип не упоминает определенные синтетические переменные типа. Это достигается с помощью восходящей проекции, применяемой к типу.

Аналогично, нисходящая проекция может быть применена для нахождения близкого подтипа типа, где этот подтип не упоминает определенные синтетические переменные типа. Поскольку такой тип не всегда существует, нисходящая проекция является частичной функцией.

Эти операции принимают в качестве входных данных набор переменных типа, на которые больше не следует ссылаться, называемых ограниченными переменными типа. Когда операции повторяются, набор ограниченных переменных типа неявно передается в рекурсивное приложение.

Восходящая проекция типа T относительно набора ограниченных переменных типа определяется следующим образом:

Нисходящая проекция типа T относительно набора ограниченных переменных типа является частичной функцией, определяемой следующим образом:

Как и lub (§4.10.4), восходящая и нисходящая проекция могут создавать бесконечные типы из-за рекурсии по границам переменных типа.

Переменная примитивного типа всегда содержит примитивное значение этого же примитивного типа.

Переменная типа класса T может содержать нулевую ссылку или ссылку на экземпляр класса T или любого класса, являющегося подклассом T.

Переменная типа интерфейса может содержать нулевую ссылку или ссылку на любой экземпляр любого класса, реализующего интерфейс.

Обратите внимание, что переменная не гарантирует, что всегда будет ссылаться на подтип своего объявленного типа, а только на подклассы или подинтерфейсы объявленного типа. Это обусловлено возможностью загрязнения кучи, обсуждаемой ниже.

Если T — примитивный тип, то переменная типа "массив T" может содержать нулевую ссылку или ссылку на любой массив типа "массив T".

Если T — ссылочный тип, то переменная типа "массив T" может содержать нулевую ссылку или ссылку на любой массив типа "массив S", где тип S является подклассом или подинтерфейсом типа T.

Переменная типа Object[] может содержать ссылку на массив любого ссылочного типа.

Переменная типа Object может содержать нулевую ссылку или ссылку на любой объект, является ли он экземпляром класса или массивом.

Возможно, что переменная параметризованного типа будет ссылаться на объект, который не является объектом этого параметризованного типа. Эта ситуация известна как загрязнение кучи.

Загрязнение кучи может произойти только в том случае, если программа выполнила некоторую операцию, связанную с сырым типом, которая привела бы к предупреждению о не проверенных во время компиляции (§4.8, §5.1.6, §5.1.9, §8.4.1, §8.4.8.3, §8.4.8.4, §9.4.1.2, §15.12.4.2), или если программа алиасирует переменную массива с нереализуемым типом элемента через переменную массива супертипа, которая является либо сырой, либо не генерической.

List l = new ArrayList<Number>();
List<String> ls = l;  // Unchecked warning

static void m(List<String>... stringLists) {
    Object[] array = stringLists;
    List<Integer> tmpList = Arrays.asList(42);
    array[0] = tmpList;                // (1)
    String s = stringLists[0].get(0);  // (2)
}

Переменная всегда будет ссылаться на объект, который является экземпляром класса, представляющего параметризованный тип.

Значение ls в приведённом выше примере всегда является экземпляром класса, который предоставляет представление List.

Присваивание из выражения сырого типа переменной параметризованного типа следует использовать только при объединении устаревшего кода, не использующего параметризованные типы, с более современным кодом, который их использует.

Если никакая операция, требующая выдачи предупреждения о не проверенных во время компиляции, не происходит, и не происходит небезопасного алиасирования переменных массивов с нереализуемыми типами элементов, то загрязнения кучи не происходит. Следует отметить, что это не означает, что загрязнение кучи происходит только в том случае, если фактически возникло предупреждение о не проверенных во время компиляции. Возможна работа программы, где некоторые двоичные файлы были сгенерированы компилятором более старой версии языка программирования Java или из источников, которые явно подавили предупреждения о не проверенных типах. Такая практика в лучшем случае неуздоровительна.

Напротив, возможно, что, несмотря на выполнение кода, который мог (и, возможно, делал) вызвать предупреждение о не проверенных во время компиляции, загрязнения кучи не происходит. Действительно, хороший стиль программирования требует, чтобы программист убедилась, что, несмотря на любые предупреждения, код правильный и загрязнения кучи не произойдёт.

Существует восемь видов переменных:

class Point {
    static int numPoints;   // numPoints is a class variable
    int x, y;               // x and y are instance variables
    int[] w = new int[10];  // w[0] is an array component
    int setX(int x) {       // x is a method parameter
        int oldx = this.x;  // oldx is a local variable
        this.x = x;
        return oldx;
    }
}

Переменная может быть объявлена final. Переменная final может быть присвоена только один раз. Это ошибка времени компиляции, если переменной final присваивается значение, если только она не является явно неинициализированной непосредственно перед присвоением (§16 (Определённое присвоение)).

После присвоения значению переменной final она всегда содержит одно и то же значение. Если переменная final ссылается на объект, то состояние объекта может быть изменено операциями над объектом, но переменная всегда будет ссылаться на тот же объект. Это также относится к массивам, поскольку массивы являются объектами; если переменная final ссылается на массив, то компоненты массива могут быть изменены операциями над массивом, но переменная всегда будет ссылаться на тот же массив.

Пустая переменная — это переменная final, объявление которой не содержит инициализатора.

Константная переменная — это переменная final примитивного типа или типа final, которая инициализируется константным выражением (§15.28). Является ли переменная константной или нет, может повлиять на инициализацию класса (§12.4.1), бинарную совместимость (§13.1), достижимость (§14.21) и определённое присвоение (§16.1.1).

Три вида переменных неявно объявляются final: поле интерфейса (§9.3), локальная переменная, объявленная как ресурс оператора try-with-resources (§14.20.3), и параметр исключения в операторе многократной обработки исключений (§14.20). Параметр исключения в операторе обработки одного исключения никогда не объявляется неявно final, но может быть эффективно final.

class Point {
    int x, y;
    int useCount;
    Point(int x, int y) { this.x = x; this.y = y; }
    static final Point origin = new Point(0, 0);
}

Некоторые переменные, которые не объявлены final, считаются эффективно final:

Если переменная является эффективно final, добавление модификатора final к её объявлению не создаст ошибок компиляции. Обратно, локальная переменная или параметр, объявленная final в корректной программе, становится эффективно final, если модификатор final удалён.

Каждая переменная в программе должна иметь значение до того, как её значение будет использовано:

class Point {
    static int npoints;
    int x, y;
    Point root;
}

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

npoints=0
p.x=0, p.y=0
p.root=null

В языке программирования Java каждая переменная и каждое выражение имеют тип, который можно определить во время компиляции. Тип может быть примитивным типом или ссылочным типом. Ссылочные типы включают типы классов и типы интерфейсов. Ссылочные типы вводятся с помощью объявлений типов, которые включают объявления классов (§8.1) и объявления интерфейсов (§9.1). Мы часто используем термин тип для обозначения класса или интерфейса.

В виртуальной машине Java каждый объект принадлежит какому-то определённому классу: классу, который был упомянут в выражении создания, которое произвело объект (§15.9), или классу, чей Class объект был использован для вызова рефлексивного метода для создания объекта, или классу String для объектов, неявно созданных оператором конкатенации строк + (§15.18.1). Этот класс называется классом объекта. Говорят, что объект является экземпляром своего класса и всех его суперклассов.

Каждый массив также имеет класс. Метод getClass, когда вызывается для объекта массива, вернёт объект класса Class, который представляет класс массива (§10.8).

Тип переменной во время компиляции всегда объявляется, а тип выражения во время компиляции может быть выведен во время компиляции. Тип переменной во время компиляции ограничивает возможные значения, которые может содержать переменная во время выполнения, или выражение может произвести во время выполнения. Если значение во время выполнения является ссылкой, которая не является null, оно ссылается на объект или массив, у которого есть класс, и этот класс обязательно будет совместим с типом во время компиляции.

Даже если переменная или выражение может иметь тип во время компиляции, который является типом интерфейса, экземпляров интерфейсов не существует. Переменная или выражение, тип которого является типом интерфейса, может ссылаться на любой объект, чья класс реализует (§8.1.5) этот интерфейс.

Иногда говорят, что переменная или выражение имеет "тип во время выполнения". Это относится к классу объекта, на который ссылается значение переменной или выражения во время выполнения, при условии, что это значение не null.

Соответствие между типами во время компиляции и типами во время выполнения неполно по двум причинам:

interface Colorable {
    void setColor(byte r, byte g, byte b);
}

class Point { int x, y; }

class ColoredPoint extends Point implements Colorable {
    byte r, g, b;
    public void setColor(byte rv, byte gv, byte bv) {
        r = rv; g = gv; b = bv;
    }
}

class Test {
    public static void main(String[] args) {
        Point p = new Point();
        ColoredPoint cp = new ColoredPoint();
        p = cp;
        Colorable c = cp;
    }
}