Yazardan: modern profesyonel programlama, üst düzey programlama dilleri için halka açık bir tür standart haline gelmeyen nesne yönelimli programlama olmadan düşünülemez ve elbette PHP bir istisna değildir. Ama öyle oldu ki, prosedürel bir programlama stilinden bir nesneye geçişe yeni başlayanlar için bazı zorluklar eşlik ediyor, bu yüzden bugün PHP OOP'nin temellerine bakacağız.

İlk olarak, 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ın kodunun anlaşılması ve okunması oldukça basittir ve büyük ölçekli ve çok karmaşık projeleri uygulamak için mükemmeldir.

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

Doğru tasarlanmış uygulamalar, ayrı modüllerden oluşur; bu, gerektiğinde hızlı bir şekilde geliştirilip güncellenebilecekleri anlamına gelir, bu da geliştirme hızını birkaç büyüklük mertebesinde artırır.

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

Bu nedenle, 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 depolanan bazı bilgileri (nesne değişkenleri olarak adlandırılır) ve yöntemlerinde açıklanan belirli bir dizi eylemi (aslında sıradan işlevler) içerir. Bu durumda, bir kural olarak, çalışmalarında yöntemler, hem okuma hem de yazma ve değiştirme anlamına gelen özelliklerde depolanan veriler üzerinde çalışır.

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, daha önce tanımlanmış bir sınıftan bir nesne oluşturulur ve ikincisi yapısını tam olarak tanımlar ve bir tür şablon görevi görür. Başka bir deyişle, sınıf, gelecekte oluşturulacak nesnelerin özelliklerini ve yöntemlerini tanımlar. Ve bu aşağıdaki örnekte görülebilir.

class Müşteri (genel $ ad; korumalı $ siparişler; genel işlev __construct ($ ad, $ siparişler) ($ bu-> ad = $ ad; $ bu-> siparişler = $ siparişler;) genel işlev getName () (bu $ döndür -> isim;)) $ müşteri = yeni Müşteri ("Ben", dizi ("id" => 10)); echo $ müşteri-> getName();

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

Bir sınıfın bir örneğini uygularken (yani, belirli bir ilgi sınıfını kullanarak yeni bir nesne oluştururken), yeni bir nesne oluşturulur ve sınıfta açıklanan özellikler de tanımlanır. Ayrıca, sınıf yapısında tanımlanmışsa, yürütme için __construct () adlı özel bir yöntem başlatılır. Gördüğünüz gibi, nesneyi oluşturmak için new anahtar sözcüğü kullanılır, ardından sınıf adı gelir. Yukarıdaki yöntem için argümanlar, gerekirse, kural olarak, gelecekteki nesne için bazı başlangıç ​​verilerinin tanımlandığı parantez içinde iletilir.

Yukarıdaki örnekte, bir nesne oluşturmaya ek olarak, getName() yöntemi çağrılır ve bunun tarafından döndürülen değer görüntülenir. Tabii ki, betiğin çalışmasının bir sonucu olarak, "Ben" kullanıcı adının çıktısını göreceğiz, çünkü yapıcı yöntemine ilk argüman olarak iletilen, burada sınıf özelliğine yazıldığı yerdir. isim isim. Buna göre, yukarıdaki yöntem, çalışmasının sonucu olarak bu özelliğin değerini döndürür.

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

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

$ müşteri2 = yeni Müşteri ("Sem", dizi ("id" => 15)); echo $ müşteri2 -> 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 nesne, hala yapıcı yöntemi tarafından oluşturulan tamamen farklı başlangıç ​​verilerine sahiptir ve bu nedenle, yöntemlerle belirlenen davranışı da farklı olacaktır.

Lütfen, sınıfın özelliklerinin ve yöntemlerinin yalnızca belirli bir nesneyle kullanılabileceğini unutmayın - örnekte tam olarak bu görülebilir ve onsuz, sınıfın dışında çalışmak açısından kesinlikle işe yaramazlar, çünkü nesnenin içinde. sınıf, elbette, yöntemlerinin kodunda kullanılabilirler. Ayrıca, nesnenin yukarıdaki öğelerine erişim, daha önce ilgilenilen nesneyi veya nesne işaretçisini - $ this anahtar sözcüğünü belirtmek için gerekli olan özel bir “->” (ok) işareti seti aracılığıyla gerçekleştirilir. $ 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, PHP'deki OOP geliştirmenin temelinin nesnelerle çalışmak olduğunu ve güzelliğin, sınıfı bir kez tanımladığımız gerçeğinde yattığını görüyoruz, bu da belirli bir veri seti ve gerekli işlevselliği oluşturduğumuz anlamına geliyor. Ve sonra, her biri ilk verilere bağlı olarak, aslında kesinlikle benzersiz olacak nesneler yaratırız.

