Гайд Основные принципы ООП

[s3m1]

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

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

Спасибо!

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

Рассмотрим такие принципы как:
Абстракция
Инкапсуляция
Наследование
Полиморфизм

Начнём с абстракции.

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

Покажу на примере:

Допустим у нас есть класс кошки

public abstract class Cat {
    public static String name;
    public static String breed;

    public Cat() {
    }

    public abstract void sleep();
}

Мы создали абстрактный класс Cat, который определяет общие характеристики - имя и породу, а также метод sleep().

Теперь для примера создадим классы домашней и дикой кошки:

public class DomesticCat extends Cat {
    public static String owner;

    @Override
    public void sleep() {
        System.out.println("Спит дома");
    }
}

public class WildCat extends Cat {
    public static String territory;

    @Override
    public void sleep() {
        System.out.println("Спит на улице");
    }
}

Абстракция позволяет нам:
Выделить общие характеристики в базовом классе.
Определить поведение.
Позволить каждому типу реализовать это поведение по своему.


Теперь поговорим об инкапсуляции.

Инкапсуляция - это механизм, который так скажем не позволяет нам напрямую управлять данными внутри классов

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

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

public abstract class Cat {
    private String name;
    private String breed;

    public Cat(String name, String breed) {
        this.name = name;
        this.breed = breed;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getBreed() {
        return breed;
    }

    public void setBreed(String breed) {
        this.breed = breed;
    }

    public abstract void sleep();
}

public class DomesticCat extends Cat {
    private String owner;

    public DomesticCat(String name, String breed, String owner) {
        super(name, breed);
        this.owner = owner;
    }

    public String getOwner() {
        return owner;
    }

    // можем оставить или убрать этот метод по желанию
    // если убрать этот метод, то мы уже не будем иметь возможности изменить владельца кошки из вне
    public void setOwner(String owner) {
        this.owner = owner;
    }

    @Override
    public void sleep() {
        System.out.println("Спит дома");
    }
}

public class WildCat extends Cat {
    private String territory;

    public WildCat(String name, String breed, String territory) {
        super(name, breed);
        this.territory = territory;
    }

    public String getTerritory() {
        return territory;
    }

    public void setTerritory(String territory) {
        this.territory = territory;
    }

    @Override
    public void sleep() {
        System.out.println("Спит на улице");
    }
}

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

Наследование позволяет создавать новые классы на основе существующих.
В нашем примере мы уже использовали наследование: DomesticCat и WildCat наследуются от Cat.
Они получают все свойства и методы базового класса.
Могут добавлять свои уникальные характеристики (owner, territory).
Могут переопределять поведение (sleep).

И наконец, полиморфизм.

Полиморфизм позволяет работать с объектами разных классов через общий интерфейс.

public class CatsFactory {
    public static void main(String[] args) {
        // кошки разных типов
        List<Cat> cats = new ArrayList<>();
        // имя, порода, владелец
        cats.add(new DomesticCat("Башмак", "Сиамская", "Иван"));
        // имя (впринципе, его можно и убрать), порода, территория
        cats.add(new WildCat("Вазген", "Рысь", "Лес"));

        // вызываем sleep() для каждой кошки
        for(Cat cat : cats) {
            cat.sleep();
        }
    }
}

Тут мы работаем с разными типами кошек через общий тип Cat.
Метод sleep() вызывается для каждой кошки.
Нужная реализация метода определяется автоматически.
Сам код становится более гибким.

Вот впринципе и всё, я бы надеялся, что кто-то после прочтения начнёт писать код чище (как и я собсна), думаю, начинающим такое на прочтение очень даже пойдёт на пользу. Пака! ?

 

[nedokoder]

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

Рассмотрим такие принципы как:
Абстракция
Инкапсуляция
Наследование
Полиморфизм

Начнём с абстракции.

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

Покажу на примере:

Допустим у нас есть класс кошки

public abstract class Cat {
    public static String name;
    public static String breed;

    public Cat() {
    }

    public abstract void sleep();
}

Мы создали абстрактный класс Cat, который определяет общие характеристики - имя и породу, а также метод sleep().

Теперь для примера создадим классы домашней и дикой кошки:

public class DomesticCat extends Cat {
    public static String owner;

    @Override
    public void sleep() {
        System.out.println("Спит дома");
    }
}

public class WildCat extends Cat {
    public static String territory;

    @Override
    public void sleep() {
        System.out.println("Спит на улице");
    }
}

Абстракция позволяет нам:
Выделить общие характеристики в базовом классе.
Определить поведение.
Позволить каждому типу реализовать это поведение по своему.


Теперь поговорим об инкапсуляции.

Инкапсуляция - это механизм, который так скажем не позволяет нам напрямую управлять данными внутри классов

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

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

public abstract class Cat {
    private String name;
    private String breed;

    public Cat(String name, String breed) {
        this.name = name;
        this.breed = breed;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getBreed() {
        return breed;
    }

    public void setBreed(String breed) {
        this.breed = breed;
    }

    public abstract void sleep();
}

public class DomesticCat extends Cat {
    private String owner;

