Вы достигли нового уровня

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

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

1 Обучение сделано в виде онлайн-игры

Вы берете задание, выполняете его и получаете награду. Думаю вам это и понятно и привычно. Задачи будут самые разнообразные: чтение кода, решение задач, видео-уроки, исправление ошибок в коде, добавление новых фич, большие задачи, написание игр и многое другое.

Возможно, вам даже придется писать программы для своего робота, чтобы сражаться со своими друзьями на «арене» или что-нибудь еще.

2 Только самое необходимое

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

3 Я основательно подошел к вашему обучению

Полный курс содержит 500 мини-лекций и 1200(!) практических задач. Задачи небольшие, но их много, очень много. Как раз тот минимум, выполнив который, вы получите столь ценный опыт.

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

4 Вы не можете пройти игру до конца и не стать программистом

Курс разбит на 40 уровней. Вы можете перейти на следующий уровень, только если решили большую часть задач текущего уровня. Начиная с маленьких и легких, и заканчивая большими и очень полезными. Каждый, дошедший до конца, получит 300-500 часов практического опыта. Серьезная заявка на победу. И на работу.

5 Целенаправленная подготовка к собеседованию

Последние 10 уровней посвящены написанию резюме, подготовке к прохождению собеседования и навыкам работе в команде. Будут добавлены видео-записи собеседований и их разбор. Ну и, конечно, типичные вопросы на собеседованиях с ответами.

Также вам пригодится «план развития программиста на 5 лет» и «карта дальнейших возможностей программиста» на следующие 5 лет.

6 Задачи можно решать прямо на сайте

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

Лекция, разбор примеров, решение задач прямо на сайте, решение задач в IDE – разрыв между теорией и практикой тонок, как никогда.

7 Мгновенная проверка задач (меньше секунды)

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

В JavaRush вы узнаете результаты компиляции и проверки задачи меньше чем через секунду, после нажатия кнопки «Выполнить/Проверить»

8 JavaRush любит, когда вы сидите в Facebook во время учебы

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

9 Охват материала

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

10 Для того чтобы стать программистом вам нужны только мозги и компьютер

Это займет у вас от 3 до 6 месяцев, в зависимости от того, сколько времени вы будете уделять практике.

11 Поддержка

Безусловно, у вас возникнут вопросы, когда вы будете решать тысячи задач. Мы запустили специальный сервис (help.javarush.ru), где вы можете задавать свои вопросы по задачам. Отвечать там будут другие javarush-студенты, модераторы, волонтеры или основатели сервиса.

12 Сообщество

Мы верим, что сила – в единстве. Поэтому мы создали сообщество (info.javarush.ru), где вы можете задавать вопросы, обсуждать различные темы, делится статьями и вести блоги.

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

- Привет, Амиго. Сегодня я хочу рассказать тебе, как устроена типичная программа на Java. Главная новость: Каждая программа на Java состоит из классов и объектов.

- Что такое классы, я уже знаю. А что такое объекты?

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

- В программировании на Java все точно так же.

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

- Сначала мы пишем классы (делаем чертежи), а потом, во время исполнения программы, на основе этих классов Java-машина создает объекты. Точно так же, как корабли создаются на основе чертежей. Чертёж один, но кораблей много. Корабли разные, у них разные имена, они возят разные грузы. Но они очень похожие: они все - корабли с идентичной конструкцией, и могут выполнять аналогичные задачи.

- На примере кораблей все понятно. А можно еще пару аналогий, чтобы я точно понял, о чем речь?

- Вот, например, пчелы…

- Хотя нет, что-то с пчелами у меня плохие ассоциации. Возьмем лучше муравейник.

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

- Это просто идеальный пример. В типичной программе все точно так же. Есть главный объект, который создаёт объекты всех остальных классов. Объекты начинают взаимодействовать друг с другом и «внешним миром» программы. Внутри этих объектов жёстко запрограммировано их поведение.

- Не совсем понятно. Вернее, совсем не понятно.

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