Yukarıdakilerden, sınıfın - hangi nesnelerin oluşturulacağı temelinde, gelecekteki projenin belirli bir varlığının verilerini ve işlevselliğini, örneğin kullanıcılarla, sayfalarla, menülerle, adreslerle vb. Ve elbette, bu tür birkaç varlık varsa, o zaman birkaç sınıf vardır, bu da her biri için en az bir nesne oluşturulacağı anlamına gelir. Her zaman olmasa da, bazen bazı sınıflar belirli alt sınıflar için ebeveyn olarak oluşturulur, bu da onların depolama görevi gördükleri anlamına gelir, bazı ortak işlevler, bu da kendi başına gelecekteki projenin bütün bir sınıf hiyerarşisinin oluşturulmasını ima eder. Ancak bu, mevcut makalenin çerçevesine uymayan tamamen farklı bir konudur.

Aslında burada sizlerleyiz ve PHP'de nesne yönelimli programlamanın temellerini kısaca gözden geçirdik. Tabii ki, 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 her şey gönlünüzce olsun !!!

PHP, en popüler betik programlama dillerinden biridir. Web sunucularının neredeyse %60'ı PHP kullanıyor.Her ay milyonlarca web sitesi ve web uygulaması PHP ile geliştiriliyor.

PHP başlangıçta Perl dilinin basit bir yedeği olarak geliştirildi ve birkaç yıl sonra son derece güçlü ve popüler hale geldi. PHP dilinin kendisi ANSI C'ye çok benzer.
PHP'nin bu kadar popüler olmasının nedenlerinden biri, öğrenme eğrisinin kısa olmasıdır.

PHP öğrenmek hiç de zor değil, özellikle Java veya C sözdizimine aşina iseniz.

PHP betikleri yazmak oldukça kolay olduğu için, herkes herhangi bir kurala uymadan ve sunum katmanını iş mantığıyla karıştırmadan PHP kodu yazabilir (bu, çok sayıda yönetilmeyen projenin varlığının ana nedenlerinden biridir). PHP'nin kodlama kurallarına sıkı sıkıya bağlı kalması gerekmediğinden, yıllar geçtikçe proje büyüdükçe yönetilmeyen devasa bir uygulamaya dönüşür.

OOP veya Nesne Yönelimli Programlama, yönetilebilir projelerin daha kolay oluşturulması için programlama uygulamalarında iyi bir şekilde kullanılmaktadır.
Prosedürel yaklaşım, nesneleri kullanmadan program kodu yazmak anlamına gelir. Prosedürel programlama, alt programlarla veya alt programlar olmadan kod yazmakla ilgilidir.

OOP, herhangi bir programlama dilini daha iyi program kodu için öğretir ve daha yüksek performans elde etmek ve yönetimlerinde kafa karışıklığı korkusu olmadan büyük projeler yazmak için kullanılır. OOP size yeniden kullanılabilecek nesneler oluşturma yeteneği verir, böylece siz veya diğer geliştiriciler bunları tekrar tekrar yapmadan projelerinde kullanabilirsiniz. OOP, büyük uygulamaların yazılması ve yönetilmesindeki engelleri ve karmaşıklıkları ortadan kaldırır.

PHP, uygulamaları 2 farklı şekilde yazmamıza izin verir, ilki prosedürel, ikincisi ise nesne yönelimli. Bu iki yaklaşım arasındaki farkı hala anlamadıysanız, bu kod parçalarına bir göz atalım - aynı örnek farklı yaklaşımlarda yazılmıştır.

prosedür:

$ user_input = $ _POST ['alan'];
$ filtered_content = filtre ($ user_input); // kullanıcı girişi filtreleme
mysql_connect ("dbhost", "dbuser", "dbpassword"); // veri tabanı
mysql_select_db ("dbname");
$ sql = "biraz sorgu";
$ sonuç = mysql_query ($ sql);
while ($ data = mysql_fetch_assoc())
{
işlem ($ veri);
}
process_user_input ($ filtrelenmiş_içerik);

Ve işte OOP kullanan aynı kod parçası:

$ input_filter = yeni filtre ();
$ input_filter-> filter_user_input(); // kullanıcı girişlerini filtrele
$ db = yeni dal ("mysql"); // veri erişim katmanı
$ db-> connect ($ dbconfig); // mysql kullanıyorduk
$ sonuç = $ db-> yürüt ($ sql);
ReportGenerator :: makereport ($ sonuç); // Veri işleme
$ model = yeni Postmodel ($ filter-> get_filtered_content ());
$ model-> insert();

Bu 2 kod parçasına yakından bakarsanız, OOP kullanan kodun daha okunaklı ve anlaşılması daha kolay olduğunu fark edeceksiniz.

