ООП: что такое инкапсуляция, абстракция, полиморфизм и наследование?

инкапсуляция - включение в класс данных (или других классов) с ограничением доступа к ним. Например, класс "ведро" может инкапсулировать в себе класс "мусор" и предоставлять методы "добавить мусора" и "опустошить ведро", но не давать никому трогать сам "мусор".

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

полиморфизм - изменение/дополнение поведения класса-предка классами-потомками. Например, класс "ведро" имеет виртуальный метод "опустошить ведро", вызывающий приватный метод "перевернуть ведро". А класс "ведро с крышкой" - наследник класса "ведро" - может переопределить метод "опустошить ведро": сначала вызвать приватный метод "открыть крышку", потом - метод предка "опустошить ведро", потом - приватный метод "закрыть крышку".

наследование - наследование это наследование. Наследование потомками методов предков. Класс "ведро с крышкой" - наследник класса "ведро" - унаследует все его защищенные и публичные методы, например "добавить мусора" и "опустошить ведро".

Разжеванней, чем в вики? Это как?
На пальцах - могу: инкапсуляция - не пускаем пользователя (т. е. другого программиста) к данным мимо наших функций; абстракция - представляем объект в виде некоторой урезанной по предметной области модели (неожиданно, да?) ; наследование - потомки сохраняют функциональность родителей; полиморфизм - конкретная функция определяется по типу объекта во время работы программы.
Что непонятно?

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

Абстракция, полиморфизм - это значит что разные классы могут иметь один и тот же набор публичных методов. Обычно это реализуется путём создания интерфейса (простейшее описание перечня методов) . Дальше этот интерфейс добавляется ко всем классам. И в последствии получается что любой класс от части является и этим интерфейсом. Вы сможете любой класс привести к типу данных = интерфейсу, и соответственно разные классы с разным содержимым будут вести себя как один и тот же тип данных. Разные классы можно скормить методу принимающему на вход класс только одного типа. Лишь бы этот тип был реализован во всех разнородных классах.

При наследовании функциональность класса расширяется. Можно класс унаследовать от интерфейса, можно от любого другого объекта. В C++ поддерживается наследование от 2 классов сразу! А в C# только от одного класса и любого кол-ва интерфейсов. Класс всегда можно рассматривать как базовый. Ну к примеру, вы узнали о существовании абстрактного класса Stream. И знаете что много процедур принимают объект типа Stream. У вас появляется идея как осуществить вызов такого метода передав в него свои уникальные данные. Просто написать нового наследника от класса Stream и переопределить в нём все методы. Получаем некий новый класс MyStream, который также легко приводится к базовому типу Stream. Ну примерно также как int легко приводится к long. Процедура получает экземпляр класса MyStream но она к нему относится так будто это Stream. Не учитывает ваши доработки. А вы в свою очередь позаботились чтобы ваш MyStream чётко соответствовал идеологии Stream.

Идеология ООП выходит очень далеко за понятие самой теории ООП. Примерно также как русский язык не описывает всего многообразия мыслей, не передаёт смысла будущих текстов.
На ООП существует много паттернов, их можно не любить но применяют их постоянно.
Рано или поздно вы спросите у друга программиста "а как мне сделать ..." и он вам сообщит некое сочетание приёмов программирования базирующееся на классах.

ООП плохо реализовано во всех скриптовых языках, так как там типизация не строгая.