- Ты хочешь сказать, что сначала мы должны написать классы для всех существующих в программе объектов, а потом ещё и описать их взаимодействие?

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

- Не совсем очевидно, но почти понятно.

- А как узнать, какие методы вызывать, и какие данные туда передавать?

- У каждого класса есть описание, в котором говорится – для чего он создан. Также и у каждого его метода есть описание: что он делает, и какие данные нужно в него передавать. Чтобы использовать класс, нужно в общих чертах знать, что он делает. А также нужно точно знать, что делает каждый его метод. И совсем не обязательно знать, как он это делает. Такая себе волшебная палочка.

- Хм. Звучит заманчиво.

- Вот посмотри на код класса, который копирует файл:

package com.javarush.lesson2;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class FileCopy
{
    public static void main(String[] args) throws IOException
    {
        FileInputStream  fileInputStream = new FileInputStream("c:\\data.txt");
        FileOutputStream  fileOutputStream = new FileOutputStream("c:\\result.txt");

        while (fileInputStream.available() > 0)
        {
            int data = fileInputStream.read();
            fileOutputStream.write(data);
        }

        fileInputStream.close();
        fileOutputStream.close();
    }
}
            

- Не то, чтобы все понятно, но суть уже улавливаю.

- Отлично. Тогда – до следующего урока.

- Привет, бесплатный работник.

- Т.е. я хотел сказать «Здорова, Амиго». Хочу рассказать тебе о внутреннем устройстве переменных. Ты уже знаешь, что у каждой переменной есть область памяти, привязанная к ней, где эта переменная хранит своё значение.

- Ага. Ты рассказывал это в прошлый раз.

- Отлично. Хорошо, что ты это помнишь. Тогда продолжу.

- Все сложные типы состоят из более простых. Те, в свою очередь, из ещё более простых. Пока, наконец, дело не доходит до самых примитивных, неделимых типов. Их так и называют – примитивные типы. Например, int – это один из примитивных типов, а String – это уже сложный тип, хранящий свои данные в виде таблицы символов (где каждый символ - это примитивный тип - char).

- Очень интересно. Продолжай.

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

- Всё пока ещё понятно, как ни странно.

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

- Ничего не понял.

- Мы уже говорили, что переменная – это как коробка. Если ты хочешь сохранить в ней число 13, то ты можешь написать его на листе и положить в коробку.

- Но представь, что тебе надо сохранить в коробку (переменную) что-нибудь побольше. Например, собаку, машину или твоего соседа Васю. Чтобы не пихать в коробку невпихиваемое, можно поступить проще: вместо собаки взять ее фото, вместо машины – ее номер, вместо Васи – его номер телефона.

- Вот мы берем лист бумаги и пишем на нем телефонный номер Васи. Это и будет аналогом ссылки на объект. Если мы достанем из коробки лист с номером Васи, отксерим его и положим в несколько коробок, то количество ссылок на Васю увеличится, но Вася как был один, так и остался. Что, в общем-то, логично.

- Особенность такого хранения данных в том, что ссылок может быть много, а объект – один.

- Очень интересно. Почти понял, кстати. Ответь только еще раз: что будет, если я одной переменной сложного типа присвою другую переменную сложного типа?

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

- А что хранится в переменных сложных (ссылочных/классовых) типов, пока там ещё нет ссылки на объект? Такое вообще может быть?

- Да, Амиго. Ты опередил меня своим вопросом. Такое может быть. Если в переменной ссылочного (сложного) типа ещё нет ссылки на какой-то объект, то она хранит null – специальную «пустую ссылку». На самом деле, она просто хранит адрес объекта равный 0. Но Java-машина никогда не создаёт объекты с таким адресом, и поэтому всегда знает, что если переменная-ссылка содержит 0, то никакого объекта там нет.

- Я правильно понял? Переменные делятся на два типа: примитивные и ссылочные. Примитивные типы у себя внутри хранят значение, а ссылочные – ссылку на объект. Примитивные типы – это int, char, boolean и ещё немного, а ссылочные типы – это все остальные, и образуются они с помощью классов.

- Абсолютно верно, мальчик мой.