OOP kodu daha iyi organize edilmiştir çünkü hangi nesnenin ne tarafından işlendiği açıktır. Prosedürel bir yaklaşımla yazılan büyük uygulamaların, birkaç sürümün yayınlanmasından sonra algılanması neredeyse imkansız hale geliyor. Elbette katı kodlama kurallarına uyabilirsiniz, ancak bunlar, programınızda OOP kullanmazsanız, bunun sonunda size projenin yönetilebilirliğini ve kullanılabilirliğini vermeyeceğini bilen milyonlarca geliştirici tarafından onaylanmıştır.
Neredeyse tüm büyük uygulamalar Nesne Yönelimli kullanılarak yazılır
yaklaşmak.

Yukarıdakilere dayanarak, OOP kullanmanın avantajları öğrenilebilir:

OOP, geliştiriciler için hayatı kolaylaştırmak için oluşturuldu. OOP kullanarak, büyük problemlerinizi çözmesi çok daha kolay olan küçük problemlere bölebilirsiniz.
OOP'nin temel gereksinimi, tüm yapmak istediğiniz nesneleri yapmaktır. Nesneler, verileri ve özellikleri birlikte paketleyebilen ayrı bir küçük kod parçasıdır. Uygulamalarda, tüm nesneler birbirleriyle etkileşime girer.

OOP, özellikle uygulamanın geliştirme süresi ve sonraki gelişimi sizin için önemli olduğunda, farklı açılardan daha iyi olarak kabul edilebilir.
OOP kullanmanın başlıca avantajları şu şekilde ifade edilebilir:

* yeniden kullanın: Bir nesne, bir dizi özelliği ve yöntemi olan ve diğer nesnelerle etkileşime girebilen mantıksal bir nesnedir.Bir nesne tamamen bağımsız olabilir veya diğer nesnelere bağlı olabilir. Nesne genellikle ortaya konan belirli sorunları çözmek için oluşturulur. Bu nedenle, diğer geliştiriciler benzer sorunlarla karşılaştığında, sınıfınızı projelerine bağlayabilir ve geliştirme süreçlerini bozacağından korkmadan kullanabilirler. Bu, Kendini Tekrar Etme anlamına gelen DRY'yi önler. Prosedürel veya modüler programlamada, yeniden kullanım yalnızca toplu olarak mümkündür.

* yeniden düzenleme: Bir projede yeniden düzenleme kullanmanız gerektiğinde, tüm nesneler küçük öğeler olduğundan ve özelliklerini ve yöntemlerini kendi içlerinde barındırdığından OOP size maksimum fayda sağlar. Bu, yeniden düzenlemenin kullanımını nispeten kolaylaştırır.

* genişletilebilirlik: Projenizin işlevselliğini artırmanız gerekiyorsa OOP ile daha iyi sonuçlar elde edebilirsiniz. OOP'nin ana özelliklerinden biri genişletilebilirliktir. İşlevsellik eklemek için nesne yeniden düzenlemeyi kullanabilirsiniz. Bunun üzerinde çalışırken, yine de kaydedebilirsiniz
eski nesne uyumluluğu - bu nedenle eski kodla sorunsuz çalışabilirsiniz. Veya nesneyi genişletebilir ve yenisinin türetildiği ana nesnenin tüm gerekli özelliklerini ve yöntemlerini içeren tamamen yeni bir tane oluşturabilir ve ardından ona yeni işlevler ekleyebilirsiniz. Buna "miras" denir ve çok önemli bir OOP özelliğidir.

* Destek: nesne yönelimli kodun bakımı daha kolaydır çünkü
çok katı kodlama kurallarına uyar ve kendini açıklayıcı bir şekilde yazılmıştır.
Örneğin, bir geliştirici kodu tamamladığında, iyileştirdiğinde veya hata ayıkladığı zaman, kodun iç yapısını kolayca bulabilir ve zaman zaman kodun bakımını yapabilir. Ayrıca, ortamınızda bir OOP geliştirme ekibi çalışırken, kodunuzu küçük parçalara böldükten sonra ekip üyeleri arasında dağıtabileceğiniz için bu en iyi çözüm olabilir. Bu küçük parçalar ayrı nesneler olarak tasarlanabilir, böylece geliştiriciler neredeyse birbirinden bağımsız çalışabilir. Sonuç olarak, tüm parçaları tek bir uygulamada bir araya getirmek çok da önemli değil.

* Yeterlik: OOP fikri aslında geliştirme sürecini daha verimli ve kolay hale getirmek için geliştirildi. Daha verimli ve daha iyi kod oluşturmak için çeşitli tasarım desenleri geliştirilmiştir.
Ayrıca, OOP'de kararlarınızı prosedürel bir yaklaşımdan daha uygun bir şekilde düşünebilirsiniz. Sorununuzu birkaç küçük soruna böldüğünüz ve her biri için ayrı ayrı çözüm bulduğunuz için büyük sorun kendiliğinden çözülür.

