Архив рубрики » JAVA «

Заведём жабу? Часть 9. Наследование.

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

Прежде, чем приступить к практике наследования следует повторить знния по модификаторам доступа. Всего существует 4 модификатора доступа.

public — доступ с любого места. Чаще всего используется для внешнего интерфейса.

protected — доступ внутри пакета и в дочерних классах. Чаще всего используется при наследовании.

без указания (или по умолчанию) — доступ внутри пакет. Такой вариант использовать нежелательно. Лучше указывать явно модификатор доступа.

private — доступ только внутри класса. Чаще всего используется для скрытия реализации (инкапсуляции). То есть для каких-либо служебных методов, которые должны работать только внутри класса.

Список представлен в порядке уменьшения области видимости (сверху-вниз).

Давайте попробуем использовать наследование в программном коде.

Наш файл MyFirstProgram.java выглядит примерно так:


package myfirstprogram;
 
import testobject.Computer;
 
public class MyFirstProgram {
 
    public static void main(String[] args) {
       
      Computer comp = new Computer("IBM", 2048, 320, 2);
       
//     comp.setName("IBM");
//       
//      comp.setRam(2048);
//      
//      comp.setHdd(320);
       
      comp.on();
       
      comp.load();
       
      comp.off();
       
    }
     
}

ПОДРОБНЕЕ »

Заведём жабу? Часть 8. Теория наследования.

Теория наследования.

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

Наследование можно назвать расширением, так как дочерний класс расширяет родительский. Представим, что у нас есть два класса. У первого класса есть три метода. Класс 2, допустим, пустой и ни с чем не связан. Класс 2 хочет унаследоваться от класса 1. В этом случае класс 1 будет являться родительским классом или по другому «суперклассом,» а класс 2 — дочерним классом, или по другому подклассом.

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

После того, как мы унаследовались от класса 1 — методы класса 1 становятся доступны и во втором классе. Как будто они автоматически скопировались в программный код и теперь эти методы можно использовать и в классе 2.  Нам не нужно вручную копировать эти методы из класса 1 и вставлять их в класс 2 — в этом случае идёт повторное использование кода.

Чаще всего применяется следующий вариант: класс 2 после наследования добавляет какие-то свои методы реализации, которые будут доступны также, как и наследуемые.

ПОДРОБНЕЕ »

Заведём жабу? Часть 7.

Конструктор

Конструктор — это блок кода внутри класса, который вызывается перед созданием объекта. У конструктора одна цель — создание экземпляра класса с заранее определённым состоянием. Под состоянием понимается совокупность значений переменных класса или по другому свойств класса. Конструктор позволяет перед созданием объекта присвоить этим переменным начальные значения, а не оставлять их «по умолчанию»

Конструктор — это НЕ МЕТОД (хотя в некоторой литературе встречается определение «метод, который инициализирует объект») и не надо его путать с методом.

У класса может быть несколько конструкторов. Мы можем использовать любой из них для создания объекта.

На схеме класс, который содержит 4 конструктора. Чаще всего у конструкторов модификатор доступа public. После того, как вызывающая сторона обратилась к одному из конструкторов, тот автоматически инициализирует объект с определённым начальным состоянием, после это объект готов к работе. Можно вызвать любой из конструкторов, каждый из них по-своему создаёт объект.

Когда в прошлых уроках мы создавали объект Computer, писали так Computer comp = new Computer();

В данном случае мы вызывали «конструктор по умолчанию», который создаётся автоматически компилятором, если другие конструкторы не указаны. Теперь мы создадим наши личные конструкторы. Перейдём в класс Computer. Создание конструктора начинается с модификатора доступа. Пусть будет public — видео везде. КОНСТРУКТОР НЕ ИМЕЕТ НИКАКИХ ВОЗВРАЩАЕМЫХ ЗНАЧЕНИЙ! Даже void писать НЕ НУЖНО! Название конструктора должно совпадать с именем класса. То есть имя конструктора будет Computer. Затем в фигурных скобках указываем параметры, которые будут передаваться в этот конструктор. Само собой конструктор пишется внутри класса.

К примеру мы хотим создать объект с начальным значением имени. Выглядеть это будет примерно так:

 

public Computer (String name) {
        
        this.name = name;
    }

 

