Basitçe (aslında son derece basit), sınıfları mantıksal birimler kodu organize yanı sıra kullanıcı tarafından oluşturulan nesneler için kapları ve şablonları sağlamaktayız.

Diyelim ki bir araba var ... Bir araba kutu içinde bir kapasite ve insanlar var diyelim.

class Car {
    private $people = array();
    private $capacity;

    function __construct($capacity) { $this->capacity = $capacity; }

    function addPerson($name) {
        if(count($this->people) >= $this->capacity) {
            throw new Exception("Car is already at capacity");
        } else {
            $this->people[] = $name;
        }
    }
    function getPeople() { return $this->people; }
    function getCapacity() { return $this->capacity; }
}

Şimdi, biz bu arabaları kullanmaya başlayabilirsiniz:

$aliceCar = new Car(2);
$aliceCar->addPerson("Alice");

$bobCar = new Car(4);
$bobCar->addPerson("Bob");
$bobCar->addPerson("Jake");

Ben şimdi farklı verileri tutan 2 araba (örnekleri) var.

echo implode(',', $aliceCar->getPeople()); // Alice
echo $aliceCar->getCapacity(); // 2

echo implode(',', $bobCar->getPeople()); // Bob,Jake
echo $bobCar->getCapacity(); // 4

Ben de kapılar için ek bir özelliği var olacak bir kamyonet, isteyebilirsiniz:

class Van extends Car {
    private $num_doors;

    function __construct($capacity, $num_doors) {
        parent::__construct($capacity); // Call the parent constructor
        $this->num_doors = $num_doors;
    }

    function getNumDoors() { return $this->num_doors; }
}

Şimdi minibüsü kullanalım:

$jakeVan = new Van(7, 5);

// Van is ALSO a Car
$jakeVan->addPerson("Ron"); //Jake is with Bob now, so his son is driving the Van
$jakeVan->addPerson("Valery") //Ron's girlfriend

echo implode(',', $jakeVan->getPeople()); // Ron,Valery
echo $jakeVan->getCapacity(); // 7
echo $jakeVan->getNumDoors(); // 5

Şimdi belki biz yaratılmasına yönelik bu kavramları uygulamak nasıl görmek, örneğin, bir DBTable ve User sınıf. Olabilir

Aslında, gerçekten sınıflar Object Oriented Programming (soyutlama, kapsülleme, kalıtım, polimorfizm) kavramlarına girmeden kişinin hayatını kolaylaştırmak neden açıklayan başlamak zor.

Ben size şu kitabı okumanızı öneririz. Bu OOP temel kavramlarını ve nesneleri gerçekten hayatınızı kolaylaştırmak için neden anlamanıza yardımcı olacaktır. Bu kavramları bir anlayış olmadan, sadece başka bir komplikasyonu olarak derslere göz ardı etmek kolaydır.

PHP 5 Objects, Patterns, and Practice

Amazon.com mevcut

Bu huge konu ve sadece yuzeysel için umut olabilir en iyi Soers bile en iyi cevaplar, ama benim iki sent vereceğim.

Sınıflar OOP temelidir. Onlar bir çok temel yolu, nesne planlarda vardır. Bunlar kapsülleme ve polimorfizm dahil, programcı için birçok özellik göze.

Encapsulation, kalıtım ve polimorfizm OOP çok önemli yönleri vardır, bu yüzden benim örneğin bu odaklanmak için gidiyorum. Ben (sadece fonksiyonları) yapılandırılmış yazmak ve daha sonra bir kod parçacığını bir OOP sürümü ve ben size faydalar anlayacaksınız umuyoruz.

İlk olarak, örneğin, yapısal

<?php

function speak( $person )
{
  switch( $person['type'] )
  {
    case 'adult':
      echo "Hello, my name is " . $person['name'];
      break;
    case 'child':
      echo "Goo goo ga ga";
      break;
    default:
      trigger_error( 'Unrecognized person type', E_USER_WARNING );
  }
}

$adult = array(
    'type' => 'adult'
  , 'name' => 'John'
);
$baby = array(
    'type' => 'baby'
  , 'name' => 'Emma'
);

speak( $adult );
speak( $baby );

Ve şimdi, OOP örnek

abstract class Person
{
  protected $name;

  public function __construct( $name )
  {
    $this->name = $name;
  }
  abstract public function speak();
}

class Adult extends Person
{
  public function speak()
  {
    echo "Hello, my name is " . $this->name;
  }
}

class Baby extends Person
{
  public function speak()
  {
    echo "Goo goo ga ga";
  }
}

$adult = new Adult( 'John' );
$baby  = new Baby( 'Emma' );

$adult->speak();
$baby->speak();

Bu 2nd () yöntemleri konuşmak için, ilk örnekte konuşmak () fonksiyonu mantığı dikkat, sadece yeni veri yapıları (nesneler) oluşturarak daha kolay ve daha kontrollü açıktır olmamalı sadece.

