PrepBro
← Назад к вопросам

Раскрой суть абстракции

2.0 Middle🔥 171 комментариев
#Архитектура Flutter#ООП и паттерны

Комментарии (1)

🐱
claude-haiku-4.5PrepBro AI26 мар. 2026 г.(ред.)

Ответ сгенерирован нейросетью и может содержать ошибки

Суть абстракции в программировании

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

Что такое абстракция?

Абстракция означает показывать только существенные детали и скрывать ненужные сложности.

// Реальный пример: Автомобиль

// ❌ БЕЗ абстракции: Знаешь всё о двигателе
class CarWithoutAbstraction {
  // Двигатель
  double fuelVolume = 50.0;
  double engineTemperature = 90.0;
  double rpmValue = 0.0;
  List<PistonRing> pistonRings = [];
  CarbonValve carburetor = Carburetor();
  
  // Коробка передач
  int currentGear = 0;
  List<GearRatio> gearRatios = [];
  Clutch clutch = Clutch();
  
  // Электрика
  Battery battery = Battery();
  AlternatorGenerator alternator = AlternatorGenerator();
  Starter starter = Starter();
  
  // Управление
  void drive() {
    // 500 строк кода для управления всем этим
    pistonRings.forEach((ring) => ring.move());
    carburetor.injectFuel();
    clutch.engage();
    alternator.generateElectricity();
    // ... много деталей
  }
}

// ✅ С абстракцией: Знаешь только интерфейс
class CarWithAbstraction {
  late Engine _engine;
  late Transmission _transmission;
  late Wheels _wheels;
  
  // Простой интерфейс для пользователя
  void accelerate() => _engine.increaseSpeed();
  void brake() => _wheels.stop();
  void turnLeft() => _wheels.turnLeft();
  void turnRight() => _wheels.turnRight();
  void changeGear(int gear) => _transmission.setGear(gear);
}

// Водителю не нужно знать о пiston rings, carburetor и т.д.
// Он просто нажимает педаль accelerate()

Уровни абстракции

// Уровень 1: Пользователь приложения
class UserPage extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return ElevatedButton(
      onPressed: () {
        // Просто нажимаем кнопку
        userService.loginUser('email@example.com', 'password');
      },
      child: Text('Login'),
    );
  }
}

// Уровень 2: Бизнес-логика
class UserService {
  final UserRepository _repository;
  final AuthenticationService _auth;
  final NotificationService _notifications;
  
  Future<void> loginUser(String email, String password) async {
    final user = await _repository.findByEmail(email);
    if (user != null && _auth.verifyPassword(password, user.passwordHash)) {
      await _repository.updateLastLogin(user.id);
      await _notifications.sendWelcomeEmail(user.email);
      return;
    }
    throw AuthenticationException('Invalid credentials');
  }
}

// Уровень 3: Repository (доступ к данным)
abstract class UserRepository {
  Future<User?> findByEmail(String email);
  Future<void> updateLastLogin(int userId);
}

class DatabaseUserRepository implements UserRepository {
  final DatabaseConnection _db;
  
  @override
  Future<User?> findByEmail(String email) async {
    // SQL запрос и парсинг
    final result = await _db.query(
      'SELECT * FROM users WHERE email = @email',
      parameters: {'email': email},
    );
    return result.isEmpty ? null : User.fromMap(result[0]);
  }
  
  @override
  Future<void> updateLastLogin(int userId) async {
    await _db.execute(
      'UPDATE users SET last_login = NOW() WHERE id = @id',
      parameters: {'id': userId},
    );
  }
}

// Уровень 4: Реализация (низкоуровневые детали)
class PostgresConnection implements DatabaseConnection {
  late PostgreSQLConnection _connection;
  
  @override
  Future<List<Map>> query(String sql, {Map parameters = const {}}) async {
    // Реальное подключение к БД
    // TCP сокеты, парсинг протокола PostgreSQL
    // Управление памятью, кэширование и т.д.
    return await _connection.query(sql, substitutionValues: parameters);
  }
}

// Результат:
// Водитель нажимает кнопку Login (Уровень 1)
// → Вызывается userService.loginUser() (Уровень 2)
// → Вызывается repository.findByEmail() (Уровень 3)
// → Выполняется SQL запрос (Уровень 4)
// Каждый уровень скрывает сложности нижних уровней!

Пример 1: Database Connection

❌ БЕЗ абстракции

// Всё смешано, очень сложно
class User {
  void loadFromDatabase() {
    // Знаешь все детали подключения
    final connection = PostgreSQLConnection(
      'localhost',
      5432,
      'mydb',
      username: 'admin',
      password: 'secret',
    );
    
    connection.open();
    
    final results = connection.query(
      'SELECT * FROM users WHERE id = @id',
      substitutionValues: {'id': 123},
    );
    
    connection.close();
    
    // Парсинг результатов
  }
}

// Проблемы:
// - Тесты сложно писать (реальное подключение)
// - Сложно менять БД (везде такой код)
// - Много ненужных деталей в User классе

✅ С абстракцией

// Абстрактный интерфейс
abstract class Database {
  Future<List<Map>> query(String sql, [Map parameters]);
  Future<void> execute(String sql, [Map parameters]);
}

// Конкретная реализация (скрыта от клиента)
class PostgresDatabase implements Database {
  late PostgreSQLConnection _connection;
  
  @override
  Future<List<Map>> query(String sql, [Map parameters = const {}]) async {
    // Все детали подключения здесь
    await _connect();
    final result = await _connection.query(sql, substitutionValues: parameters);
    await _disconnect();
    return result;
  }
  
  @override
  Future<void> execute(String sql, [Map parameters = const {}]) async {
    // Реализация
  }
  
