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

1 Лучшее – враг хорошего

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

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

Если вы занимаетесь в балете с пяти лет по 8 часов в день, всегда найдется тот, кто занимается с трех лет и по 10 часов в день. К пятнадцати годам его опыт будет превосходить ваш на 5000 часов. А ведь есть еще и гении, на каждый час которого вам нужно заниматься три. И лучшие в мире преподаватели, а вы, например, самоучка.

Единственный способ стать лучшим, не имея своего уникального пути – это работать больше всех, быть талантливым, иметь хороших преподавателей и богатых родителей. Хотя – это уже не совсем «как все», да?

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

2 Лучшим стать непросто

Всегда найдется кто-то, кто начал раньше вас. У кого-то богатые родители, кто-то учился в самом лучшем в мире университете. Кого-то родители взяли к себе на работу. Ничего страшного. Бывает. Это называется – разные стартовые условия. Но таких людей – меньшинство, в мире полно людей, которые сами добились успеха, благодаря своему нестандартному мышлению, трудолюбию и способности постоянно учиться всему новому.

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

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

3 Всегда есть тот, кто готов работать больше, чем вы

Таких людей много. Среди них есть трудоголики, перфекционисты и люди, просто влюбленные в свою работу. Да, многие из них жертвуют семьей, друзьями, и готовы работать по 80 часов в неделю. Работа и есть их жизнь. Это путь не для нас. Но они отлично способны вытеснить вас на карьерную обочину. Вы не готовы проводить 6 месяцев в году в командировках, чтобы получить повышение, а они – готовы.

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

Много работать – не путь к успеху, но работать мало – путь к поражению.

4 Культурная среда

Мало где в мире принято много и честно работать. Если в колледже вы много учитесь, пропадаете в библиотеке и сами сдаете все экзамены, то вы – заучка. А если «весь семестр гулял, но сдал» или другим способом «победил систему», то вы – молодец. На дороге под названием «работай больше» слишком большая конкуренция (дорожная пробка, если хотите), этот способ больше не работает. Вам нужно искать другой путь.

Сложно стремиться к успеху, когда само общество ненавидит успешных и богатых. Ненавидит и завидует. Бедные люди, дорвавшись до денег, начинают выставлять свое богатство на показ. Действительно богатые люди ведут себя скромнее: Билл Гейтс может ходить в футболке за $10, потому что и в ней и без нее он – Билл Гейтс.

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

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

Поосторожнее с «жертвами», когда будете становиться лучшим. Не жертвуйте действительно важными вещами: семьей, друзьями, здоровьем, любимой работой. Быть финансово успешным в 50 лет и не иметь семьи, друзей, здоровья, не любить работу – это не успех, это провал.

Решил стать программистом - купи подписку. Вся мощь проекта JavaRush к твоим услугам.

- Профессор всё свою линию гнёт. Все они, старые лекторишки, такие. Всё, что он может рассказать, ты можешь прочесть в книгах. Запомни, ещё ни один человек не научился плавать, прослушав с десяток лекций по этому поводу. Лекции помогают, когда ты 100% в теме и знаешь сам чуть меньше этого профессора.

- Ну, от лекций профессора же есть польза.

- Ага... вернее, мы надеемся, что она есть. Чем больше точек зрения на один и тот же материал ты услышишь, тем больше задумаешься, а как же дела обстоят на самом деле. Услышав только одну точку зрения, ты либо веришь ей, либо нет. Ладно, давай перейдём к делу.

- Давай рассмотрим картинку, которую я уже давал тебе ранее:

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

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

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

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

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

- Да, помню эту картинку.

- Вот и отлично. Давай напомню тебе некоторые моменты.

- Все переменные, объявленные внутри методов, существуют/видны с начала их объявления до конца метода (пример: 1).

- Если переменная определена/объявлена в каком-то блоке кода, то она существует до конца этого блока кода (пример: 2).

- Если переменная является аргументом функции, то она существует/видна во всем теле данного метода (пример: 3) .

- Если переменная является переменной класса (пример: 4), то она привязана к конкретному объекту и существует все время, пока существует объект данного класса. Если нет ни одного объекта, то нет и ни одной копии переменной. К переменной можно обращаться (переменная видна) из всех методов класса, независимо от того, объявлены они до неё или после неё. Для каждого объекта создаётся своя, независимая от других объектов, переменная. Доступ к переменной невозможен из статических методов.