name — у нас переменная типа String. В фигурных скобках мы присваиваем переменной класса computer name новое значение переданному параметру name. Напишем так name = name. Мы хотим, чтобы левая переменная name относилась к переменной класса Computer, а правая переменная name относилась к переданному параметру name, но так как их имена совпадают компилятор не может разобраться какую переменную и куда мы хотим записать. Чтобы выполнить эту задачу, следует воспользоваться ключевым словом this (этот).

Слово this обозначает, что мы используем какой-либо элемент текущего класса или объекта. В данном случае мы из текущего объекта находим переменную name и в неё мы записываем переданный параметр name. Правый nsme — переданный параметр, а левый name — переменная нашего класса.

Ключевое слово this указывает на ссылку для текущего объекта Computer. Таким образом мы можем передавать переменную с таким же именем, что и переменная класса. Если мы будем использовать ключевое слово this, то путаницы не будет.

Давайте создадим конструктор для переменной ram. Делаем по аналогии с name, только тип переменной уже будет int.

    public Computer (int ram) {
        
        this.ram = ram;
    }

В качестве входного параметра первый конструктор принимает имя, второй размер оперативной памяти. Теперь давайте попробуем создать наш объект при помощи конструктора. Перейдём в файл MyFirstProgram.java Напротив строки Computer comp = new Computer(); можно увидеть горящий символ — компилятор «говорит,» что нет такого конструктора для объекта Computer. Потому что раньше мы использовали «конструктор по умолчанию» без параметров (в скобках нет параметров), который создавала сама виртуальная машина Java автоматически, поскольку никаких конструкторов мы не прописывали.

Теперь мы прописали свои два конструктора и в этом случае действует правило, что если вы написали свои конструкторы, то конструктор «по умолчанию» исчезает, перестаёт действовать из-за чего и «ругается» компилятор.

Но если мы хотим, чтобы был конструктор «по умолчанию», нам в этом случае придётся написать его самим вручную. В качестве параметров ничего не передаётся.


public Computer() {
        
    }

Именно такой конструктор «по умолчанию» без параметров создаёт компилятор, если нет других конструкторов, но в коде он не отображается.

В данном случае нам пришлось вручную написать конструктор без параметров, чтобы мы могли создавать объект, не передавая никаких параметров в конструктор. Теперь компилятор разобрался. Если мы нажмём Ctrl и сделаем щелчок ЛКМ по Computer();, то Netbeans перенесёт нас в файл Computer.java в участок кода


public Computer() {
        
    }

То есть в тот конструктор, который мы вызываем при создании объекта.Давайте создадим конструктор для параметра hdd.


 public Computer (int hdd) {
        
        this.hdd = hdd;
    }

ВАЖНЫЙ МОМЕНТ. МЫ ХОТЕЛИ СОЗДАТЬ КОНСТРУКТОР ДЛЯ ПЕРЕМЕННОЙ HDD, ОДНАКО КОМПИЛЯТОР «РУГАЕТСЯ» ПО ПРИЧИНЕ ТОГО, ЧТО ТАКОЙ КОНСТРУКТОР УЖЕ ОПРЕДЕЛЁН В ОБЪЕКТЕ Computer. Дело в том, что компилятор «смотрит» на список параметров (то есть на передаваемые типы переменных в круглых скобках), не на их названия, а на их типы! В данном случае он «говорит» , что уже есть конструктор с одним параметром типа int. Второй такой же создать нельзя.

Если мы хотим, чтобы у нас было два конструктора с одинаковыми типами параметров и с их одинаковым количеством — то ничего не выйдет — компилятор «запретит» нам это сделать. Как же быть в этой ситуации? Чтобы не писать конструктор для каждой переменной можно создать конструктор, который будет включать в себя все нужные нам переменные, которые есть у класса. Удалим вышеприведённый кусок кода и модифицируем конструктор

 

public Computer (String name) {
        
        this.name = name;
    }

 

в следующий вид

 
   public Computer (String name, int ram, int hdd, int weight) {
        
        this.name = name;
        
        this.ram = ram;
        
         this.hdd = hdd;
         
         this.weight = weight;
    }

Теперь давайте изменим наш код так, чтобы мы присваивали значения не через «сетер,» а перед созданием объекта. Закомментируем следующий участок кода в классе MyFirstProgram, дабы показать, что можно сделать по другому.

       
//     comp.setName("IBM");
//       
//      comp.setRam(2048);
//      
//      comp.setHdd(320);