P.S ilk habratopik kitabım, eğer kitabı daha fazla çevirmek istersem, benim için oldukça ilginç ve bilgilendirici

11 Mart 2010, 11:37

Örneklerle OOP (bölüm 1)

• BT'de eğitim süreci

Kaderin iradesiyle, üniversitede tasarım kalıpları üzerine özel bir ders okumam gerekiyor. Özel ders zorunludur, bu nedenle öğrenciler bana çok farklı geliyor. Elbette aralarında pratik yapan programcılar da var. Ancak ne yazık ki çoğu, temel OOP terimlerini anlamakta bile zorluk çekiyor.

Bunu yapmak için OOP'nin temel kavramlarını (sınıf, nesne, arayüz, soyutlama, kapsülleme, kalıtım ve polimorfizm) az çok canlı örnekler kullanarak açıklamaya çalıştım.

Aşağıdaki ilk kısım sınıflar, nesneler ve arayüzler hakkındadır.
kapsülleme, polimorfizm ve kalıtımı gösterir

OOP'nin temel kavramları

Sınıf

Bir araba tasarladığınızı hayal edin. Bir arabanın bir motor, süspansiyon, iki far, 4 tekerlek vb. içermesi gerektiğini biliyorsunuz. Ayrıca arabanızın kalkabilmesi ve yavaşlayabilmesi, dönebilmesi ve geri dönebilmesi gerektiğini de biliyorsunuz. Ve en önemlisi, motor ve tekerleklerin nasıl etkileştiğini, eksantrik milinin ve krank milinin hangi yasalara göre hareket ettiğini ve ayrıca diferansiyellerin nasıl düzenlendiğini tam olarak bilirsiniz. Bilginize güveniyorsunuz ve tasarlamaya başlıyorsunuz.

Aracınızı oluşturan tüm parçaları ve bu parçaların birbirleriyle nasıl etkileşime girdiğini anlatırsınız. Ayrıca, aracın fren yapması veya uzun farları yakması için kullanıcının yapması gerekenleri de açıklarsınız. Çalışmanızın sonucu biraz eskiz olacak. OOP'nin dediği şeyi geliştirdiniz Sınıf.

Sınıf Bir varlığı tanımlamanın, bu duruma bağlı olarak durumu ve davranışı tanımlamanın yanı sıra bu varlıkla (sözleşme) etkileşim kurallarını tanımlamanın bir yoludur.

Programlama açısından bir sınıf, bir veri kümesi (alanlar, nitelikler, sınıf üyeleri) ve bunlarla çalışmak için işlevler (yöntemler) olarak görülebilir.

Programın yapısı açısından sınıf, karmaşık bir veri türüdür.

Bizim durumumuzda, sınıf varlığı temsil edecek - araba. Sınıf özellikleri motor, süspansiyon, gövde, dört tekerlek vb. olacaktır. Sınıfın yöntemleri “kapıyı aç”, “gaz pedalına bas” ve ayrıca “gaz deposundan benzinin bir kısmını motora pompala” olacak. İlk iki yöntem, diğer sınıflar (özellikle "Sürücü" sınıfı) tarafından yürütülebilir. İkincisi, sınıf içindeki etkileşimleri tanımlar ve kullanıcı tarafından kullanılamaz.

Gelecekte, "kullanıcı" kelimesinin Klondike Solitaire ve Microsoft Word ile ilişkilendirilmesine rağmen, kullanıcıları siz de dahil olmak üzere sınıfınızı kullanan programcıların kullanıcıları olarak adlandıracağız. Sınıfın yazarı olan kişiye geliştirici diyeceğiz.

Bir obje

Harika bir iş çıkardınız ve çizimlerinize göre tasarlanmış makineler montaj hattından çıkıyor. İşte fabrika bahçesinde sıralar halinde duruyorlar. Her biri çizimlerinizi tam olarak kopyalar. Tüm sistemler tam olarak sizin tasarladığınız şekilde etkileşime girer. Ancak her araba benzersizdir. Hepsinin bir gövde ve motor numarası var, ancak tüm bu numaralar farklı, arabaların rengi farklı ve hatta bazılarında damgalı diskler yerine dökümler var. Bu arabalar aslında sınıfınızın nesneleridir.

Nesne (örnek) Tamamen sınıf tarafından tanımlanan belirli bir durum ve davranışa sahip bir sınıfın ayrı bir üyesidir.

Basit bir ifadeyle, bir nesnenin belirli öznitelik değerleri ve sınıfta tanımlanan kurallara göre bu değerler üzerinde çalışan yöntemleri vardır. Bu örnekte, bir sınıf "fikirler dünyasından" soyut bir arabaysa, nesne pencerelerinizin altında duran belirli bir arabadır.

Arayüz