- Если переменная объявлена статической – помечена ключевым словом static, то она существует все время, когда существует её класс. Обычно JVM загружает класс в память при первом его использовании, тогда же и инициализируются статические переменные.

- В примере выше у нас объявлен класс Cat, у которого есть 4 переменные: a,b,s – обычные, а count – статическая. Если создать несколько объектов такого класса (например, 3 шт.), то каждый из них будет содержать свою собственную копию обычных переменных класса. Статическая же переменная – общая на всех. Формально она даже не находится внутри этих объектов, т.к. существует даже тогда, когда ни одного объекта класса Cat создано не было.

- Вот что произойдет, если мы объявим переменную s статической:

- Ага. Вроде понятно.

- А можно объявить одинаковые переменные?

- В методе - нет. Все переменные, объявленные внутри метода, должны иметь уникальные имена. Аргументы метода также считаются его переменными.

- А как насчёт переменных класса?

- Переменные класса тоже должны быть уникальными в рамках каждого конкретного класса.

Но есть исключение – имена переменных метода и переменных класса могут совпадать.

- А если мы в коде изменяем переменную, а таких переменных две, какая будет изменяться?

- Если в методе видны (доступны) несколько переменных, например, переменная класса и переменная метода, то тогда обращение произойдет к переменной метода.

class Main
{
    public int count = 0;     //объявили переменную класса

    public void run()
    {
        count = 15;           //обращение к переменной класса
        int count = 10;       //объявили локальную переменную метода
        count ++;             //обращение к переменной метода
    }
}

- В этом коде объявлены две переменных count. В строке 4 объявлена переменная класса, а в строке 9 – переменная метода.

- Когда метод run будет исполняться, то произойдет вот что:

- В строке 8 мы обращаемся к переменной класса и присваиваем ей значение 15

- В строке 9 объявляется (создается) новая переменная метода – count. Она закрывает собой переменную класса. Любой дальнейший код в методе будет видеть (обращаться) именно к переменной метода.

- Понятно.

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

- А что ещё за статические методы и статические переменные?

- Статические методы и переменные привязаны не к объектам класса, а непосредственно к самому классу. Т.е. если мы создадим 10 объектов класса Variables из примера в самом начале уровня, у нас будет 10 переменных classVariable (по одной на каждый объект) и всего одна общая переменная TEXT.

- У меня тут вопрос.

- А чем отличаются статические и нестатические методы?

- Давай рассмотрим, как работает обычный нестатический метод:

- При вызове метода в виде «объект» точка «имя метода», на самом деле вызывается метод класса, в который первым аргументом передаётся тот самый объект. Внутри метода он получает имя this. Именно с ним и его данными происходят все действия.

- Нифига себе. Так вот как, оказывается, оно все работает!

- А вот как работает статический метод:

- При вызове статического метода, никакого объекта внутрь не передаётся. Т.е. this равен null, поэтому статический метод не имеет доступа к нестатическим переменным и методам (ему нечего передать в такие методы в качестве this).

- Хм. Вроде понятно. Хотя как-то поверхностно.

- А вот и дядя Диего…

- Привет, Амиго.

- Привет, Диего.

- Я вот тут принёс тебе пару задачек на видимость переменных

class Cat
{
  private String name;
  public void setName(String name)
  {
     //написать тут ваш код
  }
}

class Cat
{
  private static int catsCount = 0;
  public static void addNewCat()
  {
     //написать тут ваш код
  }
}

class Cat
{
  private static int catsCount = 0;
  public static setCatsCount(int catsCount)
  {
     //написать тут ваш код
  }
}

class Cat
{
  private String fullName;
  public void setName(String firstName, String lastName)
  {
   String fullName = firstName + lastName;
   //написать тут ваш код
  }
}

Cat cat1 = new Cat();
   //написать тут ваш код
Cat cat2 = new Cat();
   //написать тут ваш код
System.out.println("Cats count is " + Cat.count);

- Сейчас я расскажу тебе, что такое команда и блок команд. Все очень просто. Тело метода состоит из команд. Каждая команда оканчивается точкой с запятой.