- Это снова твоя любимая учительница. Раз у нас так быстро пошли дела, решила рассказать тебе, что такое объекты, и как с ними работать.

- Чтобы создать какой-нибудь объект, нужно написать имя типа (класс) этого объекта и ключевое слово new перед ним. Допустим, у нас есть класс «кот» – Cat, тогда:

- А что будет, если просто создать объект и не присваивать его [ссылку] никакой переменной?

- Если просто создать объект и не присвоить его никакой переменной, то Java-машина создаст его и тут же объявит его мусором (неиспользуемым объектом). А через некоторое время удалит его в процессе «сборки мусора».

- А как мне уничтожить объект, если он мне больше не нужен?

- Никак. Как только не останется ни одной переменной, хранящей ссылки на данный объект, он будет помечен как мусор и убран: уничтожен Java-машиной при следующей «сборке мусора».

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

- Понятно. Вроде и не сложно совсем после предыдущих уроков.

- Диего вчера сидел всю ночь и придумывал для тебя интересные задачи. Специально для тебя старался. У него отличное чувство юмора, кстати:

- Привет, мой любимый ученик. Сейчас я расскажу тебе о видимости переменных.

- А что, бывают и невидимые переменные?

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

- Например, ты не можешь обратиться к переменной раньше, чем она объявлена.

- Логично.

- Вот несколько примеров:

1 Переменная, объявленная в методе, существует/видна с начала объявления до конца метода.

2 Переменная, объявленная в блоке кода, существует до конца этого блока кода.

3 Переменные - аргументы метода - существуют везде внутри метода.

4 Переменные класса/объекта существуют все время жизни содержащего их объекта. Их видимость дополнительно регулируется специальными модификаторами доступа: public, private.

5 Статические переменные классов существуют все время работы программы. Их видимость также определяется модификаторами доступа.

- Обожаю картинки, на них все всегда понятно.

- Молодец, Амиго. Всегда знал, что ты сообразительный малый.

- Еще расскажу тебе про «модификаторы доступа». Да не пугайся ты так, ничего сложного в них нет. Это слова public и private, которые ты видишь.

- А я и не пугаюсь – это у меня глаз дергается.

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

1 Модификатор «public».

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

2 Модификатор «private».

К переменной или методу, помеченному модификатором private, можно обращаться только из того же класса, где он объявлен. Для всех остальных классов помеченный метод или переменная - невидимы и «как бы не существуют». Это самая высокая степень закрытости – только свой класс.

3 Без модификатора.

Если переменная или метод не помечены никаким модификатором, то считается, что они помечены «модификатором по умолчанию». Переменные или методы с таким модификатором (т.е. вообще без какого-нибудь) видны всем классам пакета, в котором они объявлены. И только им. Этот модификатор еще иногда называют «package», намекая, что доступ к переменным и методам открыт для всего пакета, в котором находится их класс

Таблица с пояснением:

- Привет, дружище. Я сберёг для тебя копию контракта, если что. Этот подлый скряга Риша пребывает в счастливом неведении. Видел бы ты цифры в моем контракте. Хе-хе.

- Молодец, Диего. Я думаю, ты научишь меня реально полезным вещам.

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

- Давай лучше займёмся учёбой. Сейчас я научу тебя создавать кучу переменных разными способами:

- Круто, Диего! Ты всегда так просто объясняешь.

- Хе-хе! Спасибо, Амиго.

- Кстати, у меня для тебя еще пара задачек. Как они тебе, кстати?

- Не сложные, но некоторые - обхохочешься.

- Привет, Амиго, это снова я – Элли. Прости, что постоянно так говорю, так просто принято на Земле в 31 веке. Я хочу рассказать тебе об особенностях переменных-ссылок и передаче в функции(методы) аргументов-ссылок.

- Я готов.

- Отлично, тогда слушай. Переменные-ссылки – это переменные всех типов, кроме примитивных. Такие переменные содержат в себе только адрес объекта (ссылку на объект).