    public DomesticCat(String name, String breed, String owner) {
        super(name, breed);
        this.owner = owner;
    }

    public String getOwner() {
        return owner;
    }

    // можем оставить или убрать этот метод по желанию
    // если убрать этот метод, то мы уже не будем иметь возможности изменить владельца кошки из вне
    public void setOwner(String owner) {
        this.owner = owner;
    }

    @Override
    public void sleep() {
        System.out.println("Спит дома");
    }
}

public class WildCat extends Cat {
    private String territory;

    public WildCat(String name, String breed, String territory) {
        super(name, breed);
        this.territory = territory;
    }

    public String getTerritory() {
        return territory;
    }

    public void setTerritory(String territory) {
        this.territory = territory;
    }

    @Override
    public void sleep() {
        System.out.println("Спит на улице");
    }
}

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

Наследование позволяет создавать новые классы на основе существующих.
В нашем примере мы уже использовали наследование: DomesticCat и WildCat наследуются от Cat.
Они получают все свойства и методы базового класса.
Могут добавлять свои уникальные характеристики (owner, territory).
Могут переопределять поведение (sleep).

И наконец, полиморфизм.

Полиморфизм позволяет работать с объектами разных классов через общий интерфейс.

public class CatsFactory {
    public static void main(String[] args) {
        // кошки разных типов
        List<Cat> cats = new ArrayList<>();
        // имя, порода, владелец
        cats.add(new DomesticCat("Башмак", "Сиамская", "Иван"));
        // имя (впринципе, его можно и убрать), порода, территория
        cats.add(new WildCat("Вазген", "Рысь", "Лес"));

        // вызываем sleep() для каждой кошки
        for(Cat cat : cats) {
            cat.sleep();
        }
    }
}

Тут мы работаем с разными типами кошек через общий тип Cat.
Метод sleep() вызывается для каждой кошки.
Нужная реализация метода определяется автоматически.
Сам код становится более гибким.

Вот впринципе и всё, я бы надеялся, что кто-то после прочтения начнёт писать код чище (как и я собсна), думаю, начинающим такое на прочтение очень даже пойдёт на пользу. Пака! ?

аким, давай встречаться

 

[s3m1]

аким, давай встречаться

не надо пожалуйста(

 

[BurgerCat]

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

Рассмотрим такие принципы как:
Абстракция
Инкапсуляция
Наследование
Полиморфизм

Начнём с абстракции.

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

Покажу на примере:

Допустим у нас есть класс кошки

public abstract class Cat {
    public static String name;
    public static String breed;

    public Cat() {
    }

    public abstract void sleep();
}

Мы создали абстрактный класс Cat, который определяет общие характеристики - имя и породу, а также метод sleep().

Теперь для примера создадим классы домашней и дикой кошки:

public class DomesticCat extends Cat {
    public static String owner;

    @Override
    public void sleep() {
        System.out.println("Спит дома");
    }
}

public class WildCat extends Cat {
    public static String territory;

    @Override
    public void sleep() {
        System.out.println("Спит на улице");
    }
}

Абстракция позволяет нам:
Выделить общие характеристики в базовом классе.
Определить поведение.
Позволить каждому типу реализовать это поведение по своему.


Теперь поговорим об инкапсуляции.

Инкапсуляция - это механизм, который так скажем не позволяет нам напрямую управлять данными внутри классов

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

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

public abstract class Cat {
    private String name;
    private String breed;

    public Cat(String name, String breed) {
        this.name = name;
        this.breed = breed;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getBreed() {
        return breed;
    }

    public void setBreed(String breed) {
        this.breed = breed;
    }

    public abstract void sleep();
}

public class DomesticCat extends Cat {
    private String owner;

    public DomesticCat(String name, String breed, String owner) {
        super(name, breed);
        this.owner = owner;
    }

    public String getOwner() {
        return owner;
    }

    // можем оставить или убрать этот метод по желанию
    // если убрать этот метод, то мы уже не будем иметь возможности изменить владельца кошки из вне
    public void setOwner(String owner) {
        this.owner = owner;
    }

    @Override
    public void sleep() {
        System.out.println("Спит дома");
    }
}

public class WildCat extends Cat {
    private String territory;

    public WildCat(String name, String breed, String territory) {
        super(name, breed);
        this.territory = territory;
    }

    public String getTerritory() {
        return territory;
    }

    public void setTerritory(String territory) {
        this.territory = territory;
    }

    @Override
    public void sleep() {
        System.out.println("Спит на улице");
    }
}

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

Наследование позволяет создавать новые классы на основе существующих.
В нашем примере мы уже использовали наследование: DomesticCat и WildCat наследуются от Cat.
Они получают все свойства и методы базового класса.
Могут добавлять свои уникальные характеристики (owner, territory).
Могут переопределять поведение (sleep).

И наконец, полиморфизм.

Полиморфизм позволяет работать с объектами разных классов через общий интерфейс.

public class CatsFactory {
    public static void main(String[] args) {
        // кошки разных типов
        List<Cat> cats = new ArrayList<>();
        // имя, порода, владелец
        cats.add(new DomesticCat("Башмак", "Сиамская", "Иван"));
        // имя (впринципе, его можно и убрать), порода, территория
        cats.add(new WildCat("Вазген", "Рысь", "Лес"));

        // вызываем sleep() для каждой кошки
        for(Cat cat : cats) {
            cat.sleep();
        }
    }
}

Тут мы работаем с разными типами кошек через общий тип Cat.
Метод sleep() вызывается для каждой кошки.
Нужная реализация метода определяется автоматически.
Сам код становится более гибким.

Вот впринципе и всё, я бы надеялся, что кто-то после прочтения начнёт писать код чище (как и я собсна), думаю, начинающим такое на прочтение очень даже пойдёт на пользу. Пака! ?

Ну всё ща прочитаю и из пастера стану селфкодером?????????

 

[anatick123321]

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

Рассмотрим такие принципы как:
Абстракция
Инкапсуляция
Наследование
Полиморфизм

Начнём с абстракции.

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

Покажу на примере:

Допустим у нас есть класс кошки

public abstract class Cat {
    public static String name;
    public static String breed;

    public Cat() {
    }

    public abstract void sleep();
}

Мы создали абстрактный класс Cat, который определяет общие характеристики - имя и породу, а также метод sleep().

Теперь для примера создадим классы домашней и дикой кошки:

public class DomesticCat extends Cat {
    public static String owner;

    @Override
    public void sleep() {
        System.out.println("Спит дома");
    }
}

public class WildCat extends Cat {
    public static String territory;

    @Override
    public void sleep() {
        System.out.println("Спит на улице");
    }
}

Абстракция позволяет нам:
Выделить общие характеристики в базовом классе.
Определить поведение.
Позволить каждому типу реализовать это поведение по своему.


Теперь поговорим об инкапсуляции.

Инкапсуляция - это механизм, который так скажем не позволяет нам напрямую управлять данными внутри классов

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

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

public abstract class Cat {
    private String name;
    private String breed;

    public Cat(String name, String breed) {
        this.name = name;
        this.breed = breed;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getBreed() {
        return breed;
    }

    public void setBreed(String breed) {
        this.breed = breed;
    }

    public abstract void sleep();
}

public class DomesticCat extends Cat {
    private String owner;

    public DomesticCat(String name, String breed, String owner) {
        super(name, breed);
        this.owner = owner;
    }

    public String getOwner() {
        return owner;
    }

    // можем оставить или убрать этот метод по желанию
    // если убрать этот метод, то мы уже не будем иметь возможности изменить владельца кошки из вне
    public void setOwner(String owner) {
        this.owner = owner;
    }

    @Override
    public void sleep() {
        System.out.println("Спит дома");
    }
}

public class WildCat extends Cat {
    private String territory;

    public WildCat(String name, String breed, String territory) {
        super(name, breed);
        this.territory = territory;
    }

    public String getTerritory() {
        return territory;
    }

    public void setTerritory(String territory) {
        this.territory = territory;
    }

    @Override
    public void sleep() {
        System.out.println("Спит на улице");
    }
}

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

Наследование позволяет создавать новые классы на основе существующих.
В нашем примере мы уже использовали наследование: DomesticCat и WildCat наследуются от Cat.
Они получают все свойства и методы базового класса.
Могут добавлять свои уникальные характеристики (owner, territory).
Могут переопределять поведение (sleep).

И наконец, полиморфизм.

Полиморфизм позволяет работать с объектами разных классов через общий интерфейс.

public class CatsFactory {
    public static void main(String[] args) {
        // кошки разных типов
        List<Cat> cats = new ArrayList<>();
        // имя, порода, владелец
        cats.add(new DomesticCat("Башмак", "Сиамская", "Иван"));
        // имя (впринципе, его можно и убрать), порода, территория
        cats.add(new WildCat("Вазген", "Рысь", "Лес"));

        // вызываем sleep() для каждой кошки
        for(Cat cat : cats) {
            cat.sleep();
        }
    }
}

Тут мы работаем с разными типами кошек через общий тип Cat.
Метод sleep() вызывается для каждой кошки.
Нужная реализация метода определяется автоматически.
Сам код становится более гибким.

Вот впринципе и всё, я бы надеялся, что кто-то после прочтения начнёт писать код чище (как и я собсна), думаю, начинающим такое на прочтение очень даже пойдёт на пользу. Пака! ?

я в ахуе

 

[clearlyst]

Можна ещё про интерфейс, метод сокрытия добавить

 

[s3m1]

Можна ещё про интерфейс, метод сокрытия добавить

да как будто и так должно быть понятно как оно работает, не?

 

[VOSTOKGRIEF1]

хуйня, нахуй кому-то это надо? В каждом туторе по java, всегда начинают с этого...

 

[s3m1]

хуйня, нахуй кому-то это надо? В каждом туторе по java, всегда начинают с этого...

смотря на ваш кодстайл, это надо всем тут