Java
Общие вопросы

Ошибки начинающих java-программистов

Опубликовано: 31 окт 05
Рейтинг:

Автор: А.Грасоff™
Прислал: А.Грасоff™


Эта статья создана из топика ошибки начинающих java-программистов.
Оригинал статьи здесь: http://users.erols.com/ziring/java-npm.html
Перевод: Deady


1. Имя класса отличается от имени файла, в котором он хранится.

Все используемые мною среды java, включая Javasoft JDKs, предполагают,
что исходный код класса с модификатором public хранится в файле с точно
таким же именем, как и имя класса, и расширением .java. Несоблюдение этого
соглашения может стать причиной многих проблем, которые выявятся во время
компиляции.

Начинающие студенты (программисты) часто забывают об этом соглашении,
и, например, задают имя файла в соответствии с заданием: Lab6.java.

Ошибочный пример: Имя файла Lab6.java -
public class Airplane extends Vehicle
  Seat pilot;
  public Airplane() { 
    pilot = new Seat(); 
  }
}

Исправленный пример: Имя файла Airplane.java -
public class Airplane extends Vehicle
  Seat pilot;
  public Airplane() { 
    pilot = new Seat(); 
  }
}

Заметьте: предполагается, что имя класса начинается с заглавной буквы. В
операционных системах, которые учитывают регистр символов в именах файлов,
могут появиться дополнительные проблемы, особенно у студентов, изучающих
Java под Unix, и привыкших к системе именования файлов в DOS. Класс
MotorVehicle должен храниться в файле MotorVehicle.java, но не в файле
motorvehicle.java.


2. Сравнение с помощью ==

В Java строки - это объекты класса java.lang.String. Оператор ==, применяемый
к объектам, проверяет на равенство ссылки на объекты! Иногда студенты не
понимают семантики оператора == и пытаются применить его для сравнения
строк.

Ошибочный пример:
// проверим, равен ли первый аргумент "-a"
if (args[0] == "-a") {
    optionsAll = true;
}

Правильный способ сравнения 2х строк на равенство - это использование метода
equals() класса java.lang.String. Он возвращает true, если строки одинаковой
длины и состоят из одних и тех же символов. (Прим. перев.: вообще-то это не
гарантирует равенство. На самом деле, equals проверяет, равны ли посимвольно
2 строки)

Исправленный пример:
//  проверим, равен ли первый аргумент "-a"
if ("-a".equals(args[0])) {
    optionsAll = true;
}

Эта ошибка - дурацкая, потому что на самом деле Java код получается
синтаксически правильным, а в итоге работает не так как нужно. Некоторые
студенты также пытаются применять операторы сравнения > и <=, вместо метода compareTo() класса java.lang.String. Эту ошибку обнаружить
проще, потому что она вызывает ошибки на этапе компиляции.


3. Забыл проинициализировать объекты, являющиеся элементами массива.

В Java массив объектов - это на самом деле массив ссылок на объекты. Создание
массива - это просто создание набора ссылок, ни на что не указывающих (то
есть равных null). Чтобы на самом деле создать "полноценный" массив
объектов, необходимо проинициализировать каждый элемент массива. Многие
студенты не понимают этого; они считают, что, создавая массив объектов, они
автоматически создают сами объекты. (В большинстве случаев, студенты
приносят эту концепцию из C++, где создание массива объектов приводит к
созданию самих объектов путем вызова их конструктора по умолчанию).

В примере ниже, студент хочет создать 3 объекта класса StringBuffer. Код
будет откомпилирован без ошибок, но в последней строке произойдет
исключение NullPointerException, где происходит обращение к несуществующему
объекту.

Ошибочный пример:
// Создаем массив из StringBuffer
StringBuffer [] myTempBuffers;
myTempBuffers = new StringBuffer[3];
myTempBuffers[0].add(data);

Чтобы не допускать эту ошибку, необходимо не забывать проинициализировать
элементы массива.

Исправленный пример:
// Создаем массив из StringBuffer и инициализируем элементы
StringBuffer [] myTempBuffers;
myTempBuffers = new StringBuffer[3];
for (int ix = 0; ix < myTempBuffers.length; ix++) 
     myTempBuffers[ix] = new StringBuffer();