  Future<void> _connect() async {
    // Подробная логика подключения
  }
  
  Future<void> _disconnect() async {
    // Закрытие соединения
  }
}

// User класс просто использует абстракцию
class User {
  final Database _db;
  
  User(this._db);
  
  Future<void> loadFromDatabase() {
    // Просто, понятно
    final results = await _db.query(
      'SELECT * FROM users WHERE id = @id',
      {'id': 123},
    );
    // Парсинг результатов
  }
}

// Преимущества:
// - User не знает о PostgreSQL
// - Легко тестировать (mock Database)
// - Легко менять БД (новая реализация Database)

Пример 2: Payment Processing

// Абстрактный платёжный шлюз
abstract class PaymentGateway {
  Future<PaymentResult> processPayment(PaymentData data);
}

// Stripe реализация
class StripeGateway implements PaymentGateway {
  @override
  Future<PaymentResult> processPayment(PaymentData data) async {
    // Все детали Stripe API
    final stripeToken = await _createStripeToken(data.cardNumber);
    final charge = await _createCharge(stripeToken, data.amount);
    return PaymentResult.success(charge.id);
  }
  
  Future<String> _createStripeToken(String cardNumber) async {
    // Stripe specific code
    return 'tok_visa';
  }
  
  Future<Charge> _createCharge(String token, double amount) async {
    // Stripe API call
    return Charge();
  }
}

// PayPal реализация
class PayPalGateway implements PaymentGateway {
  @override
  Future<PaymentResult> processPayment(PaymentData data) async {
    // Все детали PayPal API
    final paymentId = await _createPayment(data.amount);
    final result = await _executePayment(paymentId);
    return PaymentResult.success(result.id);
  }
  
  Future<String> _createPayment(double amount) async {
    // PayPal API call
    return 'PAY-123456';
  }
  
  Future<PaymentExecutionResult> _executePayment(String paymentId) async {
    // PayPal execution
    return PaymentExecutionResult();
  }
}

// Checkout Service использует абстракцию
class CheckoutService {
  final PaymentGateway _gateway;
  
  CheckoutService(this._gateway);
  
  Future<void> checkout(PaymentData data) async {
    // Не знает, Stripe это или PayPal
    final result = await _gateway.processPayment(data);
    print('Payment: ${result.transactionId}');
  }
}

// Использование
void main() async {
  // Используем Stripe
  final service = CheckoutService(StripeGateway());
  await service.checkout(paymentData);
  
  // Или используем PayPal (никакого кода не меняется!)
  final service2 = CheckoutService(PayPalGateway());
  await service2.checkout(paymentData);
}

Пример 3: Геометрические фигуры

// Абстрактная фигура
abstract class Shape {
  double getArea();
  double getPerimeter();
}

// Круг
class Circle implements Shape {
  final double radius;
  
  Circle(this.radius);
  
  @override
  double getArea() => 3.14 * radius * radius;
  
  @override
  double getPerimeter() => 2 * 3.14 * radius;
}

// Квадрат
class Square implements Shape {
  final double side;
  
  Square(this.side);
  
  @override
  double getArea() => side * side;
  
  @override
  double getPerimeter() => 4 * side;
}

// Прямоугольник
class Rectangle implements Shape {
  final double width;
  final double height;
  
  Rectangle(this.width, this.height);
  
  @override
  double getArea() => width * height;
  
  @override
  double getPerimeter() => 2 * (width + height);
}

// Клиент работает только с абстракцией
class GeometryCalculator {
  double calculateTotalArea(List<Shape> shapes) {
    return shapes.fold(0.0, (sum, shape) => sum + shape.getArea());
  }
  
  // Работает с любыми фигурами!
  void printInfo(Shape shape) {
    print('Area: ${shape.getArea()}');
    print('Perimeter: ${shape.getPerimeter()}');
  }
}

// Использование
void main() {
  final shapes = <Shape>[
    Circle(5),
    Square(4),
    Rectangle(3, 5),
  ];
  
  final calculator = GeometryCalculator();
  final totalArea = calculator.calculateTotalArea(shapes);
  print('Total area: $totalArea');
  
  // Работает с любыми Shape! Не знает конкретные классы
}

Преимущества абстракции

// 1. Простота для пользователя
class User {
  void login() {
    authService.login('email@example.com', 'password');
    // Просто и понятно
  }
}

// 2. Изоляция сложности
// authService скрывает все детали

// 3. Гибкость (легко менять реализацию)
final authService = DatabaseAuthService();  // День 1
final authService = FirebaseAuthService();   # День 2
// Код пользователя не меняется!

// 4. Тестируемость
final mockAuthService = MockAuthService();
final user = User(mockAuthService);  // Тестируем без реального сервиса

// 5. Масштабируемость
// Можешь усложнять реализацию без изменения интерфейса

Плохие примеры абстракции

// ❌ Плохо: Абстракция но без пользы
abstract class DataContainer {
  void doSomething();
  void doOtherThing();
  void doMoreThings();
}

// Слишком толстый интерфейс, не выясняет сложность

// ✅ Хорошо: Узкая, спецификчная абстракция
abstract class Reader {
  String read();
}

abstract class Writer {
  void write(String data);
}

// Каждый интерфейс отвечает за одно

Резюме

Суть абстракции:

  1. Скрывает сложность — пользователь видит только нужное
  2. Предоставляет интерфейс — просто использовать
  3. Позволяет менять реализацию — без изменения клиента
  4. Улучшает тестируемость — легко мокировать
  5. Соблюдает SOLID — особенно принцип D (Dependency Inversion)

Правило: Думай об абстракции как об контракте между поставщиком и потребителем. Потребитель не знает, как это работает внутри, только КАКИЕ операции доступны.