Для того, чтобы закомментировать выделяем нужный нам диапазон, нажимаем ctrl и наклонный слэшь. Для раскомментирования делаем тоже самое. Изменим строку вызова конструктора так, чтобы вызывался конструктор с параметрами. Вот эта строка: Computer comp = new Computer();

Поставим курсор в скобки и нажмём ctrl + space (пробел). Netbeans предложит на выбор несколько конструкторов с параметрами и без. Выберем тот, где 4 параметра.

 Computer comp = new Computer(null, 0, 0, 0);

Теперь мы можем передать какие-то значения. Давайте передадим те значения, которые остались у нас в закомментированных «сетерах.» Имя — IBM, Оперативная память — 2048, Объём жесткого диска — 350, вес пусть будет — 2.


Computer comp = new Computer("IBM", 2048, 320, 2);

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

run:
Я включился. Моя модель IBM
Я загружаюсь. Мой объём жесткого диска равен 320 ГБ
Я выключился
СБОРКА УСПЕШНО ЗАВЕРШЕНА (общее время: 0 секунд)

То есть теперь мы присвоили значения переменным объекта Computer ДО СОЗДАНИЯ объекта Computer. А в прошлый раз мы создавали объект Computer, используя конструктор «по умолчанию,» и только затем после создания мы использовали «сетеры» для присвоения значений переменных.

Конструктор создаёт объект уже с начальным состоянием. В прошлый же раз у нас было состояние «по умолчанию,» которое мы изменяли при помощи «сетеров.»

Обратите внимание на данную схему. Самый упрощённый вариант работы конструктора такой:конструктор имеет несколько входных параметров, на схеме у нас 4 параметра, после вызова конструктора значения этих параметров записываются в переменные класса. Таким образом до инициализации объект получает какое-то начальное состояние или по-другому значения переменных класса.

То есть последовательность такая: запись значения в переменных класса и только после этого создание объекта.

Конструктор и метод внешне похожи, но назначение их разное. От метода конструктор отличается тем, что у него НЕТ типа возвращаемого значения, нет даже void.

Конструктор имеет имя такое же, как у класса. Методы же можно называть как угодно и только никак название класса.

Если никакой конструктор не указан — компилятор автоматически создаёт конструктор по умолчанию. (без параметров)

Следует различать конструктор «по умолчанию» (созданный автоматически компилятором), и конструктор без параметров, созданный программистом (в этот конструктор программист ещё может добавить какую-то логику работы, чего нет в конструкторе от компилятора).

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

Конструктор также имеет модификатор доступа!

Если программист в коде написал какой-то свой конструктор, то конструктор «по умолчанию» не создаётся!

Netbeans позволяет быстро создавать конструктор. Для этого следует нажать ctrl+space(пробел). Используя этот способ всё, что мы писали вручную — можно было создать автоматически.

Обратите внимание на неточность в нашем предыдущем конструкторе.


public Computer (String name, int ram, int hdd, int weight) {
        
        this.name = name;
        
        this.ram = ram;
        
         this.hdd = hdd;
         
         this.weight = weight;
    }

А именно переменная weight является типа double, но в вышеприведённом участке кода она отображена как int и компилятор это воспринял. Это произошло потому, что double включает в себя как и целые числа, так и числа с плавающей точкой. То есть диапазон типа double намного шире диапазона типа integer, поэтому мы можем передавать целое число, но записать его в тип double.

Однако так делать не рекомендуется, поскольку может возникнуть путаница. К примеру если мы хотим передать значения веса в 2 килограмма 200 граммов — ничего не выйдет, поскольку тип переменной weight в конструкторе integer. А вот 2 килограмма вполне себе запишутся в переменную weight с типом double и никаких проблем не будет. Но лучше указывать тип, который нужен ДЛЯ ПЕРЕМЕННОЙ КЛАССА. Исправим на double.


public Computer (String name, int ram, int hdd, double weight) {
        
        this.name = name;
        
        this.ram = ram;
        
         this.hdd = hdd;
         
         this.weight = weight;
    }

Заведём жабу? Часть 6.

Инкапсуляция

Страшное слово «Инкапсуляция» — представляет собой всего лишь сокрытие реализации. Если вы попробуете присмотреться, вы увидите слово «капсула». Каждый объект не должен выставлять наружу все свои параметры для изменения просто так. Это изоляция (скрытие) внутренних методов в классе с целью избежания вредного воздействия на них. При этом некоторые методы являются доступными для вызова (модификатор доступа public). Вместе эти методы создают интерфейс программа — видимые внешнему миру. Эти методы взаимодействуют со скрытыми.

 

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

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

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