ходи на занятия

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _1
{
class Program
{
public class zavod { };
public class chelovek:zavod { public int let; public string fio; };
public class manager:chelovek { };
public class raboc : chelovek { };
public class injiner : chelovek { };

static void Main(string[] args)
{
var krasmach = new zavod { };
var chelovek1 = new List { };
chelovek1.Add(new manager { let = 50,fio = "vsdsd" });
chelovek1.Add(new raboc { let = 200, fio = "s" });
chelovek1.Add(new injiner { let = 10, fio = "bbbbbbbbbbb" });
foreach(var n in chelovek1)
{
if (n.let > 60)
Console.WriteLine(n.fio);
}
Console.ReadKey();
}
}
}
222222222222
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _2
{
class Program
{
public class bibl { public string name;public int let; };
public class pechat:bibl { };
public class jurnal : pechat { };
public class kniga : pechat { };
public class uceb : pechat { };

static void Main(string[] args)
{
var sfu = new bibl { name = "sfu" };
var pechat1 = new List { };
pechat1.Add(new jurnal { name = "1", let = 2 });
pechat1.Add(new kniga { name = "2", let = 6 });
pechat1.Add(new uceb { name = "3", let = 3 });
foreach(var n in pechat1)
{
if (n.let < 5)
Console.WriteLine(n.name);
}
Console.ReadKey();
}
}
}
33333333333333
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _3
{
class Program
{
public class student { public string name; };
public class isp : student { };
public class zahet: isp { };
public class exem : isp { };
public class itogtest : isp { };
static void Main(string[] args)
{
var sasha = new student { };
var isp1 = new List { };
isp1.Add(new zahet {name = "prog"});
isp1.Add(new itogtest {name = "mat" });
isp1.Add(new exem {name="istor"});
isp1.Add(new exem { name = "algem" });
for (int i = 0; i < isp1.Count; i++)
{
if (isp1[i] is exem)
Console.WriteLine(isp1[i].name);
}
Console.ReadKey();
}
}
}
444444444444444444444
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _9
{
class Program
{
public class skald { };
public class moloko : skald { };
public class hleb : skald { };
public class myaso : skald { };
static void Main(string[] args)
{
int mo=0, my=0, h = 0;
var produkt1 = new List();
produkt1.Add(new moloko());
produkt1.Add(new moloko());
produkt1.Add(new hleb());
produkt1.Add(new myaso());
foreach (var n in produkt1)
{
if (n is moloko)
mo++;
if (n is hleb)
h++;
if (n is myaso)
my++;
}
if (mo < 2)
Console.WriteLine("Молоко");
if (h < 2)
Console.WriteLine("Хлеб");
if (my < 2)
Console.WriteLine("Мясо");
Console.ReadKey();
}
}
}
5555555555555
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _10
{
class Program
{
List PO;
public class nout { }
public class ofis : nout { }
public class inst : nout { }
public class igra : nout { }
static void Main(string[] args)
{
var PO1 = new List();
PO1.Add(new ofis());
PO1.Add(new ofis());
PO1.Add(new ofis());
PO1.Add(new inst());
PO1.Add(new inst());
PO1.Add(new inst());
PO1.Add(new igra());
PO1.Add(new igra());
PO1.Add(new igra());
int k = 0;
for (int i=0;i<PO1.Count;i++)
{

if (PO1[i] is igra)
{
PO1.Remove(PO1[i]);
k++;
}
}
Console.WriteLine(k);
Console.ReadKey();
}
}
}

namespace Лаб_8_испр
{
class Program
{
static int Main(string[] args)
{
List Cars = new List();
Random rand = new Random();
for (int i = 0; i < 20; i++)
Cars.Add(new Car(rand.Next(0, 2), rand.Next(1, 4), rand.Next(0, 100), rand.Next(20, 30)));
do
{
Console.WriteLine("1. Заказать машину ");
Console.WriteLine("2. Вывести список машин ");
Console.WriteLine("3. Выход ");
char Menu;
Menu = Convert.ToChar(Console.ReadLine());
if (Menu == '1')
{
double a;
int b;
Console.Write("Введите расстояние до цели: ");
a = Convert.ToDouble(Console.ReadLine());
Console.Write(" Введите кол-во пассажиров: ");
b = Convert.ToInt32(Console.ReadLine());
foreach (Car el in Cars)
{
if (el.status == 0 && el.count >= b && el.oil >= el.rashodoil / 100 * a)
{
el.status = 1;
el.oil = el.oil - el.rashodoil / 100 * a;
break;
}
}
}
else if (Menu == '2')
{
for (int i = 0; i < Cars.Count; i++)
{
Console.WriteLine(Cars[i].status + " " + Cars[i].rashodoil + " " + Cars[i].oil + " " + Cars[i].count);
}
}
else if (Menu == '3')
return 0;
else
Console.WriteLine("Неверный пункт меню");
Console.ReadKey();
Console.Clear();

} while (true);
}
}
public class Car
{
public int status;
public int count;
public double oil;
public double rashodoil;
public Car(int status, int count, int oil, int rashodoil)
{
this.status = status;
this.count = count;
this.oil = oil;
this.rashodoil = rashodoil;
}
}
}