- Блок команд состоит из нескольких команд, объединённых вместе фигурными скобками. Тело метода является блоком команд.

{
    throw new RuntimeException();
}

{
    return null;
}

{
    System.out.println(23);
    System.out.println(1);
    System.out.println(14);
}

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

- Привет, Амиго. Сегодня мы разберём условные операторы.

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

- Он состоит из трех частей: «условия», «команды 1» и «команды 2». Если условие верно (истинно), тогда выполняется «команда 1», иначе выполняется «команда 2». Команды никогда не выполняются одновременно. Общий вид этого оператора таков:

if (условие)
    команда_1;
else
    команда_2;

- Как интересно. Думаю, с таким оператором программировать гораздо интереснее.

- Ага. Вот тебе парочка примеров:

if (a < b)
    System.out.println("А меньше Б");
else
    System.out.println("Б меньше А");

if (a < b)
{
    System.out.println("А меньше Б");
    System.out.println("Б больше А");
}
else
{
     System.out.println("Б меньше А");
     System.out.println("А больше Б");
}

if (a < b)
{
    a = 0;
}
else
{
}

if (a < b)
{
    a = 0;
}

if (a < b)
    a = 0;

- Привет, Амиго. У нас на планете мы пользуемся более продвинутым Паскалем. Вот как это все выглядело бы на Паскале.

If a < b Then
    WriteLn ('a меньше b');

if (a < b)
    System.out.println("a меньше b");

If a < b Then
    WriteLn('a меньше b')
Else 
    WriteLn('a больше b');

if (a < b)
    System.out.println("a меньше b");
else
    System.out.println("a больше b");

If a < b Then
    Begin
        WriteLn('a меньше b');
        WriteLn('a меньше b');
    End
Else 
    Begin
        WriteLn('a больше b');
        WriteLn('a больше b');
    End;
End;

if (a < b)
{
    System.out.println("a меньше b");
    System.out.println("a меньше b");
}
else
{
    System.out.println("a больше b");
    System.out.println("a больше b");
}

If a < b And a < c Then
    WriteLn('a минимальное из a, b, c');

if (a < b && a < c)
    System.out.println("a минимальное из a, b, c");

If a < b Or a < c Then
    WriteLn('a или меньше b, или меньше c');

if (a < b || a < c)
    System.out.println("a или меньше b, или меньше c");

If Not (a < b) Then
    WriteLn('b меньше либо равно a')
Else
    WriteLn('b больше a');

if ( !(a < b) )
    System.out.println("b меньше либо равно a");
else
    System.out.println("b больше a");

If a < b Then
    Begin
        If a < c Then 
            WriteLn('a – это минимум')
        Else 
            WriteLn('c – это минимум');
    End
Else
    Begin
        If b < c Then 
            WriteLn('b – это минимум')
        Else 
            WriteLn('c – это минимум');
    End;

if (a < b)
{
    if (a < c)
        System.out.println("a – это минимум");
    else
        System.out.println("c – это минимум");
}
else
{
    if (b < c)
        System.out.println("b – это минимум");
    else
        System.out.println("c – это минимум");
}

If a <= b And a <= c Then
    WriteLn('a – это минимум')
Else If b <= a And b <= c Then
    WriteLn('b – это минимум')
Else If c <= a And c <= b Then
    WriteLn('c – это минимум');

if (a <= b && a <= c)
    System.out.println("a – это минимум");
else   if (b <= a && b <= c)
    System.out.println("b – это минимум");
else   if (c <= a && c <= b)
    System.out.println("c – это минимум");

- Хочу рассказать тебе немного о сравнении переменных в Java.

- Самые простые операторы сравнения ты уже знаешь – это меньше (<) и больше (>).

- Ага.

- Так же есть «равно»(==) и «не равно»(!=). А еще «меньше либо равно»(<=) и «больше либо равно»(>=).

- О, это уже интереснее.

- Обрати внимание, что операторов «=<» и «=>» в Java нет!

- Знак «=» используется для операции присваивания, поэтому для равенства используют «==» - два знака равно. Для того, чтобы проверить, что переменные не равны, используют «!=»

- Ясно.

- При сравнении двух переменных в Java с использованием оператора «==», происходит сравнение того, что эти переменные в себе содержат.