myTempBuffers[0].add(data);


4. Помещение в один файл сразу нескольких классов с модификатором public

Файлы с исходным java-кодом определенным образом связаны с классами,
содержащимися в этих файлах. Связь можно охарактеризовать так:

  • Любой Java-класс хранится не более чем в одном файле
  • В любой файл с исходным кодом можно поместить не более 1-го класса с
    модификатором public
  • Если в файле с исходным кодом есть класс с модификатором public, имя
    файла и имя класса должны быть строго одинаковыми (прим. перев.: до
    регистра, см. п.1)

    Иногда студенты забывают о 2-ом правиле, что приводит к ошибкам на этапе
    компиляции. Сообщение об ошибке для 2-го и 3-го правила будет одинаковым
    (в чем собственно и заключается трудность распознания этой ошибки).


    5. Подмена поля класса локальной переменной.

    Java позволяет объявлять внутри метода переменные, чье имя совпадает с
    полями класса. В таком случае преимущество будет отдано локальным
    переменным, и они будут использоваться вместо полей.

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

    Ошибочный пример:
    public class Point3 {
        int i = 0;    
        int j = 0;    
        int k = 0;
    
        public boolean hits(Point[] p2list) {
          for(int i = 0; i < p2list.length; i++) {
            Point p2 = p2list[i];
            if (p2.x == i && p2.y == j)
              return true;
          }
          return false;
        }
    }
    

    Есть несколько способов, как исправить эту ошибку. Наиболее простой -
    обращаться к полям класса с помощью неявного указателя this: this.имя_поля.
    Более лучший способ - это переименовать поле класса или локальную
    переменную, тогда подмены не произойдет. (прим. перев.: 2-ой способ - не
    наш метод. К тому же он не гарантирует, что я когда нибудь случайно не
    подменю поле переменной. Еще большая трудность возникнет при
    наследовании, когда я вообще не вижу, какие поля есть у класса)

    Исправленный пример:
      // One way to fix the problem
      int i = 0;    
      int j = 0;    
      int k = 0;
    
      public boolean hits(Point[] p2list) {
        for(int i = 0; i < p2list.length; i++) {
          Point p2 = p2list[i];
          if (p2.x == this.i && p2.y == this.j)
            return true;
        }
        return false;
      }
    
      // *****************************
      // Более лучший способ
      int x = 0;    
      int y = 0;    
      int z = 0;
    
      public boolean hits(Point[] p2list) {
        for(int i = 0; i < p2list.length; i++) {
          Point p2 = p2list[i];
          if (p2.x == x && p2.y == y)
            return true;
        }
        return false;
      }
    

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

    прим. перев.

    немного сумбурно, но смысл такой
    public class Test {
       private int param = 0;
    
       public Test(int param) {
          this.param = param;
       }
    }
    
    то есть в конструкторе все смотрится красиво, но для обычных методов
    применять это не следует.



    6. Забыл вызвать конструктор родителя (суперкласса).

    Когда класс расширяет другой класс, каждый конструктор подкласса должен
    вызвать какой-либо конструктор суперкласса. Обычно это достигается вызовом
    конструктора суперкласса методом super(x), помещенным в первой строке
    конструктора. Если в первой строке конвтруктора нет вызова super(x),
    компилятор самостоятельно вставляет этот вызов, но без параметров: super().
    (прим. перев.: х...се, а я и не знал )

    Иногда студенты забывают об этом требовании. Обычно это не является
    проблемой: вызов конструктора суперкласса вставляется компилятором и все
    работает отлично. Однако если у суперкласса нет конструктора по умолчанию
    (прим. перев.: то есть конструктора без параметров), то компилятор выдаст
    ошибку. В примере ниже все конструкторы суперкласса java.io.File имеют
    1 или 2 параметра:

    Ошибочный пример:
    public class JavaClassFile extends File {
        String classname;
        public JavaClassFile(String cl) {
            classname = cl;
        }
    }
    

    Решением проблемы является вставка явного вызова правильного
    конструктора суперкласса:

    Исправленный пример:
    public class JavaClassFile extends File {
        String classname;
        public JavaClassFile(String cl) {
            super(cl + ".class");
            classname = cl;
        }
    }
    

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


    7. Неправильный перехват исключений

    Система обработки исключений в Java достаточно мощная, но трудная для
    понимания новичками. Студенты, хорошо владеющие C++ или Ada, обычно не
    испытывают сложностей, в отличие от программистов C и Fortran. Примеры ниже
    показывают некоторые распространенные ошибки.

    В данном примере для исключения не указано имя. На эту ошибку укажет
    компилятор на этапе компиляции, так что ее легко исправить самостоятельно.

    Ошибочный пример:
    try {
        stream1 = new FileInputStream("data.txt");
    } catch (IOException) { 
        message("Could not open data.txt");
    }
    

    Исправленный пример:
    try {
       stream1 = new FileInputStream("data.txt");
    } catch (IOException ie) { 
       message("Could not open data.txt: " + ie);
    }
    


    Порядок расположения блоков catch определяет очередность перехвата
    исключений. Нужно учитывать, что каждый такой блок перехватит все
    исключения указанного класса или любого его подкласса. Если не учесть
    это, то можно получить недостижимый блок catch, на что укажет компилятор.
    В примере ниже SocketException является подклассом IOException.

    Ошибочный пример:
    try {
        serviceSocket.setSoTimeout(1000);
        newsock = serviceSocket.accept();
    } catch (IOException ie) { 
        message("Error accepting connection.");
    } catch (SocketException se) {
        message("Error setting time-out.");
    }
    

    Исправленный пример:
    try {
        serviceSocket.setSoTimeout(1000);
        newsock = serviceSocket.accept();
    } catch (SocketException se) {
        message("Error setting time-out.");
    } catch (IOException ie) { 
        message("Error accepting connection.");
    }
    


    Если в коде возможно появление исключения, которое не перехватавается
    ни одним блоком try-catch, то это исключение следует объявить в заголовке
    метода. (Для исключений - подклассов класса RuntimeException это не
    обязательно). Студенты иногда забывают о том, что вызов метода может
    порождать исключение. Проще всего это исправить, помещая вызов метода в
    блок try-catch.

    Ошибочный пример:
    public void waitFor(int sec) {
        Thread.sleep(sec * 1000);
    }
    

    Исправленный пример:
    public void waitFor(int sec) throws InterruptedException {
        Thread.sleep(sec * 1000);
    }
    


    8. Метод доступа имеет тип void

    Это очень простая ошибка. Студент создает метод для доступа к переменной,
    но указывает, что метод ничего не возвращает (помещает модификатор void
    в загогловок метода). Чтобы исправить эту ошибку, нужно указать правильный
    тип возвращаемого значения.

    Ошибочный пример:
    public class Line {
        private Point start, end;
        public void getStart() { 
          return start; 
        }
    }
    

    Исправленный пример:
    public class Line {
        private Point start, end;
        public Point getStart() { 
          return start; 
        }
    }
    

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


    9. Вызов нестатичных методов класса из метода main()

    Входной точкой любой Java программы должен быть статичный метод main:
    public static void main(String[] args) {
      ...
    }
    

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

    Ошибочный пример:
    public class DivTest {
        boolean divisible(int x, int y) {
            return (x % y == 0);
        }
    
        public static void main(String[] args) {
            int v1 = 14;
            int v2 = 9;
    
            // на следующие строки компилятор выдаст ошибку
            if (divisible(v1, v2)) {
                System.out.println(v1 + " is a multiple of " + v2);
            } else {
                System.out.println(v2 + " does not divide " + v1);
            }
        }
    }
    

    Есть 2 способа исправления ошибки: сделать нужный метод статичным
    или создать экземпляр класса. Чтобы правильно выбрать нужный способ,
    задайте себе вопрос: использует ли метод поля или другие методы класса.
    Если да, то следует создать экземпляр класса и вызвать у него метод,
    иначе следует сделать метод статичным.

    Исправленный пример 1:
    public class DivTest {
        int modulus;
    
        public DivTest(int m) { 
          modulus = m; 
        }
        
        boolean divisible(int x) {
            return (x % modulus == 0);
        }
    
        public static void main(String[] args) {
            int v1 = 14;
            int v2 = 9;
    
            DivTest tester = new DivTest(v2);
    
            if (tester.divisible(v1) {
                System.out.println(v1 + " is a multiple of " + v2);
            } else {
                System.out.println(v2 + " does not divide " + v1);
            }
        }
    }
    

    Исправленный пример 2:
    
    public class DivTest {
        static boolean divisible(int x, int y) {
            return (x % y == 0);
        }
    
        public static void main(String[] args) {
            int v1 = 14;
            int v2 = 9;
    
            if (divisible(v1, v2)) {
                System.out.println(v1 + " is a multiple of " + v2);
            } else {
                System.out.println(v2 + " does not divide " + v1);
            }
        }
    }
    


    10. Использование объектов класса String как параметров метода.

    В Java класс java.lang.String хранит строковые данные. Однако, строки в Java
    (1) обладают постоянством (то есть их нельзя изменять),
    (2) являются объектами.

    Поэтому с ними нельзя обращаться как просто с буфером символов, это
    неизменяемые объекты. Иногда студенты передают строки, ошибочно
    расчитывая на то, что строка-объект будет передана как массив символов
    по ссылке (как в C или C++). Компилятор обычно не считает это ошибкой.

    Ошибочный пример.
    public static void main(String args[]) {
       String test1 = "Today is ";
       appendTodaysDate(test1);
       System.out.println(test1);
    }
    
    /* прим. редактора: закомментированный метод должен иметь модификатор
        static (здесь автором допущена ошибка №9)
    public void appendTodaysDate(String line) {
        line = line + (new Date()).toString();
    }
    */
    
    public static void appendTodaysDate(String line) {
        line = line + (new Date()).toString();
    }
    

    В примере выше студент хочет изменить значение локальной переменной test1,
    присваивая новое значение параметру line в методе appendTodaysDate.
    Естественно это не сработает. Значение line изменится, но значение test1
    останется прежним.

    Эта ошибка возникает из-за непонимания того, что (1) java объекты всегда
    передаются по ссылке и (2) строки в Java неизменяемы. Нужно осмыслить, что
    объекты-строки никогда не изменяют своего значения, а все операции над
    строками создают новый объект.

    Чтобы исправить ошибку в примере выше, нужно или возвращать строку из
    метода, или передавать объект StringBuffer как параметр методу вместо String.

    Исправленный пример 1:
    public static void main(String args[]) {
       String test1 = "Today is ";
       test1 = appendTodaysDate(test1);
       System.out.println(test1);
    }
    
    public static String appendTodaysDate(String line) {
        return (line + (new Date()).toString());
    }
    

    Исправленный пример 2:
    public static void main(String args[]) {
       StringBuffer test1 = new StringBuffer("Today is ");
       appendTodaysDate(test1);
       System.out.println(test1.toString());
    }
    
    public static void appendTodaysDate(StringBuffer line) {
        line.append((new Date()).toString());
    }
    

    прим. перев.
    вообще-то понять в чем ошибка не так просто.
    так как объекты передаются по ссылке, то значит line ссылается туда же,
    куда и test1. А значит создавая новый line, мы создаем новый test1.
    в неправильном примере все выглядит так, как будто передача String идет
    по значению, а не по ссылке.



    11. Объявление конструктора как метода

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

    В примере ниже, студент хочет проинициализировать поле класса Vector list
    при создании класса. Этого не произойдет, так как метод 'IntList' - это не
    конструктор.

    Ошибочный пример.
    public class IntList {
        Vector list;
    
        // Выглядит как конструктор, но на самом деле это метод
        public void IntList() {
            list = new Vector();
        }
    
        public append(int n) {
            list.addElement(new Integer(n));
        }
    }
    

    Код выдаст исключение NullPointerException при первом же ображении к полю
    list. Ошибку легко исправить: нужно просто убрать возвращаемое значение
    из заголовка метода.

    Исправленный пример:
    public class IntList {
        Vector list;
    
        // Это конструктор
        public IntList() {
            list = new Vector();
        }
    
        public append(int n) {
            list.addElement(new Integer(n));
        }
    }
    


    12. Забыл привести объект к нужному типу.

    Как и во всех других объектно-ориентированных языках, в Java можно
    обращаться к объекту как к его суперклассу. Это называется 'upcasting',
    он выполняется в Java автоматически. Однако, если переменная, поле
    класса или возвращаемое значение метода объявлено как суперкласс, поля
    и методы подкласса будут невидимы. Обращение к суперклассу как к подклассу
    называется 'downcasting', его нужно прописывать самостоятельно (то есть
    привести объект к нужному подклассу).

    Студенты часто забывают о приведении оъекта к подклассу. Чаще всего это
    случается при использовании массивов объектов Object и коллекций из пакета
    java.util (имеется ввиду Collection Framework). В примере ниже объект String
    заносится в массив, а затем извлекается из массива для сравнения с другой
    строкой. Компилятор обнаружит ошибку и не станет компилировать код, пока не
    будет явно указано приведение типов.

    Ошибочный пример.
    Object arr[] = new Object[10];
    arr[0] = "m"; 
    arr[1] = new Character('m');
    
    String arg = args[0];
    if (arr[0].compareTo(arg) < 0) {
        System.out.println(arg + " comes before " + arr[0]);
    }
    

    Смысл приведения типов для некоторых оказывается затруднительным.
    Особенно часто затруднения вызывают динамические методы. В примере выше,
    если бы использовался метод equals вместо compareTo, компилятор бы не
    выдал ошибку, и код бы правильно отработал, так как вызвался бы метод
    equals именно класса String. Нужно понять, что динамическое связывание отличается от downcasting.

    Исправленный пример:
    Object arr[] = new Object[10];
    arr[0] = "m"; 
    arr[1] = new Character('m');
    
    String arg = args[0];
    if ( ((String) arr[0]).compareTo(arg) < 0) {
        System.out.println(arg + " comes before " + arr[0]);
    }
    


    13. Использование интерфейсов.

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

    Ошибочный пример.
    public class SharkSim extends Runnable {
        float length;
        ...
    }
    

    Исправленный пример:
    public class SharkSim implements Runnable {
        float length;
        ...
    }
    

    Связанная с этим ошибка: неправильный порядок блоков extends и implements.
    Согласно спецификации Java, объявление о расширении класса должно идти
    перед объявлениями о реализации интерфейсов. Также, для интерфейсов
    ключевое слово implements нужно писать всего 1 раз, несколько интерфейсов
    разделяются запятыми.

    Еще ряд ошибочных примеров:
    // Неправильный порядок
    public class SharkSim implements Swimmer extends Animal {
        float length;
        ...
    }
    
    // ключевое слово implements встречается несколько раз
    public class DiverSim implements Swimmer implements Runnable {
        int airLeft;
        ...
    }
    

    Исправленные примеры:
    // Правильный порядок
    public class SharkSim extends Animal implements Swimmer {
        float length;
        ...
    }
    
    // Несколько интерфейсов разделяются запятыми
    public class DiverSim implements Swimmer, Runnable {
        int airLeft;
        ...
    }
    


    14. Забыл использовать значение, возвращаемое методом суперкласса

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

    В примере ниже студент хочет вставить результат метода toString()
    суперкласса в результат метода toString() подкласса. При этом он не
    использует возвращаемое значение метода суперкласса.

    Ошибочный пример.
    public class GraphicalRectangle extends Rectangle {
          Color fillColor;
          boolean beveled;
          ...
          public String toString() {
              super();
              return("color=" + fillColor + ", beveled=" + beveled);
          }
    }
    

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

    Исправленный пример:
    public class GraphicalRectangle extends Rectangle {
          Color fillColor;
          boolean beveled;
          ...
          public String toString() {
              String rectStr = super();
              return(rectStr + " - " +
             "color=" + fillColor + ", beveled=" + beveled);
          }
    }
    


    15. Забыл добавить AWT компоненты

    В AWT используется простая модель построения графического интерфейса:
    каждый компонент интерфейса должен быть сначала создан с помощью своего
    конструктора, а затем помещен в окно приложения с помощью метода add()
    родительского компонента. Таким образом, интерфейс на AWT получает
    иерархическую структуру.

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

    Ошибочный пример.
    public class TestFrame extends Frame implements ActionListener {
        public Button exit;
    
        public TestFrame() {
            super("Test Frame");
            exit = new Button("Quit");
        }
    }
    

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

    Исправленный пример:
    public class TestFrame extends Frame implements ActionListener {
        public Button exit;
    
        public TestFrame() {
            super("Test Frame");
    
            exit = new Button("Quit");
    
            Panel controlPanel = new Panel();
            controlPanel.add(exit);
    
            add("Center", controlPanel);
    
            exit.addActionListener(this);
        }
    
        public void actionPerformed(ActionEvent e) {
            System.exit(0);
        }
    }
    


    17. Забыл запустить поток

    Многопоточность в Java реализуется с помощью класса java.lang.Thread.
    Жизненный цикл потока состоит из 4х этапов: проинициализирован, запущен,
    заблокирован и остановлен. ТОлько что созданный поток находится в
    проинициализированном состоянии. Чтобы перевести его в запущенное
    состояние, необходимо вызвать его метод start(). Иногда студенты создают
    потоки, но забывают запустить их. Обычно ошибка возникает при недостаточных
    знаниях студента о параллельном программировании и многопоточности. (прим.
    перев.: не вижу связи) Чтобы исправить ошибку, необходимо просто запустить
    поток.

    В примере ниже, студент хочет создать анимацию картинки используя интерфейс
    Runnable, но он забыл запустить поток.

    Ошибочный пример.
    public class AnimCanvas extends Canvas implements Runnable {
            protected Thread myThread;
            public AnimCanvas() {
                    myThread = new Thread(this);
            }
    
            // метод run() не будет вызван,
            // потому что поток не запущен.
            public void run() {
                    for(int n = 0; n < 10000; n++) {
                       try { 
                         Thread.sleep(100); 
                       } catch (InterruptedException e) { }
                       
                       animateStep(n);
                    }       
            }
            ...
    }
    

    Исправленный пример:
    public class AnimCanvas extends Canvas implements Runnable {
            static final int LIMIT = 10000;
            protected Thread myThread;
    
            public AnimCanvas() {
                    myThread = new Thread(this);
                    myThread.start();
            }
    
            public void run() {
                    for(int n = 0; n < LIMIT; n++) {
                            try { 
                              Thread.sleep(100); 
                            } catch (InterruptedException e) { }
    
                            animateStep(n);
                    }
            }
            ...
    }
    

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


    18. Использование запрещенного метода readLine() класса java.io.DataInputStream

    В Java версии 1.0 для считывания строки текста необходимо было
    использовать метод readLine() класса java.io.DataInputStream. В Java
    версии 1.1 был добавлен целый набор классов для ввода-вывода,
    обеспечивающий операции ввода-вывода для текста: классы Reader и
    Writer. Таким образом с версии 1.1 для чтения строки текста надо
    использовать метод readLine() класса java.io.BufferedReader. Студенты
    могут не знат об этом изменении, особенно если они обучались по
    старым книгам. (прим. перев. вообще-то уже не актуально. вряд ли кто-то
    станет сейчас учиться по книгам 10летней давности.)

    Старый метод readLine() оставлен в JDK, но объявлен как запрещенный, что
    часто смущает студентов. Необходимо понять, что использование метода
    readLine() класса java.io.DataInputStream не является неправильным, оно
    просто устарело. Необходимо использовать класс BufferedReader.

    Ошибочный пример.
    public class LineReader {
        private DataInputStream dis;
    
        public LineReader(InputStream is) {
            dis = new DataInputStream(is);
        }
    
        public String getLine() { 
            String ret = null;
    
            try {
              ret = dis.readLine();  // Неправильно! Запрещено.
            } catch (IOException ie) { }
    
            return ret;
        }
    }
    

    Исправленный пример:
    public class LineReader {
        private BufferedReader br;
    
        public LineReader(InputStream is) {
            br = new BufferedReader(new InputStreamReader(is));
        }
    
        public String getLine() { 
            String ret = null;
    
            try {
              ret = br.readLine(); 
            } catch (IOException ie) { }
    
            return ret;
        }
    }
    

    Есть и другие запрещенные методы в версиях, более поздних чем 1.0, но
    этот встречается чаще всего.


    19. Использование типа double как float

    Как и в большинстве других языков, в Java поддерживаются операции
    над числами с плавающей точкой (дробными числами). В Java есть 2
    типа-примитива для чисел с плавающей точкой: double для чисел с
    64-битной точностью по стандарту IEEE, и float, для чисел с 32-битной
    точностью по стандарту IEEE. Трудность заключается в использовании
    десятичных чисел, таких как 1.75, 12.9e17 или -0.00003 - компилятор
    присваивает им тип double.

    Java не производит приведение типов в операциях, в которых может произойти
    потеря точности. Такое приведение типов должен осуществлять программист.
    Например, Java не позволит присвоить значение типа int переменной типа byte
    без приведения типов, как показано в примере ниже.

    byte byteValue1 = 17; /* неправильно! */
    byte byteValue2 = (byte)19; /* правильно */ 
    

    Так как дробные числа представлены типом double, и присваивание double
    переменной типа float может привести к потере точности, компилятор
    пожалуется на любую попытку использовать дробные числа как float. Так что
    использование присваиваний, приведенных ниже, не даст классу
    откомпилироваться.

    float realValue1 = -1.7;          /* неправильно! */
    float realValue2 = (float)(-1.9); /* правильно */ 
    

    Это присваивание сработало бы в C или C++, для Java все гораздо строже.
    Есть 3 способа избавиться от этой ошибки.

    Можно использовать тип double вместо типа float. Это наиболее простое
    решение. На самом деле нет особого смысла использовать 32-битную
    арифметику вместо 64-битной, разницу в скорости все равно скушает
    JVM (к тому же в современных процессорах все дробные числа приводятся
    к формату 80-битного регистра процессора перед любой операцией).
    Единственный плюс использования float - это то, что они занимают
    меньше памяти, что бывает полезно при работе с большим числом дробных
    переменых.

    Можно использовать модификатор для обозначения типа числа, чтобы
    сообщить компилятору как хранить число. Модификатор для типа
    float - 'f'. Таким образом, компилятор присвоит числу 1.75 тип double,
    а 1.75f - float. Например:

    float realValue1 = 1.7;    /* неправильно! */
    float realValue2 = 1.9f;   /* правильно */ 
    

    Можно использовать явное приведение типов. Это наименее элегантный способ,
    но он полезен при конвертации переменной типа double в тип float. Пример:

    float realValue1 = 1.7f; 
    double realValue2 = 1.9;
    realValue1 = (float)realValue2;
    

    Подробнее о числах с плавающей точкой можно почитать здесь и здесь.


    -- комментарий переводчика --
    все.

    в примере 10 на самом деле допущена ошибка 9. я ее сразу заметил, но
    забыл написать примечание. а исправлять не стал чтобы не было
    расхождений с первоисточником

  • Комментарии


    • В 1 пункте в примерах не хватает открывающей фигурной скобки.

    • В 9 пункте в первом примере в 18 строке кода не хватает второй закрывающей скобочки. Верно так:
      if (tester.divisible(v1)) {

      В целом, этот пример я переписала бы так. Считаю, такое решение с точки зрения задачи лучше её отображает:
      http://pastebin.com/RNhYmyVe

    • очень помогла статья, перерыл кучу форумов, а тут описана как раз моя проблема, очень подробно, спасибо

    • Ухты, даже отзывы есть смешные и благодарные! Ура!

    • Кое-что помогло. Спасибо. :)

    • аааа.... не могу поменять логику программирования на JAVA после DELPHI!!!! ))) спасибо... мне помогло

    • Очень полезно

    • очень полезно! мне в тему сейчас

    • На всем спотыкался :)

    • Надо было раздобыть это все пораньше. Практически на каждую граблю наступал. Сейчас было занятно вспомнить :)

    • Надо было раздобыть это все пораньше. Практически на каждую граблю наступал. Сейчас было занятно вспомнить :)

    • Для новичков просто супер, на годок бы раньше этот материальчик.

    • Полезная инфа! Но многое для меня знакомо;)

    • Познавательно.

    • мощно!

    • Хорошо информировано, много полезного для новичка.

    • Дас ис фантастиш

    • Гут !



    Необходимо войти на сайт, чтобы оставлять комментарии

    Раздел FAQ: Java / Общие вопросы / Ошибки начинающих java-программистов