Теперь откроем наш класс Computer. Внутри методов on(); off(); load(); внутри никакой сложной реализации нет, мы просто выводим информацию на экран. Теперь изменим внутреннюю реализацию так, чтобы один из public-методов вызывал внутренний метод. Для создания внутреннего метода мы используем модификатор доступа private.  Пусть наш метод выводит на экран данные, которые будут передаваться в этот метод.


private void print (String str){
   
  System.out.println(str);

}

Наш метод ничего не будет возвращать, просто выводить данные на экран, поэтому его тип будет void. Название нашего метода — print. В качестве параметра ему будет передаваться строка, а для того, чтобы передать строку, тип нашего параметра должен быть String. str — сам параметр (контейнер, переменная) в которую мы отправляем данные. В фигурных скобках команда для вывода на экран, а вместо надписи в кавычках пишем название переменной — str.

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

Теперь изменим наши методы onn, off и load, чтобы они не сами выводили надпись, а передавали нашему внутреннему методу print свой текст.


  public void on(){
                   
       print("Я включился " + name);  
        
    }
    
      public void off(){
        
      print("Я выключился");  
          
    }
    
     public void load(){
         
      print("Я загружаюсь. Мой объём жесткого диска равен " + hdd + " ГБ");  
        
    }
     
  private void print (String str){
   
      System.out.println(str);
}

Теперь текст на экран выводит отдельный метод, который недоступен для внешнего пользования, поскольку у него модификатор доступа private. Метод print не доступен из файла MyFirstProgram.java, поскольку имеет модификатор private. Если мы запустим программу — она выведет те же самые значения, что и ранее. То есть функционал класса не поменялся, но изменилась внутренняя реализация.

В классе MyFirstProgram ничего не поменялось — это простейший пример интерфейса. При изменении внутренней реализации — для пользователя изменения незаметны.

В Netbeabs есть одно свойство, которое позволяет быстро просмотреть интерфейс любого класса, а аткже всю его внутреннюю реализацию. Для этого следует перейти в окно «Навигатор» (Меню Окно — Навигация — Навигатор). В навигаторе доступны все методы нашего класса. Методы, отмеченные замком слева означает private-метод, то есть скрытый метод. У метода print как раз такой значок в виде звонка. Метод print имеет модификатор доступа private.

Методы on(); off(); и load(); не имеют замка — данные методы имеют модификатор доступ public. Также отображаются переменные нашего класса. И в классе они также имеют модификатор доступ private. Переменные обозначаются синими квадратиками, а методы обозначаются кружками. Снизу можно переключать область видимости, например, чтобы сделать доступными только публичные методы. Можно также скрыть переменные. Если щелкнуть два раза по методу или переменной в навигаторе — курсор автоматически перейдёт к этой переменной или методу в самом коде.

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

Заведём жабу? Часть 5.

Доступ к свойствам объекта (Get и Set)

На данный момент у нас есть два файла java — это Computer.java с вот таким содержимым


package testobject;
 
public class Computer {
     
    public String name;    
      
    public int ram;  
         
    public int hdd;
     
    public double weight;
     
    public void on(){
        
       int time;
         
       System.out.println("Я включился. Моя модель " + name);  
         
    }
     
      public void off(){
         
       System.out.println("Я выключился");  
           
    }
     
    public void load(){
       
    System.out.println("Я загружаюсь. Мой объём жесткого диска равен " + hdd + " ГБ");  
      
 }
     
}

И файл MyFirstProgram.java с таким содержимым:

package myfirstprogram;
 
import testobject.Computer;
 
public class MyFirstProgram {
 
    public static void main(String[] args) {
       
      Computer comp = new Computer();
       
      comp.name = "IBM";
       
      comp.hdd = 350;
       
      comp.on();
       
      comp.load();
       
      comp.off();
       
    }
     
}

Сегодня мы рассмотрим доступ к свойствам объекта при помощи так называемых «гетеров» и «сетеров». В прошлом уроке мы создали у объекта Computer несколько характеристик: public String name; public int ram; public int hdd; public double weight; Всё это, как вы помните, свойства объекта или ещё говорят переменные класса. Обратите внимание, что наши переменные класса используют модификатор доступа public.

