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

Объект — объекты имеют состояние и поведение. Например: собака может иметь состояние — цвет, имя, а также и поведение — кивать, бежать, лаить, кушать. Объект является экземпляром класса.

Класс — может быть определен как шаблон, который описывает поведение объекта.

Метод — является в основном поведением. Класс может содержать несколько методов. Именно в методах логически записанные данные манипулируют и выполняют все действия.

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

Первая программа и знакомство с синтаксисом языка

Давайте рассмотрим простой код, в результате которого будут выведены на экран слова «Привет мир!», а за одно и синтаксис Java.

public class MyFirstJavaProgram {
   
   public static void main(String []args) {
   /* Это первая моя java-программа.
   В результате выполнения на экран будет выведено 'Привет мир!'
   */
      System.out.println("Привет мир!"); // Вывод сообщения на экран
   }
} 

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

  • Откройте блокнот и добавьте код, указанный выше.
  • Сохраните файл как «MyFirstJavaProgram.java». Ниже мы рассмотрим синтаксис Java и узнаем почему именно под таким именем.
  • Откройте окно командной строки и перейдите в каталог, где был сохранен файл. Предположим, что это «C:\».
  • Введите «Javac MyFirstJavaProgram.java» и нажмите ввод, чтобы скомпилировать код. Если нет ошибки в коде, командная строка приведет Вас к следующей строке: (Assumption: The path variable is set).
  • Теперь введите «java MyFirstJavaProgram» для запуска программы.
  • Теперь Вы увидите «Привет Мир!», напечатанный в окне.
C:> javac MyFirstJavaProgram.java
C:> java MyFirstJavaProgram
Привет мир!

Основы синтаксиса языка Java

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

  • Чувствительность к регистру — Java чувствителен к регистру, то есть идентификатор Hello и hello имеют разный смысл.
  • Название классов — для всех первая буква должна быть в верхнем регистре.
  • Если несколько слов используются, чтобы сформировать название класса, первая буква каждого внутреннего слова должна быть в верхнем регистре, например, «MyJavaClass».
  • Название методов — в синтаксисе Java все имена методов должны начинаться с буквы нижнего регистра.
  • Если несколько слов используются, чтобы сформировать имя метода, то первая буква каждого внутреннего слова должна быть в верхнем регистре, например, «public void myMethodName()».
  • Название файла программы — наименование файла программы должно точно совпадать с именем класса.
  • При сохранении файла, Вы должны сохранить его, используя имя класса (помните о чувствительности к регистру) и добавить «.java» в конце имени (если имена не совпадают, Ваша программа не будет компилироваться), например, «MyJavaProgram» — это название класса, тогда файл должен быть сохранен как «MyJavaProgram.java».
  • public static void main(String args[]) — обработка программы начинается с метода main(), который является обязательной частью каждой программы.

Идентификаторы в Java

Идентификаторы — имена, используемые для классов, переменных и методов. Все компоненты Java требуют имена.

Существует несколько правил в синтаксисе языка Java, которые необходимо помнить об идентификаторе. Они следующие:

  • Каждый идентификатор должен начинаться с «A» до «Z» или «a» до «z», «$» или «_».
  • После первого символа может иметь любую комбинацию символов.
  • Ключевое слово не может быть использовано в качестве идентификатора.
  • Самое главное — идентификатор в Java чувствителен к регистру.
  • Пример правильного написания: age, $salary, _value, __1_value.
  • Пример неправильного написания: 123abc, -salary.

Перечисления

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

С использованием перечисления в Java можно уменьшить количество ошибок в коде.

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

Пример кода перечисления в Java

class FreshJuice {

   enum FreshJuiceSize{ SMALL, MEDIUM, LARGE }
   FreshJuiceSize size;
}

public class FreshJuiceTest {

   public static void main(String args[]){
      FreshJuice juice = new FreshJuice();
      juice.size = FreshJuice.FreshJuiceSize.MEDIUM;
      System.out.println("Размер: " + juice.size);
   }
}

Полученный результат выше приведенного примера:

Размер: MEDIUM

Примечание: в Java перечисления могут быть объявлены как самостоятельно, так и внутри класса. Методы, переменные, конструкторы могут быть определены также внутри перечисления.

Типы переменных

В Java мы увидим следующие существующие типы:

  • переменные экземпляра (instance variables);
  • переменные класса (class variables);
  • локальные переменные (local variables);
  • параметры (parameters);