Bir kahve makinesine gittiğimizde veya direksiyona geçtiğimizde onlarla etkileşime girmeye başlarız. Genellikle, etkileşim belirli bir dizi öğenin yardımıyla gerçekleşir: madeni paraları kabul etmek için bir yuva, bir içecek seçmek için bir düğme ve bir kahve makinesinde bir bardak dağıtmak için bir bölme; direksiyon simidi, pedallar, arabada vites kolu. Her zaman etkileşimde bulunabileceğimiz sınırlı bir kontrol grubu vardır.

Arayüz Diğer sınıflar tarafından kullanılabilen bir sınıf yöntemleri koleksiyonudur.

Açıkçası, bir sınıfın arayüzü, bir dizi genel nitelikle birlikte tüm genel yöntemlerinin bir kümesi olacaktır. Temel olarak, bir arabirim, üzerinde olası tüm eylemleri açıkça tanımlayan bir sınıfı belirtir.
Arayüze iyi bir örnek, hızlanma, frenleme, dönüş, vites değiştirme, farları yakma gibi yöntemleri başlatmanıza izin veren bir araba gösterge panelidir. Yani, başka bir sınıfın (bizim durumumuzda, sürücü) araba ile etkileşime girerken gerçekleştirebileceği tüm eylemler.

Bir sınıf arayüzünü tanımlarken, esneklik ve basitlik arasında bir denge kurmak çok önemlidir. Basit bir arayüze sahip bir sınıfın kullanımı kolay olacaktır, ancak onun yardımıyla çözemeyeceği problemler olacaktır. Aynı zamanda, eğer arayüz esnekse, büyük olasılıkla, çok sayıda parametreye sahip oldukça karmaşık yöntemlerden oluşacak ve bu da çok şey yapmanıza izin verecektir, ancak onu kullanmak büyük zorluklar ve risklerle dolu olacaktır. hata yapmaktan, kafa karıştıran bir şey.

Basit bir arayüz örneği, otomatik şanzımanlı bir makinedir. İki haftalık bir sürüş kursunu tamamlayan herhangi bir sarışın, yönetimini çok hızlı bir şekilde öğrenebilecektir. Öte yandan, modern bir yolcu uçağının kontrolünde ustalaşmak için birkaç ay, hatta yıllar süren zorlu bir eğitim gerekir. İki haftalık uçuş tecrübesi olan bir adam tarafından işletilen bir Boeing'de olmak istemem. Öte yandan, bir arabayı asla Moskova'dan Washington'a kalkıp uçmaya zorlamayacaksınız.

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 çok temel bir seviyeden öğrenmek isteyen hem yeni başlayanlar hem de ileri düzey programcılar için tasarlanmıştır.

PHP 5'teki en önemli değişikliklerden biri, gelişmiş performans sağlayan tam nesne modelidir. PHP 5'e eklenen önemli yeni özelliklerden bazıları, nihai ve soyut yöntemler, sınıflar, arayüzler, klonlama ve sihirli yöntemleri içerir. Bu OOP PHP eğitiminde, her birinin nasıl kullanılabileceğine dair örneklere bakacağız.

Nesne yönelimli programlamada, bir nesneye referanslar veya işaretçiler gibi davranılır. Bu, her yeni değişkenin tüm nesnenin bir kopyasını değil, bir nesneye başvuru içerdiği anlamına gelir.

Kavraması 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 gelecektir.

PHP'de OOP nedir?

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

İşte aptallar için bir OOP PHP açıklaması. Etrafımızdaki dünyaya bakın, nesnelerle dolu. Güneş, ay, arabalar, ağaçlar, evler vb. vesaire. Bunların hepsi nesnelerdir, nitelikleri ve işlevleri vardır. Düşünme sürecinde nesnelerle çalışırız. Araba dediğimizde tekerlekleri, motoru, koltukları, kapıları düşünmezsiniz, arabayı olduğu gibi düşünürsünüz. Basitçe söylemek gerekirse, bir özne veya nesne açısından düşünürsünüz. Nesne yönelimi, öğelerin nesneler olarak programlama temsilidir.

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

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

Nesne yönelimli programlama, verileri (öznitelikleri) içeren nesnelere ve bu verileri işleyen yöntemlere (işlevsellik) 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 gruplandırmasına izin verir, sınıf, bu verilere erişmek için birbiriyle ilişkili veriler ve işlevler içerebilir.

PHP'deki OOP'nin temelleri, bakımı ve yönetimi daha kolay kod geliştirmenize yardımcı olur. Kodunuz ne kadar temiz ve okunabilir 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 Yönelimli Programlama ile modüler yapıya sahip web sitesi uygulamaları oluşturabiliriz.

PHP OOP eğitimindeki önemli terimler:

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

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 veriler ve işlevler içerir. Veriler ve işlevler özel erişim kimliğine sahiptir. 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

