10 главных конструкций языка Java
10 главных конструкций языка C 10 главных конструкций языка Go 10 главных конструкций языка Swift
10 главных конструкций языка Java

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

Так как авто­ры язы­ка Java при созда­нии вдох­нов­ля­лись язы­ка­ми C и C++, то в Java тоже появи­лось мно­го похо­жих кон­струк­ций и команд. Если вы зна­е­те C или C++, то осво­ить Java вам будет гораз­до проще.

👉 В Java после каж­дой коман­ды ста­вит­ся точ­ка с запятой.

Комментарии

Ком­мен­та­рии в Java точ­но такие же, как в C-подобных язы­ках — есть одно­строч­ные, кото­рые рабо­та­ют толь­ко для одной стро­ки, и многострочные.

// Это однострочный комментарий

// Для каждой строки нужно добавлять его отдельно

/* А это — многострочный

его можно сделать любой длины,

если в начале и в конце поставить нужные символы */

Переменные и типы данных

Как и в C, в Java есть несколь­ко типов дан­ных с раз­ным объ­ё­мом выде­ля­е­мой памя­ти. Пред­по­ла­га­ет­ся, что про­грам­мист сам решит, какой тип исполь­зо­вать луч­ше все­го в каж­дой ситу­а­ции и сам будет сле­дить за тем, что­бы в пере­мен­ную поме­сти­лось всё что нужно.

// целое, 1 байт
byte b;

// целое, 2 байта
short s;

// целое, 4 байта
int x = 420;

// целое, 8 байт
long l;

// дробное, 4 байта
float fl = 4.3;

// дробное, 8 байт
double d,q;

// логический тип, true или false
boolean bol;

Присваивание и сравнение

Всё как и везде:

// это присваивание

x = 10;

// а это — сравнение x и 10

// результат сравнения отправляется в переменную b

boolean bol;

b = (x == 10);

Ещё есть метод срав­не­ния .equal — он рабо­та­ет более гиб­ко и пред­ска­зу­е­мо, чем ==, пото­му что двой­ное рав­но может срав­ни­вать толь­ко чис­ла и строки.

Структура программы

Раз­ра­бот­чи­кам Java понра­ви­лось, что в C вся про­грам­ма состо­ит из функ­ций, сре­ди кото­рых есть одна обя­за­тель­ная — main, поэто­му сде­ла­ли точ­но так же. В клас­сах эта функ­ция назы­ва­ет­ся методом.

Но есть одно важ­ное отли­чие: каж­дая java-программа — это как бы один боль­шой класс со сво­и­ми раз­де­ла­ми, кото­рые долж­ны быть у каж­до­го клас­са. Бла­го­да­ря это­му боль­шие про­грам­мы лег­ко соби­ра­ют­ся из малень­ких java-кирпичиков и рабо­та­ют друг с дру­гом как с клас­са­ми, исполь­зуя все их возможности.

// программа — тоже класс
public class Program {
   	// публичная часть класса, доступная всем
   	// в ней сразу делают основную функцию программы main
    public static void main(String[] args) {
        // объявляем переменные
        String name = "Код";
        // выводим строку на экран
        System.out.printf("Привет, это журнал %s \n", name);
    // конец основной функции
    }
// конец описания класса
}

Ввод и вывод

Для вво­да и выво­да исполь­зу­ют систем­ный класс System и два его объ­ек­та — in и out. Но на прак­ти­ке чаще все­го вме­сто in исполь­зу­ют объ­ект Scanner, что­бы мож­но было более гиб­ко управ­лять вво­дом данных.

// подключаем класс Scanner 
import java.util.Scanner;

// класс с программой
public class Program {
   
  	// основная функция
    public static void main(String[] args) {
         
        // создаём новый объект ввода, через который будем дальше работать
        Scanner in = new Scanner(System.in);

        // выводим строку
        System.out.print("Введите имя: ");
        // создаём переменную name и помещаем в неё то, что пользователь введёт с клавиатуры
        String name = in.nextLine();

        // выводим ещё одну строку
        System.out.print("Возраст: ");
        // так же запоминаем возраст в другую переменную
        int age = in.nextInt();

        // просим ввести рост
        System.out.print("Введите рост: ");
        // запоминаем введённое значение
        float height = in.nextFloat();

        // выводим строку с результатом
        System.out.printf("Имя: %s  Возраст: %d  Рост: %.2f \n", name, age, height);

        // закрываем наш объект ввода, потому что пока он больше не нужен
        in.close();
    }
}

Условные операторы if и switch

Рабо­та­ют так же, как в C и в любых совре­мен­ных язы­ках высо­ко­го уров­ня. Глав­ное здесь — сле­дить за фигур­ны­ми скоб­ка­ми и не пере­пу­тать, что к чему отно­сит­ся. Про­ще все­го это регу­ли­ро­вать отступами:

// числа для сравнения
int num1 = 6;
int num2 = 8;

// если первое больше второго
if(num1>num2){
	// выводим результат
    System.out.println("Первое число больше второго");
}
// если первое условие не выполнилось — можем проверить второе
else if(num1<num2){
		// выводим другой результат
    	System.out.println("Первое число меньше второго");
	}
	// если и это условие не выполнилось
	else{
		// выводим финальное сообщение
	    System.out.println("Числа равны");
	}

