Как на java написать приложение для android

Время на прочтение
8 мин

Количество просмотров 528K

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

Статья затронет весь цикл разработки приложения. Вместе мы напишем простенькую игру “Крестики-Нолики” с одним экраном (в ОС Android это называется Activity).

Отсутствие опыта разработки на языке Java не должно стать препятствием в освоении Android. Так, в примерах не будут использоваться специфичные для Java конструкции (или они будет минимизированы на столько, на сколько это возможно). Если Вы пишете, например, на PHP и знакомы с основополагающими принципами в разработке ПО, эта статья будет вам наиболее полезна. В свою очередь так как, я не являюсь экспертом по разработке на Java, можно предположить, что исходный код не претендует на лейбл “лучшие практики разработки на Java”.

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

Перечислю необходимые инструменты. Их 3:

1. JDK — набор для разработки на языке Java;
2. Android SDK and AVD Manager — набор утилит для разработки + эмулятор;
3. IDE c поддержкой разработки для Android:
   • Eclipse + ADT plugin;
   • IntelliJ IDEA Community Edition;
   • Netbeans + nbandroid plugin;

Утилиты устанавливаются в определенном выше порядке. Ставить все перечисленные IDE смысла нет (разве только если Вы испытываете затруднения с выбором подходящей). Я использую IntelliJ IDEA Community Edition, одну из самых развитых на данный момент IDE для Java.

Запуск виртуального устройства

Запустив AVD Manager и установив дополнительные пакеты (SDK различных версий), можно приступить к созданию виртуального устройства с необходимыми параметрами. Разобраться в интерфейсе не должно составить труда.

Список устройств

Создание проекта

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

Итак, File->New Project:

По нажатию кнопки F6 проект соберется, откомпилируется и запустится на виртуальном девайсе.

Структура проекта

На предыдущем скриншоте видна структура проекта. Так как в этой статье мы преследуем сугубо практические цели, заострим внимание лишь на тех папках, которые будем использовать в процессе работы. Это следующие каталоги: gen, res и src.

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

Папка res предназначена для хранения ресурсов, таких как картинки, тексты (в том числе переводы), значения по-умолчанию, макеты (layouts).

src — это папка в которой будет происходить основная часть работы, ибо тут хранятся файлы с исходными текстами нашей программы.

Первые строки

Как только создается Activity (экран приложения), вызывается метод onCreate(). IDE заполнила его 2 строчками:

super.onCreate(savedInstanceState);
setContentView(R.layout.main);

Метод setContentView (равносильно this.setContentView) устанавливает xml-макет для текущего экрана. Далее xml-макеты будем называть «layout», а экраны — «Activity». Layout в приложении будет следующий:

<?xml version="1.0" encoding="utf-8"?>
<TableLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    android:id="@+id/main_l"
    android:gravity="center"
    >
</TableLayout>

Для этого приложения идеально подойдет TableLayout. Id можно присвоить любому ресурсу. В данном случае, TableLayout присвоен id = main_l. При помощи метода findViewById() можно получить доступ к виду:

    private TableLayout layout; // это свойство класса KrestikinolikiActivity

    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        layout = (TableLayout) findViewById(R.id.main_l);
        buildGameField();
    }

Теперь необходимо реализовать метод buildGameField(). Для этого требуется сгенерировать поле в виде матрицы. Этим будет заниматься класс Game. Сначала нужно создать класс Square для ячеек и класс Player, объекты которого будут заполнять эти ячейки.

Square.java

package com.example;

public class Square {
    private Player player = null;

    public void fill(Player player) {
        this.player = player;
    }

    public boolean isFilled() {
        if (player != null) {
            return true;
        }
        return false;
    }

    public Player getPlayer() {
        return player;
    }
}

Player.java

package com.example;


public class Player {
    private String name;

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

    public CharSequence getName() {
        return (CharSequence) name;
    }
}

Все классы нашего приложения находятся в папке src.

Game.java

package com.example;

public class Game {
 /**
     * поле
     */
    private Square[][] field;
 
 /**
     * Конструктор
     *
     */
    public Game() {
        field = new Square[3][3];
        squareCount = 0;
        // заполнение поля
        for (int i = 0, l = field.length; i < l; i++) {
            for (int j = 0, l2 = field[i].length; j < l2; j++) {
                field[i][j] = new Square();
                squareCount++;
            }
        }
    }
 
 public Square[][] getField() {
        return field;
    }
}

Инициализация Game в конструкторе KrestikinolikiActivity.

public KrestikinolikiActivity() {
    game = new Game();
 game.start(); // будет реализован позже
}

Метод buildGameField() класса KrestikinolikiActivity. Он динамически добавляет строки и колонки в таблицу (игровое поле):

private Button[][] buttons = new Button[3][3];
 //(....)
    private void buildGameField() {
        Square[][] field = game.getField();
        for (int i = 0, lenI = field.length; i < lenI; i++ ) {
            TableRow row = new TableRow(this); // создание строки таблицы
            for (int j = 0, lenJ = field[i].length; j < lenJ; j++) {
                Button button = new Button(this);
                buttons[i][j] = button;
                button.setOnClickListener(new Listener(i, j)); // установка слушателя, реагирующего на клик по кнопке
                row.addView(button, new TableRow.LayoutParams(TableRow.LayoutParams.WRAP_CONTENT,
                        TableRow.LayoutParams.WRAP_CONTENT)); // добавление кнопки в строку таблицы
                button.setWidth(107);
                button.setHeight(107);
            }
            layout.addView(row, new TableLayout.LayoutParams(TableLayout.LayoutParams.WRAP_CONTENT,
                    TableLayout.LayoutParams.WRAP_CONTENT)); // добавление строки в таблицу
        }
    }

В строке 8 создается объект, реализующий интерфейс View.OnClickListener. Создадим вложенный класс Listener. Он будет виден только из KrestikinolikiActivity.

public class Listener implements View.OnClickListener {
        private int x = 0;
        private int y = 0;

        public Listener(int x, int y) {
            this.x = x;
            this.y = y;
        }

        public void onClick(View view) {
            Button button = (Button) view;
        }
    }

Осталось реализовать логику игры.

public class Game {
    /**
     * игроки
     */
    private Player[] players;
    /**
     * поле
     */
    private Square[][] field;
    /**
     * начата ли игра?
     */
    private boolean started;
    /**
     * текущий игрок
     */
    private Player activePlayer;
    /**
     * Считает колличество заполненных ячеек
     */
    private int filled;
    /**
     * Всего ячеек
     */
    private int squareCount;

    /**
     * Конструктор
     *
     */
    public Game() {
        field = new Square[3][3];
        squareCount = 0;
        // заполнение поля
        for (int i = 0, l = field.length; i < l; i++) {
            for (int j = 0, l2 = field[i].length; j < l2; j++) {
                field[i][j] = new Square();
                squareCount++;
            }
        }
        players = new Player[2];
        started = false;
        activePlayer = null;
        filled = 0;
    }

    public void start() {
        resetPlayers();
        started = true;
    }

    private void resetPlayers() {
        players[0] = new Player("X");
        players[1] = new Player("O");
        setCurrentActivePlayer(players[0]);
    }

    public Square[][] getField() {
        return field;
    }

    private void setCurrentActivePlayer(Player player) {
        activePlayer = player;
    }

    public boolean makeTurn(int x, int y) {
        if (field[x][y].isFilled()) {
            return false;
        }
        field[x][y].fill(getCurrentActivePlayer());
        filled++;
        switchPlayers();
        return true;
    }

    private void switchPlayers() {
        activePlayer = (activePlayer == players[0]) ? players[1] : players[0];
    }

    public Player getCurrentActivePlayer() {
        return activePlayer;
    }

    public boolean isFieldFilled() {
        return squareCount == filled;
    }

    public void reset() {
        resetField();
        resetPlayers();
    }

    private void resetField() {
        for (int i = 0, l = field.length; i < l; i++) {
            for (int j = 0, l2 = field[i].length; j < l2; j++) {
                field[i][j].fill(null);
            }
        }
        filled = 0;
    }
}

Определение победителя

К. О. подсказывает, что в крестики-нолики выирывает тот, кто выстроет X или O в линию длиной, равной длине поля по-вертикали, или по-горизонтали, или по-диагонали. Первая мысль, которая приходит в голову — это написать методы для каждого случая. Думаю, в этом случае хорошо подойдет паттерн Chain of Responsobility. Определим интерфейс

package com.example;

public interface WinnerCheckerInterface {
    public Player checkWinner();
}

Так как Game наделен обязанностью выявлять победителя, он реализует этот интерфейс. Настало время создать виртуальных «лайнсменов», каждый из которых будет проверять свою сторону. Все они реализует интерфейс WinnerCheckerInterface.

WinnerCheckerHorizontal.java

package com.example;

