IMPORTANT: Per accedir als fitxer de subversion: http://acacha.org/svn (sense password). Poc a poc s'aniran migrant els enllaços. Encara però funciona el subversion de la farga però no se sap fins quan... (usuari: prova i la paraula de pas 123456)

Classes

https://laracasts.com/series/object-oriented-bootcamp-in-php/episodes/1

Programació estructurada

Classes com a Blueprints (http://en.wikipedia.org/wiki/Blueprint). Les classes són representacions d'objectes en la vida real. En informàtica la "vida real" és el "temps d'execució" d'un programa. Les classes es defineixen en "temps de compilació|interpretació" i estes classes no es tornen objectes "reals" fins que el programa és executat.

Sinònims de blueprint:

  • Cianotipo | plànol | projecte| avantprojecte | pla d'acció

Com anomenem les classes?:

  • Quan representen objectes solem posar noms: Casa (Home), Tasca (Task), Cotxe (Car). Es recomanable que quan treballeu em codi utilitzeu l'anglès.

Nous conceptes:

  • Properties vs variables:
  • Mètodes vs funcions: Les funcions dins d'una classe les anomenem mètodes.

En tots dos casos (propietats i mètodes) tenen un scope (vegeu apartat scope) i un control d'accés (vegeu encapsulació).

Instanciació|creació"

Utilitzar la paraula reservada new és el mètode més comú per crear un objecte a partir d'una classe aka instanciar una classe.

Constructors

Són mètodes especials que es criden en el moment inicial de creació d'un objecte.

Getters and Setters

Encapsulation

Inheritance

Messages

Namespace and Autoloading

Statics and constants

Interfaces

Abstract

Polimorfisme

Polymorphism is a long word for a very simple concept.

Polymorphism describes a pattern in object oriented programming in which classes have different functionality while sharing a common interface.

Exemple i explicació amb PHP

http://code.tutsplus.com/tutorials/understanding-and-applying-polymorphism-in-php--net-14362

Exemple de refactorització amb polimorfisme:

Suposeu el típic exemple de ifs anidats:

function signUp($subscription) {
    if ($subscription == 'forever') {
        return $this->createForeverSubscription()
    } elseif ($subscription == 'forever') {
           return $this->createMonthltySubscription()
    }
}

MIreu com podem evitar aquest codi de if/else anidats utilitzant el polimorfisme i les interfícies:


//Subscription is an interface
function signUp(Subscription $subscription) {
    $subscription->create();
}

//Factoria:
function getSubscriptionType($type) {
   if (type=='forever') {
       //ForeverSubscription implements Subscription interface
       return new ForeverSubscription();
   }
   //MonthlySubscription implements Subscription interface
   return MonthlySubscription();
}

$subscription = getSubscritionType('forever');
signUp($subscription);

Observeu que encara podem millorar el codi de getSubscriptionType per evitar haver de posar més ifs:

function getSubscriptionType($type) {
        $method = 'create'.Str::studly($type).'Subscription';
        if (method_exists($this, $method)) {
            return $this->$method();
        }
        throw new InvalidArgumentException("Subscription type [$type] not supported.");
}

function createForefeverSubscription(){
      //ForeverSubscription implements Subscription interface
      return new ForeverSubscription();
}

function createMonthlySubscription(){
      //MonthlySubscription implements Subscription interface
      return new MonthlySubscription();
}

De fet Laravel es fa un fart d'utilitzar els Managers i el concepte Laravel Driver vegeu [1] [2]

Recursos:

Scope and context

Traits

aka Mixins

Exemple d'ús de traits amb PHP

https://github.com/illuminate/filesystem/blob/master/Filesystem.php

S'utilitza la paraula reservada use però dins d'una classe (normalment ho veiem fora de la classe per utilitzar namespaces). El trait és diu Macroable

https://github.com/illuminate/support/blob/master/Traits/Macroable.php

Que permet crear objectes de forma dinàmica (fixeu-vos s'utilitza el mètode màgic (PHP Magic Methods) __call de PHP i no pas un constructor).

Screencast sobre com utilitzar els traits per aprimar una classe mastodontica:

https://laracasts.com/series/whip-monstrous-code-into-shape/episodes/5

Object composition vs class inheritance

Molt bon vídeo explicatiu: https://www.youtube.com/watch?v=wfMtDGfHWpA
https://medium.com/javascript-scene/how-to-learn-es6-47d9a1ac2620#.3baobgm4g

Object composition

Composition over inheritance (or Composite Reuse Principle) in object-oriented programming is the principle that classes should achieve polymorphic behavior and code reuse by their composition (by containing instances of other classes that implement the desired functionality) rather than inheritance from a base or parent class.[2] This is an often-stated principle of OOP, such as in the influential Design Patterns: "Favor 'object composition' over 'class inheritance'."[3]


Resources:

Llenguatges de programació

Javascript

Vegeu Javascript i Javascript OOP

PHP

Vegeu PHP

Vegeu també

Enllaços externs