Переменные экземпляра. Пусть у нас есть несколько объектов одного класса Automobile(). Помимо общих параметров у них есть уникальные, скажем, максимальная скорость maxSpeed(). Их можно инициировать в теле программы, а можно хранить в нестатических полях класса (объявленных без добавления слова static). Таким образом, каждый экземпляр будет обладать индивидуальным параметром, не зависящим от скоростей других объектов.

public class Automobile{
  public String name;
  private double maxSpeed;
  public Automobile (String autoName){
     name = autoName;
  }}

Переменная класса, или статическая переменная java, напротив, объявляется исключительно с применением слова static. В данном случае её значение будет одинаковым для всех экземпляров. В случае того же автомобиля, введём параметр gearsNum – число передач. Для всех экземпляров оно будет равно 6.

Необязательный модификатор final позволяет присвоить значение переменной только один раз. За соблюдением этого следит компилятор.

public class Automobile{
  public String model;
  private double maxSpeed;

  public static final int gearsNum = 6;
}

Локальные переменные и методы в java неизменно связаны. В последних часто фигурируют вспомогательные параметры, которые в дальнейшем коде не нужны. Для объявления локальной переменной нет особой формы инициализации, границы её действия зависят лишь от места объявления. В данном случае — в фигурных скобках внутри метода. При выходе из него переменная будет уничтожена, поэтому обратиться к ней будет уже нельзя.

Крайний случай локальных переменных — это параметры. В частности, классический пример «Hello, World!»:

class HelloWorld {
   public static void main(String[] args) {
       System.out.println("Hello World!");
   }
}

Здесь сразу два параметра. Первая — собственно, «Hello, World!», вторая — аргумент строки args в main.

 

Модификаторы

Модификаторы доступа - это ключевые слова (зарезервированные идентификаторы), которые определяют доступность класса или его членов. В языке Java предусмотрены следующие модификаторы доступа:

  • public - общедоступный;
  • protected - защищенный;
  • private - закрытый;
  • default - пакетный.
  1. Если метод или поле имеют модификатор public, то они доступны любому классу и пакету.
  2. Если метод или поле имеют модификатор доступа protected, то они, прежде всего, доступны самому классу и его наследникам. Кроме того, доступ к этим членам класса могут получить их собратья по пакету.
  3. Если метод или поле имеют модификатор доступа private, то они доступны только в рамках класса. Такие члены класса не наследуются, поэтому их невозомжно заместить в подклассах. Помните об этом.
  4. Если метод или поле имеют модификатор доступа по умолчанию, то они доступны только в рамках пакета.

Для членов класса (полей и методов) разрешено использование всех указанных выше модификаторов.
 
Элементы помеченные как public имеют наибольшую видимость и доступны другим классам отовсюду

public class MyClass {
 
  public String myField;
 
  public void myMethod(){
  
  }
 
}


Следует отметить, что поля, редко обозначают как общедоступные, чаще как закрытые и доступ к ним осуществляется в этом случае через public-методы

Protected-члены доступны в классе в котором они определены и в подклассах. Так же данные члены доступны другим классам, находящимся в этом же пакете

public class MyClass {

  protected String myField;
 
  protected void myMethod(){
  
  }

}


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

public class MyClass {

  private String myField;
 
  private void myMethod(){
  
  }

}

 
Отдельно следует сказать о пакетном уровне доступа (default). Отметим, что ключевое слово default в отличие от остальных модификаторов не пишется. Элемент считается с пакетным уровнем доступа, если не указан ни один из модификаторов доступа

 public class MyClass {

  String myField;
 
  void myMethod(){
  
  }
}


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

Для классов и интерфейсов верхнего уровня, т.е. не вложенных (внутренних), применимы только общедоступный (public) и пакетный (default) модификаторы. Если класс объявлен как public, то к нему можно получить доступ отовсюду.

Если же модификатор доступа не указан, то класс имеет пакетную область видимости и доступ к нему имеют только классы из того же пакета

 class MyClass {
 
 }

Отметим, что внутренние классы как статические так и нестатические могут иметь любой модификатор доступа (public, protected, private) или не иметь ни одного (пакетный доступ).

Массив

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

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

Индекс начального элемента — 0, следующего за ним — 1 и т. д. Индекс последнего элемента в массиве — на единицу меньше, чем размер массива.