public class WinnerCheckerHorizontal implements WinnerCheckerInterface {
    private Game game;

    public WinnerCheckerHorizontal(Game game) {
        this.game = game;
    }

    public Player checkWinner() {
        Square[][] field = game.getField();
        Player currPlayer;
        Player lastPlayer = null;
        for (int i = 0, len = field.length; i < len; i++) {
            lastPlayer = null;
            int successCounter = 1;
            for (int j = 0, len2 = field[i].length; j < len2; j++) {
                currPlayer = field[i][j].getPlayer();
                if (currPlayer == lastPlayer && (currPlayer != null && lastPlayer !=null)) {
                    successCounter++;
                    if (successCounter == len2) {
                        return currPlayer;
                    }
                }
                lastPlayer = currPlayer;
            }
        }
        return null;
    }
}

WinnerCheckerVertical.java

package com.example;

public class WinnerCheckerVertical implements WinnerCheckerInterface {
    private Game game;

    public WinnerCheckerVertical (Game game) {
        this.game = game;
    }
    public Player checkWinner() {
        Square[][] field = game.getField();
        Player currPlayer;
        Player lastPlayer = null;
        for (int i = 0, len = field.length; i < len; i++) {
            lastPlayer = null;
            int successCounter = 1;
            for (int j = 0, len2 = field[i].length; j < len2; j++) {
                currPlayer = field[j][i].getPlayer();
                if (currPlayer == lastPlayer && (currPlayer != null && lastPlayer !=null)) {
                    successCounter++;
                    if (successCounter == len2) {
                        return currPlayer;
                    }
                }
                lastPlayer = currPlayer;
            }
        }
        return null;
    }
}

WinnerCheckerDiagonalLeft.java

package com.example;

public class WinnerCheckerDiagonalLeft implements WinnerCheckerInterface {
    private Game game;

    public WinnerCheckerDiagonalLeft(Game game) {
        this.game = game;
    }

    public Player checkWinner() {
        Square[][] field = game.getField();
        Player currPlayer;
        Player lastPlayer = null;
        int successCounter = 1;
        for (int i = 0, len = field.length; i < len; i++) {
            currPlayer = field[i][i].getPlayer();
            if (currPlayer != null) {
                if (lastPlayer == currPlayer) {
                    successCounter++;
                    if (successCounter == len) {
                        return currPlayer;
                    }
                }
            }
            lastPlayer = currPlayer;
        }
        return null;
    }
}

WinnerCheckerDiagonalRight.java

package com.example;

public class WinnerCheckerDiagonalRight implements WinnerCheckerInterface {
    private Game game;

    public WinnerCheckerDiagonalRight(Game game) {
        this.game = game;
    }

    public Player checkWinner() {
        Square[][] field = game.getField();
        Player currPlayer;
        Player lastPlayer = null;
        int successCounter = 1;
        for (int i = 0, len = field.length; i < len; i++) {
            currPlayer = field[i][len - (i + 1)].getPlayer();
            if (currPlayer != null) {
                if (lastPlayer == currPlayer) {
                    successCounter++;
                    if (successCounter == len) {
                        return currPlayer;
                    }
                }
            }
            lastPlayer = currPlayer;
        }
        return null;
    }
}

Проинициализируем их в конструкторе Game:

//(....)
 /**
     * "Судьи" =). После каждого хода они будут проверять,
     * нет ли победителя
     */
    private WinnerCheckerInterface[] winnerCheckers;
 //(....)
    public Game() {
        //(....)
        winnerCheckers = new WinnerCheckerInterface[4];
        winnerCheckers[0] = new WinnerCheckerHorizontal(this);
        winnerCheckers[1] = new WinnerCheckerVertical(this);
        winnerCheckers[2] = new WinnerCheckerDiagonalLeft(this);
        winnerCheckers[3] = new WinnerCheckerDiagonalRight(this);
        //(....)
    }

Реализация checkWinner():

public Player checkWinner() {
        for (WinnerCheckerInterface winChecker : winnerCheckers) {
            Player winner = winChecker.checkWinner();
            if (winner != null) {
                return winner;
            }
        }
        return null;
    }

Победителя проверяем после каждого хода. Добавим кода в метод onClick() класса Listener

public void onClick(View view) {
            Button button = (Button) view;
            Game g = game;
            Player player = g.getCurrentActivePlayer();
            if (makeTurn(x, y)) {
                button.setText(player.getName());
            }
            Player winner = g.checkWinner();
            if (winner != null) {
                gameOver(winner);
            }
            if (g.isFieldFilled()) {  // в случае, если поле заполнено
                gameOver();
            }
        }

Метод gameOver() реализован в 2-х вариантах:

private void gameOver(Player player) {
        CharSequence text = "Player "" + player.getName() + "" won!";
        Toast.makeText(this, text, Toast.LENGTH_SHORT).show();
        game.reset();
        refresh();
    }

    private void gameOver() {
        CharSequence text = "Draw";
        Toast.makeText(this, text, Toast.LENGTH_SHORT).show();
        game.reset();
        refresh();
    }

Для Java, gameOver(Player player) и gameOver() — разные методы. Воспользовавшись Builder’ом Toast.makeText, можно быстро создать и показать уведомление. refresh() обновляет состояние поля:

private void refresh() {
        Square[][] field = game.getField();

        for (int i = 0, len = field.length; i < len; i++) {
            for (int j = 0, len2 = field[i].length; j < len2; j++) {
                if (field[i][j].getPlayer() == null) {
                    buttons[i][j].setText("");
                } else {
                    buttons[i][j].setText(field[i][j].getPlayer().getName());
                }
            }
        }
    }

Готово! Надеюсь, эта статья помогла Вам освоиться в мире разработки под OS Android. Благодарю за внимание!

Видео готового приложения

Исходники .

PS: статья была опубликована по просьбе комментаторов этого поста.

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="ru.skillbox.skillboxapp">

    <application
        android:allowBackup="true"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:roundIcon="@mipmap/ic_launcher_round"
        android:supportsRtl="true"
        android:theme="@style/AppTheme">
        <activity
            android:name=".FullscreenActivity"
            android:configChanges="orientation|keyboardHidden|screenSize"
            android:label="@string/app_name"
            android:theme="@style/FullscreenTheme">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>

</manifest>

Научитесь: Профессия Мобильный разработчик
Узнать больше

Hello Kitty: Пример для Java
Здороваемся с вашим котом (Kotlin)
Здороваемся с вашим котом (Java)

После установки Android Studio (далее Студия) можно приступать к созданию своей первой программы.

Учтите, что студия постоянно обновляется, поэтому внешний вид окон и другие детали могут отличаться от данного примера. Иногда изменения носят косметический характер и новичкам достаточно просто разобраться и вникнуть в изучаемый материал. А иногда изменения слишком значительны и могут сбить с толку. Скриншоты у многих уроков сделаны со старых версий студии от 2.3 до 4.2. Если что-то сильно изменилось, то напишите мне, я постараюсь заменить картинки.

В качестве языка программирования для Android используется Java или Kotlin. Для создания пользовательского интерфейса используется XML.

Здесь следует сделать небольшое отступление. В Android Studio 3.0 добавлена полноценная поддержка нового языка Kotlin, разработанная котанами. Google объявила в 2017 году новый «кошачий» язык основным. Но вы должны понимать, что за предыдущие годы было написано огромное количество примеров на Java. Если вы новичок в программировании, то лучше в первый период обучения полностью сосредоточиться на Java, вам будет проще находить ответы на вопросы. Kotlin от вас никуда не денется, перейти потом на него будет проще, а вот обратный процесс будет проходить тяжелее. Когда немного освоитесь в Java, то можете параллельно изучать примеры на Kotlin. Google сейчас активно переписывает документацию под Kotlin, но до полного перехода ещё далеко, даже меньше 50%. Новые уроки я пишу в основном под Kotlin, но на сайте полно примеров под Java.

Статья в очередной раз переписана. На этот раз основной упор сделан на Kotlin. Возможно, где-то в статье остались хвосты от Java-варианта. Хвосты — это нормально.

По традиции, заложенной в прошлом веке, каждый программист должен был написать «Hello World!» (Здравствуй, Мир!) в качестве первой программы. Времена меняются, и программа «Hello World!» уже встроена в среду разработки под Android в целях совместимости, а современные программисты должны писать программу Hello Kitty! (Привет, киска!). Согласитесь, что здороваться с котёнком имеет больше здравого смысла, чем с каким-то миром.

Разобьём задачу на две части. Сначала запустим готовую программу Hello World! без написания кода, чтобы убедиться, что весь инструментарий корректно установился, и мы можем создавать и отлаживать программы. А потом уже напишем свою первую программу.

Создание нового проекта

Запускаем Студию и выбираем File | New | New Project…. Появится диалоговое окно мастера.