- Т.е. для переменных примитивных типов происходит сравнение значений.

- Для переменных ссылочных типов происходит сравнение ссылок. Т.е. если объекты идентичны внутри, но ссылки на них разные, сравнение покажет, что они неравны: результатом сравнения будет false(ложь). Сравнение ссылок будет true(истина), только если обе ссылки указывают на один и тот же объект.

- Для сравнения объектов по их внутреннему содержанию используют специальный метод equals. Этот метод (и все методы класса Object) добавляется компилятором в твой класс, даже если ты их не объявляешь. Поясняю на примерах:

int a = 5;
int b = 5;
System.out.println(a == b);

Cat cat1 = new Cat("Vaska");
Cat cat2 = cat1;
System.out.println(cat1 == cat2);

String s = new String("Mama");
String s2 = s;
System.out.println(s == s2);

Cat cat1 = new Cat("Vaska");
Cat cat2 = new Cat("Vaska");
System.out.println(cat1 == cat2);

String s = new String("Mama");
String s2 = new String("Mama");
System.out.println(s == s2);

Cat cat1 = new Cat("Vaska");
Cat cat2 = new Cat("Vaska");
System.out.println(cat1.equals(cat2));

String s = new String("Mama");
String s2 = new String("Mama");
System.out.println(s.equals(s2));

- И, кстати, чуть не забыл, вот тебе несколько заданий:

- Привет, Амиго. Хочу рассказать тебе о новом типе данных. Это тип boolean. Переменные этого типа могут принимать всего два значения – true (истина/правда) и false (ложь).

- А как его использовать?

- Этот тип неявно используется во многих местах. Так же, как и результат любого сложения – число, то и результат любого сравнения – истина или ложь – тип boolean. Примеры:

if (a > b) 
    System.out.println(a);

boolean m = (a > b);
if (m) 
    System.out.println(a);

boolean m = (a > b);
if (m == true) 
    System.out.println(a);

boolean m = (a > b);
if (m) 
    System.out.println(a);

- Еще примеры:

public boolean isALessThenB (int a, int b)
{
    if (a < b)
        return true;
    else 
        return false;
}

public boolean isALessThenB (int a, int b)
{
    boolean m = (a < b);
    if (m)
        return true;
    else 
        return false;
}

public boolean isALessThenB (int a, int b)
{
    boolean m = (a < b);
    return m;
}

public boolean  isALessThenB (int a, int b)
{
    return a < b;
}

- А что мне делать, если я хочу записать, выражение 0<a<b ?

- Ну, выражений, которые включают три оператора, в Java нет, поэтому тут нужно воспользоваться такой конструкцией: (0<a) И (a<b)

- Так и писать И?

- Подожди, сейчас все объясню.

- В Java есть три логических оператора: AND (и), OR (или) и NOT (не). С помощью них можно строить условия различной сложности. Эти операторы можно применять только к выражению, имеющему тип boolean. Т.е. (a+1) AND (3) написать нельзя, а (a>1)AND (a<3) – можно.

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

- С переменными типа boolean (логический тип) можно выполнять различные операции.

- А какие?

- Вот сейчас мы их и рассмотрим:

- А можно побольше примеров?

- Конечно:

- Привет.

- Привет, Элли!

- Настало… время изучать циклы! Циклы такая же простая штука, как и условия, только интересней. С помощью цикла можно выполнить какую-нибудь команду или блок команд несколько раз. Общий вид цикла такой:

while(условие типа boolean) 
    команда;

while(условие типа boolean) 
    блок команд в фигурных скобках

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

- А если оно всегда истинно или всегда ложно?

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

Примеры.

int i = 3;
while (i >= 0)
{
    System.out.println(i);
    i--;    //уменьшение i на 1
}

int i = 0;
while (i < 3)
{
    System.out.println(i);
    i++;   //увеличение i на 1
}

boolean isExit = false;
while (!isExit)
{
    String s = buffer.readLine();
    isExit = s.equals("exit");
}

while (true) 
    System.out.println("C");

while (true) 
{
    String s = buffer.readLine();
    if (s.equals("exit")) 
        break;
}

- Вроде и не сложно. После условий. Уже хочется попробовать.

- Привет друг. Билаабо сейчас расскажет, как это все выглядело бы на Паскале.