Bir nesne aynı zamanda bir örnek olarak da bilinir. Bir sınıf başlatıldığında, bir nesne oluşturulur. Bir sınıf bir kalıpsa, nesne bir kalıp kullanılarak oluşturulan nihai 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, yalnızca bu sınıfın işlevleriyle 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. Ayrıca diğer sınıflar tarafından görülmezler. Bir nesnenin verilerine erişmek için üye değişkenleri 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 fonksiyon otomatik olarak çağrılır ve sınıf değişkenlerini başlatır.

Yıkıcı

Bu, bir nesne atı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ın) tüm özelliklerini ve işlevlerini aldığı süreçtir.

süper sınıf

Temel veya ana 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 sınıf veya türetilmiş sınıf, alt sınıf üst sınıftan miras alır.

polimorfizm

Bu, OOP'de bir fonksiyonun farklı amaçlar için kullanılabileceği bir olgudur.

kapsülleme

Nesne yönelimli programlamanın en önemli kavramlarından biridir. Bu verilerle çalışan veriler ve işlevler birbiriyle ilişkilidir 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 sahip 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. Sınıf, bir şablon, desen veya şekildir ve bir nesne, o belirli şablon veya şekilden dökülen bir ürün veya parçadır.

Örneğin bir ev alın. Sınıf evin temelidir; boyutları, şekli, kapı sayısı, koridorlar vb. Ancak bu sadece bir proje, evin kendisi değil. Planda yer alan bilgilere dayanarak 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. Yığındı:

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 (plan) beş nesne (ev) oluşturulmuştur. Nesne her zaman onu oluşturmak için kullanılan sınıfta verilen talimatları izleyecektir.

PHP'de OOP'nin Faydaları:

1. Daha iyi mimari ve daha temiz kod

Nesne yönelimli PHP, daha iyi kataloglanır ve paketlenmesi daha kolaydır, bu da optimum mimariye izin verir. Tipik olarak, 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 verileri içeren nesneleri uygulayarak, kod okunabilir ve temizdir.

1. yeniden kullanın

Nesne yönelimli programlama, kodu yeniden kullanılabilir hale getirir. Nesneler bir kez oluşturulduktan sonra tekrar tekrar kullanılabilir. Her şeyi sıfırdan yazmak yerine iş birimlerini birleştirerek programlar oluşturulabilir. Bu zamandan tasarruf sağlar ve üretkenliği artırır.

1. Bakımı ve güncellemesi 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öntemleri ekleyebiliriz.

1. kapsülleme

Kapsülleme, nesnenin değişkenlerinin değerlerinin dışarıdan görünmemesi, dolayısıyla veri güvenliğinin sağlanması anlamına gelir. Ancak ihtiyaç duyulursa, erişim değiştiricileri kullanılarak verilere erişilebilir. Güvenli programlar oluşturmak için bir sınıftaki veriler ve üye işlevler 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 ardından kendi özellikleri ona eklenir. Alt sınıf, üst sınıfın değişkenlerini ve yöntemlerini devralır. Gereksiz kodları kaldırmanın yanı sıra mevcut sınıfların kullanımını genişletebiliriz.

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

Bir dizi PHP OOP öğreticisinin ilkine hoş geldiniz! Bu dizideki tüm dersleri okuduktan sonra, OOP'nin temel ilke ve kavramlarını öğrenecek ve PHP'de hızlı ve kolay bir şekilde faydalı uygulamalar oluşturmayı öğreneceksiniz.

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

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

PHP nesnelerinin dünyasına dalmaya hazır mısınız? O zaman devam et!

Nesneye Yönelik Programlama Nedir?

PHP'de kendi işlevlerinizi oluşturup bunları kullandıysanız, prosedürel bir programlama stili kullanmışsınızdır. Prosedürel programlamada genellikle veri yapıları yaratırsınız - sayılar, diziler, diziler vb. - bazı verileri depolamak ve sonra bu yapıları bu verileri işleyen özel işlevlerle işlersiniz.

Nesneye Yönelik Programlama veya OOP devam etti çünkü burada veri yapılarını ve bunları işleyen 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ğu zaman, 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, kullanıcı adı, e-posta adresi, şifre vb.) ve bu bilgileri işleyecek yöntemleri depolayacak bir Üye nesnesi oluşturmalısınız. (kayıt, yetkilendirme, çıkış, yasaklama vb.).