Окно имеет несколько разделов. В основном, мы будем использовать раздел Phone and Tablet.

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

Несколько лет назад был только один шаблон. Список шаблонов постоянно меняется (добавляют и удаляют). В 3.1 было 13, в Android Studio 3.2 добавили 14-й шаблон Fragment+ViewModel. А в 3.3 число сократилось до 12 (причём один из них относится к экзотическому C++). В версии 4.0 шаблонов стало 15.

В версии Dolphin 2020.3.1 шаблонов стало 21.

• No Activity
• Basic Activity
• Basic Activity (Material 3)
• Bottom Navigation Activity
• Empty Compose Activity
• Empty Compose Activity (Material 3)
• Empty Activity
• Fullscreen Activity
• Google AdMob Ads Activity
• Google Maps Activity
• Google Pay Activity
• Login Activity
• Primary/Detail Flow
• Navigation Drawer Activity
• Responsive Activity
• Settings Activity
• Scrolling Activity
• Tabbed Activity
• Fragment + ViewModel
• Game Activity(C++) (NEW!)
• Native C++

В версию Dolphin добавили новый шаблон Game Activity(C++) (стало 21).

В версию Chipmunk добавили три новых шаблона (стало 20).

Шаблон Empty Activity предназначен для обычных телефонов. На картинке над названием шаблона вы видите приблизительный вид приложения с использованием данной заготовки. Для учебных программ в 99% подойдёт этот вариант. Практически все примеры на сайте написаны с помощью данного шаблона.

Шаблон Primary/Detail Flow (раньше было Master/Detail Flow, BLM и всё такое) предназначен для планшетов с реализацией двухпанельного режима. Шаблон Fullscreen Activity можно использовать для игр, когда требуется дополнительное пространство без лишних деталей. Другие шаблоны нужны для создания приложений с гуглокартами или сервисами Google Play.

В следующем окне настраиваются параметры проекта.

Поле Name — понятное имя для приложения, которое будет отображаться в заголовке приложения. По умолчанию у вас уже может быть My Application. Заменим на Hello World. В принципе вы могли написать здесь и Здравствуй, мир!, но у Android есть замечательная возможность выводить нужные строки на телефонах с разными языками. Скажем, у американца на телефоне появится надпись на английском, а у русского — на русском. Поэтому в первоначальных настройках всегда используются английские варианты, а локализованные строки подготовите позже. Необходимо сразу вырабатывать привычку к правильному коду.

Поле Package name формирует специальный Java-пакет. В Java используется перевёрнутый вариант для наименования пакетов, поэтому сначала идёт ru, а потом уже название сайта. Пакет служит для уникальной идентификации вашего приложения, когда вы будете его распространять. Если сто человек напишет сто приложений с названием «Cat», то будет непонятно, где приложение, написанное разработчиком Василием Котовым. А приложение с именем пакета ru.vaskakotov.cat проще найти. Обратите внимание, что Гугл в своей документации использует пакет com.example в демонстрационных целях. Если вы будете просто копировать примеры из документации и в таком виде попытаетесь выложить в Google Play, то у вас ничего не выйдет — это название зарезервировано и запрещено к использованию в магазине приложений.

Третье поле Save location позволяет выбрать место на диске для создаваемого проекта. Вы можете создать на своём диске отдельную папку для своих проектов и хранить свои программы в ней. Студия запоминает последнюю папку и будет автоматически предлагать сохранение в ней. В случае необходимости вы можете задать другое местоположение для отдельного проекта через кнопку с значком папки.

В поле Language можно выбрать язык: Kotlin или Java.

В блоке Minimum API level выбираем минимальную версию системы, под которую будет работать приложение. Выберите свой вариант. На данный момент Гугл поддерживает версии, начиная с API 9, выпуская специальные библиотеки совместимости для старых устройств. Но вы можете выбрать более современный вариант. У меня в наличии телефон с минимальной версией Android 5.0, поэтому я выставляю этот вариант.

Если щёлкнуть по ссылке Help me choose, то откроется окно с графиком. Если вам интересно, можете посмотреть, но котиков там нет.

Если по каким-то причинам нужно поддерживать старые библиотеки, то ставьте флажок Use legacy android.support libraries. К вам это вряд ли относится, игнорируем флажок.

Сразу покажу приём, который вам пригодится в дальнейшем при обновлении библиотек. Откройте файл build.gradle, который относится к модулю.

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

При подведении мыши появится подсказка, что библиотека устарела. Выбираем пункт для обновления Change to …. Повторяйте эти шаги для других библиотек при необходимости.

Затем нажмите ссылку синхронизации Sync Now в верхнем правом углу студии.

Данным способом вы потом будете неоднократно пользоваться в своих проектах, когда библиотеки будут устаревать. Студия сама определит, что пора обновиться (это относится не ко всем библиотекам, некоторые нужно проверять вручную).

Мы закончили с первоначальной настройкой. Нажимаем кнопку Finish и смотрим, что дальше будет.

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

Боковая левая часть студии имеет несколько боковых вкладок. Скорее всего у вас будет активна первая вкладка 1:Project. Вкладки Structure и ResourceManager и другие используются гораздо реже.

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

Содержание проекта

Вкладка Android содержит две основные папки: app и Gradle Scripts. Первая папка app является отдельным модулем для приложения и содержит все необходимые файлы приложения — код, ресурсы картинок и т.п. Вторая папка служит для различных настроек, управления проектом и многих других вещей.

Сейчас нас должна интересовать папка app. Раскройте её. В ней находятся папки: manifest, java, res.

manifests

Папка manifests (раньше была в единственном числе) содержит единственный файл манифеста AndroidManifest.xml. В этом файле должны быть объявлены все активности, службы, приёмники и контент-провайдеры приложения. Также он должен содержать требуемые приложению разрешения. Например, если приложению требуется доступ к сети, это должно быть определено здесь. «AndroidManifest.xml» можно рассматривать, как описание для развёртывания Android-приложения.

Более подробно о структуре манифеста читайте в дополнительной статье Файл AndroidManifest.xml

java

Папка java содержит три подпапки — одну рабочую и два для тестов. Рабочая папка имеет название вашего пакета и содержит файлы классов. Сейчас там один класс MainActivity. Папки для тестов можете не трогать. Если вы знаете, как работают пакеты в Java, то можете создавать новые папки и подпапки.

res

Папка res содержит файлы ресурсов, разбитых на отдельные подпапки. В режиме Android выводятся виртуальные папки, если вы посмотрите на реальное содержимое на диске компьютера, то структура будет немного иной. Чтобы увидеть реальную структуру, не обязательно открывать Проводник (Windows) и искать там свой проект, можно просто переключиться в режим Project.

• drawable — в этих папках хранят графические ресурсы — картинки и xml-файлы, описывающие цвет и фигуры. В реальности на диске находятся папки drawable, drawable-anydpi, drawable-hdpi, drawable-mdpi, drawable-v24, drawable-xhdpi, drawable-xxhdpi. Состав папок менялся в каждой версии студии, сейчас там вообще две папки drawable и drawable-v24
• layout — в данной папке содержатся xml-файлы, описывающие внешний вид форм и различных элементов форм. После создания проекта там уже имеется файл activity_main.xml, который отвечает за внешний вид главного окна приложения.
• mipmap — здесь хранят значки приложения под разные разрешения экрана. В реальности это папки mipmap-anydpi-v26, mipmap-hdpi, mipmap-mdpi, mipmap-xhdpi, mipmap-xxhdpi, mipmap-xxxhdpi
• values — тут размещаются строковые ресурсы, ресурсы цветов, тем, стилей и измерений, которые мы можем использовать в нашем проекте. Здесь вы можете видеть файлы colors.xml, strings.xml, styles.xml. В старых проектах был ещё файл dimens.xml, сейчас от него отказались

В студии версии 4.1 убрали файл styles.xml, а вместо неё добавили файл themes.xml в папке values, и файл themes.xml в новой папке values-night. Файлы предназначены для обычной и ночной темы.

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

Работа с проектом — Здравствуй, Мир!

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

Для изучения вам нужно открыть два файла — MainActivity.kt (скорее всего он уже открыт) и activity_main.xml (res/layout) в центральной части Студии. Если файлы не открыты, то откройте их самостоятельно двойным щелчком для редактирования (или просмотра). Таким способом вы можете открыть любой нужный вам файл.

Не будем пока изучать код, а просто нажмём на зелёный треугольник Run (Shift+F10) на панели инструментов в верхней части студии для запуска приложения.

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

Если всё сделали правильно, то в эмуляторе или на устройстве загрузится ваша программа. Поздравляю!

Итак, если программа запустилась, то увидите окно приложения с надписью Hello World!. Заголовок у программы будет также Hello World (берётся название проекта). Все эти строки можно найти в файле res/values/strings.xml и отредактировать при желании.

