PHP - OOP veya prosedürel yaklaşım. Nesneye Yönelik Programlama (OOP PHP)

Muhtemelen boş kadroların yarısında (daha fazla değilse), OOP hakkında bilgi ve anlayış gereklidir. Evet, bu metodoloji kesinlikle birçok programcıyı kazandı! Bu hesapta neredeyse hiç uygun ve erişilebilir malzeme bulunmadığından, OOP anlayışı genellikle deneyimle gelir. Ve olsa bile, okuyucuların onlara rastlayacağı gerçeğinden uzaktır. Umarım bu harika metodolojinin ilkelerini dedikleri gibi parmaklarımda açıklayabilirim.

Bu yüzden makalenin başında zaten böyle bir "metodoloji" teriminden bahsetmiştim. Programlamaya uygulandığında, bu terim, bir programcının oldukça uygun programlar yazabileceğine bağlı kalarak, kodu düzenlemek için bir dizi yöntemin, onu yazma yöntemlerinin varlığını ifade eder.

OOP (veya nesne yönelimli programlama), programın ana yapı taşları nesneler ve sınıflar olduğunda ve programın mantığı bunların etkileşimi üzerine kurulduğunda, program kodunu organize etmenin bir yoludur.

Nesneler ve sınıflar hakkında

Sınıfprogramcının kendisi tarafından oluşturulabilen bir veri yapısıdır. OOP terimleriyle, bir sınıf aşağıdakilerden oluşur: alanlar(basit bir şekilde - değişkenler) ve yöntemler(basit bir şekilde - işlevler). Ve ortaya çıktığı gibi, verilerin ve bunlar üzerinde çalışma işlevlerinin tek bir yapıda birleşimi hayal edilemez bir güç sağlar. Bir objesınıfın somut bir örneğidir. Veri yapısına sahip bir sınıf analojisine bağlı kalarak, nesne, alanlara bazı değerlerin atandığı belirli bir veri yapısıdır. Bir örnekle açıklamama izin verin:

Diyelim ki iki kenarla verilen bir üçgenin çevresini ve alanını ve aralarındaki açıları hesaplayan bir program yazmamız gerekiyor. OOP kullanarak böyle bir program yazmak için, bir sınıf (yani yapı) Üçgen oluşturmamız gerekecek. Üçgen sınıfı üç alanı (üç değişken) depolar: A tarafı, B tarafı, aralarındaki açı; ve iki yöntem (iki işlev): çevreyi hesaplayın, alanı hesaplayın. Bu sınıfla herhangi bir üçgeni tanımlayabilir ve çevreyi ve alanı hesaplayabiliriz. Bu nedenle, belirli kenarları ve aralarında bir açı olan belirli bir üçgen, Triangle sınıfının bir örneği olarak adlandırılacaktır. Dolayısıyla, bir sınıf bir şablondur ve bir örnek, şablonun somut bir uygulamasıdır. Ancak halihazırda örnekler nesnelerdir, yani belirli değerleri depolayan somut öğelerdir.

En yaygın nesne yönelimli programlama dillerinden biri java'dır. Orada nesneleri kullanmadan yapamazsınız. Bu dilde üçgeni tanımlayan sınıfın kodu şöyle görünecektir:

/ ** * Sınıf Üçgeni. * / class Üçgen (/ ** * Sınıfın kurucusu olarak adlandırılan özel bir yöntem. * Giriş olarak üç parametre alır: * A tarafının uzunluğu, B tarafının uzunluğu, * bu taraflar arasındaki açı (derece cinsinden) * / Üçgen (çift tarafA, çift tarafB , double angleAB) (this.sideA \u003d sideA; this.sideB \u003d sideB; this.angleAB \u003d angleAB;) double sideA; // Sınıf alanı, A tarafının değerini sınırlanmış üçgen çift taraflıB içinde depolar; // Sınıf alanı, yan değeri depolar Sınırlı üçgende çift açılı B; // Sınıf alanı, sınırlı üçgende iki taraf arasındaki açıları (derece cinsinden) saklar / ** * Üçgenin alanını hesaplayan sınıf yöntemi * / double getSquare () (double square \u003d this.sideA * this .sideB * Math.sin (this.angleAB * Math.PI / 180); return square;) / ** * Üçgenin çevresini hesaplayan sınıf yöntemi * / double getPerimeter () (double sideC \u003d Math.sqrt (Math.pow (this.sideA, 2) + Math.pow (this.sideB, 2) - 2 * this.sideA * this.sideB * Math.cos (thi s.angleAB * Math.PI / 180)); çift \u200b\u200bçevre \u003d this.sideA + this.sideB + sideC; dönüş çevresi; ))

Aşağıdaki kodu sınıfın içine eklersek:

/ ** * Programın başladığı yer burasıdır * / public static void main (String args) (// 5, 17, 35 değerleri Triangle sınıfının yapıcısına gider Triangle triangle1 \u003d new Triangle (5, 17, 35); System.out .println ("Triangle1 area:" + triangle1.getSquare ()); System.out.println ("Triangle1 perimeter:" + triangle1.getPerimeter ()); // 6, 8, 60 değerleri Triangle Triangle sınıfı yapıcı üçgen2'ye gider \u003d new Triangle (6, 8, 60); System.out.println ("Triangle1 area:" + triangle2.getSquare ()); System.out.println ("Triangle1 çevre:" + triangle2.getPerimeter ());)

daha sonra program yürütmek için zaten başlatılabilir. Bu, java dilinin bir özelliğidir. Sınıfın böyle bir yöntemi varsa

Genel statik void main (String argümanları)

daha sonra bu sınıf çalıştırılabilir. Koda daha yakından bakalım. Çizgi ile başlayalım

Üçgen üçgen 1 \u003d yeni Üçgen (5, 17, 35);

Burada Triangle sınıfının bir üçgen1 örneğini oluşturuyoruz ve hemen kenarların parametrelerini ve aralarındaki açıyı ayarlıyoruz. Bu durumda, yapıcı adı verilen özel bir yöntem çağrılır ve nesnenin alanlarını kurucuya iletilen değerlerle doldurur. Peki ve çizgiler

System.out.println ("Üçgen alan1:" + triangle1.getSquare ()); System.out.println ("Üçgen1'in çevresi:" + triangle1.getPerimeter ());

Üçgenin hesaplanan alanını ve çevresini konsola verir.

Benzer şekilde, Triangle sınıfının ikinci örneği için de her şey olur.

Sınıfları anlamak ve somut nesneler oluşturmak, OOP metodolojisini anlamak için kesin bir ilk adımdır.

Bir kez daha, en önemlisi:

OOP program kodunu düzenlemenin bir yoludur;

Sınıf onlarla çalışmak için verileri ve işlevleri bir araya getiren özel bir veri yapısıdır (sınıf alanları ve sınıf yöntemleri);

Bir objealanlarına belirli değerler atanan bir sınıfın somut bir örneğidir.

Üç sihirli kelime

OOP, üç temel yaklaşımı içerir: kalıtım, kapsülleme ve polimorfizm. İlk olarak, işte wikipedia'daki tanımlar:

Kapsülleme, bir sınıfta onlarla çalışan verileri ve yöntemleri birleştirmenize olanak tanıyan bir sistem özelliğidir. Bazı diller (örn. C ++), kapsüllemeyi gizleme ile eşleştirir, ancak çoğu (Smalltalk, Eiffel, OCaml) ikisi arasında ayrım yapar.

Kalıtım, işlevselliği kısmen veya tamamen ödünç alınmış mevcut bir sınıfı temel alarak yeni bir sınıfı tanımlamanıza olanak tanıyan bir sistem özelliğidir. Kalıtımın türetildiği sınıfa temel, üst sınıf veya üst sınıf denir. Yeni sınıf bir soy, mirasçı, çocuk veya türetilmiş sınıftır.

Polimorfizm, nesnenin türü ve iç yapısı hakkında bilgi olmadan aynı arayüzle nesnelerin kullanılmasına izin veren bir sistem özelliğidir.

Bütün bu tanımların pratikte ne anlama geldiğini anlamak oldukça zordur. Bu konuyu kapsayan özelleşmiş kitaplarda, her tanım genellikle tam bir bölüm, ancak en azından bir paragraf içerir. Yine de, bir programcının beynine sonsuza dek anlaşılması ve basılması gereken şeyin özü çok azdır.
Düzlemdeki rakamlar, analiz için örnek teşkil edecektir. Okul geometrisinden, bir düzlemde açıklanan tüm şekiller için çevreyi ve alanı hesaplayabileceğinizi biliyoruz. Örneğin, bir nokta için her iki parametre de sıfırdır. Bir doğru parçası için sadece çevreyi hesaplayabiliriz. Ve kare, dikdörtgen veya üçgen için - ikisi de. Şimdi bu görevi OOP terimleriyle tanımlayacağız. Ayrıca, bir sınıf hiyerarşisine dönüşen bir akıl yürütme zincirini yakalamak gereksiz olmayacaktır ve bu da çalışma kodunda somutlaşmıştır. Git:

Öyleyse, bir nokta, diğer tüm yapıların (figürlerin) temeli olan en küçük geometrik figürdür. Bu nedenle, nokta temel üst sınıf olarak seçilir. Java'da bir puan sınıfı yazalım:

/ ** * Puan sınıfı. Temel sınıf * / sınıf Nokta (/ ** * Boş yapıcı * / Nokta () () / ** * Şeklin alanını hesaplayan sınıf yöntemi * / double getSquare () (return 0;) / ** * Sınıf yöntemi şeklin çevresini hesaplar * / double getPerimeter () (return 0;) / ** * Şeklin açıklamasını döndüren sınıf yöntemi * / String getDescription () (return "Point";))

Ortaya çıkan Point sınıfı boş bir kurucuya sahiptir, çünkü bu örnekte belirli koordinatlar olmadan çalışıyoruz ve yalnızca parametreler ve tarafların değerleri ile çalışıyoruz. Noktanın kenarı olmadığı için ona parametre aktarılmasına gerek yoktur. Ayrıca, sınıfın alan ve çevre hesaplaması için Point :: getSquare () ve Point :: getPerimeter () yöntemlerine sahip olduğuna dikkat edin, her ikisi de 0 döndürür. Bir nokta için bu mantıklıdır.

Bizim amacımız diğer tüm şekillerin temeli olduğundan, bu diğer şekillerin sınıflarını Point sınıfından miras alırız. Nokta sınıfından miras alınan çizgi parçasının sınıfını tanımlayalım:

/ ** * Class Linear * / class LineSegment, Point (LineSegment (double segmentLength) (this.segmentLength \u003d segmentLength;) double segmentLength; // Segmentin uzunluğu / ** * Bir segmentin alanını hesaplayan geçersiz kılınan sınıf yöntemi * / double getSquare ( ) (return 0;) / ** * Segment çevresini hesaplayan geçersiz kılınan sınıf yöntemi * / double getPerimeter () (return this.segmentLength;) String getDescription () (return "Segment length:" + this.segmentLength;))

Class LineSegment Point'i genişletir

lineSegment sınıfının Point sınıfından miras aldığı anlamına gelir. LineSegment :: getSquare () ve LineSegment :: getPerimeter () yöntemleri, karşılık gelen temel sınıf yöntemlerini geçersiz kılar. Bir çizgi parçasının alanı her zaman sıfırdır ve çevrenin alanı o çizgi parçasının uzunluğuna eşittir.

Şimdi, segment sınıfı gibi, üçgen sınıfını da tanımlıyoruz (bu da nokta sınıfından miras alır):

/ ** * Sınıf Üçgeni. * / class Üçgen, Noktayı genişletir (/ ** * Sınıfın kurucusu. Giriş olarak üç parametre alır: * A tarafının uzunluğu, B tarafının uzunluğu, * bu taraflar arasındaki açı (derece olarak) * / Üçgen (çift tarafA, çift tarafB, çift açıAB ) (this.sideA \u003d sideA; this.sideB \u003d sideB; this.angleAB \u003d angleAB;) double sideA; // Sınıf alanı, A tarafının değerini açıklanan çift taraflı B üçgeninde saklar; // Sınıf alanı, B tarafının değerini açıklanan üçgende saklar üçgen çift açıAB; // Sınıf alanı, sınırlanmış üçgende iki taraf arasındaki açıyı (derece cinsinden) saklar / ** * Üçgenin alanını hesaplayan sınıf yöntemi * / double getSquare () (çift kare \u003d (this.sideA * this.sideB * Math.sin (this.angleAB * Math.PI / 180)) / 2; return square;) / ** * Bir üçgenin çevresini hesaplayan bir sınıf yöntemi * / double getPerimeter () (double sideC \u003d Math.sqrt (Math. pow (this.sideA, 2) + Math.pow (this.sideB, 2) - 2 * this.sideA * this.sideB * Math.cos (this.angleAB * Mat h.PI / 180)); çift \u200b\u200bçevre \u003d this.sideA + this.sideB + sideC; dönüş çevresi; ) String getDescription () ("Kenarları olan bir üçgen:" + this.sideA + "," + this.sideB + "ve aralarında bir açı:" + this.angleAB;))

Bu yeni bir şey değil. Ayrıca, Triangle :: getSquare () ve Triangle :: getPerimeter () yöntemleri, karşılık gelen temel sınıf yöntemlerini geçersiz kılar.
Pekala, şimdi, aslında, polimorfizmin büyüsünü gösteren ve OOP'nin gücünü ortaya çıkaran kod:

Sınıf Ana (/ ** * Programın başladığı yer burasıdır * / public static void main (String args) (// ArrayList - Bu, java'da // belirli bir türdeki nesneleri bir dizide saklamanıza izin veren özel bir veri yapısıdır. ArrayList Figures \u003d new ArrayList (); // rakamlar dizisine üç farklı nesne ekleyin Figure.add (new Point ()); Figures.add (new LineSegment (133)); Figures.add (new Triangle (10, 17, 55)); for ( int i \u003d 0; i

Point sınıfının bir dizi nesnesini oluşturduk ve LineSegment ve Triangle sınıfları Point sınıfından miras alındığından, onları da bu diziye yerleştirebiliriz. Figürler dizisindeki her bir figürün Point sınıfının bir nesnesi olarak kabul edilebileceği ortaya çıktı. Polimorfizm bununla ilgilidir: figürler dizisindeki nesnelerin hangi sınıfa ait olduğu bilinmemektedir, ancak bu dizideki tüm nesneler aynı temel Point sınıfına ait olduğundan, Point sınıfına uygulanabilen tüm yöntemler türetilmiş sınıflarına da uygulanabilir.

Şimdi kapsülleme hakkında. Alanı ve çevreyi hesaplamak için şekil parametrelerini ve yöntemlerini bir sınıfa yerleştirmiş olmamız, kapsüllemedir, şekilleri ayrı sınıflarda kapsülledik. Çevreyi hesaplamak için sınıfta özel bir yöntem kullandığımız gerçeği kapsüllemedir, çevre hesaplamasını getPerimiter () yönteminde kapsülledik. Başka bir deyişle, kapsülleme, uygulama gizlemedir (belki de en kısa ve aynı zamanda kapsüllemenin kapsamlı tanımı).

Tam örnek kod:

Java.util.ArrayList'i içe aktarın; class Main (/ ** * Programın başladığı yer burasıdır * / public static void main (String args) (// ArrayList - Bu, java'da // belirli bir türdeki nesneleri bir dizide saklamanıza izin veren özel bir veri yapısıdır. ArrayList Figures \u003d new ArrayList (); // rakamlar dizisine üç farklı nesne ekleyin Figure.add (new Point ()); Figures.add (new LineSegment (133)); Figures.add (new Triangle (10, 17, 55)); for ( int i \u003d 0; i

Nesne yönelimli programlama, PHP sınıfları, PHP yapıcıları, PHP yıkıcıları, PHP sihirli yöntemleri vb. Gibi kavramları ele alacağız. Bu eğitim, PHP OOP'yi temel bir seviyeden öğrenmek isteyen yeni başlayanlar ve ileri düzey programcılar için tasarlanmıştır.

PHP 5'teki en önemli değişikliklerden biri, gelişmiş performansa izin veren tam nesne modelidir. PHP 5'te eklenen bazı önemli yeni özellikler arasında son ve soyut yöntemler, sınıflar, arayüzler, klonlama ve sihirli yöntemler bulunur. Bu OOP PHP eğitiminde, bunların her birinin nasıl kullanılabileceğine dair örneklere bakacağız.

Nesne yönelimli programlamada, bir nesne referanslar veya işaretçilerle aynı şekilde ele alınır. Bu, her yeni değişkenin tüm nesnenin bir kopyasını değil, bir nesneye referans içerdiği anlamına gelir.

Kavranması en zor kavram, geleneksel PHP programlamasından farklı olduğu için OOP'nin temelleridir. Ancak temel ilkeleri anladığınızda, modelin kendisi sizin için basit ve anlaşılır hale gelir.

PHP'de OOP nedir?

Nesne yönelimli programlama terimi "nesne" kelimesiyle başladığından, bunun nesnelerin oluşturulduğu ve kullanıldığı özel bir programlama türü olduğunu söyleyebiliriz.

İşte aptallar için PHP OOP'nin bir açıklaması. Çevremizdeki dünyaya bakın, nesnelerle dolu. Güneş, ay, arabalar, ağaçlar, evler vb. vb. Bunların hepsi nesneler, nitelikleri ve işlevleri var. Düşünme sürecinde nesnelerle çalışırız. Bir arabadan bahsettiğimizde aklınıza tekerlekleri, motoru, koltukları, kapıları değil, bir arabayı olduğu gibi düşünüyorsunuz. Basitçe söylemek gerekirse, bir konu veya nesne açısından düşünürsünüz. Nesne yönelimi, elemanların nesneler olarak programlama temsilidir.

Araba bir nesnedir. Renk, boyut, ağırlık ve hareket işlevi özelliklerine sahiptir. İşlevsel olmayan herhangi bir nesne işe yaramaz. OOP'de, programcı nesneleri kullanır; her nesnenin bazı nitelikleri ve işlevleri vardır. Genel olarak programlama, nesneleri kullanarak modüller oluşturmaya indirgenmiştir.

Nesne yönelimli programlamanın basit bir tanımı:

Nesneye yönelik programlama, bu verileri işleyen verileri (öznitelikleri) ve yöntemleri (işlevselliği) içeren nesnelere dayalı programlamadır. Nesneler, programcı tarafından tanımlanan bir veri türüdür ve farklı nesneler arasındaki etkileşimler de programcı tarafından tanımlanır.

Başka bir deyişle, OOP, programcının benzer görevleri sınıflar halinde gruplamasına izin verir, sınıf, bu verilere erişmek için birbiriyle ilişkili veriler ve işlevler içerebilir.

PHP'deki OOP temelleri, bakımı ve yönetimi daha kolay olan kod geliştirmenize yardımcı olur. Kodunuz ne kadar temiz ve okunaklı olursa, onu yeniden kullanma olasılığınız o kadar artar. Sonuç olarak, tasarım desenleri sisteme uygulanabilir. OOP'de, modüller gerektiği gibi oluşturulur ve kullanılır. PHP Nesne Tabanlı Programlama ile modüler bir yapıya sahip web sitesi uygulamaları oluşturabiliyoruz.

PHP OOP öğreticisindeki önemli terimler:

Aşağıda, nesne yönelimli PHP'de sıklıkla kullanılan bazı önemli terimlerin genel bir tanımı bulunmaktadır.

Sınıf

OOP PHP'de sınıf, bir programcı tarafından tanımlanan bir veri türüdür. Sınıf, bu verilerle çalışmak için verileri ve işlevleri içerir. Veriler ve işlevler özeldir. Bu, sınıfın dışında görünmedikleri anlamına gelir. Sınıf, gerektiği kadar kopya veya örnek oluşturabileceğiniz bir şablon veya kalıptır.

Bir obje

Nesne aynı zamanda örnek olarak da bilinir. Bir sınıf başlatıldığında, bir nesne oluşturulur. Bir sınıf bir kalıpsa, o zaman bir nesne, bir kalıp kullanılarak oluşturulan son bir üründür. Bir sınıf tanımlandıktan sonra, ondan birçok nesne oluşturulabilir.

Üye değişkeni

Bir sınıfta tanımlanan değişkenlere üye değişkenler denir. Aslında bu, bu sınıfın içerdiği verilerdir, sadece bu sınıfın fonksiyonları ile değiştirilebilir. Genellikle üye değişkenler yalnızca bu sınıf için görünür ve diğer sınıflardan gizlenir.

Üye işlevi

Sınıfta tanımlanan işlevlere üye işlevler denir. Diğer sınıflara da görünmezler. Bir nesnenin verilerine erişmek için üye değişkenlerini değiştirmek için kullanılırlar.

Yapıcı

Yapıcı, özel bir üye işlevi türüdür. Bir sınıf ayarlandığında, bir nesne oluşturulur, bu işlev otomatik olarak çağrılır ve sınıf değişkenlerini başlatır.

Yıkıcı

Bu, bir nesne elden çıkarıldığında otomatik olarak çağrılan özel bir işlev türüdür.

Miras

PHP 5'te OOP kalıtımı, bir sınıfın (alt sınıfın) başka bir sınıfın (üst sınıf) tüm özniteliklerini ve işlevlerini aldığı süreçtir.

Süper sınıf

Temel veya üst sınıf olarak da bilinir - bir veya daha fazla alt sınıf tarafından miras alınır.

Alt sınıf

Alt veya türetilmiş sınıf, alt sınıf, üst sınıftan miras alır.

Polimorfizm

Bu, bir işlevin farklı amaçlar için kullanılabildiği OOP'de bir olgudur.

Kapsülleme

Nesne yönelimli programlamadaki en önemli kavramlardan biri. Bu verilerle çalışan veriler ve işlevler bağlantılıdır ve diğer işlevler tarafından görülmez.

Soyutlama

Soyutlama, işlevlerin veya sınıfların uygulama ayrıntılarının görünür olmadığı anlamına gelir.

Bu, aynı ada ancak farklı sayıda bağımsız değişkene sahip işlevlerin farklı şekilde yürütüldüğü anlamına gelir.

Sınıflar ve nesneler:

Sınıf ve nesne, nesne yönelimli programlamada eşanlamlı terimler olarak yaygın olarak kullanılır, ancak özünde birbirlerinden çok farklıdırlar. Bir sınıf bir şablon, desen veya şekildir ve bir nesne, o belirli şablon veya şekilden bir ürün veya parçadır.

Örneğin bir evi ele alalım. Sınıf, evin temelidir; boyutları, şekli, kapı sayısı, yürüme yolları vb. Ama bu sadece bir proje, evin kendisi değil. Planın içerdiği bilgilere göre fiziksel bir ev inşa edildiğinde, o bir nesnedir.

Bundan önce nesne, plandaki bilgilere göre bir ev veya nesnenin inşa edildiği bir tahta, tuğla, çimento vb.

PHP OOP'deki bir sınıf, bir sınıf örneğinin oluşturulduğu, bir nesnenin oluşturulduğu bir plan veya şablondur. Sınıf oluşturulduktan sonra istediğimiz kadar nesne oluşturabiliriz. Yukarıdaki resimde bir sınıftan (plandan) beş nesne (ev) oluşturulmuştur. Nesne, onu oluşturmak için kullanılan sınıfta verilen talimatları her zaman izleyecektir.

PHP'de OOP'nin faydaları:

1. Daha iyi mimari ve daha temiz kod

Nesne yönelimli PHP, daha iyi kataloglanmıştır ve paketlemesi daha kolaydır, optimum mimari sağlar. Genellikle her sınıf ayrı bir dosyaya kaydedilir. Prosedürel diller, okunması veya anlaşılması çok zor olan karmaşık kodlarla karakterize edilir. OOP'de, nesneler arasındaki ilişkilerin net bir tanımıyla özel veriler içeren nesneler uygulayarak kod okunabilir ve temizdir.

1. Yeniden kullan

Nesneye yönelik programlama, kodu yeniden kullanılabilir hale getirir. Bir kez oluşturulan nesneler tekrar tekrar kullanılabilir. Her şeyi sıfırdan yazmak yerine çalışma birimleri birleştirilerek programlar oluşturulabilir. Bu zaman kazandırır ve üretkenliği artırır.

1. Bakımı ve güncellenmesi kolay

Nesnelerin kendi verileri ve işlevleri vardır, tüm yapıları kompakt ve sıkıştırılmıştır, bu da kodda değişiklik yapmayı kolaylaştırır. Geleneksel prosedürel programlama, değişiklik yapmak için bir nokta bulmanın çok zor olduğu yerlerde kod oluşturur. PHP OOP'de yeni bir özellik ekleyebilir ve ardından bu özelliği işlemek için ilgili yöntemler ekleyebiliriz.

1. Kapsülleme

Kapsülleme, nesnenin değişkenlerinin değerlerinin dışarıdan görünmediği ve dolayısıyla veri güvenliğinin uygulandığı anlamına gelir. Ancak ihtiyaç duyulursa, verilere erişim değiştiriciler kullanılarak erişilebilir. Güvenli programlar oluşturmak için, bir sınıftaki veriler ve üye işlevleri diğer sınıflardan gizlenebilir. Bir nesne oluşturulduktan sonra, onu kullanmak için hiçbir uygulama bilgisine gerek yoktur.

1. Miras

Miras alan sınıf, ana sınıfın tüm özelliklerini alır ve daha sonra kendi özellikleri ona eklenir. Alt sınıf, üst sınıfın değişkenlerini ve yöntemlerini miras alır. Mevcut sınıfların kullanımını genişletebilir, gereksiz kodları kaldırabiliriz.

Yazardan: Modern profesyonel programlama, nesne yönelimli programlama olmadan düşünülemez. Bu, yüksek seviyeli programlama dilleri için kamuya açık bir tür standart haline gelmemiştir ve elbette PHP de bir istisna değildir. Ancak, prosedürel programlama stilinden bir nesneye geçişe yeni başlayanlar için bazı zorluklar eşlik etti, bu nedenle bugün PHP OOP'nin temellerine bakacağız.

Öncelikle neden bu kadar yaygın olduğunu anlamak için nesne yönelimli yaklaşımın temel avantajlarına bakalım.

Nesne yönelimli yaklaşım kodunun anlaşılması ve okunması oldukça basittir ve büyük ölçekli ve çok karmaşık projeler için harikadır.

Bu programlama yaklaşımı kullanılarak yazılan uygulamaların modernize edilmesi ve genişletilmesi kolaydır.

Doğru tasarlanmış uygulamalar, ayrı modüllerden oluşur; bu, gerekirse, hızlı bir şekilde iyileştirilebileceği ve güncellenebileceği anlamına gelir, bu da geliştirme hızını birkaç kat arttırır.

Artık söz konusu kodlama stilinin temel güçlü yönleri belirlendiğine göre, doğrudan bu dersin özüne gidebilirsiniz.

Dolayısıyla, PHP'de nesne yönelimli programlama, verileri ve bunları karşılık gelen nesnelere dönüştüren işlevleri bağlama ilkesine dayanır. Bu, benzer unsurların birbirinden ayrı olarak tanımlandığı olağan prosedür yaklaşımından biraz farklıdır. Yani nesneler, özelliklerinde saklanan bazı bilgileri (nesne değişkenleri olarak adlandırılır) ve yöntemlerinde açıklanan belirli bir eylemler kümesini (aslında sıradan işlevler) içerir. Aynı zamanda, yöntemler, kural olarak, çalışmalarında, özelliklerde depolanan veriler üzerinde çalışır; bu, hem okuma hem de yazma ve değiştirme anlamına gelir.

Buna göre, PHP'deki nesne yönelimli programlama metodolojisinin temelinin nesnelerle çalışmak veya verileri işlemek için kullanmak olduğunu söyleyebiliriz.

Bu durumda, nesne önceden tanımlanmış bir sınıftan oluşturulur ve ikincisi yapısını tam olarak tanımlar ve bir tür şablon olarak hareket eder. Başka bir deyişle, sınıf, gelecekte oluşturulmuş nesnelerin özelliklerini ve yöntemlerini tanımlar. Ve bu aşağıdaki örnekte görülebilir.

sınıf Müşteri (public $ isim; korumalı $ siparişler; public function __construct ($ ad, $ siparişler) ($ this-\u003e name \u003d $ name; $ this-\u003e orders \u003d $ siparişler;) public function getName () ($ this döndür -\u003e ad;)) $ müşteri \u003d yeni Müşteri ("Ben", dizi ("id" \u003d\u003e 10)); echo $ müşteri-\u003e getName ();

sınıf Müşteri ( public $ isim; korumalı $ siparişler; public function __construct ($ isim, $ siparişler) ( $ this -\u003e isim \u003d $ isim; $ this -\u003e siparişler \u003d $ siparişler; genel işlev getName () ( $ this -\u003e isim döndür; $ müşteri \u003d yeni Müşteri ("Ben", dizi ("id" \u003d\u003e 10)); echo $ müşteri -\u003e getName ();

Bir sınıfın bir örneğini uygularken (yani, belirli bir ilgi sınıfını kullanarak yeni bir nesne yaratırken), yeni bir nesne oluşturulur ve sınıfta açıklanan özellikler de tanımlanır. Ayrıca, sınıf yapısında açıklanmışsa, __construct () adlı özel bir yöntem çalıştırılır. Gördüğünüz gibi, yeni anahtar sözcük, nesneyi oluşturmak için ve ardından sınıf adı kullanılır. Yukarıdaki yöntem için argümanlar, gerekirse parantez içinde iletilir ve burada, kural olarak, gelecekteki nesne için bazı başlangıç \u200b\u200bverileri tanımlanır.

Yukarıdaki örnekte, bir nesne oluşturmaya ek olarak, getName () yöntemi çağrılır ve onun döndürdüğü değer görüntülenir. Elbette, betiğin çalışmasının bir sonucu olarak, kullanıcı adının çıktısını göreceğiz - "Ben", çünkü bu, ad adı altında sınıf özelliğine yazılan yapıcı yöntemine ilk argüman olarak iletilen budur. Buna göre, yukarıdaki yöntem, çalışması sonucunda bu mülkün değerini döndürür.

Aynı zamanda, daha önce açıklanan sınıftan başka bir benzer nesne oluşturmanızı kimse yasaklamaz:

$ müşteri2 \u003d yeni Müşteri ("Sem", dizi ("id" \u003d\u003e 15)); echo $ müşteri2-\u003e getName ();

$ müşteri2 \u003d yeni Müşteri ("Sem", dizi ("id" \u003d\u003e 15)); echo $ müşteri2 -\u003e getName ();

Bu durumda, ekranda tamamen farklı bir kullanıcının adını göreceğiz - "Sem". Böylece, aslında aynı şablondan tamamen farklı bir nesne yarattık - bir sınıf. Aynı zamanda, bu nesnenin tamamen farklı başlangıç \u200b\u200bverileri vardır ve bunlar hala yapıcı yöntemle oluşturulur, yani yöntemlerle belirlenen davranışları da farklı olacaktır.

Lütfen sınıfın özelliklerinin ve yöntemlerinin yalnızca belirli bir nesne ile kullanılabileceğini unutmayın - bu, örnekte tam olarak görülebilen şeydir ve onsuz, sınıfın dışında çalışma açısından kesinlikle faydasızdırlar, çünkü sınıfın içinde elbette yapabilirler. yöntemlerinin kodunda kullanılır. Dahası, nesnenin yukarıdaki öğelerine erişim, özel bir işaret kümesi “-\u003e” (ok) aracılığıyla gerçekleştirilir, bundan önce ilgilenilen nesneyi veya nesne işaretçisini - $ this anahtar sözcüğünü belirtmek gerekir. $ This nesne işaretçisi, özelliklerine veya yöntemlerine erişmek için doğrudan sınıfın içinde yöntemlerin kodunda kullanılır.

Ve yine, siz ve ben gördük ki, PHP'deki OOP geliştirmenin temelinin nesnelerle çalışmak olduğunu ve güzel olan, sınıfı bir kez tanımlamamız, yani belirli bir veri kümesi ve gerekli işlevselliği oluşturmamızdır. Ve sonra, her biri ilk verilere bağlı olarak, aslında tamamen benzersiz olacak nesneler yaratıyoruz.

Yukarıdakilerden, sınıfın - hangi nesnelerin oluşturulacağı temelinde, örneğin kullanıcılar, sayfalar, menüler, adresler vb.İle çalışmak gibi gelecekteki projenin belirli bir varlığının verilerini ve işlevselliğini açıkladığını izler. Ve tabii ki, bu tür birkaç varlık varsa, o zaman birkaç sınıf vardır, bu da her biri için en az bir nesnenin oluşturulacağı anlamına gelir. Her zaman olmasa da, bazen bazı sınıflar belirli alt sınıflar için ebeveyn olarak yaratılır, bu da onların depolama, bazı ortak işlevler olarak hareket ettikleri anlamına gelir; bu, kendi başına gelecekteki projenin tüm sınıf hiyerarşisinin oluşturulmasını gerektirir. Ancak bu, mevcut makalenin çerçevesine uymayan tamamen farklı bir konudur.

Aslında, kısaca yanınızdayız ve PHP'de nesne yönelimli programlamanın temellerini gözden geçirdik. Elbette bu tür bir programlama, onu gerçekten iyi anlamak ve geliştirmelerinizde kullanmak istiyorsanız, bir makaleden daha fazla dikkat gerektirir. Bu konu, premium kursta daha ayrıntılı olarak tartışılmaktadır.

Başarılı kodlama ile size en iyisi !!!

Bu eğitimde, PHP'de nesne yönelimli programlamanın temellerini öğreneceksiniz. Genel olarak OOP'nin ilkelerini öğrenecek ve PHP'de basit betiklerin nasıl yazılacağını öğreneceksiniz.

PHP OOP öğreticilerinin ilkine hoş geldiniz! Bu serideki tüm dersleri okuduktan sonra, OOP'nin temel ilkelerini ve kavramlarını öğrenecek ve PHP'de hızlı ve kolay bir şekilde yararlı uygulamaları nasıl oluşturacağınızı öğreneceksiniz.

Bu eğitimde sizi hızlandırmaya ve temel OOP kavramlarını tanıtmaya başlayacağım. Öğreneceksiniz:

• oOP nedir
• oOP, daha iyi PHP betikleri oluşturmanıza nasıl yardımcı olur
• sınıflar, nesneler, yöntemler, sınıf değişkenleri gibi bazı temel kavramlar
• pHP komut dosyası yazmaya nereden başlamalı

PHP nesneleri dünyasına dalmaya hazır mısınız? Öyleyse devam et!

Nesne Tabanlı Programlama nedir?

PHP'de kendi işlevlerinizi oluşturduysanız ve bunları kullandıysanız, prosedürel programlama stilini kullandınız. Prosedürel programlamada, genellikle veri yapıları oluşturursunuz - sayılar, dizeler, diziler vb. - bazı verileri depolamak için ve sonra bu yapıları bu verileri işleyen özel işlevlerle işlersiniz.

Nesneye Yönelik Programlama veya OOP, ilerlemiştir çünkü burada onları işleyen veri yapılarını ve işlevleri nesne adı verilen tek bir varlıkta saklıyoruz. Verileri bir işlevle işlemek yerine, bu verileri bir nesneye yükler ve ardından onu işlemek ve istenen sonucu elde etmek için yöntemlerini çağırırsınız.

Çoğunlukla, OOP ile oluşturulan nesneler gerçek dünyadaki varlıkları yansıtır. Örneğin, siteniz için bir forum oluşturuyorsanız, her forum üyesiyle ilgili bilgileri (ad, giriş, e-posta adresi, şifre vb.) Ve bu bilgileri işleyecek yöntemleri (kayıt) saklayacak bir Üye nesnesi oluşturmalısınız. , yetkilendirme, çıkış, yasaklama vb.).

Neden OOP kullanıyorsunuz?

Prosedürel ve Nesne Yönelimli, aynı şeyi yapmanın iki farklı yoludur. Bu, birinin diğerinden daha iyi olduğu anlamına gelmez - herkes istediği gibi yazar, böylece iki yaklaşımı tek bir senaryoda kolayca birleştirebilirsiniz.

Ancak, geliştiriciler için OOP'nin bazı avantajları şunlardır:

• Gerçek durumları yansıtmak daha kolaydır: Yukarıda belirttiğim gibi nesneler gerçek varlıkları yansıtır - insanlar, ürünler, kartlar, blog makaleleri vb. Bu, uygulamanızı tasarlamaya yeni başladığınızda görevi büyük ölçüde basitleştirir, çünkü her nesnenin amacı ve hedefi nesneler arasındaki ilişkiler net ve anlaşılır olacaktır.
• Modüler programlar yazmak daha kolaydır: OOP, modül yazmakla ilgilidir. Kodunuzu modüllere bölerek, onu yönetmeniz, hata ayıklamanız ve genişletmeniz daha kolay olacaktır.
• Birçok kez kullanılacak kod yazmak daha kolaydır: Birden fazla kullanılabilen kod yazmak, bir uygulama yazarken zaman kazandırır ve zamanla birçok uygulamada kullanabileceğiniz bu tür modüllerden oluşan bütün bir kitaplık bile oluşturabilirsiniz. OOP, bu tür bir kod yazmayı nispeten kolaylaştırır çünkü veri yapıları ve işlevleri, herhangi bir sayıda kullanılabilen tek bir nesnede kapsüllenir.

Bazı temel kavramlar

Komut dosyaları yazmaya başlamadan önce, sınıf, nesne, sınıf değişkeni ve yöntem gibi kavramları iyi anlamanız gerekir.

Sınıflar

Sınıf, bir nesnenin iskeletidir. Bu, şunları tanımlayan bir kod parçasıdır:

• Oluşturulan sınıf nesnelerini içerecek veri türleri
• Bu nesneleri içerecek işlevler.

Bir OOP uygulaması oluşturduğunuzda, genellikle uygulamanızdaki farklı varlık türlerini temsil eden birkaç sınıf oluşturursunuz. Örneğin, bir forum oluşturmak için Forum, Konu, Gönderi ve Üye sınıflarını oluşturabilirsiniz.

Nesneler

Nesne, bir sınıf aracılığıyla oluşturulan özel tipte bir değişkendir. Geçerli veriler ve onu işlemek için işlevler içerir. Tek bir sınıftan istediğiniz kadar nesne oluşturabilirsiniz. Bir nesnenin her işlevi, aynı sınıftan oluşturulmuş olsalar bile başka bir nesneden bağımsızdır.

Gerçek varlıklarla karşılaştırma için:

• Sınıf, bir arabanın iskeletidir: arabanın nasıl görüneceğini ve nasıl davranacağını tanımlar, ancak yine de soyut bir varlıktır.
• Bir nesne, tel kafesten yapılmış gerçek bir arabadır: gerçek özellikleri (hız gibi) ve davranışları (hızlanma veya yavaşlama gibi) vardır.

Not: Bir nesneye genellikle bir sınıfın varlığı denir ve bir sınıfın bir nesnesini yaratma sürecine bir uygulama adı verilir.

Sınıf değişkenleri

Bir nesnede depolanan veri değerleri, sınıf değişkenleri adı verilen özel değişkenlere yazılır. Bir sınıfın değişkenleri, nesnesi ile yakından ilgilidir. Sınıfın tüm nesnelerinin aynı değişkenlere sahip olmasına rağmen, değerleri farklı olabilir.

Yöntemler

Bir sınıfta tanımlanan ve bu sınıfın nesnelerine uygulanan işlevlere yöntem denir. Normal işlevlerden pek farklı değildirler - onlara değer iletebilirsiniz, yerel değişkenler içerebilirler ve değerleri döndürürler. Bununla birlikte, yöntemlerin nesne değişkenleriyle çalışması daha olasıdır. Örneğin, forumunuzdaki kullanıcıları yetkilendirmek için login () yöntemi, loggedIn sınıf değişkeninin değerini true olarak ayarlayabilir.

PHP'de nasıl sınıf oluştururum?

Artık sınıfların, yöntemlerin, sınıf değişkenlerinin ve nesnelerin ne olduğunu zaten bildiğinize göre, PHP kodunuzda birkaç sınıf ve nesne oluşturmanın zamanı geldi.

İlk olarak, aslında bir sınıf oluşturmanız gerektiğini görelim. Temel olarak, bir sınıf oluşturma komut dosyası şuna benzer:

Sınıf SınıfAdı (// (sınıf tanımı))

Örneğin, forumunuz için bir Üye sınıfı oluşturuyorsanız, şöyle yazarsınız:

Sınıf Üyesi (// (sınıf tanımı))

Yeterince basit. Doğal olarak, bu sınıf siz ona değişkenler ve yöntemler ekleyene kadar hiçbir şey yapmayacaktır. Ancak yukarıdaki kod, kullanılabilecek geçerli bir PHP sınıfı oluşturur.

İyi biçim kuralı: Her sınıfı, sınıf adıyla aynı ada sahip ayrı bir dosyaya koyun. Örneğin, Member sınıfını Member.php dosyasına koyun ve sınıflar diyelim bir klasörde saklayın.

PHP'de nasıl nesne yaratırım?

Yeni anahtar kelimeyi kullanarak bir nesne oluşturabilirsiniz:

Yeni SınıfAdı ()

Bu kod, ClassName sınıfının bir nesnesini yaratacaktır. Bu nesneyi daha sonra kullanmanız gerekecek, bu yüzden onu bir değişkende saklamanız gerekir. Örneğin, Üye sınıfının bir nesnesini oluşturalım ve bunu $ üye değişkeninde saklayalım:

$ üye \u003d yeni Üye ();

Aynı sınıftan başka bir nesne de oluşturabiliriz:

$ üye2 \u003d yeni Üye ();

Bu iki nesneyi aynı sınıftan oluşturmamıza rağmen, $ üye ve $ üye2 değişkenleri birbirinden bağımsızdır.

Sınıf değişkenleri oluşturun

Artık sınıfların ve sınıf nesnelerinin nasıl oluşturulacağını bildiğimize göre, sınıf değişkenlerinin nasıl oluşturulacağını görelim. Sınıfa eklenebilecek sınıf değişkenleri için 3 erişim tanımlayıcısı vardır:

• Genel sınıf değişkenleri (genel): erişilebilir - ör. sınıfın içinde veya dışında - bu kodun nerede bulunduğuna bakılmaksızın, komut dosyasının herhangi bir yerinde okunabilir ve / veya değiştirilebilirler
• Sınıfın özel değişkenleri (özel): yalnızca sınıfın yöntemlerinde kullanılabilir. En iyi uygulama, nesneleri kodun geri kalanından ayırmak için sınıf değişkenlerini özel yapmaktır.
• Korumalı sınıf değişkenleri (korumalı): kendi sınıfınızın yöntemlerinin yanı sıra miras alınan sınıfların yöntemlerinde de mevcuttur (kalıtım hakkında daha sonra konuşacağız).

Bir sınıf değişkeni oluşturmak için genel, özel veya korumalı anahtar kelimeyi yazın ve ardından değişken adını girin:

Sınıf SınıfAdı (public $ propertyName; private $ propertyName; korumalı $ propertyName;)

Kullanıcı adını tutmak için Üye sınıfımıza genel bir sınıf değişkeni ekleyelim:

Sınıf Üyesi (genel $ username \u003d "";)

Sınıf değişkenimizi başlattığımıza dikkat edin, değerinin boş bir dizge, "". Bu, yeni bir kullanıcı oluşturulduğunda, adının varsayılan değerinin boş bir dize olacağı anlamına gelir. PHP'deki normal değişkenlerde olduğu gibi, sınıf değişkenlerinin ilklendirilmesine gerek yoktur, ancak yine de tembel olmamak daha iyidir. Bir sınıf değişkenini başlatmazsanız, varsayılan olarak null olur.

Sınıf değişkenlerine erişim

Bir nesnenin değişkenine erişmek için -\u003e operatörünü kullanın:

$ nesne-\u003e özellikAdı

Hadi deneyelim. Üye sınıfını ve bir sınıf değişkenini bildiren, bu sınıfın bir nesnesini oluşturan ve ardından sınıf değişkeninin değerini ayarlayıp ekranda görüntüleyen bir betik yazalım:

username \u003d "Fred"; echo $ üye-\u003e kullanıcı adı; // "Fred" çıktı mı?\u003e

Bu kodu çalıştırın, $ üye-\u003e username sınıf değişkeninin değeri olan "Fred" dizesini gösterecektir. Gördüğünüz gibi, bir nesne değişkeni üzerinde normal bir değişkenle aynı şekilde işlem yaparsınız - ona bir değer ayarlayabilir ve okuyabilirsiniz.

Bir sınıfa yöntemler ekleme

Yöntemler oluşturmaya ne dersiniz? Daha önce bahsettiğim gibi, yöntemler bir sınıfın parçası olan normal işlevlerdir. Dolayısıyla, aynı işlev anahtar sözcüğü kullanılarak oluşturulmalarına şaşırmayabilirsiniz. Düzenli işlevler oluşturmanın tek farkı, bildirimine erişim tanımlayıcılarından (genel, özel, korumalı) birini de ekleyebilmenizdir. Bunda, yöntemler sınıf değişkenlerine benzer:

Sınıf SınıfAdı (genel işlev yöntemAdı () (// (kod)) özel işlev yöntemAdı () (// (kod)) korumalı işlev yöntemAdı () (// (kod)))

Not: Sınıf değişkenlerinde olduğu gibi, genel yöntemler herhangi bir yerden çağrılabilir, özel yöntemler yalnızca sınıf içinde çağrılabilir ve korumalı yöntemler sınıfın kendisinden ve mirasçısından çağrılabilir.

Sınıfımıza bazı yöntemler ve sınıf değişkenleri eklemeye çalışalım:

• kullanıcı kimliği için private $ loggedIn sınıf değişkeni, yani gelsin ya da gelmesin
• $ loggedIn sınıf değişkenini true olarak ayarlayarak foruma giriş yapacak login () yöntemi,
• $ loggedIn sınıf değişkeninin değerini false olarak ayarlayarak forumdan çıkış yapacak olan logout () yöntemi,
• $ loggedIn sınıf değişkeninin değerini döndürecek isLoggedIn () yöntemi.

İşte kodumuz:

loggedIn \u003d true; ) public function logout () ($ this-\u003e loggedIn \u003d false;) public function isLoggedIn () (return $ this-\u003e loggedIn;))?\u003e

Yeni $ this anahtar kelimesini kullandığımızı fark etmiş olabilirsiniz. Nesne yöntemleri bağlamında, $ this özel değişkeni nesnenin kendisine atıfta bulunur. Bir nesne yönteminde $ this kullanarak, yöntem nesnenin herhangi bir sınıf değişkenine ve yöntemine erişebilir.

Örneğin, login () yöntemi, $ this-\u003e loggedIn aracılığıyla bir nesnenin $ loggedIn sınıf değişkenine erişebilir.

Bu arada, sınıf değişkenimiz özeldir, bu nedenle komut dosyasının herhangi bir kısmından çağrılamaz, yalnızca login (), logout () ve isLoggedIn () yöntemlerinden çağrılabilir. Bu iyi bir yaklaşımdır, çünkü nesnenin içi (örneğin, nasıl yazılır, kullanıcının oturum açmış olup olmadığı) kodun geri kalanından ayrıdır. Mümkün olduğunda, nesnelerinizi bağımsız, mobil ve güvende tutmak için özel değişkenler kullanmaya çalışın.

Not: Örneğimizdeki $ username sınıfı değişkeni geneldir. Bunu sadece bir nesnenin sınıfının değişkenlerine nasıl erişebileceğinizi göstermek için yaptım. Gerçek projelerde, bunun yerine, bu değişkeni özel yapmanız ve gerekirse kullanıcı adının değerlerini ayarlamak için public sınıfının özel değişkenlerini oluşturmanız gerekir.

Yöntemleri kullanma

Bir nesne yöntemini çağırmak için, zaten arkadaş olduğunuz -\u003e operatörünü kullanın.

$ nesne-\u003e yöntemAdı ()

Bu, normal bir işlev çağrısı gibi çalışır. Bağımsız değişkenleri parantez içinde iletebilirsiniz (tabii ki herhangi bir bağımsız değişken kabul ederse), bir yöntem çağrısı da daha sonra kullanabileceğiniz belirli değerleri döndürebilir.

loggedIn \u003d true; ) public function logout () ($ this-\u003e loggedIn \u003d false;) public function isLoggedIn () (return $ this-\u003e loggedIn;)) $ üye \u003d new Üye (); $ üye-\u003e kullanıcı adı \u003d "Fred"; echo $ üye-\u003e kullanıcı adı. "dır-dir". ($ üye-\u003e
"; $ üye-\u003e login (); echo $ üye-\u003e kullanıcı adı." is ". ($ üye-\u003e isLoggedIn ()?" giriş yapıldı ":" çıkış yapıldı ")."
"; $ üye-\u003e logout (); echo $ üye-\u003e kullanıcı adı." is ". ($ üye-\u003e isLoggedIn ()?" giriş yaptı ":" çıkış yapıldı ")."
"; ?>

Bu komut dosyası aşağıdakileri gösterecektir:

Fred oturumu kapatıldı Fred oturumu açıldı Fred oturumu kapatıldı

Şu şekilde çalışır:

1. Üye sınıfını tanımladıktan sonra, bir nesne oluşturduk ve bunu $ üye değişkeninde sakladık. Ayrıca bu nesnenin $ username sınıf değişkenini "Fred" olarak ayarladık.
2. Daha sonra kullanıcının oturum açıp açmadığını belirlemek için $ member-\u003e isLoggedIn () yöntemini çağırdık. Bu yöntem basitçe $ loggedIn sınıf değişkeninin değerini döndürür. Bu sınıf değişkeninin varsayılan değeri yanlış olduğundan, $ üye-\u003e isLoggedIn () çağrısının sonucu yanlış olacaktır, bu nedenle "Fred oturumu kapatıldı" mesajı görüntülenecektir.
3. Daha sonra login () yöntemini çağırıyoruz. $ LoggedIn sınıf değişkenini true olarak ayarlayacaktır.
4. Şimdi, $ member-\u003e isLoggedIn () yönteminin çağrılması true değerini döndürür ve "Fred oturum açtı" mesajını görüntüler.
5. $ LoggedIn özelliğinin değerini false olarak ayarlayan logout () yöntemini çağırıyoruz.
6. Üçüncü kez $ üye-\u003e isLoggedIn () yöntemini çağıralım. $ LoggedIn özelliğinin değeri yeniden false olarak ayarlandığından, şimdi false döndürür. Bu nedenle, "Fred oturumu kapatıldı" mesajı tekrar görüntülenecektir.

Not: Bunu ilk gören siz olmanız durumunda:?:, Üçlü bir operatördür. Bu, if… else bloklarının basitleştirilmiş bir sürümüdür. Bu tür operatörler hakkında bilgi edinebilirsiniz.

sonuçlar

Bu eğitimde, PHP'de OOP'nin temellerini öğrendiniz. Aşağıdaki gibi şeyler öğrendiniz:

• oOP nedir ve neden onu kullanmak faydalıdır
• sınıflar, nesneler, sınıf değişkenleri ve yöntemlerle ilgili kavramlar
• sınıflar ve nesneler nasıl oluşturulur
• sınıf değişkenleri nasıl oluşturulur ve kullanılır
• genel, özel, korumalı erişim tanımlayıcıları kavramları
• sınıf yöntemleri nasıl oluşturulur ve uygulanır

Bu konuda zaten çok şey öğrendiniz ve sonraki derslerde çok daha fazlasını öğreneceksiniz. Bununla birlikte, size verdiğim tüm örnekleri incelediyseniz, sağlam bir temeliniz var. OOP uygulamaları oluşturmaya başlayabilirsiniz.

PHP'de nesne yönelimli bir yaklaşım kullanarak web uygulamaları geliştirmek, yordamsal bir yaklaşımı kullanmaya alışkın olan geliştiriciler için başlangıçta kafa karıştırıcı olabilir, ancak aslında OOP ile ilgili zor bir şey yoktur. Bu derste, OOP'nin teorik yönlerine bakacağız ve ayrıca pratikte kazanılan bilgileri nasıl uygulayacağımızı öğreneceğiz.

Kurs, nesne stilinde uygulama yazmak için yeterli olması gereken, OOP'nin temellerini adım adım öğreneceğimiz 17 dersten oluşmaktadır.

Bu kursu tamamladıktan sonra, nesne yönelimli programlamanın ne olduğunu anlayacak, sınıfların ve nesnelerin ne olduğunu öğrenecek ve aralarındaki farkı anlayacaksınız. Özellikler, yöntemler ve sınıf sabitleri hakkında bilgi edinin.

Kursu tamamladıktan sonra, web uygulamanız için uygun ve esnek mantık oluşturmak ve dallanmış sınıf hiyerarşileri oluşturmak için sınıf mirasını kullanabileceksiniz. Yöntemleri geçersiz kılabilecek ve böylece işlevselliklerini genişletebilecek, soyut sınıflar yaratabileceksiniz. Kurstan, arayüzleri kullanmanın anlamını öğrenecek ve onları gerçekten ihtiyaç duyduğunuz yerde nasıl kullanacağınızı ve arayüzler uğruna arayüz kullanmayacağınızı öğreneceksiniz. Kursta, içerme dosyalarının uzun listelerini hariç tutmanıza izin verecek otomatik yükleme sınıfları konusuna özellikle dikkat edilir. Burada hem otomatik yükleme işlevleri hem de bu amaçla Composer paket yöneticisinin nasıl kullanılacağını öğreneceksiniz.

Tüm bunlar ve çok daha fazlası, önerilen PHP'de OOP dersinin derslerinden öğreneceksiniz.

Kursun tüm dersleri:

Kursun tanımı: Bu derste OOP'nin teorik yönlerini ele alacağız ve ayrıca pratikte kazanılan bilgileri nasıl uygulayacağımızı öğreneceğiz. Kurs, nesne stilinde uygulama yazmak için yeterli olması gereken OOP'nin temellerini adım adım öğreneceğimiz 17 dersten oluşmaktadır.