Однако следует помнить, что использовать модификатор доступа public в полях класса не безопасно. Любой, кто использует объект, может напрямую изменить свойство объекта. Например, такие свойства, как объём жесткого диска, количество оперативной памяти, вес — не могут быть меньше 0. Но сейчас мы можем присвоить им отрицательные значения, так как наши переменные имеют модификатор доступа public. (comp.hdd = -100;)

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

ВЫВОДЫ

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

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

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

get — получить значение.

set — передать значение.

В коде представляют собой обычные методы, но имя, как правило, начинается с префиксом get или set, чтобы было понятней. К примеру getName и setName.

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

ПОДРОБНЕЕ »

Заведём жабу? Часть 4

Типы переменных в JAVA.

В JAVA сущестуют два типа переменных. Примитивные и Ссылочные.

1.Примитивные

byte (целые числа, 1 байт)
short (целые числа, 2 байта)
int (целые числа, 4 байта)
long (целые числа, 8 байтов)
float (вещественные числа, 4 байта)
double (вещественные числа, 8 байтов)
char (символ Unicode, 2 байта)
boolean (значение истина/ложь, 1 байт)

2. Ссылочные. (от слова ссылка).- String, Computer и прочие объекты.

 

В нашем примере Computer comp = new Computer(); переменная comp — это ссылочная переменная, так как она содержит ссылка на объект. К ссылочным переменным относятся типы String.  Ссылочным типом может быть любой тип объекта, созданный в программе. В нашем случае это переменная типа Computer. Почему String — это ссылочный тип? Это задумка разработчиков языка Java. При создании переменной типа String всегда создаётся объект в памяти. 

К примеру, мы напишем String str = «abc»; здесь создаться объект типа String со значением abc и ссылка на объект будет находиться в переменной str.  Тип переменной String — это ссылочный тип.

Значение NULL.

Null — это пустое значение. Используется для ссылочных переменных и означает, что переменная не имеет указатель на какой-либо объект. В нашем случае после создания объекта Computer переменная comp ссылается на объект Computer в памяти.

Если после этого мы присвоем переменной comp значение null (comp = null;) , то после этого переменная comp уже не будет ссылаться на объект Computer. В этом случае на объект Computer больше никто не ссылается, то есть в нашей программе нет больше ссылок на объект Computer.

Когда ссылка на объект уничтожается и переменная comp ни на что не ссылается, Computer становится кандидатом на удаление сборщиком мусора.

 

Заведём жабу? Часть 3

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

Теперь созданим первый объект в среде Netbeans.

  1. Запустите редактор Netbeans.
  2. Нажмите ПКМ (Правая Кнопка Мыши) по строке Пакеты исходных кодов (слева) — в открывшемся окне выберите Создать — Пакет java (в некоторых версиях Новый — Пакет java)
  3. В графе «имя пакета» введите testobject. Нажмите готов.
  4. Нажмите ПКМ на созданном пакете testobject. Выберите Создать — Класс Java
  5. В открывшемся окне в графе Имя класса введите Computer. Нажмите «Готово».

Мы создали класс Computer, который находится в пакете testobject.

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package testobject;

/**
 *
 * @author пк
 */
public class Computer {
    
}

Комментарии можно удалить. Структура кода простейшая. Объявление пакета и объявление публичного класса.Теперь следует добавить какие-то характеристики нашему объекту Computer. Характеристики в программном коде представляют собой переменные, объявленные внутри класса. По другому их называют ПОЛЯМИ КЛАССА или свойствами класса. То есть эти переменные находятся внутри класса. Давайте добавим новое поля, которое будет характеризовать модель нашему компьютера. public String name;


package testobject;

public class computer {

    public String name;    
        
}

public — модификатор доступа. Говорит нам о том, что переменная name будет доступна из любого места программы.
String — тип переменной (тип данных). String предназначен для хранения строк текста.
name — имя переменной, в этом контейнере будет храниться имя компьютера. Может быть любым, но желательно, чтобы подходило по смыслу. Мы могли бы написать и так — «imia.»

Добавим ещё одну характеристику к нашему компьютеру. Оперативная память измеряется у нас в целых числах, значит тип переменной (тип данных) у нас будет целое число — int. Пишем public int ram;


package testobject;

public class computer {

    public String name;    
    
    public int ram;     
}

Добавим характеристику жесткого диска. public int hdd; И характеристику веса. Вес может содержать числа с двойной точностью (числа после запятой), значит тип переменной будет double. public double weight;