Теперь посмотрим на код. Сначала изучим activity_main.xml.

Смотреть его можно в разных режимах — Code, Split, Design (до версии 3.6 — Design и Text).

Откройте в режиме Code. Подробнее о режимах чуть ниже.

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout 
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity">

    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Hello World!"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintLeft_toLeftOf="parent"
        app:layout_constraintRight_toRightOf="parent"
        app:layout_constraintTop_toTopOf="parent" />

</androidx.constraintlayout.widget.ConstraintLayout>

Сейчас в студии используется новый код шаблона на основе ConstraintLayout, который появился в Android Studio 2.3 в марте 2017 года. Раньше использовался другой код с RelativeLayout (а ещё раньше и другой код с LinearLayout). Если вам будут попадаться старые примеры, то в студии есть контекстное меню, которое поможет сконвертировать старый код в новый.

Немного о XML-коде. Имеется специальный контейнер ConstraintLayout, в котором размещён компонент TextView, предназначенный для вывода текста.

Теперь посмотрим на Kotlin-код (MainActivity.kt)

package ru.alexanderklimov.helloworld

import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
    }
}

В первой строке идёт название пакета — его мы задавали при создании проекта (Package Name). Далее идут строки импорта необходимых классов для проекта. Для экономии места они свёрнуты в одну группу. Разверните её. Если однажды вы увидите, что имена классов выводятся серым цветом, значит они не используются в проекте (подсказка Unused import statement) и можете спокойно удалить лишние строки. Также они могут удаляться автоматически (настраивается).

Далее идёт объявление самого класса, который наследуется (двоеточие :) от абстрактного класса Activity. Это базовый класс для всех экранов приложения. У вас будет AppCompatActivity. В старых версиях не было плюшек, которые появились после Android 4, поэтому для них была создана специальная библиотека совместимости, которая позволяет использовать новинки от новых версий Android в старых программах. Класс AppCompatActivity как раз и относится к библиотеке совместимости. Считайте её родственником базовой Activity. У неё есть все нужные методы и вспомогательные классы, но названия могут немного различаться.

На разных этапах использовались разные названия класса активности, которые могут вам встретиться в старых проектах. Например, сначала использовался FragmenActivity, затем ActionBarActivity, а 22 апреля 2015 года вышла новая версия библиотеки совместимости и на данный момент используется новый класс AppCompatActivity.

В самом классе мы видим метод onCreate() – он вызывается, когда приложение создаёт и отображает разметку активности. Метод помечен ключевым словом override (переопределён из базового класса). Ключевое слово может пригодиться вам. Если вы сделаете опечатку в имени метода, то компилятор сможет предупредить вас, сообщив об отсутствии такого метода у родительского класса Activity.

Разберём код метода.

Строка super.onCreate(savedInstanceState) – это конструктор родительского класса, выполняющий необходимые операции для работы активности. Эту строчку вам не придётся трогать, оставляйте без изменений.

Вторая строчка setContentView(R.layout.activity_main) представляет больший интерес. Метод setContentView(int) подключает содержимое из файла разметки. В качестве аргумента мы указываем имя файла без расширения из папки res/layout. По умолчанию проект создаёт в нём файл activity_main.xml. Вы можете переименовать файл или создать свой файл с именем cat.xml и подключить его к своей активности. Тогда код будет выглядеть так:

setContentView(R.layout.cat)

Чтобы ваш код был аккуратным, старайтесь придерживаться стандартов. Если вы создаёте разметку для активности, то используйте префикс activity_ для имени файла. Например, разметка для второй активности может иметь имя activity_second.xml.

Hello Kitty!

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

Создаём новый проект. Снова выбираем шаблон Empty Activity и устанавливаем нужные настройки.

На данный момент наша программа слишком проста. Представьте себе, что у вас на экране должны располагаться несколько кнопок, текстовых полей, картинок. Каждому объекту нужно задать размеры, координаты, цвет, текст и так далее. Android поддерживает способ, основанный на XML-разметке, который будет напоминать разметку веб-страницы. Начинающие программисты могут использовать визуальный способ перетаскивания объектов с помощью мыши. Более продвинутые могут писать код вручную. Чаще используется комбинированный подход.

Файлы XML-разметки находятся в папке res/layout вашего проекта. Слово «res» является сокращением от слова «resources» (ресурсы). Папка содержит ресурсы, не связанные с кодом. Кроме разметки, там же содержатся изображения, звуки, строки для локализации и т.д.

Раскройте слева в структуре проектов папки res/layout и дважды щёлкните на файле activity_main.xml, если он у вас закрыт. Обратите внимание, что XML-файлы можно просматривать в разных режимах: текстовом, визуальном и смешанном. Для этого предназначены три вкладки в верхней части окна редактора: Code, Split, Design (если вы не кот и не пользуетесь мышкой, а предпочитаете клавиатуру, то используйте комбинацию Alt + Shift + Left/Right Arrow (Windows) для циклического переключения между режимами).

Переключитесь в режим Code (текстовый режим).

Структура XML-файла достаточна проста — стандартное дерево XML-элементов, где каждый узел является именем класса View (TextView — один из элементов View). Вы можете создать интерфейс программы, используя структуру и синтаксис XML. Подобный подход позволяет разделить код программы и визуальное представление.

Когда разметка открыта в графическом представлении, то слева от основной части редактора кода можно увидеть панель инструментов, в которой сгруппированы различные элементы по группам Widgets, Text, Layouts и так далее. В группе Buttons найдите элемент ImageButton, перетащите её на форму и отпустите. Точное расположение нас не интересует, поэтому не заморачивайтесь по этому поводу, постарайтесь разместить компонент в центре экрана активности. У вас появится диалоговое окно с просьбой выбрать изображение для кнопки. Пока выбирайте любую, например, первую. Потом заменим.

Теперь научимся менять фон для экрана приложения. Сейчас у нас экран белого цвета. Возвращаемся в файл разметки activity_main.xml. Справа найдите вкладку Attributes, в которой отображаются свойства для выбранного элемента. А слева есть вкладка Component Tree, который отображает структуру компонентов на экране. Вам нужно нужно выделить какой-нибудь компонент, что на вкладке свойств увидеть все доступные свойства компонента. Новички часто путаются на первых порах и начинают менять свойства не у тех элементов, которые им были нужны. Сейчас у вас есть окно активности, графическая кнопка ImageButton и текстовая метка TextView с надписью Hello World!. Пощёлкайте по этим элементами, чтобы увидеть, как меняется содержание свойств в панели свойств. Так как мы собираемся работать с фоном экрана приложения, то щёлкните на ConstraintLayout. В панели свойств отобразятся самые употребительные свойства выбранного компонента. К ним относятся идентификатор, ширина и высота.

Прокручиваем список атрибутов в All attributes и находим свойство background. Щёлкните рядом с этим словом во второй колонке, где нужно прописывать значения. Появится текстовое поле, в которое можно ввести значение вручную. Рядом есть маленькая кнопка, которая запустит диалоговое окно для создания ресурса.

Переходим на вкладку Color и выбираем цвет. Вы можете выбрать цвет, определённый в приложении (секция app) или в системе (секция android).

Давайте выберем цвет colorAccent и нажмём кнопку OK.