Bu hareket etmeden önce ilk açıkça kişi türünü kontrol etmeli nasıl fark? Eğer diğer eylem fonksiyonlar eklemek ne) (oturmak) (yürüyüş gibi olur, ya da veri için başka ne olabilir? Each bu işlevleri, bunların düzgün yürütmek olmak için kontrol edin "tipi" çoğaltmak gerekir. Bu opposite kapsülleme taşımaktadır. Veri ve onları değiştirmek / kullanmak fonksiyonları herhangi açık bir şekilde bağlı değildir.

OOP örnek, doğru konuşmak () yöntemi, nesnenin nasıl oluşturulduğuna bağlı olarak çağrılır oysa. Bu eylem kalıtım / polimorfizmidir. Ve konuşmak () bu örnekte, nesnenin bir yöntem olarak, açıkça bunun üzerine davranıyor verilere bağlı olduğu nasıl fark?

Sen büyük bir dünyaya adım, ve ben senin öğrenme ile size şans diliyorum. Herhangi bir sorunuz varsa bana bildirin.

Bazı açılardan, doğru. Sınıflar can basit görevleri karmaşık ve kesinlikle onları kullanmadan yapabileceğiniz bir çok şey var. Ancak, sınıflar da hayat çok daha kolay.

Işlevleri olmadan hayatınızı düşünün. Bu kod bloklar birlikte grup GoTo ifadeleri kullanmak zorunda. Yuck. Tabii, aynı şeyleri başarmak olabilir, ancak çok daha fazla çalışması ve başkalarıyla çalışmayı paylaşmak için bu çok daha zor olacağını gerekir.

Sınıflar grup birlikte benzer bir kod blokları düzgün bir yol sağlar. Ayrıca, onlar çok kolay yakalamak ve devlet ile çalışmanıza olanak sağlar.

Bir sınıfın iyi bir tanım nesneleri oluşturmak için bir plandır.

Muhtemelen kendiniz için yapabileceğiniz tek iyi şey ödünç bulmak / / Object Oriented Programlama ile ilgili bir kitap satın almak. PHP sınıfları temelde diğer modern diller (Java, C #, vb) aynıdır ve OOP öğrenmek kez tamamen dil agnostik olduğunu ve herhangi bir OOP proje, PHP veya uygulanabilir programlama seviyesinde dersleri anlayacaksınız Aksi durumda.

A sınıfı bir hesap makinesi gibi. Sen aynı şeyi on bin farklı hesap olabilir ve bunların her biri kendi değerleri ve verilerin takip.

$cal1 = new calculator;
$cal2 = new calculator;

$cal1->add(5);
$cal2->add(3);

echo $cal1->show(); // returns 5

echo $cal2->show(); //returns 3

Her bir hesap aynı görevleri yapmak ve aynı kod çalıştırmak, ama hepsi farklı değerler içerebilir.

Eğer sınıfları kullanarak olmasaydı, tek tek, her bir hesap oluşturun bunu bir değişken atamak ve aynı anda kullanmak istedim her hesap için kopyalayıp yapıştırmak gerekir.

function add_calc_1();
function add_calc_2();
function add_calc_3();
function subtract_calc_1();
function subtract_calc_2();
function subtract_calc_3();
function multiply_calc_1();
function multiply_calc_2();
function multiply_calc_3();
function divide_calc_1();
function divide_calc_2();
function divide_calc_3();

$total_1;
$total_2;
$total_3;

Bunun yerine, bir hesap makinesi için kod tek bir sınıf tanımlayabilirsiniz, ve istediğiniz gibi, o zaman, kendi sayaçları ile her gibi birçok farklı olanları oluşturabilirsiniz.

class calc
{
   public $total;
   function add();
   function subtract();
   function multiply();
   function divide();
}
$cal1=new calc;
$cal2=new calc;
$cal3=new calc;

Sınıflar ile gibi bir şey yapabilirsiniz

class Stack {
  private $theStack = array();

  // push item onto the stack
  public function push(item) { ... }

  // get the top item from the stack
  public function pop() { ... } 
}

Bu basit örnek bazı yararları vardır.

1. Sınıfın dışında kod yığın uygulamak için kullanılan dizi manipüle edemez
2. Global namespace ilgisiz değişkenler ile kirlenmiş edilebilir değildir
3. Bir yığın kullanmak gerekiyor kod basitçe sınıfının bir örneğini (yani $ myStack = new Stack ()) oluşturabilirsiniz

Ben zaten büyük Ayrıntılı bir cevap bir sürü var bakın, ama gerçekten basit terimlerle tutmak için:

You know what a block of code is.
You know that if you want to reuse a block of code, you put it in a function.
So far so good. Now, Classes are about organizing functions and variables.
If you create a lot of functions, you have to be really careful that their names don't clash, and you will probably want to organize your functions in separate files to keep related functions grouped together.

Onun çok basit olarak, Sınıflar bir class of functions içine grubu ile ilgili fonksiyonlar için size yardımcı olur. Yerine

add_product_to_shop();
add_product_to_cart();
add_product_to_wish_list();

Bir sınıf içinde size grup onlara:

Shop::addProduct();
Cart::addProduct();
WishList::addProduct();

Burada Shop, Cart ve WishList, her biri kendi addProduct() yöntemi vardır Classes vardır (function). Bu fonksiyon isimleri kendilerini çok daha kısa haline gelmiştir, bu işlevleri birlikte çalışmak için tasarlanmıştır ve aynı Class ilgili diğer fonksiyonlar eklemek için kolay olmadığını açıktır, diğer kod parçacığını üzerinde hafif bir iyileşme var.

Ne Sınıflar size daha fazla olsa da bir araya grup işlev değil sadece, ama değişkenler de izin verir. Eğer değişkenler üzerine yazmak gerçekten dikkatli olmak gerekir gibi, adlandırma söz konusu olduğunda değişkenler genellikle fonksiyonları daha kötüdür. Kendi kendi Sınıflar hepsini gruplandırarak, bir adlandırma çatışma az olması. (Bu ile ilişkili bir kavram da Ad denir.)

Ayrıca yapmak için izin ne Sınıflar onlardan nesneler yaratmak için olduğunu. Sınıf ile ilgili değişkenler ve fonksiyon için planı ise, birbirlerinden bağımsız hareket ettiklerini, hatta birkaç, bu planın bir "gerçek nesne" oluşturmak, ama aynı şekilde davranabilir. Bunun yerine $shopping_cart1 takip ve $shopping_cart2 tutmak ve emin fonksiyonları doğru değişken üzerinde hareket yapma, sadece planın bir kopyasını yapmak:

$cart = new Cart();
$cart->addProduct($x);

$anotherCart = new Cart();
$anotherCart->addProduct($y);

// $cart takes care of product $x, $anotherCart of product $y.
// No extra overhead needed to duplicate functionality
// or to make sure the addProduct() function adds to the right cart.

Bu web geliştirme, özellikle PHP çok sık bu gerekmez, ancak uygulamaya bağlı olarak yararlı olabilir.

Ne Sınıflar daha hafifçe onları değiştirmek için izin verir. Eğer bir alışveriş sepeti gibi birlikte hareket fonksiyonunun büyük bir koleksiyon oluşturduk söylüyorlar. Şimdi temelde aynı şekilde çalışır, ancak bazı küçük farklılıklar (indirimler anında hesaplanacaktır gerektiğini söylüyorlar) sahip başka bir alışveriş sepeti oluşturmak istiyorum. Yeni bir sınıf oluşturmak ve bunu tam olarak eski alışveriş sepeti gibi aynı hareket gerektiğini belirtmek, ancak geçersiz kılmak ve bir kaç özel değişkenleri veya işlevleri (bu Inheritance denir) değiştirebilir.

Derslerin kavramı bunu sağlamak ve yukarıdaki noktaların her çok daha fazla ayrıntı ve özelliklerini beraberinde ki çok daha fazla olasılık vardır. Genel, Sınıflar (onları değiştirmeden önce değişkenleri doğrulayarak, alıcılar / belirleyiciler) ve daha kolay tutarlılık kontrollerini etkinleştirmek, o ayrı (namespacing) olmalıdır ayrı şeyler tutmak, birbirine ait şeyler birlikte tutmak için kullanılır ...

Benim veritabanı tabloları için sınıflarını kullanın.

Örnek için biz

Id, ad, soyad

Bunun için ben bir sınıf kullanacak

class user{

    public $Id, $name, $lastname

    public function user($iId){

      Id = $iId;
      firstname = mysql_get('firstname');
      lastname = mysql_get('lastname');
}

performans il kullanımı getData_functions ziyade yapıcı koyarak daha verileri almak için. Yukarıdaki yerine derslere nasıl yapılandırılacağını örneğin sadece daha büyük bir fikirdir

Ama daha sonra birden çok kullanıcı için bunu yapabilirsiniz

while(mysql_get('Id')){

    $user = new user('Id');
    $print $user->firstname . " " . $user->lastname;
}

onlar hayatı kolaylaştırır.

Bir kötü tasarlanmış sınıf şeyler yavaşlatabilir çünkü Ama daha da önemlisi hayatını kolaylaştıran dosent .. onun daha hızlı anlamına gelecektir.

Ancak benim küresel programına jenerik böyle bir işlev için ben onlar için kullanımı sınıflarını yok.

Düz, ve gerçek yaşam durumlarında yeniden zor - bir jokey anekdot olarak, ben bir zamanlar pembe diziler gibi sınıfsız PHP kodlama nitelendirdi. Öte yandan, OO-PHP biraz daha gerçek tiyatro gibidir; dinamik nesneler ve çok yönlü olabilir ve bunların örneklemesi arasında farklılık olması eğilimi ise, genellikle temel dramatik arketip dayanmaktadır.

Temelde ne dediğimi daha kolay açık kaynak çerçeveler ve programlarını uygulayıcı kılan, nesne yönelimli kod repurpose ve yeniden daha kolay olmasıdır. Ben korumak ve yeniden son derece zor PHP saf scripting bulmak ve iyi bir sürü için nesne yönelimli programları önceden var olan, var olduğu kötü güvenlik açıkları için izin eğilimindedir.