У опе­ра­то­ра мно­же­ствен­но­го выбо­ра есть осо­бен­ность: ему не нуж­ны фигур­ные скоб­ки для дей­ствий в каж­дом слу­чае. Ком­пью­тер по син­так­си­су пони­ма­ет, что к чему отно­сит­ся, и выби­ра­ет нуж­ный вариант.

// число для сравнения
int num = 8;

// сравниваем значение этого числа с нашими вариантами
switch(num){     
	// если число = 1
    case 1: 
    	// выводим сообщение
        System.out.println("число равно 1");
        // выходим из дальнейших проверок
        break;
    // если число = 8
    case 8: 
        System.out.println("число равно 8");
        // увеличиваем число на 1
        num++;
        break;
    // если число = 9
    case 9: 
        System.out.println("число равно 9");
        break;
    // если ни один из вариантов не подошёл
    default:
        System.out.println("число не равно 1, 8, 9");
}

Циклы

В Java есть три основ­ных вида циклов:

  • for — с извест­ным чис­лом повто­ре­ний и счётчиком;
  • do — с про­вер­кой усло­вия до цикла;
  • while — усло­вие про­ве­ря­ет­ся после пер­во­го выпол­не­ния цикла.

Ещё есть два полез­ных оператора:

  • break — пре­ры­ва­ет цикл в любой момент;
  • continue — сра­зу пере­хо­дит к сле­ду­ю­ще­му вит­ку цик­ла без выпол­не­ния осталь­ных команд.

// цикл со счётчиком
// задаётся начальное значение, условие и шаг цикла
for (int i = 1; i < 9; i++){
	// тело цикла
    System.out.printf("Квадрат числа %d равен %d \n", i, i * i);
}

// то же самое с циклом do
int j = 1;
// начинаем цикл
do{
	// выводим результат
    System.out.printf("Квадрат числа %d равен %d \n", i, i * i);
    // увеличиваем переменную цикла
    j++;
}
// проверяем условие цикла
while (j < 9);

// и то же самое с циклом while
int k = 1;
// начинаем цикл и сразу проверяем условие
while (k < 10){
	// выводим результат
    System.out.printf("Квадрат числа %d равен %d \n", k, k * k);
    // увеличиваем переменную цикла
    k++;
}

Функции (они же методы)

Так как каж­дая про­грам­ма — это опи­са­ние какого-то клас­са, то функ­ции в Java — это и есть мето­ды это­го клас­са. Функ­ций (или мето­дов) может быть сколь­ко угод­но, глав­ное — соблю­дать пра­ви­ла опи­са­ния клас­сов. Пока­жем на примере:

// программа — класс
public class Program{

    // публичная часть, доступная всем
    // основная функция-метод main
    public static void main (String args[]){
    	// вызваем методы (функции) в любое время
    	hello();
    	welcome();
    }

    // метод hellо(), который не передаёт и не принимает никаких аргументов
    void hello(){
         
        System.out.println("Привет!");
    } 

    // метод welcome()
    void welcome(){

        System.out.println("Это журнал Код.");
    }
}

Классы

В Java всё постро­е­но на клас­сах, от самой про­грам­мы до реа­ли­за­ций раз­лич­ных функ­ций. Конеч­но, мож­но не исполь­зо­вать клас­сы и рабо­тать в чисто про­це­дур­ном сти­ле, но в Java так не при­ня­то. Это ООП-язык с род­ной под­держ­кой клас­сов на всех уровнях.

Сами клас­сы объ­яв­ля­ют­ся и исполь­зу­ют­ся так же, как и в любом дру­гом ООП-языке:

// объявляем новый класс с информацией о заказанном товаре
class Order{
     
   	// переменные класса
    String name;        // название 
    int cost;           // стоимость

    // метод класса
    void displayInfo(){
    	// выводим информацию о заказе
        System.out.printf("Заказ: %s \tСтоимость: %d\n", name, cost);
    }
}

Объекты

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

Обыч­но исполь­зу­ют клас­сы, про­пи­сан­ные в том же фай­ле, что и про­грам­ма. Если нуж­но исполь­зо­вать класс из дру­гой про­грам­мы, её под­клю­ча­ют отдель­но. Вот самый про­стой спо­соб сде­лать объ­ект на осно­ве преды­ду­ще­го клас­са с заказом:

// программа — тоже класс
public class Program{

    // основная функция-метод main
    public static void main (String args[]){
    	// создаём новый объект на основе класса ниже
    	Order new_order;
    	// заполняем данные
    	new_order.name = "Айфон";
    	new_order.cost = 9999;

    	// вызываем метод класса
    	new_order.displayInfo();
    }

   
}

// объявляем новый класс с информацией о заказанном товаре
class Order{
     
   	// переменные класса
    String name;        // название 
    int cost;           // стоимость

    // метод класса
    void displayInfo(){
    	// выводим информацию о заказе
        System.out.printf("Заказ: %s \tСтоимость: %d\n", name, cost);
    }
}

Текст:

Миха­ил Полянин

Редак­ту­ра:

Мак­сим Ильяхов

Худож­ник:

Даня Бер­ков­ский

Кор­рек­тор:

Ири­на Михеева

Вёрст­ка:

Мария Дро­но­ва

Соц­се­ти:

Олег Веш­кур­цев