Экран окрасится в розовый цвет. Получилось глаМУРненько (в предыдущих версиях в качестве colorAccent использовался другой цвет, поэтому здесь расхождение между описанием и реальным цветом. Можете самостоятельно попытаться установить розовый цвет.

Если переключиться в текстовый режим, то увидим, что у элемента ConstraintLayout добавилась строчка:

android:background="@color/colorAccent"

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

android:background="#ffffc0cb"

Старайтесь так не делать, всегда используйте ресурсы.

Далее поменяем картинку для графической кнопки. Находим подходящее изображение и копируем его в папку res/drawable. Картинку можете взять у меня.

Простое перетаскивание из проводника в папку студии не сработает. Поэтому лучше скопировать картинку в буфер, затем щёлкнуть правой кнопкой мыши на папке drawable в студии, выбрать команду «Вставить». Сначала появится первое диалоговое окно для выбора папки, выбираем папку drawable.

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

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

Выделяем элемент ImageButton на форме и в панели свойств выбираем свойство srcCompat, щёлкаем на кнопку и выбираем в диалоговом окне ресурс в категории Drawable — вы там должны увидеть ресурс pinkhellokitty (имя добавленного ранее файла).

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

Мы закончили работу с графическим интерфейсом приложения. Напоследок, выделите элемент TextView с надписью Hello, World и в окне свойств посмотрите на его идентификатор (ID). Если там пусто, то удалите его, он не оправдал наших надежд. В разделе Text найдите компонент TextView (самый первый) и перетащите его на форму приложения. Постарайтесь разместить его под графической кнопкой с котёнком.

У этого компонента точно будет что-то написано в свойстве id. Скорее всего, это будет textView. Запомните его. Впрочем, мы могли не удалять первый компонент, а прописать идентификатор вручную. Но мне пришлось бы объяснять лишние детали, а так сразу получили результат. Вот я не удалял его и у меня экран выглядит так. А у вас будет текст TextView. Ничего страшного.

Если текст вам кажется мелковатым, то у свойства textAppearance установите значение AppCompat.Display2.

У меня получилось следующее.

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout 
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:background="#ffffc0cb"
    tools:context=".MainActivity">

    <TextView
        android:id="@+id/textView"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:textAppearance="@style/TextAppearance.AppCompat.Display2"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintLeft_toLeftOf="parent"
        app:layout_constraintRight_toRightOf="parent"
        app:layout_constraintTop_toBottomOf="@+id/imageButton"
        tools:text="Имя кота" />

    <ImageButton
        android:id="@+id/imageButton"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_marginTop="32dp"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent"
        app:srcCompat="@drawable/pinkhellokitty" />

</androidx.constraintlayout.widget.ConstraintLayout>

Здесь очень много кода, который генерирует ConstraintLayout при размещении и выравнивании компонентов. Это новый контейнер, к которому нужно привыкать. Сейчас нет смысла объяснять принцип его работы, на сайте есть отдельная статья по нему. Пока советую при ручном размещении нажимать значок Infer Constraints (изображение волшебной палочки) в режиме дизайна — студия попытается предугадать нужные настройки самостоятельно.

Различия c Java начинаются с имени файла класса MainActivity.kt. У него расширение kt вместо java, но располагается в аналогичном пакете как у Java. Скорее всего он у вас уже открыт в редакторе. Если нет, то двойным щелчком запустите его из левой части студии.

Синтаксис кода немного отличается от Java. Первое, что бросается в глаза — не нужно ставить точку с запятой в конце оператора.

Так как мы собираемся менять текст в текстовой метке, необходимо прописать данный элемент в коде. До метода onCreate() наберите строчку:

private lateinit var mHelloTextView: TextView

Мы объявили переменную типа TextView под именем mHelloTextView.

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

Далее внутри метода onCreate() после вызова метода setContentView() добавьте строку:

mHelloTextView = findViewById(R.id.textView) // помните, я просил запомнить идентификатор?

Избегайте соблазна скопировать строку с сайта и вставить в код, пишите самостоятельно и активно используйте автозавершение (Ctrl+Пробел) при наборе слов. Студия часто сама активно помогает подсказками. Теперь система знает о существовании элемента TextView, и мы можем к нему обращаться для изменения различных свойств, например, поменять текст.

Далее объявляем компонент ImageButton и пишем код для обработчика щелчка — обращаемся к элементу mHelloTextView и через его метод setText() программно меняем текст на нужные слова.

Общий код класса получится следующим. Я намерено оставил вещи, которые можно было упростить.

package ru.alexanderklimov.hellokot

import android.os.Bundle
import android.widget.ImageButton
import android.widget.TextView
import androidx.appcompat.app.AppCompatActivity

class MainActivity : AppCompatActivity() {

    private lateinit var mHelloTextView: TextView

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        mHelloTextView = findViewById(R.id.textView)

        var imageButton: ImageButton = findViewById(R.id.imageButton)
        // альтернативный вариант
        // val imageButton = findViewById<ImageButton>(R.id.imageButton)
        // или val imageButton = findViewById(R.id.imageButton) as ImageButton

        imageButton.setOnClickListener {
            mHelloTextView.setText("Hello Kitty")
        }
    }
}

Запускаем программу и нажимаем на кнопку с изображением котёнка. Если всё сделали правильно, то отобразится замечательная фраза. С этого момента можете считать себя настоящим программистом — вы научились создавать цветовые и графические ресурсы, менять фон у приложения через XML-разметку, обрабатывать нажатия кнопки и выводить текстовые сообщения.

В данном случае я написал код в Java-стиле, не используя особенностей Kotlin. Студия подчеркнёт волнистой чертой метод setText() и предложить заменить его на свойство.

Kotlin позволяет заменить пары Java-методов вида getXX/setXX свойствами без приставок. Были методы getText()/setText(), остались рожки да ножки свойство text. Если вы что-то присваиваете свойству, значит вы хотите использовать setText(), а если хотите прочитать значение свойства — значит вы хотите вызвать getText(). Вот так изящно работает Kotlin.

Второй момент связан с рефакторингом кода. Раньше в эпоху Java было принято присваивать глобальным переменным имена с приставкой m (member). Сейчас в этом нет необходимости, студия выделяет подобные переменные другим цветом. Чтобы вручную не изменять в проекте все упоминания переменной, используют так называемый рефакторинг (изменение кода без потери его функциональности). Сделать это проще всего через комбинацию клавиш SHIFT+F6. Выделяем нужное слово, нажимаем указанную комбинацию клавиш и выбираем один из предложенных вариантов или печатаем свой вариант. В нашем случае подойдёт вариант helloTextView.

Можно заменить строчку кода.

imageButton.setOnClickListener {
    helloTextView.text = "Hello Kitty!"
}

В папке appbuildoutputsapk проекта можно найти готовый APK-файл, который вы можете выложить у себя на сайте и дать скачать своим знакомым (в телефоне должно быть разрешение на установку неподписанных приложений), вы станете невероятно круты в их глазах.

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

Пример для Java

Примечание: Для примера на Java — Там же в окне свойств у ImageButton находим свойство onClick и вручную прописываем onClick — это будет именем метода для обработки нажатия на кнопку. Вы можете придумать и другое имя, например, onButtonPressed. Для Kotlin можно не использовать эту конструкцию.

В текстовом режиме установите курсор мыши внутри текста «onClick» у кнопки и нажмите комбинацию Alt+Enter

В всплывающем окне выберите вариант Create ‘onClick(View)’ in ‘MainActivity’.

В коде класса MainActivity появится заготовка для обработки щелчка кнопки.

Раз уж у нас теперь открыт файл MainActivity.java, то продолжим теперь работу в нём. Так как мы собираемся менять текст в текстовой метке, необходимо прописать данный элемент в коде. До метода onCreate() наберите строчку:

private TextView mHelloTextView;

Мы объявили переменную типа TextView под именем mHelloTextView.

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

Далее внутри метода onCreate() после вызова метода setContentView() добавьте строку:

mHelloTextView = findViewById(R.id.textView); // помните, я просил запомнить идентификатор?

Избегайте соблазна скопировать строку с сайта и вставить в код, пишите самостоятельно и активно используйте автозавершение (Ctrl+Пробел) при наборе слов. Студия часто сама активно помогает подсказками. Теперь система знает о существовании элемента TextView, и мы можем к нему обращаться для изменения различных свойств, например, поменять текст.

В старых примерах вам может встретиться вариант со скобками.

mHelloTextView = (TextView) findViewById(R.id.textView);

Если вы используете компилятор compileSdkVersion 26 и выше, то скобки с названием компонента можно опустить, так как изменилась сигнатура метода.

// было
public View findViewById(int id);

// стало
public <T extends View> T findViewById(int id);

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

Переходим к заготовке для щелчка кнопки.

public void onClick(View view) {
}

В следующих занятиях мы подробнее разберём работу с данным методом, пока просто пишем код между фигурными скобками:

mHelloTextView.setText("Hello Kitty!");

Мы обращаемся к элементу mHelloTextView и через его метод setText() программно меняем текст на нужные слова.

Исходный код для ленивых

Ткните лапкой, чтобы развернуть текст

// Если этот код работает, его написал Александр Климов,
// а если нет, то не знаю, кто его писал.

package ru.alexanderklimov.hellokitty;

import android.os.Bundle;
import android.view.View;
import android.widget.EditText;
import android.widget.TextView;

import androidx.appcompat.app.AppCompatActivity;

public class MainActivity extends AppCompatActivity {

    private TextView mHelloTextView;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        mHelloTextView = findViewById(R.id.textView);
    }

    public void onClick(View view) {
        mHelloTextView.setText("Hello Kitty!");
    }
}

Здороваемся с вашим котом (Kotlin)

Программа получилась замечательная, но у неё есть недостаток. Она показывает одну и ту же фразу «Hello Kitty!». Вряд ли ваш кот знает английский, да и здороваться лучше по имени. Не пытайтесь с котом мяукать, иначе разговор выглядит следующим образом.

Поздороваемся с котом по человечески. Найдите в разделе Text компонент Plain Text и перетащите его на экран активности, разместив где-то над картинкой. Оставляем все свойства без изменений, разве только в свойстве hint можно добавить строчку-подсказку, которая будет исчезать при вводе текста.

<EditText
    android:id="@+id/editText"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:layout_marginTop="29dp"
    android:ems="10"
    android:inputType="textPersonName"
    android:text="Name"
    app:layout_constraintEnd_toEndOf="parent"
    app:layout_constraintStart_toStartOf="parent"
    app:layout_constraintTop_toTopOf="parent" />

