Как создать в собственный класс в java

Рассмотрим пример создания простейшего класса. Давайте с его помощью смоделируем окружности на координатной плоскости.

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

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

// описываем отдельный новый класс
class Circle {
    // свойства класса
    public double x; // абсцисса центра
    public double y; // ордината центра
    public double r; // радиус
    // методы класса
    // выводит на экран параметры окружности
    public void printCircle() {
        System.out.println("Окружность с центром ("+x+";"+y+") и радиусом "+r);
    }    
    // перемещает центр, движение окружности
    public void moveCircle(double a, double b) {
        x = x + a;
        y = y + b;
    }
    // масштабируем, выполняем преобразование подобия с коэффициентом k
    public void zoomCircle(double k) {
        r = r * k;
    }    
}
 
// описываем основной класс, содержащий метод main
public class Main {
    public static void main(String[] args) {
        // Создаём объект (окружность класса Circle), у неё будет нулевой
        // радиус и центр в (0.0;0.0), поскольку все свойства получат
        // значения по умолчанию
        Circle o1 = new Circle();
        // выводим на экран параметры окружности
        o1.printCircle();
        // Меняем абсциссу центра, обращааясь к свойству x
        o1.x = 3;
        // Меняем радиус, обращааясь к свойству r
        o1.r = 12.3;
        // выводим на экран обновлённые параметры окружности
        o1.printCircle();
        // Создаём другой объект того же класса
        Circle o2 = new Circle();
        o2.r = 3.14;
        o2.zoomCircle(1.66);
        o2.printCircle(); // Окружность с центром (0.0;0.0) и радиусом 5.2124
    }
}

Конструкторы

Когда мы создаём объект командой Circle o1 = new Circle(); используется так называемый конструктор по умолчанию (или конструктор без параметров) — это специальный метод класса, мы его не определяли явно, но даже если его не определить он создаётся автоматически, выполняется при создании каждого нового объекта и присваивает первоначальные значения его свойствам (инициализирует их). Значения по умолчанию для свойств зависят от их типа (0 или 0.0 для чиловых типов, false для логического типа и т.д.).

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

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

class Circle {
    public double x; // абсцисса центра
    public double y; // ордината центра
    public double r; // радиус
 
    public void printCircle() {
        System.out.println("Окружность с центром ("+x+";"+y+") и радиусом "+r);
    }    
    public void moveCircle(double a, double b) {
        x = x + a;
        y = y + b;
    }
    public void zoomCircle(double k) {
        r = r * k;
    }
    // конструктор по умолчанию, теперь сразу после создания объекта будем
    // получать окружность единичного радиуса с центром в начале координат
    public Circle() {
        x = 0.0;
        y = 0.0;
        r = 1.0;
    }
}
 
public class Main {
    public static void main(String[] args) {
        Circle o1 = new Circle();
        o1.printCircle(); // Окружность с центром (0.0;0.0) и радиусом 1.0
    }
}
Поскольку методы можно перегружать, а конструктор является методом, то с помощью перегрузки можно создать дополнительные варианты конструкторов. Например, удобно иметь конструктор, который позволит при создании объекта явно указывать координаты его центра и длину радиуса.

Описать подобный конструктор можно в дополнение к основному следующим образом:

public Circle(double a, double b, double s) {
        x = a;
        y = b;
        r = s;
    }
Теперь при создании объектов можно пользоваться любым конструктором на выбор:

Circle o1 = new Circle();
        o1.printCircle(); // Окружность с центром (0.0;0.0) и радиусом 1.0
        Circle o2 = new Circle(1,-1,14);
        o2.printCircle(); // Окружность с центром (1.0;-1.0) и радиусом 14.0
Нужно учитывать следующий факт: если в классе описан явно хотя бы один конструктор с параметрами, то конструктор по умолчанию (без параметров) создаваться автоматические уже не будет (его в такой ситуации надо описывать явно). Хотя, если вам требуется только конструктор с параметрами (как второй из нашего примера), то можно обойтись и совсем без конструктора по умолчанию (описать в классе только один конструктор с параметрами).

Доступ к членам класса из тела методов

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

public double squareCircle() {
        double s = Math.PI * r * r;
        return s;
    }
Результат работы метода можно увидеть следующим образом:

System.out.println("Площадь круга o2: "+o2.squareCircle()); //615.75...
Обратите внимание: внутри каждого метода класса доступны свойства того объекта, для которого метод будет вызываться. То есть если мы вызываем метод для объекта o2, то внутри метода при его выполнении мы будем работать именно со свойствами объекта o2 (o2.x будет доступно x, o2.r будет доступно как r и т.д.).

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

Например, можно было бы начать описание метода для масштабирования таким образом:

public void zoomCircle(double r) {…
Как же в таком случае обращаться к свойствам объекта (ведь имена этих свойств перекрываются формальным параметром)?

Решение такой неоднозначности существует: к любому свойству внутри метода можно обращаться не только по имени, но и через ссылку this. То есть внутри метода можно написать x=13;, а можно this.x=13; — эффект будет идентичный. Соответственно, когда имя формального параметра перекрывает имя свойства, к имени свойства нужно обращаться через ссылку this. Тогда метод можно переписать таким образом:

public void zoomCircle(double r) {
        this.r = this.r * r;
    }
Понятно, что удобнее не допускать перекрывания имён свойств именами локальных параметров в методах. Иногда, впрочем, требуется внутри метода применить какой-то другой метод к текущему объекту, тогда без ссылки this не обойтись.

Добавим в класс метод, проверяющий, совпадают ли две окружности по площади.

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

Метод можно описать так:

public boolean equalsCircle(Circle cir) {
        if(this.squareCircle() == cir.squareCircle()) {
            return true;
        } else {
            return false;
        }
    }
Пример использования метода:

if(o1.equalsCircle(o2)) {
            System.out.println("Круги o2 и o1 имеют равную площадь");
        } else {
            System.out.println("Круги o2 и o1 имеют различную площадь");
        }
Рассмотрим пример класса точек на плоскости:

class Point {
    public double x; // абсцисса точки
    public double y; // ордината точки
 
    // возвращает строку с описанием точки
    public String toString() {
        return "("+x+";"+y+")";
    }
    // выводит на экран описание точки
    public void printPoint() {
        System.out.print(this.toString());
    } 
    // метод перемещает точку на указанный вектор
    public void movePoint(double a, double b) {
        x = x + a;
        y = y + b;
    }
    // метод изменяет координаты точки на указанные
    public void setPoint(double a, double b) {
        x = a;
        y = b;
    } 
    // конструктор по умолчанию, создающий точку в начале координат
    public Point() {
        x = 0.0;
        y = 0.0;
    }
    // конструктор, создающий точку с указанными координатами
    public Point(double a, double b) {
        x = a;
        y = b;
    }  
    // метод вычисляющий расстояние между точками
    public double length(Point p) {
        return Math.sqrt( Math.pow(p.x-x,2) + Math.pow(p.y-y,2) );
    }
    // метод проверяющий совпадают ли точки
    public boolean equalsPoint(Point p) {
        if(this.x == p.x && this.y == p.y) {
            return true;
        } else {
            return false;
        }
    }    
}
 
public class Main {
    public static void main(String[] args) {
        Point p1 = new Point();
        Point p2 = new Point(1,1);
        System.out.println("Растстояние между точками "+p1+" и "+p2+" равно "+p1.length(p2));
    }
}
В этом классе создаётся отдельный метод toString(), предназначенный для представления каждого объекта в виде строки. Этот метод можно использовать для собственных нужд (например, он вызывается в методе printPoint(), печатающем строку на экран), но кроме этого метод toString() будет вызываться автоматически, когда возникнет попытка автоприведения объекта к строковому типу.

Например, мы можем пользоваться методом явно:

Point p3 = new Point(3,4.67);
System.out.println("Координаты точки: "+p3.toString());
А можем просто обединять наш объект с другой строкой, провоцируя автоприведение:

Point p4 = new Point(3.2,2.3);
System.out.println("Координаты точки: "+p4);
Результат при этом будем получать идентичный.

Такой особенный метод toString() существует на самом деле для всех объектов в Java. Любой класс в Java является наследниом класса Object (хотя наследование мы явно при создании своего класса никак не используем) и от этого родительского класса получает ряд готовых методов (среди которых toString() тоже присутствует). Теперь в классе Point мы метод toString() перегрузили, сделав для него такую реализацию, которая требуется нам в нашей программе.

Ещё один яркий пример метода, наследуемого от коренного класса Object — это метод equals(Object o) для сравнения объектов — его можно применять к любым двум объектам (даже если они из разных классов), вызывая метод для одного из них, а второй передавая через параметр. Метод будет возвращать истинное значение тогда и только тогда, когда будет вызван для двух ссылок на один и тот же объект. В своих программах с практической точки зрения равными можно считать разные объекты имеющие одинаковый набор текущих значений в полях, поэтому метод equals обычно тоже перегружают. Вместе с ним обязательно перегружать и метод hashCode(), возвращающий некоторое целое число для каждого объекта, являющегося его уникальным числовым идентификатором (хешем). По умолчанию (в той реализации, которая представлена в классе Object) это число строится на основании адреса объекта в памяти, но при перегрузке метода можно придумать свою собственную реализацию, главное, чтобы она удовлетворяла одному важному правилу: если два обекта совпадают в соответствии с методом equals, то у них должны быть одинаковые хеши, возвращаемые методом hashCode(), при этом обратного не требуется. Например, для нашего класса Point мы могли бы в качестве хеша возвращать произведение координат точки.

Не требуется, но рекомендуется для своих классов перегружать перечисленные выше методы. В примере это сделано для метода toString, но не сделано для equals и hashCode.

Как работать с циклами

Есть два вида циклов в Java, for и while.

For

Цикл for состоит из трех секций:

for (int i = 0; i < 3; i++) {}
Первая секция выполняется один раз, когда мы входим в цикл. В нашем примере здесь задается начальное значение переменной i. Вторая секция проверяет логическое условие, если оно возвращает true, выполняются операторы в цикле, если false, выход из цикла. Вторая секция в первый раз запускается сразу после первой секции, и выполняется каждый раз, пока условие верно, вызывая третью секцию. Третья секция — заключительный оператор, его действие выполняется каждый раз при выполнении цикла. В нашем примере это инкремент, который при каждом выполнении увеличивает значение переменной на единицу.

Таким образом, цикл будет работать 3 раза. Вот порядок команд:

int i = 0;
i < 3 // 0 < 3 = true
      // Inside of loop
i++ // i is now 1
i < 3 // 1 < 3 = true
      // Inside of loop
i++ // i is now 2
i < 3 // 2 < 3 = true
      // Inside of loop
i++ // i is now 3
i < 3 // 3 < 3 = false
      // Loop is done...
Мы можем опустить первую и третью секции цикла (как бы странно это ни выглядело), и цикл все еще будет работать:

for (;i < 5;) {}
Для случаев, где нужно использовать цикл схожих повторяющихся действий, мы используем цикл while

While

Синтаксис похож на предыдущий:

while (condition) {}
Условие будет работать впервые при вводе и каждый раз, когда вызывается цикл. Если условие возвратит false, то цикл не будет работать.
Если мы хотим, чтобы цикл всегда выполнял по крайней мере одно действие, мы можем использовать do-while:

do {
 
} while(condition);
Не забудьте точку с запятой в конце.

Foreach

Другая версия for, это foreach. Но в Java решили не добавлять новое ключевое слово each. Ключевое слово, которое мы используем, все еще for, но когда мы хотим выполнить действия над элементами массива, делаем так:

int[] arr = {2, 0, 1, 3};
for (int el : arr) {
    System.out.println(el);
}
Это была короткая версия, эквивалентная следующей записи:

int[] arr = {1, 9, 9, 5};
for (int i = 0; i < arr.length; i++) {
    int el = arr[i];
    System.out.println(el);
}
Заметьте, что, если вы хотите использовать индекс элемента в цикле, Вы должны использовать более длинную версию и не можете использовать foreach.

break and continue

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

int i;
for (i = 0; i < 5; i++) {
    if (i >= 2) {
        break;
    }
    System.out.println("Yuhu");
}
System.out.println(i);
// Output:
// Yuhu
// Yuhu
// 2
Оператор continue остановит текущую итерацию и переместится в следующую. Заметьте, что в цикле for действие в третьей секции будет выполнено при этом.

int i;
for (i = 0; i < 5; i++) {
    if (i >= 3) {
        break;
    }
    System.out.println("Yuhu");
    if (i >= 1) {
        continue;
    }
    System.out.println("Tata");
}
System.out.println(i);
// Output
// Yuhu
// Tata
// Yuhu
// Yuhu
// 3

Как работать с условными операторами

Условные операторы в Java

Java использует булевские (логические) переменные, чтобы оценивать условия. Значение true или false возвратится, после того как выражение будет оценено. Например:

int a = 4;
boolean b = a == 4;
if (b) {
    System.out.println("It's true!");
}
Конечно, мы обычно не присваиваем условное выражение булевской переменной, мы просто используем короткую версию:

int a = 4;
if (a == 4) {
    System.out.println("Ohhh! So a is 4!");
}

Логические операторы

Есть не так много операторов, которые можно использовать в условиях. Вот они:

int a = 4;
int b = 5;
boolean result;
result = a < b;  // истина result = a > b;  // ложь
result = a <= 4; // меньше или равно - истина result = b >= 6;  // больше или равно - ложь
result = a == b;  // равно - ложь
result = a != b;  // неравно - истина
result = a > b || a < b;  // логическое ИЛИ - истина
result = 3 < a && a < 6;  // логическое И - истина
result = !result;  // Логическое НЕ - ложь

Оператор if — else

Синтаксис оператора if — else довольно прост:

if (a == b) {
    // Тело метода. Выполняется если a и b равны.
}
Так же мы можем добавить еще одно выражение, на случай, если условие не выполняется:

if (a == b) {
    // Мы уже знаем эту часть
} else {
    // a и b не равны... :/
}
Если тело метода можно разместить в одну строку, можно не использовать { }

if (a == b) System.out.println("Yeah!");
else System.out.println("Ohhh...");
Или

if (a == b)
    System.out.println("Another line Wow!");
else
    System.out.println("Double rainbow!");
Несмотря на то, что такой метод мог бы сделать ваш код короче, мы строго рекомендуем новичкам не использовать короткую версию условного оператора

Другая сторона if

Есть еще один способ записать if — else в одну строку — с помощью оператора?:

int a = 4;
int result = a == 4 ? 1 : 8;
// result будет равен 1
// Или обычная форма записи:
int result;
if (a == 4) {
    result = 1;
} else {
    result = 8;
}
Опять же, мы не рекомендуем новичкам использовать эту версию if.

Операторы == и equals

Оператор == работает немного по-другому на объектах, нежели на примитивах. Когда вы используем объекты и хотите проверить, равны ли они, оператор == скажет что они равны, только если объекты одинаковы, но если вы хотите проверить их на логическое соответствие, используйте метод equals. Например:

String a = new String("Wow");
String b = new String("Wow");
String sameA = a;
 
boolean r1 = a == b;      // Ложь, так как a и b не один и тот же объект
boolean r2 = a.equals(b); // Истина, так как a и b логически равны
boolean r3 = a == sameA;  // Истина, так как a и sameA действительно один и тот же объект

Как объявить массив в Java

Массив (англ. Array) это объект, хранящий в себе фиксированное количество значений одного типа. Другими словами, массив — это нумерованный набор переменных. Переменная в массиве называется элементом массива, а ее позиция в массиве задается индексом.

Массивы в Java тоже представляют собой объекты. Они должны быть объявлены, а затем созданы. Чтобы объявить переменную, которая будет содержать массив целых чисел, мы используем следующий синтаксис:

int[] arr;
Обратите внимание, размер не указан, так что мы еще не создали массив.

arr = new int[10];
Теперь мы создали новый массив размером 10. Мы можем проверить размер массива, выведя на экран его длину:

System.out.println(arr.length);
Так же мы можем получить доступ к массиву и установить значения:

arr[0] = 4;
arr[1] = arr[0] + 5;
Счет элементов массива в Java начинается с нуля, то есть доступ к первому элементу можно получить по индексу 0 (например, arr[0]). Кроме того, как показано на примере, массив размером 5 будет заканчиваться на индексе 4, так как счет начинается с нуля.

int[] arr = new int[5]
arr[4] = 4;  // Получение доступа и присвоение значения последнему элементу
Есть также возможность создать массив с указанием значений в одну строку:

int[] arr = {1, 2, 3, 4, 5};
Кстати, если вы попытаетесь вывести массив целиком на экран, получите что-то в этом роде: [I@f7e6a96.

Для вывода всех значений массива используйте метод Arrays.toString(), преобразующий массив в строку.

System.out.println(Arrays.toString(arr));
Или напишите цикл, выводящий последовательно элементы массива.

for(int i=0; i<arr.length; i++) {
            System.out.println(arr[i]);
        }
Попрактикуйтесь в написании кода, прежде чем перейти к следующему уроку.

Как разобраться с переменными в Java

Примитивные типы в Java

Несмотря на то, что язык Java объектно-ориентирован, не все типы — объекты. Существуют так называемые примитивы (primitives). Вот список всех примитивов в Java:

  • byte (число, 1 байт)
  • short (число, 2 байта)
  • int (число, 4 байта)
  • long (число, 8 байтов)
  • float (число с плавающей точкой, 4 байта)
  • double (число с плавающей точкой, 8 байтов)
  • char (символ, 2 байта)
  • boolean (true (истина) или false (ложь), 1 байт)

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

Числа в Java

Чтобы объявить и присвоить число используйте следующий синтаксис:

int myNumber;
myNumber = 5;
= это оператор присваивания.

Вы можете объединить эти операции:

int myNumber = 5;
Чтобы объявить число с плавающей точкой, используйте следующий синтаксис:

double d = 4.5;
d = 3.0;
Если вы хотите использовать float, то:

float f = (float) 4.5;
Или:

float f = 4.5f
(f — более короткий способ объявить float)

Символы и строки в Java

В Java символ — свой собственный тип, и это не просто число. Синтаксис:

char c = 'g';
String — не примитив. Это реальный тип. Вот несколько способов использования строки:

Создание строки с помощью конструктора

String s1 = new String("Who let the dogs out?");
С помощью двойных кавычек (» «).

String s2 = "Who who who who!";
В Java присутсвует конкатенация (объединение) строк при помощи оператора +.

String s3 = s1 + s2;
В Java нет перегрузки операторов! Оператор + определен только для строк, вы никогда не увидите его с другими объектами, только с примитивами.

int num = 5;
String s = "I have " + num + " cookies";
Заметьте, что кавычки с примитивами не используются.

Логический тип boolean в Java

Каждый оператор сравнения в Java возвращает булевскую переменную (boolean), которая может принять только два значения: true (истина) или false (ложь).

boolean b = false;
b = true;
 
boolean toBe = false;
b = toBe || !toBe;
if (b) {
    System.out.println(toBe);
}
Оператор || это логическое «или».

А например, такой код не будет работать по причине несовместимости типов:

int children = 0;
b = children;  // Не будет работать, требуется boolean, а найден int
if (children) {  // Не будет работать, требуется boolean, а найден int
    // Не будет работать, требуется boolean, а найден int
}

Как написать на Java первую программу "Hello world"

Рекомендуем использовать среду разработки IntelliJ IDEA — скачайте бесплатную версию Community Edition и установите ее.

Первая программа на Java

Запустите среду разработки и нажмите Создать проект (Create new project). Далее в окне создания проекта слева вверху выберите язык проекта Java и нажмите внизу кнопку Next. Дальнейшие настройки можно оставить по умолчанию. На последнем экране можно изменить имя и местоположение проекта, и создать проект нажатием кнопки Finish.

Далее откроется пустое окно проекта в среде разработки. Слева откройте вкладку Project дерева проекта. Раскройте проект и найдите внутри папку src. В этой папке всегда размещается код, написанный программистами. Пока она пуста, веди мы еще ничего не писали. Давайте это исправим.

Правой клавишей мыши вызовите контекстное меню папки src и выберите New> Java Class. Далее укажите имя класса — Main. Это будет главный класс нашего проекта, в нем мы будем писать наш код.

Давайте напишем программу Hello World, которая просто выводит на экран надпись «Hello, World!».

public class Main {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}
Первая строка объявляет класс под названием Main.

public class Main {
В Java каждая строка кода, которая может выполняться должна находиться внутри класса. Эта строка объявляет класс Main, модификатор доступа public означает что класс общедоступен и любой другой класс может получить доступ к нему. На данный момент это не важно, так что не волнуйтесь. Для начала просто напишем наш код в классе Main, а про объекты поговорим позже.

Обратите внимание, что, когда мы объявляем общедоступный класс (public), мы должны объявить его в файле с тем же именем (Main.java), иначе мы получим ошибку при компиляции.

Следующая строка:

public static void main(String[] args) {
Это точка входа нашей Java программы. Метод main должен иметь точно такую же сигнатуру, как показано, иначе программа не будет работать.

  • public снова же означает, что метод общедоступен
  • static означает что вы можете выполнить этот метод без создания экземпляра класса Main
  • void означает, что метод не возвращает никакого значения
  • main — имя метода

При помощи этой строки мы выводим на экран «Hello, World!».

System.out.println("Hello, World!");
Это массив строк. Мы будем использовать его в следующем уроке, так что не волнуйтесь, если сейчас вы не все понимаете.

Пока потренируйтесь выводить различный текст, ибо только практика сделает из вас программиста!

Как установить и настроить Java

Установка Java Development Kit

  1. Перейдите на сайт Oracle и загрузите JDK для вашей платформы.
  2. После загрузки извлеките полученный архив и запустите извлеченное приложение.
  3. В процессе установке выберите вариант «Development Tool» и нажмите «Next».
  4. Спустя некоторое время установка завершится.

Итак, вы установили Java Development Kit, но это еще не всё. Необходимо настроить его для вашей системы.

Настройка JDK на примере Windows

  1. Перейдите в папку %ProgramFiles%\Java\%версия установленного вами jdk%\bin, нажмите на свойства любого файла в этой папке и скопируйте путь к нему.
  2. Перейдите в свойства вашего компьютера, откройте вкладку «Дополнительно», нажмите «Переменные среды…». В открывшемся окне создайте новую переменную, назовите её Path, в её значение вставьте скопированный ранее путь.
  3. Теперь самое важное. Откройте командную строку и наберите javac, чтобы убедиться, что JRE установлен и настроен. Если выдаётся список аргументов к команде javac, то поздравляю, вы успешно установили и настроили всё, что необходимо для использования Java!

После установки JDK и JRE не помешает установить на компьютер одну из IDE.

Установка IDE

Для начала разберёмся, что такое IDE.

IDE (Integrated Development Environment) – это комплекс программных средств, используемый программистами для разработки программного обеспечения. IDE позволяет с лёгкостью писать, запускать, отлаживать и тестировать код.

Для написания сложных программ целесообразно использовать IDE. Мы рассмотрим наиболее популярные.

Блокнот
Да, и в блокноте можно писать код! Для разработки вам потребуется всего лишь установить JDK и указать путь к ней. Пишете код в блокноте, компилируете с помощью командной строки. Тем не менее, для разработки сложных программ это не самый лучший вариант из-за отсутствия каких-либо дополнительных возможностей, присутствующих в продвинутых IDE.

NetBeans
NetBeans — выбор профессиональных Java-разработчиков. В ней есть уникальные возможности и инструменты, которые позволят вам сделать вашу программу кроссплатформенной, а код удобочитаемым. NetBeans поддерживает не только Java, но и другие языки программирования для десктоп- и веб-разработки. Она полностью бесплатна, скачать её можно с официального сайта. Вот лишь некоторые её возможности:

  • форматирование кода;
  • установка сторонних библиотек;
  • простой графический интерфейс;
  • и многое, многое другое…

Eclipse
Eclipse, как и Netbeans — одна из наиболее популярных IDE. Она предоставляет впечатляющий интуитивно понятный интерфейс и производительную среду разработки, позволяющую комфортно разрабатывать приложения на Java. Скачать Eclipse можно бесплатно с официального сайта. Преимущества:

  • возможность форматировать код так, как вам удобно;
  • поддержка разбиения кода на модули;
  • лёгкость использования одного и того же кода в разных проектах;
  • перетаскивание (drag-and-drop);
  • просмотр содержимого библиотек;
  • удобный интерфейс.

IntelliJ IDEA
IntelliJ IDEA — известная IDE для Java, написанная, как ни странно, на Java. Укомплектована уникальными инструментами и позволяет без проблем ориентироваться в программе. Нахождение ошибок и отладка кода никогда не были такими легкими, как с IntelliJ IDEA.

JCreator
JCreator — продвинутая и самая быстрая IDE для Java, написанная на C++.