Neden OOP'u kullanmalısınız?

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 komut dosyasında 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 gönderileri, vb. Bu, uygulamanızı henüz tasarlamaya başladığınızda, her nesnenin amacı olduğundan, görevi büyük ölçüde basitleştirir. , nesneler arasındaki amaç ilişkilerinin yanı sıra açık ve anlaşılır olacaktır.
• Modüler programlar yazmak daha kolaydır: OOP, modül yazmayı içerir. Kodunuzu modüllere bölerek, onu yönetmeniz, hata ayıklamanız ve genişletmeniz daha kolay olacaktır.
• Birçok kez kullanılacak kodu yazmak daha kolaydır: Birden fazla kullanılabilecek kod yazmak, bir uygulama yazarken zamandan tasarruf etmenizi sağlar ve zamanla bu tür modüllerden kullanabileceğiniz bütün bir kitaplık bile oluşturabilirsiniz. birçok uygulama. OOP, veri yapıları ve işlevleri, herhangi bir sayıda kullanılabilecek tek bir nesnede kapsüllendiğinden, bu tür kodları yazmayı nispeten kolaylaştırır.

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 nesne için bir iskelettir. Bu, aşağıdakileri tanımlayan bir kod parçasıdır:

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

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

nesneler

Bir nesne, bir sınıf aracılığıyla oluşturulan özel türde bir değişkendir. Onu işlemek için geçerli veriler ve 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 araba için bir iskelettir: arabanın nasıl görüneceğini ve hareket edeceğini tanımlar, ancak yine de soyut bir varlıktır.
• Bir nesne, bir tel kafesten yaratılan gerçek bir arabadır: gerçek özelliklere (hız gibi) ve davranışına (hızlanma veya yavaşlama gibi) sahiptir.

Not: Bir nesneye genellikle bir sınıfın varlığı denir ve bir sınıfın nesnesini oluşturma işlemine uygulama denir.

sınıf değişkenleri

Bir nesnede saklanan 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, nesnesiyle yakından ilişkilidir. Bir 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 çok farklı değiller - onlara değerler iletebilirsiniz, yerel değişkenler ve dönüş değerleri içerebilirler. Ancak, yöntemlerin nesne değişkenleriyle çalışması daha olasıdır. Örneğin, forumunuzdaki kullanıcıları yetkilendirmek için login () yöntemi, loginIn sınıf değişkeninin değerini true olarak ayarlayabilir.

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

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

İlk olarak, gerçekte nasıl bir sınıf oluşturmanız gerektiğini görelim. Temel olarak, bir sınıf oluşturmak için komut dosyası şöyle görünür:

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ı))

Bu 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 form kuralı: Her sınıfı, sınıf adıyla aynı ada sahip ayrı bir dosyaya koyun. Örneğin Üye sınıfını Member.php dosyasına yerleştirin ve sınıflar diyelim bir klasörde saklayın.

PHP'de nesneleri nasıl oluştururum?

new anahtar sözcüğünü 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 gerekiyor. Örneğin, Üye sınıfından bir nesne oluşturalım ve onu $ üye değişkeninde saklayalım:

$ üye = yeni Üye ();

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

$ üye2 = 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ı ve sınıf nesnelerini nasıl oluşturacağımızı bildiğimize göre, sınıf değişkenlerini nasıl oluşturacağımızı 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 - yani. bunlar okunabilir ve/veya değiştirilebilir - bu kodun nerede olduğuna bakılmaksızın betiğin herhangi bir yerinde - sınıfın içinde veya dışında
• Sınıfın özel değişkenleri (özel): yalnızca sınıfın yöntemleri için kullanılabilir. Nesneleri kodun geri kalanından ayırmak için sınıf değişkenlerini özel yapmak en iyisidir.
• 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öntemleri için kullanılabilir (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şkenin adını girin:

Sınıf SınıfAdı (genel $ propertyName; özel $ propertyName; korumalı $ propertyName;)

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

Sınıf Üyesi (genel $ kullanıcı adı = "";)

Sınıf değişkenimizi başlattığımıza dikkat edin, değeri boş bir “” dizesidir. Bu, yeni bir kullanıcı oluştururken adının varsayılan değerinin boş bir dizeye eşit olacağı anlamına gelir. PHP'deki normal değişkenlerde olduğu gibi, sınıf değişkenlerinin başlatılması gerekmez, 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şme

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

$ nesne-> özellikAdı

Hadi deneyelim. Bir Üye sınıfı ve bir sınıf değişkeni bildiren, bu sınıfın bir nesnesini oluşturan ve ardından sınıf değişkeninin değerini ayarlayan ve görüntüleyen bir komut dosyası yazalım:

kullanıcı adı = "Fred"; echo $ üye-> kullanıcı adı; // "Fred" çıktısı mı?>

Bu kodu çalıştırın, $ üye-> 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 çalışırsınız - ona bir değer ayarlayabilir ve okuyabilirsiniz.

Bir sınıfa metot ekleme

Yöntemler oluşturmaya ne dersiniz? Daha önce bahsettiğim gibi, yöntemler bir sınıfın parçası olan düzenli işlevlerdir. Bu nedenle, aynı function anahtar sözcüğü kullanılarak oluşturulduklarına şaşırmayabilirsiniz. Normal işlevler oluşturmaktan 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: Tıpkı 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ı metotlar ve sınıf değişkenleri eklemeye çalışalım:

• kullanıcı kimliği için özel sınıf değişkeni $ login, yani. gelse de gelmese de
• $ LogIn sınıfı değişkeninin değerini true olarak ayarlayarak foruma giriş yapacak olan login () yöntemi,
• $ loginIn sınıf değişkeninin değerini false olarak ayarlayarak forumdan çıkış yapacak olan logout () yöntemi,
• $ loginIn sınıf değişkeninin değerini döndürecek olan isLoggedIn () yöntemi.

İşte kodumuz:

loginIn = true; ) genel işlev oturumu kapat () ($ this-> loginIn = false;) public function isLoggedIn () (dönüş $ this-> loginIn;))?>

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

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