Отредактируем код для щелчка кнопки.

private lateinit var editText: EditText // до метода onCreate()

imageButton.setOnClickListener {
    if (editText.text.isEmpty()) {
        helloTextView.text = "Hello Kitty!";
    } else {
        helloTextView.text = "Привет, " + editText.text
    }
}

Мы внесли небольшую проверку. Если в текстовом поле пустой текст, мы по-прежнему выводим надпись «Hello Kitty!». Если пользователь введёт имя своего кота, то приложение поздоровается с ним. Какая умная и вежливая программа у нас получилась.

Здороваемся с вашим котом (Java)

Переходим в класс MainActivity и добавляем новую переменную рядом с переменной mHelloTextView:

private EditText mNameEditText;

Свяжем созданную переменную с компонентом в методе onCreate():

mNameEditText = findViewById(R.id.editText);

Поменяем код для щелчка кнопки.

public void onClick(View view) {
    if (mNameEditText.getText().length() == 0) {
        mHelloTextView.setText("Hello Kitty!");
    } else {
        mHelloTextView.setText("Привет, " + mNameEditText.getText());
    }
}

Мы внесли небольшую проверку. Если в текстовом поле пустой текст, то длина текста составляет ноль символов, и мы по-прежнему выводим надпись «Hello Kitty!». Если пользователь введёт имя своего кота, то приложение поздоровается с ним.

Дополнительное чтение

Обсуждение статьи на форуме.

Исходник на Гитхабе (Java)

Реклама

Android – базирующаяся на ОС Linux операционная система с открытым исходным кодом, предназначенная для мобильных устройств – таких, как, например, смартфоны или планшетные компьютеры.

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

От вас же, в свою очередь, требуется только желание и базовое понимание программирования на языке Java. Не так много, правда? Что ж, начнём!

Среда разработки

Для разработки приложений под Android можно использовать любые из перечисленных операционных систем:

При этом все необходимые инструменты для разработки Android-приложений находятся в свободном доступе и вы можете загрузить их из Интернета. Для того, чтобы начать создавать приложения под Android, вам понадобятся:

Структура приложений

Поздравляем, ваше оборудование готово к работе! Однако прежде чем приступить к вашему первому приложению, поговорим о том, что из себя представляет приложение на Android и из чего оно состоит.

Компоненты приложения являются своего рода «строительными блоками» для приложения Android. Эти компоненты связаны файлом-манифестом приложения AndroidManifest.xml, который описывает каждый компонент приложения и взаимодействие этих компонентов между собой.

Есть четыре базовых типа компонентов, которые могут быть использованы в приложении Android:

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

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

Первое приложение

Итак, давайте приступим к созданию простого Android-приложения, которое будет выводить на экран «Hello World!».

У вас к этому времени уже должен быть установлен Android Studio последней версии. Ниже будет приведена небольшая пошаговая инструкция:

Теперь перед вами открылась привычная среда разработки. К сожалению или к счастью, но сейчас вам не нужно будет писать код – среда разработки уже сделала это за вас, создав файлы для приложения, выводящего «Hello world!» на экран, по умолчанию. Вместо этого хотелось бы обратить ваше внимание на несколько созданных файлов и папок, найти которые вы можете в колонке слева, отображающей все элементы проекта.

В папке «Java» содержатся исходные файлы формата .java для вашего приложения. По умолчанию в ней находится исходный файл MainActivity.java, имеющий класс Операция – он запускается при нажатии пользователем на иконку приложения на устройстве. Этот файл содержит главный код приложения, и именно он преобразуется в файл .exe для запуска приложения на устройстве.

Это файл типа «Манифест», который описывает основные характеристики приложения и определяет каждый из его компонентов. Он является своего рода интерфейсом между ОС Android и вашим приложением – если компонент не упомянут в этом файле, он не будет отображен и в операционной системе.

Это автоматически генерируемый файл, содержащий определённые данные касательно приложения – такие, как, например, версия SDK.

Запустить приложение можно двумя способами: на реальном устройстве или на эмуляторе в самой среде разработки. В нашем случае мы рассмотрим более универсальный случай – запуск на эмуляторе, полностью имитирующем работу устройства с операционной системой Android.

Запуск приложения на эмуляторе

Попытайтесь запустить приложение кнопкой «Run» – в появившемся диалоговом окне выберите пункт «Create New Virtual Device». В последующих окнах нужно будет выбрать размер экрана и версию Android – помните, что она должна быть не ниже, чем указанная на этапе создания проекта. В случае, если данная версия Android будет отсутствовать на компьютере, Android Studio предложит ее загрузить. Остальные пункты можно оставить без изменений – на данный момент нет необходимости их изменять. После выбора всех настроек нажмите кнопку «Finish», и если вы увидели на своем мониторе экран телефона с названием вашего приложения сверху и с надписью «Hello world!» на экране, значит, вы можете себя поздравить – вы создали свое первое Android-приложение!

Теперь у вас есть базовое понимание и минимальный опыт в создании приложений на Android. Этого, разумеется, совершенно не хватит, чтобы заниматься разработкой, но это необходимый для дальнейшего развития фундамент – продолжайте изучать и практиковаться! Всего наилучшего!

Также можно научиться создавать приложения на Android и другие ОС после прохождения нашего шестимесячного курса «Профессия: Разработчик» 👉 Узнать подробности!

Последнее обновление: 14.10.2021

Теперь создадим первое приложение в среде Android Studio для операционной системы Android. Откроем Android Studio и на начальном экране выберем пункт
New Project:

При создании проекта Android Studio вначале предложит нам выбрать шаблон проекта:

Android Studio предоставляет ряд шаблонов для различных ситуаций. Выберем в этом списке шаблон Empty Activity,
который предосавляет самый простейший фукционал, необходимый для начала, и нажмем на кнопку Next.

После этого отобразится окно настроек нового проекта:

В окне создания нового проекта мы можем установить его начальные настройки:

• В поле Name вводится название приложения. Укажем в качестве имени название HelloApp

• В поле Package Name указывается имя пакета, где будет размещаться главный класс
  приложения. В данном случае для тестовых проектов это значение не играет ольшого значения, поэтому установим com.example.helloapp.

• В поле Save Location установливается расположение файлов проекта на жестком диске. Можно оставить значение по умолчанию.

• В поле Language в качестве языка программирования укажем Java (будьт внимательны, так как по умолчанию в этом поле стоит Kotlin)

• В поле Minimum SDK указывается самая минимальная поддерживаемая версия SDK. Оставим значение по умолчанию — API 21: Android 5.0
  (Lollipop), которая означает, что наше приложение можно будет запустить начиная с Android 5.0, а это 94% устройств. На более старых устройствах запустить будет нельзя.

  Стоит учитывать, что чем выше версия SDK, тем меньше диапазон поддерживаемых устройств.

Далее нажмем на кнопку Finish, и Android Studio создаст новый проект:

Вначале вкратце рассмотрим структуру проекта, что он уже имеет по умолчанию

Проект Android может состоять из различных модулей. По умолчанию, когда мы создаем проект, создается один модуль — app. Модуль имеет три подпапки:

• manifests: хранит файл манифеста AndroidManifest.xml, который описывает конфигурацию приложения
  и определяет каждый из компонентов данного приложения.

• java: хранит файлы кода на языке java, которые структурированы по отдельным пакетам. Так, в папке com.example.helloapp (название
  которого было указано на этапе создания проекта) имеется по умолчанию файл MainActivity.java с кодом на языке Java, который представляет класс
  MainActivity, запускаемый по умолчанию при старте приложения

• res: содержит используемые в приложении ресурсы. Все ресурсы разбиты на подпапки.

  • папка drawable предназначена для хранения изображений, используемых в приложении

  • папка layout предназначена для хранения файлов, определяющих графический интерфейс.
    По умолчанию здесь есть файл activity_main.xml, который определяет интерфейс для класса MainActivity в виде xml

  • папки mipmap содержат файлы изображений, которые предназначены для создания иконки приложения при различных разрешениях экрана.

  • папка values хранит различные xml-файлы, содержащие коллекции ресурсов — различных данных, которые применяются в приложении. По умолчанию здесь есть два файла и одна папка:

    • файл colors.xml хранит описание цветов, используемых в приложении

    • файл strings.xml содержит строковые ресурсы, используемые в приложении

    • папки themes хранит две темы приложения — для светлую (дневную) и темную (ночную)

Отдельный элемент Gradle Scripts содержит ряд скриптов, которые используются при построении приложения.

Во всей этой структуре следует выделить файл MainActivity.java, который открыт в Android Studio и который содержит логику приложения и собственно с него начинается выполнение
приложения. И также выделим файл activity_main.xml, который определяет графический интерфейс — по сути то, что увидит пользователь
на своем смартфоне после загрузки приложения.