В Java массивы являются объектами. Это значит, что имя, которое даётся каждому массиву, лишь указывает на адрес какого-то фрагмента данных в памяти. Кроме адреса в этой переменной ничего не хранится. Индекс массива, фактически, указывает на то, насколько надо отступить от начального элемента массива в памяти, чтоб добраться до нужного элемента.

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

Возможные следующие варианты объявления массива:

тип[] имя;
тип  имя[];

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

Примеры:

int[] a;
double[] ar1;
double  ar2[];

В примере мы объявили имена для трёх массивов. С первом именем a сможет быть далее связан массив из элементов типа int, а с именами ar1 и ar2 далее смогут быть связаны массивы из вещественных чисел (типа double). Пока мы не создали массивы, а только подготовили имена для них.

Теперь создать (или как ещё говорят инициализировать) массивы можно следующим образом:

a = new int[10]; // массив  из 10 элементов типа int
int n = 5;
ar1 =  new double[n]; // Массив из 5 элементов double
ar2 = {3.14, 2.71, 0, -2.5, 99.123}; // Массив из 6 элементов типа double

Примеры основных операций с массивами

1. Объявление массива String[] aArray = new String[5];

String[] bArray = {"a","b","c", "d", "e"};
String[] cArray = new String[]{"a","b","c","d","e"};

2. Вывод массива в Java int[] intArray = { 1, 2, 3, 4, 5 };

String intArrayString = Arrays.toString(intArray);

// print directly will print reference value
System.out.println(intArray);
// [I@7150bd4d
 
System.out.println(intArrayString);
// [1, 2, 3, 4, 5]

3. Создание ArrayList из массива String[] stringArray = { "a", "b", "c", "d", "e" };

ArrayList arrayList = new ArrayList(Arrays.asList(stringArray));
System.out.println(arrayList);
// [a, b, c, d, e]


4. Проверка массива на наличие конкретного значения String[] stringArray = { "a", "b", "c", "d", "e" };

boolean b = Arrays.asList(stringArray).contains("a");
System.out.println(b);
// true


5. Объединение двух массивов int[] intArray = { 1, 2, 3, 4, 5 };

int[] intArray2 = { 6, 7, 8, 9, 10 };
// Apache Commons Lang library
int[] combinedIntArray = ArrayUtils.addAll(intArray, intArray2);


6. Объявление массива в одной строке method(new String[]{"a", "b", "c", "d", "e"});


7. Объединение элементов массива в строку // containing the provided list of elements

// Apache common lang
String j = StringUtils.join(new String[] { "a", "b", "c" }, ", ");
System.out.println(j);
// a, b, c


8. Преобразование ArrayList в массив String[] stringArray = { "a", "b", "c", "d", "e" };

ArrayList arrayList = new ArrayList(Arrays.asList(stringArray));
String[] stringArr = new String[arrayList.size()];
arrayList.toArray(stringArr);
for (String s : stringArr)
    System.out.println(s);


9. Преобразование массива во множество (Set) Set set = new HashSet(Arrays.asList(stringArray));

System.out.println(set);
//[d, e, b, c, a]


10. Возврат массива с элементами в обратном порядке int[] intArray = { 1, 2, 3, 4, 5 };

ArrayUtils.reverse(intArray);
System.out.println(Arrays.toString(intArray));
//[5, 4, 3, 2, 1]


11. Удаление элемента из массива int[] intArray = { 1, 2, 3, 4, 5 };

int[] removed = ArrayUtils.removeElement(intArray, 3);//create a new array
System.out.println(Arrays.toString(removed));

Комментарии в Java

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

Пример комментария

public class MyFirstJavaProgram{

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

    public static void main(String []args){
       // Однострочный комментарий.
       /* Тоже однострочный комментарий. */
       System.out.println("Привет мир"); 
    }
} 

Ключевые слова в Java

Всего зарезервировано 50 ключевых слов в Java. Ниже в таблице приведен список зарезервированных ключевых слов.

Список ключевых слов
abstract assert boolean break
byte case catch char
class const continue default
do double else enum
extends final finally float
for goto if implements
import instanceof int interface
long native new package
private protected public return
short static strictfp super
switch synchronized this throw
throws transient try void
volatile while    

Важно! Ключевое слово не может быть употреблено в качестве константы или переменной, или любых других имен идентификаторов.

Пустая строка

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

Наследование

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

Интерфейс

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

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