Aggregation vs Inheritance

Агрегация vs
Наследование

Как реализовать пагинацию
в вашем проекте?

class ViewController: UIViewController, UITableViewDataSource, UITableViewDelegate {
var currentPage = 1
var pageSize = 50
func tableView(_ tableView: UITableView, willDisplay cell: UITableViewCell, forRowAt indexPath: IndexPath) {
if indexPath.row == (currentPage * pageSize) - 1 {
currentPage += 1
tableView.reloadData()
}
}
func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
return pageSize * currentPage
}
func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
let cell = tableView.dequeueReusableCell(withIdentifier: "cell", for: indexPath)
cell.textLabel?.text = String(indexPath.row)
return cell
}
}

Как добавить
пагинацию в другой
ViewController?

class ViewController: UIViewController, UITableViewDataSource, UITableViewDelegate {
var currentPage = 1
var pageSize = 50
currentPage += 1
}
}
}
return cell
}
}
class AnotherViewController: UIViewController, UITableViewDataSource, UITableViewDelegate {
var currentPage = 1
var pageSize = 50
currentPage += 1
}
}
}
let cell = tableView.dequeueReusableCell(withIdentifier: "anotherCell", for: indexPath)
cell.textLabel?.text = "cell " + String(indexPath.row)
return cell
}
}

Мы получили
дублирование кода

import UIKit
class PaginableViewController: UIViewController, UITableViewDelegate, UITableViewDataSource {
var currentPage = 1
var pageSize = 50
currentPage += 1
}
}
}
return cell(for: indexPath, in: tableView)
}
func cell(for indexPath: IndexPath, in tableView: UITableView) -> UITableViewCell {
fatalError("func must be overriden by subclass")
}
}
class ViewController: PaginableViewController {
override func cell(for indexPath: IndexPath, in tableView: UITableView) -> UITableViewCell {
return cell
}
}
class AnotherViewController: PaginableViewController {
let cell = tableView.dequeueReusableCell(withIdentifier: "anotherCell", for: indexPath)
cell.textLabel?.text = "cell " + String(indexPath.row)
return cell
}
}

OK. Теперь нам нужно
добавить refresh control

class ViewController: PaginableViewController {
@IBOutlet weak var tableView: UITableView!
var refreshControl: UIRefreshControl = {
let refreshControl = UIRefreshControl()
refreshControl.addTarget(self, action: #selector(handleRefresh(_:)), for: .valueChanged)
refreshControl.tintColor = .red
return refreshControl
}()
override func viewDidLoad() {
super.viewDidLoad()
tableView.addSubview(refreshControl)
}
@objc func handleRefresh(_ refreshControl: UIRefreshControl) {
currentPage = 1
refreshControl.endRefreshing()
}
return cell
}
}

Я должен создать
RefreshableViewController чтобы
иметь возможность
переиспользовать код

class RefreshableViewController: UIViewController {
var refreshControl: UIRefreshControl = {
}()
super.viewDidLoad()
tableView.addSubview(refreshControl)
}
loadFirstPage()
}
func loadFirstPage() {
fatalError("func should be overridden by subclass")
}
}

Давайте
унаследуем мой
ViewController от
RefreshableView
Controller

class ViewController: PaginableViewController

Виды отношений между
классами
• Ассоциация

• Агрегация

• Композиция

• Наследование

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

Наследование
Более точным типом отношений является отношение открытого
наследования, которое говорит, что все, что справедливо для базового
класса справедливо и для его наследника.

Недостатки
наследования
• Далеко не все отношения между классами
определяются отношением «является»

• Наследование является самой сильной связью между
двумя классами, которую невозможно разорвать во
время исполнения (это отношение является
статическим и, в строготипизированных языках
определяется во время компиляции)

Композиция и агрегация
Оба они моделируют отношение «является частью» (HAS-A Relationship) и
обычно выражаются в том, что класс целого содержит поля (или свойства)
своих составных частей.

Разница между композицией и агрегацией
заключается в том, что в случае
композиции целое явно контролирует время
жизни своей составной части (часть не существует
без целого), а в случае агрегации целое хоть и
содержит свою составную часть, время их жизни

Композиция
class CustomService {
var object = CustomObject()
func doSomething() {
//Используем object
}
}

Агрегация
class CustomService {
weak var object: CustomObject?
init(object: CustomObject) {
self.object = object
}
func doSomething() {
//Используем object
}
}

Как это может быть
полезно в нашей
ситуации?

protocol RefreshableViewController: class {
var tableView: UITableView! { get }
func loadFirstPage()
}
class RefreshTableService {
weak var viewController: RefreshableViewController? {
didSet {
viewController?.tableView.addSubview(refreshControl)
}
}
lazy var refreshControl: UIRefreshControl = {
}()
viewController?.loadFirstPage()
viewController?.tableView.reloadData()
}
}

class ViewController: PaginableViewController, RefreshableViewController {
var refreshTableService = RefreshTableService()
super.viewDidLoad()
refreshTableService.viewController = self
}
return cell
}
func loadFirstPage() {
currentPage = 1
}
}

Aggregation vs Inheritance

Recommended

Recommended

More Related Content

Featured

Featured (20)

Aggregation vs Inheritance