Bu arada, sınıf değişkenimiz özeldir, bu nedenle betiğin herhangi bir bölümünden değil, yalnızca login (), logout () ve isLoggedIn () yöntemlerinden çağrılabilir. Bu iyi bir yaklaşımdır, çünkü nesnenin içi (örneğin, tam olarak nasıl yazıldığı, kullanıcının oturum açıp açmadığı) kodun geri kalanından ayrıdır. Mümkün olduğunda, nesnelerinizi bağımsız, mobil ve güvenli 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 private yapmanız ve gerekirse kullanıcı adının değerlerini ayarlamak için public sınıfın özel değişkenlerini oluşturmanız gerekir.

yöntemleri kullanma

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

$ nesne-> yöntemAdı ()

Bu, normal bir işlev çağrısı gibi çalışır. Argümanları parantez içinde iletebilirsiniz (elbette herhangi bir argümanı kabul ederse), bir yöntem çağrısı ayrıca daha sonra kullanabileceğiniz belirli değerleri de döndürebilir.

loginIn = true; ) genel işlev oturumu kapat () ($ this-> loginIn = false;) public function isLoggedIn () (dönüş $ this-> loginIn;)) $ üye = yeni Üye (); $ üye-> kullanıcı adı = "Fred"; echo $ üye-> kullanıcı adı. "NS". ($ üye->
"; $ üye-> oturum açma (); echo $ üye-> kullanıcı adı.", ". ($ üye-> isLoggedIn ()?" oturum açmış ":" oturumu kapatmış ")."
"; $ üye-> oturumu kapat (); echo $ üye-> kullanıcı adı." ". ($ üye-> isLoggedIn ()?" oturum açmış ":" oturumu kapatmış ")."
"; ?>

Bu komut dosyası aşağıdakileri görüntüler:

Fred'in oturumu kapatıldı Fred'in oturumu açıldı Fred'in oturumu kapatıldı

İşte nasıl çalıştığı:

1. Üye sınıfını tanımladıktan sonra bir nesne oluşturduk ve onu $ üye değişkenine kaydettik. 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 $ üye-> isLoggedIn() yöntemini çağırdık. Bu yöntem basitçe $ loginIn sınıf değişkeninin değerini döndürür. Bu sınıf değişkeninin varsayılan değeri false olduğundan, $ üye-> isLoggedIn () çağrısının sonucu false olacaktır, bu nedenle "Fred oturumu kapatılmıştır" mesajı görüntülenecektir.
3. Ardından login() metodunu çağırıyoruz. $ LogIn sınıf değişkenini true olarak ayarlayacaktır.
4. Şimdi, $ üye-> isLoggedIn () yöntemini çağırmak true değerini döndürür ve "Fred oturum açtı" mesajını görüntüler.
5. $ loginIn özelliğinin değerini false olarak ayarlayan logout() yöntemini çağıralım.
6. Üçüncü kez $ üye-> isLoggedIn() yöntemini çağıralım. $ LogIn özelliğinin değeri tekrar false olarak ayarlandığından, şimdi false döndürecektir. Böylece, "Fred oturumu kapattı" mesajı tekrar görüntülenecektir.

Not: Bunu ilk kez gördüyseniz:?:, Üçlü bir operatördür. Bu, if… else bloklarının basitleştirilmiş bir versiyonudur. Bu tür operatörler hakkında bilgi edinebilirsiniz.

sonuçlar

Bu eğitimde, PHP'de OOP'nin temellerini öğrendiniz. Şunlar hakkında bilgi edindiniz:

• OOP nedir ve onu kullanmak neden faydalıdır?
• sınıflar, nesneler, sınıf değişkenleri ve yöntemleri 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

Zaten çok şey öğrendiniz ve sonraki derslerde çok daha fazlasını öğreneceksiniz. Ancak size verdiğim tüm örnekler üzerinde çalıştıysanız, sağlam bir temeliniz var demektir. OOP uygulamaları oluşturmaya başlayabilirsiniz.