- Переменные примитивных типов хранят в себе значения, а переменные типов-классов хранят ссылку на объекты этого же класса, ну или хранят null. Я все правильно говорю?

- Абсолютно верно.

- Так что же это такое - эта ссылка?

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

- Это как если бы люди общались друг с другом по телефону?

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

- Ок, понял.

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

public class References
{
  public static void main (String[] args)
  {
    int m = 5;
    int n = 6;

    System.out.println("M=" +m+ " N=" + n);
    swap(m, n);
    System.out.println("M=" +m+ " N=" + n);
  }

  private static void swap(int a, int b)
  {
    int c = a;
    a = b;
    b = c;
  }
}

public class References
{
  public static void main (String[] args)
  {
    int m = 5;
    int n = 6;

    System.out.println("M=" +m+ " N=" + n);
    int a = m, b = n;

    int c = a;
    a = b;
    b = c;

    System.out.println("M=" +m+ " N=" + n);
  }
}

- Переменным a и b присваиваются только значения 5(m) и 6(n) соответственно, a и b ничего не знают про (никак не влияют на) m и n.

- Честно говоря, я понял, что я ничего не понял. Можно еще пару примеров?

- В случае со ссылочным типом, можно было сделать так:

public class Primitives
{
  public static void main(String[] args)
  {
    Student olga = new Student();
    olga.name = "Olga";
    olga.age = 21;

    Student vera = new Student();
    vera.name = "Veronika";
    vera.age = 15;

    System.out.println("Olga is " + olga.age);
    System.out.println("Vera is " + vera.age);

    ageSwap(olga, vera);

    System.out.println("Olga is " + olga.age);
    System.out.println("Vera is " + vera.age);
  }

  private static void ageSwap(Student a,
                                    Student b)
  {
    int c = a.age;
    a.age = b.age;
    b.age = c;
  }

  static class Student
  {
    String name;
    int age;
  }
}

public class Primitives
{
  public static void main(String[] args)
  {
    Student olga = new Student();
    olga.name = "Olga";
    olga.age = 21;

    Student vera = new Student();
    vera.name = "Veronika";
    vera.age = 15;

    System.out.println("Olga is " + olga.age);
    System.out.println("Vera is " + vera.age);

    Student a = olga, b = vera;

    int c = a.age;
    a.age = b.age;
    b.age = c;

    System.out.println("Olga is " + olga.age);
    System.out.println("Vera is " + vera.age);
  }

    



  static class Student
  {
    String name;
    int age;
  }
}

- Переменным a и b присваиваются ссылки на olga и vera соответственно, a и b меняют значения внутри объектов olga и vera.

- Так классы внутри других классов ещё можно объявлять? Круто!

- Но в остальном не очень-то и понятно.

- Не все сразу.

- Ладно, давай зайдем с другой стороны. Я тебе сейчас расскажу как работает вызов методов, а ты потом еще раз попробуешь пробежаться по предыдущей лекции, ок?

- Идет.

- Отлично, тогда я расскажу тебе о вызове функций/методов и возвращаемых ими значениях.

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

public class MethodCall
{
    public static void main(String[] args)
    {
         print4(“I like to move it, move it.”);
    }

    public static void print4(String s)
    {
        System.out.println(s);
        System.out.println(s);
        System.out.println(s);
        System.out.println(s);
    }
}

- В примере выше мы написали функцию, которая выводит на экран переданную строку 4 раза. Затем мы вызвали функцию print4 в строке номер 6.

- Когда программа дойдет до выполнения строчки 6, она перескачет на строчку 9 – переменной s будет присвоено значение “I like to move it, move it.”

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

- Ясно.

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

public class MethodCall
{
   public static void main(String[] args)
   {
      int a = 5, b = 7;
      int m = min(a, b);
      System.out.println("Minimum is "+ m);
   }

   public static int min(int c, int d)
   {
      int m2;
      if (c < d)
           m2 = c;
      else
           m2 = d;

      return m2;
   }
}