Возможные проблемы

Для создания приложения используется Java. А для построения приложения применяется инфраструктура Gradle. Однако текущая используемая версия
Gradle может быть несовместима с выбранной по умолчанию версией JDK. И в этом случае Android Studio может отображать ошибки, например, ошибку
Unsupported class file major version 61:

Эта ошибка говорит о том, что версия JDK 17 несовместима с текущей версией Gradle. И надо использовать меньшую версию.

Для решения этой проблемы перейдем в студии к меню File ->Settings (на MacOS это пункт Android Studio -> Preferences)

Затем в открывшемся окне настроек перейдем к пункту меню Build, Execution, Deployment -> Build Tools -> Gradle
и далее найдем поле Gradle JDK, где изменим версию JDK. Она должна иметь версию 11 и выше.
Как правило, вместе с Android Studio устанавливается и поддерживаемая версия JDK — на данный момент это JDK 11. И ее можно выбрать в списке JDK:

Наиболее оптимальный пункт для выбора версий JDK, которая идет вместе с Android Studio, называется Embedded JDK version….
Как видно на скриншоте, это версия 11, но при последующих обновлениях Android Studio эта версия может измениться.

После сделанных изменений сначала нажмем на кнопку Apply, а затем на кнопку OK. И повторим запуск проекта.

Запуск проекта

Созданный выше проект уже содержит некоторый примитивный функционал. Правда, этот функционал почти ничего не делает, только выводит на
экран строку «Hello world!». Тем не менее это уже фактически приложение, которое мы можем запустить.

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

Режим разработчика на телефоне

По умолчанию опции разработчика на смартфонах скрыты. Чтобы сделать их доступными, надо зайти в Settings > About phone (Настройки > О телефоне)
(в Android 8 это в Settings > System > About phone (Настройки > Система > О телефоне)) и семь
раз нажать Build Number (Номер сборки).

Теперь необходимо включить отладку по USB. Для этого перейдем в
Settings > System > Advanced > Developer options или
Настройки > Система > Дополнительно > Для разработчиков
(в Android 8 это в Settings > System > Developer options или Настройки > Система > Для разработчиков ).

И включим возможность отладки по USB:

Запуск приложения

Подключим устройство с ОС Android (если мы тестируем на реальном устройстве) и запустим проект, нажав на зеленую стрелочку на панели инструментов.

Выберем устройство и нажмем на кнопку OK. И после запуска мы увидим наше приложение на экране устройства:

В этой
серии туториалов  вы познакомитесь с
Java, языком программирования, используемым для разработки приложений для
Android. Наша
цель — подготовить тех, кто уже знаком с одним языком программирования, таким
как PHP или Objective-C, которые помогут в работе с Java и окунут вас в разработку приложений для
Android. В этом
уроке вы получите краткое введение в основы Java, включая
объектно-ориентированное программирование, наследование и многое другое. Если
вы новичок в Java или просто хотите разобраться в деталях, то этот курс для
вас!

Давайте начнем

Что
касается предпосылок, мы предположим, что вы понимаете, как программировать
(возможно, на PHP, или Visual Basic или C ++), но вы не знакомы со спецификой
программирования на языке Java. Мы не
собираемся учить вас программировать; мы собираемся предоставить вам четкие
примеры обычно используемых конструкций и принципов языка Java, указав на
некоторые советы и трюки касательно 
Android. 

Что вам понадобится

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

Для
разработки приложений для Android (или любых приложений Java, если на то пошло)
вам нужна среда разработки для написания и сборки приложений. Eclipse
— очень популярная среда разработки (IDE) для Java и предпочтительная среда
разработки для Android. Она доступна для операционных систем Windows, Mac
и Linux.

Полные инструкции по установке Eclipse (включая
поддерживаемые версии) и Android SDK см. На веб-сайте разработчика Android.

Что такое Java? 

Приложения
для Android разрабатываются с использованием языка Java. На
данный момент это действительно ваш единственный вариант для нативных
приложений. Java —
очень популярный язык программирования, разработанный Sun Microsystems (теперь
принадлежащий Oracle). Разработанные
намного позже после C и C ++, Java включает в себя многие из мощных функций
этих мощных языков программирования и устраняет некоторые из их недостатков. Тем не
менее, языки программирования настолько же сильны, как и их библиотеки. Эти
библиотеки существуют, чтобы помочь разработчикам создавать приложения.

Некоторые из основных основных функций Java:

• Его
  легко изучить  и понять
• Он разработан, чтобы быть независимым от платформы и
  безопасным, так как использует
  виртуальные машины. 
• Он
  является объектно-ориентированным 

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

Почему Java легко изучить?

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

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

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

char character = 'a';
if(character=='a')
{
    doSomething();
} else {
    doSomethingElse();
}