i := 3;
While i >= 0 Do
Begin 
    WriteLn(i);
    i := i - 1;
End;

int i = 3;
while (i >= 0)
{
    System.out.println(i);
    i--;
}

i := 0;
While i < 3 Do
Begin 
    WriteLn(i);
    i := i + 1;
End;

int i = 0;
while (i < 3)
{
    System.out.println(i);
    i++;
}

isExit := False;
While Not isExit Do
Begin
    ReadLn(s);
    isExit :=  (s = 'exit');
End;

boolean isExit = false;
while (!isExit)
{
    String s = buffer.readLine();
    isExit = s.equals("exit");
}

While True Do
    WriteLn('C');

while (true)
    System.out.println('C');

While True Do
Begin
    ReadLn(s);
    If  s = 'exit' Then 
        Break;
End;

while (true) 
{
    String s = buffer.readLine();
    if (s.equals("exit")) 
        break;    
}

- Ну, сравнение с Паскалем полезно тем, кто его знает.

- А ты что - не знаешь? Это ж самый любимый язык на моей планете!

- Ладно, ладно. Верю, что это классный язык. И если бы я его уже знал, это бы мне помогло.

- Привет, Амиго!

- Я слышал, ты циклы выучил. Подкину-ка я тебе ещё пару задачек.

- Хочу рассказать тебе ещё об одном цикле. Это цикл называется for. Это ещё одна запись цикла while, просто более компактная и удобная [для программистов]. Примеры:

int i = 3;
while (i >= 0)
{
    System.out.println(i);
    i--;
}

for (int i = 3; i >= 0; i--)
{
    System.out.println(i);
}

int i = 0;
while (i < 3)
{
    System.out.println(i);
    i++;
}

for (int i = 0; i < 3; i++)
{
    System.out.println(i);
}

boolean isExit = false;
while (!isExit)
{
    String s = buffer.readLine();
    isExit = s.equals("exit");
}

for (boolean isExit = false; !isExit; )
{
    String s = buffer.readLine();
    isExit = s.equals("exit");
}

while (true)
    System.out.println("C");

for (; true; )
    System.out.println("C");

while (true)
{
    String s = buffer.readLine();
    if (s.equals("exit"))
        break;    
}

for (; true; )
{
    String s = buffer.readLine();
    if (s.equals("exit"))
        break;    
}

- Эээ?

- Данные циклы эквиваленты. Если while содержит в скобках одно условие, то for – три. Но при компиляции for превращается в такой же цикл, как и while.

- Первое выражение в цикле for (выделено зеленым) выполняется один раз до цикла.

- Второе выражение выполняется каждый раз перед исполнением тела цикла – аналогично условию в цикле while.

- Третье – каждый раз после исполнения тела цикла.

- А зачем нужен ещё один цикл. С while все прекрасно понятно.

- Это сделано для удобства программистов. Циклы встречаются в программировании очень часто, и удобно, когда в одной строчке собрана информация о стартовом значении переменой, условии её изменения и команда, которая её меняет.

- Амиго, ты не поверишь, но в Паскале есть цикл For. Он вообще есть практически во всех языках программирования. Только в Паскале он гораздо понятнее. Вот, смотри:

For i := 1 to 10 do
Begin
    Writeln(i);
End;

for (int i = 1; i <= 10; i++)
{
    System.out.println(i);
}

For i := 1 to 10 do step 2
Begin
    Writeln(i);
End;

for (int i = 1; i <= 10; i= i + 2)
{
    System.out.println(i);
}

For i := 10 downto 0 do step 2
Begin
    Writeln(i);
End;

for (int i = 10; i >= 0; i= i - 2)
{
    System.out.println(i);
}

- Сегодня мой счастливый день. Я придумал для тебя 5 новых задач. Креативность так и прёт. Удачи тебе мой друг. Она тебе понадобится…

- Привет, Амиго. Как успехи?

- Отлично, профессор Нудлс. Уже выучили циклы for и while.

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

Дополнительные материалы по 4-му уровню

- Привет, Амиго! Я был должен тебе сегодня что-то прочитать, но давай сначала посмотрим немного телевизор, а потом приступим?

- Здорово, боец!

- Здравия желаю, капитан Бобров!

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