package testobject;

public class Computer {
    
    public String name;    
     
    public int ram;  
        
    public int hdd;
    
    public double weight;
}

Мы создали 4 поля или 4 характеристики объекта Computer, которые будут характеризовать его своими значениями. Теперь давайте добавим какие-либо действия для нашего объекта Computer. Действия в программном коде представляют собой обычные МЕТОДЫ. Добавим метод «Включиться» (on).

 public void on(){
        
    }

Разберём данные строки.

public — модификатор доступа. Говорит нам о том, что метод будет доступен из любого места программы.

void — говорит нам о том, что метод не будет возвращать никаких значений.

on — название метода (может быть любым).
on() — скобки. В скобках мы можем передавать какие-то параметры в данный метод. Пока мы ничего не будем передавать — оставим их пустыми.

Каждый метод обрамляется фигурными скобками { }.

Мы создали одно действие для компьютера — on, то есть включить. По аналогии создадим метод выключить (off).

 public void off(){
        
    }

Добавим метод загрузка (load)

 public void load(){
        
    }

Теперь в каждом методе напишем, что он выполняет. Уже известной командой: System.out.println(«Ваш текст»); (печать в строку).

Обратите внимание, когда Вы нажимаете точку — Netbeans выдаёт список опций.

 public void on(){
        
       System.out.println("Я включился");  
        
    }
    
      public void off(){
        
       System.out.println("Я выключился");  
          
    }
    
     public void load(){
         
       System.out.println("Я загружаюсь");  
        
    }

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


  public String name;    
     
    public int ram;  
        
    public int hdd;
    
    public double weight;

Они будут доступны внутри этого класса и внутри этих методов:


Они будут доступны даже, если модификатор доступа будет private. Private - обозначает доступ внутри класса. Если переменная объявлен внутри метода, например вот так (переменная время - time):


 public void on(){

   int time; 
        
   System.out.println("Я включился");  
        
    }

То эта переменная (time) не будет доступна в других методах! Она имеет область доступа только локально — внутри метода on. Это закрытая переменная, которая действует только во время работы метода. Как только метод отработал — эта переменная уже нигде не доступна. Теперь следует научиться создавать объект Computer, или, как ещё говорят, инициализировать. Для инициализации используется определённое ключевое слово. Итак:

1) Удалите переменную int time;
Код файла Computer.java должен выглядеть так:


package testobject;

public class Computer {
    
    public String name;    
     
    public int ram;  
        
    public int hdd;
    
    public double weight;
    
    public void on(){
       
       int time;
        
       System.out.println("Я включился");  
        
    }
    
      public void off(){
        
       System.out.println("Я выключился");  
          
    }
    
     public void load(){
         
       System.out.println("Я загружаюсь");  
        
    }
    
}

2) Перейдите в файл MyFirstProgram.java. Удалите оператор System.out.println(«Hello, world!»); Код должен быть таким:


package myfirstprogram;

public class MyFirstProgram {

    public static void main(String[] args) {
      
        
        
    }
    
}

3) Для того, чтобы создать наш объект Computer, необходимо написать следующую конструкцию: Computer comp = new Computer();


package myfirstprogram;

public class MyFirstProgram {

    public static void main(String[] args) {
      
      Computer comp = new Computer();  
        
    }
    
}

ПОДРОБНЕЕ »

Заведём жабу? Часть 2

Теперь остановимся на структуре кода. Сейчас у нас файл MyFirstProgram.java содержит следующий код:

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package myfirstprogram;

/**
 *
 * @author Максим
 */
public class MyFirstProgram {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
    }
    
}

Любой код java пишется внутри класса. Не может быть код вне класса! В нашем случае класс имеет название MyFirstProgram.
Обычно класс определяет в себе код с определённым функционалом, с каким-то смыслом.
(к примеру класс database — стало быть код в нём служит для работы с базой данных).
Класс — это контейнер для программного кода. Границы класса задаются фигурным скобками {}.
Netbeans подсвечивает эти границы, чтобы мы их видели визуально. Скобки также задают границы методов (у нас сейчас один метод
public static void main(String[] args)), границы условных операторов и различных участков кода.
Метод — одно из основных понятий в языке java! Метод — это аналог понятия функции из процедурных языков программирования
(например из Паскаля, Дельфи, Лазаруса)

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

ПОДРОБНЕЕ »