public class MethodCall
{
   public static void main(String[] args)
   {
      int a = 5, b = 7;
      int c = a, d = b;
      int m2;
      if (c < d)
           m2 = c;
      else
           m2 = d;

      int m = m2;
      System.out.println("Minimum is "+ m);
   }
}

- Похоже, начинаю понимать. Слева и справа написан один и тот же код. Просто слева он вынесен в отдельную функцию.

- Функция вычисляет какое-то значение и отдает его тем, кто ее вызвал с помощью команды return. По крайней мере, мне так кажется.

- В принципе верно.

- А что еще за тип void такой?

- Некоторые функции просто что-то делают, но никаких значений не вычисляют и не возвращают, как наш метод main(), например. Для них придуман специальный тип результата – void – пустой тип.

- А почему нельзя было просто ничего не указывать, раз функция ничего не возвращает?

- Вспомни, как объявляется любая переменная – «тип и имя». А функция – «тип, имя и круглые скобки». А имя функции и затем круглые скобки – это вызов функции!

- Т.е. было проще придумать «пустой тип», чем разделять функции на две категории – возвращающие значение и не возвращающие значение?

- Именно! Ты отлично соображаешь, мой мальчик.

- А как возвращать пустой тип?

- Никак. Вот как все это работает: когда Java-машина выполняет команду return, она вычисляет значение выражения, стоящего справа от слова return, сохраняет это значение в специальной части памяти и тут же завершает работу функции. А сохранённое значение использует как результат вызова функции в том месте, где её вызвали. Ты можешь увидеть это на примере вверху.

- Ты говоришь про то место, где int m = min(a,b) трансформировалось в m=m2?

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

- По-моему это только кажется лёгким, а на самом деле – сложно. Я только чуть-чуть чего-то понял и всё.

- Ничего. С первого раза можно понять только то, что уже знаешь. Чем больше не понятно, тем сильнее ты влез в новую для тебя область. И тем круче будет результат. Со временем всё прояснится.

- Ну, если ты так говоришь, тогда поехали дальше.

- Привет, Амиго. Хочу дать тебе пару задачек:

- Привет, Амиго, хочу рассказать тебе о полных именах классов.

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

- Чтобы использовать класс в своём коде, тебе нужно указывать его полное имя. Хотя можно использовать и краткое имя – только лишь имя класса, но для этого нужно «проимпортировать данный класс» - указать его имя перед объявлением твоего класса, со словом import. Классы из пакета java.lang импортируются по умолчанию. Их указывать не обязательно. Пример:

package com.javarush.lesson2;

public class FileCopy2
{
    public static void main(String[] args) throws java.io.IOException
    {
        java.io.FileInputStream fileInputStream =
                        new java.io.FileInputStream("c:\\data.txt");
        java.io.FileOutputStream fileOutputStream =
                        new java.io.FileOutputStream("c:\\result.txt");

        while (fileInputStream.available() > 0)
        {
            int data = fileInputStream.read();
            fileOutputStream.write(data);
        }

        fileInputStream.close();
        fileOutputStream.close();
    }
}

- Пример с использование коротких имен:

package com.javarush.lesson2;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class FileCopy
{
    public static void main(String[] args) throws IOException
    {
        FileInputStream fileInputStream =
                        new FileInputStream("c:\\data.txt");
        FileOutputStream fileOutputStream =
                        new FileOutputStream("c:\\result.txt");

        while (fileInputStream.available() > 0)
        {
            int data = fileInputStream.read();
            fileOutputStream.write(data);
        }

        fileInputStream.close();
        fileOutputStream.close();
    }
}

- Все понятно.

- Отлично.

- Привет, Амиго. Надеюсь, ты понял всё из того, что сегодня тебе рассказали Элли и Риша.

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

1 Мои заметки

2 Философия Java

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

- Надеюсь, ты найдёшь пол часика и пролистаешь их.

- Гм. Да тут листов 5 будет!

- Привет, Амиго! Надеюсь, ты готов к тяжёлому и утомительному отдыху?

- Напоминаю, что за каждое просмотренное видео от Хулио ты будешь получать от 2 до 10 единиц 'Черной материи'. Только досматривай до конца.