namespace Лаб_9
{
class Program
{
class Cat
{
private string _name;
public string Name
{
get { return _name; }
set
{
if (string.IsNullOrEmpty (_name))
{
_name = value;
}
Console.WriteLine("Имя уже введено");
}
}
public int Health { get; private set; }
public string Color
{
get { return (Health > 5) ? "Зеленый" : ((Health < 3) ? "Красный" : "Желтый"); }
private set { }
}

public Cat(int Health)
{
this.Name = "";
this.Health = Health;
}
public void Nakaz()
{
Health--;
}
public void Eat()
{
Health++;
}
}
static void Main(string[] args)
{
Cat C = new Cat(4);
char menu;
do
{
Console.WriteLine("1. Назвать кошку");
Console.WriteLine("2. Кормить кошку");
Console.WriteLine("3. Наказать кошку");
Console.WriteLine("0. Выход");
Console.WriteLine("=========================");
Console.WriteLine("Имя: " + C.Name + "; Здоровье: " + C.Health + "; Окрас: " + C.Color);
menu = Convert.ToChar(Console.ReadLine());
switch (menu)
{
case '1':
{
Console.Write("Введите имя: ");
C.Name = Console.ReadLine();
break;
}

case '2':
{
C.Eat();
break;
}

case '3':
{
C.Nakaz();
break;
}

case '0': break;

default:
{
Console.WriteLine("Такого пункта меню нет ");

Инкапсуляция - это скрытие реализации для пользователя. Наведу пример автомобиля. В автомобиле есть коробка передач, есть система управления и т. д. Эти элементы взаимодействуют с внутренними элементами, но для того чтобы тебе ехать, не обязательно знать как там все работает, тебе главное нажать на педали, включить передачу и ехать, а вот как оно все работает уже скрыто от тебя. вот это и есть ИНКАПСУЛЯЦИЯ, тоесть скрытие как работает автомобиль (скрытие реализации) .
Абстракция - это такое понятие которое как бы разделяет физическое состояние от так сказать вымешленного.
Например у тебя есть идея создать какой нибудь объект. Ты на листе рисуешь его составные, придумываешь как они будут взаимодействовать между собой, придумываешь какие действия будут от пользователя скрыты, тоесть инкапсулируешь их. тоесть ты создаешь абстракцию своей идеи, своего объекта, тоесть он еще не является физическим а только вымешленным. Вот приблизительно что такое абстракция.
Наследованния - это такое явление которое расширяет объекты. НАпример тот же автомобиль. Компания создала автомобиль например BMW X7. но через год эта компания хочет создать похожую модель но добавить туда некоторые возможности. Да, они могут начать создание заново, но для этого у них уйдет много времени. Для того чтобы им это не делать, они просто берут эту же модель и добавляют ей необходимые функции. ТОесть новый автомобиль будет унаследовать все то что было и у предшественника+со своими возможностями. Также само посмотреть с урока биология. есть класс ЖИВОТНЫЕ - это как бы общее понятие всех животных (все животные могут есть, пить, размножатся). Ниже по иерархии стоит например класс Собачьи которые расширяют какбы класс животные. они могут есть, пить, размножатся как и все животные, приэтом собаки могут еще и лаять, что не все могут животные.. ТОесть собачьи класс унаследован (расширен) от класса Животные.
Полиморфизм - это так называемый принцип в котором при одной какой то форме действий могут выполнятся различные реализации. Например в том же автомобиле. У всех есть педали (газ, тормоз, сцепление). Как бы у всех машин есть единый интерфейс, тоесть когда жмешь газ - машина едет, когда тормоз тормозит. Но в разных машинах при нажатии на одну и ту же педаль выполняются разные реализации. Одна набирает скорость быстрей, одна тормозит быстрей. Тоесть ПОлиморфизм - это один интерфейс, много действий (реализаций)
Все эти 4 принципа ООП, применяются в программировании и есть очень полезными и удобными.

на сколько я знаю инкапсуляция это вид доступа к переменной свойству или методу