Если
вы просто прочитаете код вслух, вы можете в значительной степени сказать, что
этот фрагмент кода работает. Существует
одна переменная, называемая символом. Если переменная символа равна букве a, мы сделаем что-то (вызовем
метод doSomething (), или в другом случае (вызывая метод doSomethingElse ().

Почему важна независимость платформы?

Со
многими языками программирования вам нужно использовать компилятор, чтобы
уменьшить код на машинный язык, который может понять устройство. Хотя
это хорошо, разные устройства используют разные машинные языки. Это
означает, что вам нужно скомпилировать ваши приложения для каждого другого
устройства или машинного языка, другими словами, ваш код не очень портативен. Это не
относится к Java. Компиляторы Java преобразуют ваш код из человеческих
читаемых исходных файлов Java в так называемый «байт-код» в мире Java. Они интерпретируются виртуальной машиной Java, которая
работает так же, как физический процессор взаимодействует с машинным кодом,
чтобы выполнить скомпилированный код. Хотя
может показаться, что это неэффективно, было сделано много усилий, чтобы этот
процесс был очень быстрым и эффективный. Эти
усилия окупились в том, что производительность Java, как правило, уступает
только C/C++ в общих сравнениях производительности языка.

Приложения
Android запускаются на специальной виртуальной машине под названием Dalvik VM. Хотя
сведения об этой виртуальной машине не важны для среднего разработчика, может
быть полезно подумать о VM Dalvik как о пузыре, в котором работает ваше
приложение для Android, позволяя вам не беспокоиться о том, является ли
устройство Motorola Droid, HTC Evo, или новейший тостер под управлением
Android. Вам
все равно, пока устройство Dalvik VM дружелюбное, и это задача производителя
устройства, а не ваша.

Почему Java безопасен?

Давайте
рассмотрим эту мысль немного глубже. Поскольку
приложения Java работают в оболочке, которая является виртуальной машиной, они
изолированы от базового устройства. Таким
образом, виртуальная машина может инкапсулировать, содержать и управлять
выполнением кода безопасным образом по сравнению с языками, которые работают
непосредственно с машинным кодом. Платформа Android делает шаг вперед. Каждое
приложение для Android работает в операционной системе (на базе Linux),
используя другую учетную запись пользователя и в своем собственном экземпляре
Dalvik VM. Приложения
Android тщательно контролируются операционной системой и закрываются, если они не
работают правильно (например, используют слишком большую вычислительную
мощность, становятся невосприимчивыми, ресурсы отходов и т. д.). Поэтому
важно разрабатывать приложения, которые являются стабильными и отзывчивыми. Приложения
могут общаться друг с другом с использованием четко определенных протоколов.

Компиляция кода

Как и многие языки, Java по-прежнему является скомпилированным языком, хотя он не компилирует весь путь до машинного кода. Это
означает, что вы, разработчик, должны скомпилировать ваши проекты Android и
упаковать их для развертывания на устройства. Среда
разработки Eclipse (используемая с плагином для разработки Android) делает это
довольно безболезненным процессом. В
Eclipse автоматическая компиляция часто включается по умолчанию. Это
означает, что каждый раз, когда вы сохраняете файл проекта, Eclipse
перекомпилирует изменения для вашего пакета приложений. Вы
сразу видите ошибки компиляции. Eclipse также интерпретирует Java по мере ввода, обеспечивая удобную окраску и
форматирование кода, а также показывающие многие типы ошибок, когда вы идете.  Часто
вы можете щелкнуть по ошибке, и Eclipse автоматически исправит опечатку или
добавит оператор импорта или предоставит вам заглушку для метода, сохраняя
множество ввода.

Вы
можете вручную скомпилировать свой код, если хотите. В
Eclipse вы найдете настройки сборки в меню проекта. Если
вы включили «Build Automatically», вы все равно можете выбрать опцию «Clean
…», которая позволит вам полностью перестроить все файлы. Если
«Build Automatically» отключено, включены опции «Build All» и «Build Project». «Build
All» означает создание всех проектов в рабочей области. У вас может быть много проектов в рабочем пространстве Eclipse.

Процесс сборки для обычных проектов Java приводит к созданию файла с расширением JAR — Java ARchive.  Приложения Android берут файлы JAR и упаковывают их для развертывания на устройствах как файлы Android PacKage с расширением .apk. Эти
форматы включают не только ваш скомпилированный Java-код, но и любые другие
ресурсы, такие как строки, изображения или звуковые файлы, которые требуется
выполнить вашему приложению, а также файл манифеста приложения,
AndroidManifest.xml. Файл
манифеста Android является файлом, требуемым всеми приложениями Android,
которые вы используете для определения сведений о конфигурации вашего
приложения.

Что такое объектно-ориентированный язык программирования?

Отлично. Время для очень короткого и 20 000-футового просмотра объектно-ориентированного
программирования (ООП). ООП —
это стиль или техника программирования, которые основаны на определении
структур данных, называемых объектами. Для
тех, кто новичок в ООП, объект можно воспринимать так же, как пользовательский
тип данных. Например,
у вас может быть объект Dog, который представляет собой чертёж общей собаки, с именем,
породой и полом. Затем
вы можете создавать разные экземпляры объекта Dog для представления конкретных
собак. Каждый объект Dog должен быть создан путем вызова его конструктора (метода, который имеет то же имя, что и сам объект, и может иметь или не иметь параметров для установки начальных значений). Например,
следующие объекты Dog используют конструктор с тремя параметрами (имя, порода,
пол):

Dog dog1 = new Dog("Lassie", collie, female);
Dog dog2 = new Dog("Fifi", poodle, female);
Dog dog3 = new Dog("Asta", foxterrier, male);

Итак,
где этот объект Dog определен? Ну,
здесь нам нужно начать определение некоторых фундаментальных строительных
блоков языка программирования Java. Класс предоставляет определение для объекта. Таким
образом, есть класс Dog где-нибудь, определенный вами или в какой-то библиотеке
где-нибудь. Вообще
говоря, класс будет определен в собственном файле с именем файла,
соответствующим имени класса (например, Dog.java).  Существуют исключения из этого правила, такие как классы, определенные в других классах (когда класс объявляется внутри класса, он обычно определяется для использования в родительском классе только как вспомогательный класс и
называется внутренним классом).

Если вы хотите ссылаться на объект из другого класса, вам нужно включить оператор импорта в начало вашего файла класса, так же, как вы бы использовали оператор #include на компилированном языке, таком как C.

Класс
обычно описывает данные и поведение объекта.  Поведение определяется с помощью методов класса. Метод является общим термином для подпрограммы на языке ООП.  Многие
общие классы объектов определены в библиотеках общих классов, таких как
комплекты разработки программного обеспечения (SDK), тогда как другие
определяются вами, разработчиком, в ваших собственных целях. Затем программное обеспечение создается с использованием и
манипулированием экземплярами объектов по-разному.

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

• Википедия имеет хороший обзор ООП
• Sun
  Java Tutorials на Java
• Учебники
  Java в Oracle

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

Понимание
наследования

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

Эта
концепция лучше всего иллюстрируется примером.  Давайте
притворимся, что мы разрабатываем Java-приложение для имитации аквариума. В этом
аквариуме есть рыба. Поэтому
мы могли бы определить класс для представления рыбы. Этот класс, называемый Fish, может включать в себя некоторые
поля данных (также называемые атрибутами или переменными-членами класса) для
описания объекта рыбы: вида, цвета и размера; а также некоторые его поведение в
виде методов (также называемых подпрограммами или функциями в процедурных
языках), таких как eat (), sleep () и makeBabyFish ().

Для создания и инициализации объекта используется специальный тип метода, называемый конструктором; конструкторы называются такими же, как и их класс, имогут включать в себя параметры. Следующий класс Fish имеет два конструктора: один для создания общего объекта Fish, а другой для конструирования определенного объекта Fish с некоторыми исходными данными. Вы
также увидите, что у класса Fish есть два метода eat (): один для приема
чего-то случайного, а другой — для еды другой рыбы, который будет представлен
другим экземпляром класса Fish:

public class Fish {

    private String mSpecies;
    private String mColor;
    private int mSize;

    Fish() {
        // generic fish
        mSpecies = "unknown";
        mColor = "unknown";
        mSize = 0;
    }

    Fish(String species, String color, int size) {
        mSpecies = species;
        mColor = color;
        mSize = size;
    }
    public void eat() {
        // eat some algae
    };
        
    public void eat(Fish fishToEat) {
        // eat another fish!
    };
        
    public void sleep() {
        // sleep
    };
        
    public void makeBabyFish(Fish fishSpouse, int numBabies) {
        // Make numBabies worth of baby fish with Fish spouse
    };
}

Классы могут быть организованы в иерархии, где производный класс (или подкласс) включает все функции его родительского класса (orsuperclass), но уточняет и добавляет к ним, чтобы определить более конкретный объект, используя ключевое слово extends. Это называется наследованием.

Например,
класс Fish может иметь два подкласса: FreshwaterFish и SaltwaterFish. Эти
подклассы будут иметь все функции класса Fish, но могут дополнительно настроить
объекты с помощью новых атрибутов и поведения или модифицированного поведения
из родительского класса Fish. Например,
класс FreshwaterFish может включать информацию о типе пресноводной среды, в
которой они жили (например, река, озеро, пруд или лужа).  Аналогично,
класс SaltwaterFish может настроить метод makeBabyFish() таким образом, чтобы
рыба ест своего партнера после размножения (как определено в суперклассе),
используя механизм переопределения, например:

public class SaltwaterFish extends Fish
{
    @Override
    public void makeBabyFish(Fish fishSpouse, int numBabies) {
        // call parent method
        super.makeBabyFish(fishSpouse, numBabies);
        // eat mate
        eat(fishSpouse);
    }
}

Организация поведения объекта с интерфейсами

В Java
вы можете организовать поведение объектов в так называемых интерфейсах.  Хотя
класс определяет объект, интерфейс определяет некоторое поведение, которое
может быть применено к объекту.  Например,
мы можем определить интерфейс Swimmer, который предоставляет набор методов,
которые являются общими для всех объектов, которые могут плавать, будь то рыба,
выдры или погружные андроиды. Интерфейс
Swimmer может указывать четыре метода: startSwimming(), stopSwimming(), dive() и surface().

public interface Swimmer
{
    void startSwimming();
    void stopSwimming();
    void dive(); 
    void surface(); 
}

Затем класс, подобный Fish, может реализовать интерфейс
Swimmer (с использованием ключевого слова реализует) и обеспечить реализацию
поведения плавания:

public class Fish implements Swimmer {
    // Provide implementations of the four methods within the Swimmer interface 
}

Организация классов и интерфейсов с пакетами

Затем иерархии классов, такие как наши классы рыбы, могут быть организованы в пакеты. Пакет — это просто набор классов и интерфейсов, объединенных вместе.  Разработчики
используют пространства имен для уникального имени пакетов. Например,
мы могли бы использовать com.mamlambo.aquarium или om.ourclient.project.subproject
в качестве нашего имени пакета, чтобы отслеживать наши классы, связанные с
рыбой.

Заключение

Вау!
Вы только что начали курс по сбору данных в Java для разработки Android.  Мы
рассмотрели здесь довольно много материала, поэтому давайте немного
поразмыслим, прежде чем переходить к следующему уроку этой серии уроков.  В
уроке 2 мы переключим внимание на подробные детали синтаксиса Java.

Вы
только поцарапали поверхность Java-разработки для разработки Android.  Ознакомьтесь
со всеми другими замечательными учебниками на Mobiletuts +, чтобы погрузиться
глубже в разработку Java и Android. Удачи!

Об авторах

Разработчики мобильных устройств Лорен Дарси и Шейн Кондер совместно со своими коллегами разработали несколько книг по разработке Android: углубленную книгу по программированию под названием Android Wireless Application Development и разработку приложений для Android от Sams TeachYourself за 24 часа.  Когда
они не пишут книги, они тратят свое время на разработку мобильного программного
обеспечения в своей компании и предоставление консультационных услуг. Их можно найти по электронной почте: androidwirelessdev+mt@gmail.com, через свойблог  androidbook.blogspot.com и на Twitter @androidwireless.

Нужна
дополнительная помощь? Написание приложений для Android? Ознакомьтесь с нашими новейшими книгами и ресурсами!

Связанные учебные пособия:

• Изучите
  Java для разработки Android: синтаксис Java
• Введение
  в разработку Android SDK
• Начало Android: Начало работы с FortuneCrunch
• Общие
  конфигурации виртуальных устройств Android
• Запуск
  приложения «Карты в приложении»
• Разрешение пользователям отправлять электронную почту в
  приложении
• Использование
  предупреждений, тостов и уведомлений
• Создание
  простых пользовательских форм