PHP – Soyut Sınıflar

Soyut sınıflar içerisinde en az bir soyut metot bulunduran sınıflardır. Genel amaçları bir çok işi ortak yapan ortak sınıfları bir araya toplamaktır. Aşağıda buna uygun bir örnek verilmiştir.

Soyut sınıf denilmesinin sebebi soyut metotların sınıf içerisinde bir görev yapmaması miras yolu(kalıtım) ile kendinden türeyen sınıflara devretmesidir. Soyut sınıflar kendi içlerinde soyut metotlar dışında somut metotlarda bulundurabilir. Bu metotlar ezilmezler(override).

Metotlar ve veri alanları soyut sınıfta protected ve public olarak tanımlanmalıdır ki türeyen sınıfta kullanılabilsin. Sadece soyut sınıfta kullanılan bir veri alanı ise private olarak ta kullanılabilir.

Soyut sınıfta tanımlanmış bir durumda türeyen sınıfta ezilirken(override) erişim türünde kısıtlama yapılamaz. Örneğin; soyut sınıfta public olarak tanımlanan bir alan türetilmiş sınıfta public olmak zorundadır. Soyut sınıfta protected olarak tanımlanan bir alan protected veya public olmak zorundadır. Genişletilebilir ama daraltma yapılamaz.

Bir sınıfın soyut olarak tanımlanması için class deyiminin önüne abstract deyimi getirilir. Soyut sınıfta metotların soyut olarak belirlenmesi için erişim tipinin önüne veya function deyiminin önüne abstract deyimim getirilmeli ve gövdesiz bir metot olmalıdır. Soyut sınıfın hiç soyut metodu yoksa o sınıf soyut metot olarak işlem görmez.

Soyut metotlarda sınıf dışında bir değişkene atama yapılamaz. Yani new ile bir sınıf kurulumu yapılamaz.

Bir örnek verelim.

<?php
abstract class Soyut
{
    protected $toplam_ödeme;
    abstract public function __construct();
    abstract public function Ödeme($miktar);
 
    public function Ödenen() {
        return $this->toplam_ödeme;
    }
}

<?php

abstract class Soyut

{

protected $toplam_ödeme;

abstract public function __construct();

abstract public function Ödeme($miktar);

public function Ödenen() {

return $this->toplam_ödeme;

}

Yukarıda Soyut adında bir soyut sınıf tanımladık. Soyut sınıfımızı extends ile genişletelim. Ortak iş yapan 2 sınıf oluşturalım.

<?php
class Telefon extends Soyut
{
    public function __construct() {
        $this->toplam_ödeme = 10;
    }
    public function Ödeme($ödeme) {
        $this->toplam_ödeme += 1.1 * $ödeme;
    }
    public function ADSL($ödeme) {
        $this->toplam_ödeme += 1.18 * $ödeme;
    }
}
 
class Dogalgaz extends Soyut
{
    public function __construct() {
        $this->toplam_ödeme = 18;
    }
    public function Ödeme($ödeme) {
        $this->toplam_ödeme += 1.2 * $ödeme;
    }
}

<?php

class Telefon extends Soyut

{

public function __construct() {

$this->toplam_ödeme = 10;

}

public function Ödeme($ödeme) {

$this->toplam_ödeme += 1.1 * $ödeme;

}

public function ADSL($ödeme) {

$this->toplam_ödeme += 1.18 * $ödeme;

}

class Dogalgaz extends Soyut

{

public function __construct() {

$this->toplam_ödeme = 18;

}

public function Ödeme($ödeme) {

$this->toplam_ödeme += 1.2 * $ödeme;

}

Yukarıdaki örnekte Soyut sınıfından Telefon ve Dogalgaz isminde 2 tane somut sınıf türettik. Soyut sınıfından kurucuyu(__construct) ve Ödeme fonksiyonlarını eziyor, Ödenen metodunu ise kalıtım ile miras alıyoruz.

Ödenen metodu 2 sınıfta da aynı işi yapmaktadır. Kurucu metot ve Ödeme metodu kendi sınıflarının belirledikleri görevi yerine getirmektedir.

Sınıflarımızı kurup sonuçları görelim.

<?php
$tel = new Telefon();
$tel->Ödeme(50);
echo $tel->Ödenen();
$dgl = new Dogalgaz();
$dgl->Ödeme(50);
echo $dgl->Ödenen();

<?php

$tel = new Telefon();

$tel->Ödeme(50);

echo $tel->Ödenen();

$dgl = new Dogalgaz();

$dgl->Ödeme(50);

echo $dgl->Ödenen();

sonuçlar:

65
78

Aynı parametreleri girmemize rağmen soyut sınıflar sayesinde sonuçlar farklı çıktı.

Google haritalar kullanımı – Gmaps.js

Şirketiniz veya kendiniz için google mapsi kullanarak konumunuzu adresinizi göstermek isteyebilirsiniz ama malesef ki google maps ile bunu yapmak artık zorlaştı bunun için açık kaynak lı bir eklenti yardımıyla istedigimiz işlemleri kolayca yapabiliyoruz..

Peki bunu nasıl kullanıcam?

http://hpneo.github.io/gmaps/
Eklentiye ulaşmak için yukarıdaki linke tıklayarak örneklere ve kaynak dosyasına ulaşabilirsiniz.

http://hpneo.github.io/gmaps/examples/markers.html

Yukarıdaki örnek en çok kullanılan örneklerden biri.

Github kullanmayan arkadaşlar için indirme linki aşagıda yer almakta.

Google maps indir

Gorillaz – Clint Eastwood

I) PHP Nesne Tabanlı Programlama

Bu bölümde, PHP hakkında nesne tabanlı programlama (OOP – object-oriented programming) üzerine bilgi vermeye çalışacağım.

PHP 5 ile OOP yapısı tamamen desteklenir oldu. OOP’da temel programlama kavramları şunlardır:

Abstraction (Soyutlama)
Polymorphism (Çok biçimlilik)
Encapsulation (Sarmalama)
Inheritance (Kalıtım)

Soyutlama, problemi çözerken ilgili metodların belli parçalar halinde yazılarak kodların basit ve anlaşılır hale getirilmesidir diyebiliriz. Çok biçimlilik ise, yazdığımız nesnenin yada fonksiyonun farklı veri yada giriş değerleri ile kullanılabilmesidir. Sarmalama ise, yazdığınız sınıf içerisindei metodların dışarıdan erişilebilir olup olmamalarını sağladığımız bir çeşit güvenlik katmanıdır diyebiliriz. Son olarak Kalıtım ise, var olan sınıfların kalıtım (miras alınarak) yeniden/istenildiği kadar oluşturululabilmesi.

Nesneler

Nesneler (class) PHP OOP yapısının temel taşıdır. Aslında zaten OOP yapısının temelinde de nesneler vardır. Günümüzde OOP yapısını destekleyen diller için de bu öğreneceklerimiz çoğunlukla geçerli olacaktır.

Nesneler yani class’lar, sizin yarafınızdan yapmak istediğiniz programın amacına uygun olarak yazılır yada başkası tarafından önceden yazılmış nesneler baz alınarak kullanılabilir. Bu nesneler kalıtım olayı ile oluşturulup kullanılır.

class Simple {}
 
$object = new Simple();

class Simple {}

$object = new Simple();

Yukarıdaki minik örnekten yola çıakrsan sınıfımızın isminin Simple olduğunu ve

class Simple {}

1	class Simple {}

ile yazılmaya başlandığını görebiliriz. Elbette bu örnekte sadece nesnemizin adı tanımlanıyor, içerisinde hiçbir metod olmadığından bir işe yaramayacaktır…

$object = new Simple();

1	$object = new Simple();

bölümünde ise $object değişkenimize new Simple() diyerek (miras alma) nesnemizin bir örneğini oluşturuyoruz. Eğer sınıfımızın içinde metodlarımız olsaydı artık bunları alt satırlarda $object değişkenimizin alt metodları/fonksiyonları gibi kullanabilirdik.

Nesne İçerisindeki Değişkenler

Nesne içerisinde değişken kullanımını ve erişimi kısa ve basit bir örnek ile sizlere zenim hazırlamak için açıklamaya çalışacağım. Aşağıdaki örneği inceleyelim;

class Person {
 
    public $name = "";
}
 
$p1 = new Person();
$p1->name = "Değer 1";
 
$p2 = new Person();
$p2->name = "Değer 2";
 
echo $p1->name . "\n";
echo $p2->name . "\n";

class Person {

public $name = "";

}

$p1 = new Person();

$p1->name = "Değer 1";

$p2 = new Person();

$p2->name = "Değer 2";

echo $p1->name . "\n";

echo $p2->name . "\n";

Burada, Person isminde bir sınıfımız var ve içerisinde $name adından public yapıda bir değişkene sahip. Değişkenlerin alabilecekleri yapıları (OOP’un sarmalama özelliğidir) daha sonra göreceğiz.

$p1 = new Person();
$p1->name = "Değer 1";

1 2	$p1 = new Person(); $p1->name = "Değer 1";

Yukarıda, sınıfırmızdan türetip ($p1), sınıf üyesi olan name değişkenine bir değer atıyoruz. Daha sonra aynı işlemi $p2 ile türetip yine name değişkenimize başka bir değer atıyoruz.

echo $p1->name . "\n";
echo $p2->name . "\n";
// Çıktısı
// --------
// Değer 1
// Değer 2

echo $p1->name . "\n";

echo $p2->name . "\n";

// Çıktısı

// --------

// Değer 1

// Değer 2

Daha sonra kodumuzu çalıştırdığımızda $p1 ve $p2 içerisindeki name değerlerini ekrana yazıyoruz.

Burda bilinmesi gereken, gördüğünüz gibi aynı değişkene erişiyoruz ama neden farklı farklı değerler alabiliyor? Çünkü sınıfı 2 ayrı değişkende create ediyoruz ve ikisi için de bellekte farklı yer açılıyor. Yani birbirinden bağımsız olarak çalışıyorlar.

Metodlar

Metodlar, fonksiyonları içerisinde barındıran sınıfların gövdesidir diyebiliriz. Metodlar, OOP’un sarmalama (encapsulation) özelliği ile erişim yapısı istediğimiz gibi şekillendirilebilir. Özellikle büyük projelerde ve sınıflarda sarmalama özelliğini iyi kullanmak ve planlamak gerekir. Her zaman olduğu gibi bi örnek üzerinde bunları irdelersek daha faydalı olacaktır…

class Circle {
 
    public $radius;
 
    function setRadius($radius) {
        $this->radius = $radius;
    }
 
    function area() {
        return $this->radius * $this->radius * M_PI;
    }
}
 
$c = new Circle();
$c->setRadius(5);
 
echo $c->area(), "\n";

class Circle {

public $radius;

function setRadius($radius) {

$this->radius = $radius;

}

function area() {

return $this->radius * $this->radius * M_PI;

}

$c = new Circle();

$c->setRadius(5);

echo $c->area(), "\n";

Yukarıdaki örnekte Circle isminde bi sınıfımız ve içinde 2 metodumuz var.

    public $radius;

1	public $radius;

Burada ise sınıfımız içerisinde bulunan değişkenimiz var (member field). public etiketi ise ona sınıf dışından da erişebileceğimzi anlamına geliyor.

function setRadius($radius) {
    $this->radius = $radius;
}

function setRadius($radius) {

$this->radius = $radius;

}

Burada setRadius isminde bir metodumuz var. Normal bir PHP fonksiyonu farkı yok, ancak sınıflar içerisinde tanımlanan fonksiyonlara method diyoruz. $this değişkeni ise özel bir değişkendir. Sınıf içerisindeki değişkenlerimize (member fields) ulaşmak için kullanıyoruz.

function area() {
    return $this->radius * $this->radius * M_PI;
}

function area() {

return $this->radius * $this->radius * M_PI;

}

Burada ise area metodumuz gerekli hesaplamaları yaparak return ile sonucu döndermekte.

Burada, metodlara genel bir bakış yapmış olduk.

Erişim Belirteçleri

Yukarıda bahsi geçen public tanımını hatırlıyorsunuz umarım, şimdi o konu üzerinde konuşacağız. PHP 5′de 3 tane erişim tipi vardır. public, private ve protected.

public, her yerden erişilebilir anlamına gelir. Hem sınıf içindeki metodlar erişir hem de sınıftan miras alıp oluşturduğumuz değişken üzerinden erişilebilir yani kalıtım yolu ile aktarılırlar.
private, bu erişim belirteci sadece sınıfın içinden erişilebileceği anlamına gelir. Bu öğeler kalıtım yoluyla aktarılmaz.
protected, bu erişim belirteci sadece sınıfın içinden erişilebileceği fakat alt sınıflara aktarılabileceği anlamına gelmektedir (extends ile)

extends

Eğer sınıfımız başka bir sınıfın alt sınıfı olacaksa extends anahtar sözcüğü ile aktarılır.

Şimdi, bir örnek ile görelim.

class Base {
 
    public $name = "Base";
    protected $id = 6124;
    private $is_defined = "yes"; 
 
}
 
class Derived extends Base {
 
    public function info() {
        echo "This is Derived class\n";
        echo "Members inherited: \n";
 
        echo $this->name . "\n";
        echo $this->id . "\n";
        echo $this->is_defined . "\n";
    }
}
 
$derived = new Derived();
$derived->info();

class Base {

public $name = "Base";

protected $id = 6124;

private $is_defined = "yes";

}

class Derived extends Base {

public function info() {

echo "This is Derived class\n";

echo "Members inherited: \n";

echo $this->name . "\n";

echo $this->id . "\n";

echo $this->is_defined . "\n";

}

$derived = new Derived();

$derived->info();

Burada, koda baktığımızda çoğu şeyi biliyoruz tek bilmediğimiz extends bölümü olabilir.

class Derived extends Base

1	class Derived extends Base

Burada Derived sınıfı Base sınıfından türetiliyor. Bunun anlamı Base sınıfı içerisindeki değişkenler ve var olsaydı metodları Derived sınıfına aktarıyor manasına gelmekte. Yukarıda erişim belirteclerini hatırlarsak ve bu kodu çalıştırdığımızda Base sınıfındaki değişkenler içinde sadece private $is_defined = “yes”; bölümünün Derived içerisine aktarılmadığını görüyoruz. Bu da sarmalama konusunun ne olduğunu bize açıklamış oluyor.

Kısaca, public heryerden ulaşılır ve aktarılır extends ile… private, sınıf içinden ulaşılır sadece ve extends ile aktarılabilir… protected ise sınıf içinden ulaşılır ancak extends ile aktarılamaz.

Yapılandırıcı

Yapılandırıcılar, sınıfların miras alındıkları anca otomatik tetiklenecek metoddur. Hemen örnekleyelim;

class Song {
 
    function __construct($song) {
        echo "Song $song is created \n";
    }
}
 
$song = new Song("Bad romance");

class Song {

function __construct($song) {

echo "Song $song is created \n";

}

$song = new Song("Bad romance");

Yukarıdaki örnekte görüldüğü gibi Song sınıfımızı miras aldığımız bölümde new Song(“Bad romance”); şeklinde parametre gönderebiliyoruz. Bu parametre de yapılandırıcı (__construct) içerisinde echo ile ekrana basılıyor. Elbette __construct metodu, parametresiz ayda bir yada birden fazla parametre çeklinde olabilir. İhtiyacımıza göre düzenleyebiliriz.

__toString() Metodu

Sınıfımızı create edip print yada echo ile ekrana basmak istersek __toString Metodu varsa eğer otomatikman devreye giriyor. Çok kullanılan bir tanım olmasa da sınıfımızı test/debug ederken işimize yarar. Örnek;

class Cat {
 
    public $name;
    public $age;
 
    function __construct($name, $age) {
        $this->age = $age;
        $this->name = $name;
    }
 
    function __toString() {
        return "Cat: $this->name, Age: $this->age \n";
    }
 
}
 
$missy = new Cat("Missy", 6);
$lucky = new Cat("Lucky", 4);
 
print $missy;
echo $lucky;
 
// Çıktısı
// ---------
// Cat: Missy, Age: 6
// Cat: Lucky, Age: 4

class Cat {

public $name;

public $age;

function __construct($name, $age) {

$this->age = $age;

$this->name = $name;

}

function __toString() {

return "Cat: $this->name, Age: $this->age \n";

}

$missy = new Cat("Missy", 6);

$lucky = new Cat("Lucky", 4);

print $missy;

echo $lucky;

// Çıktısı

// ---------

// Cat: Missy, Age: 6

// Cat: Lucky, Age: 4

Kalıtım

Nesneye yönelik programlamanın temellerinden olan kalıtım (inheritance), yeni sınıflar yazarken elimizde var olan eski sınıfları kullanmamızı sağlar. Yeni sınıfın bir çok özelliği eski yazılan sınıfla aynıdır. Kalıtım yoluyla yeni sınıfta bu üyeleri (metodları) tekrardan yazmaya gerek kalmaz. Bazı üyeler ise farklıdır (Eğer tüm üyeler aynı olsa yeni sınıf yazmaya gerek kalmazd!). Eğer bu üyelerin tanımlamaları superclass’ta (üst sınıfta) mevcutsa, bu durumda bunlar farklılastırılır (overriding). Eğer yeni eklenecek üyelerin prototipleri superclasst’ta mevcut değilse bunlar direkt olarak yeni sınıfa (subclass) eklenebilir.

Kalıtım, yazılımın yeniden kullanılması ihtiyacına büyük ölcüde katkıda bulunur. Zaten kalıtım kavramının ortaya cıkmasının sebebi, özellikle büyük çaplı yazılım geliştirme çalışmalarında aynı kod parcalarının tekrar tekrar kullanılmasını önlemek ve yeni sınıfları var olanların üstüne inşa etmektir. Gerçek hayattaki nesne modeli de buna uygundur.

class Base {
    function __construct() {
       echo "Construction of Base class \n";
    }
}
 
class Derived extends Base {
    function __construct() {
        parent::__construct();
        echo "Construction of Derived class \n";
    }
}
 
$obj1 = new Base();
$obj2 = new Derived();

class Base {

function __construct() {

echo "Construction of Base class \n";

}

class Derived extends Base {

function __construct() {

parent::__construct();

echo "Construction of Derived class \n";

}

$obj1 = new Base();

$obj2 = new Derived();

Yukarıdaki örnekte önemli olan nokta, Deriven’ın yapılandırıcı bölümündeki parent::__construct(); satırıdır. Burdan görülüyor ki, parent:: ile superclass’a ulaşabiliyoruz ve onun yapılandırıcısını tetikleyebiliyoruz. Umarım parent anahtar kelimesinin de ne iş yaptığını anlamış olduk.

Şimdi, biraz daha derin bir örnek yapalım,

abstract class Being { 
    protected $isAlive = true;
 
    public function isAlive() {
        if ($this->isAlive) {
            echo "Being is alive\n";
        } else {
            echo "Being is not alive\n";
        }
    }
 
    public function kill() {
        $this->isAlive = false;
    }
 
}
 
abstract class Animal extends Being {
 
    protected $age;
 
    public function __construct($age) {
        $this->age = $age;
    }
 
    protected function setAge($age) {
        $this->age = $age;
    }
 
    public function getAge() {
        return $this->age;
    }
}
 
class Cat extends Animal {
 
    private $name;
 
    public function __construct($name, $age) {
        $this->name = $name;
        parent::__construct($age);
    }
 
    public function getName() {
        return $this->name;
    }
}
 
$cat = new Cat("Cici", 4);
$cat->isAlive();
echo $cat->getName() . " is " .  $cat->getAge() . " years old\n";
$cat->kill();
$cat->isAlive();

abstract class Being {

protected $isAlive = true;

public function isAlive() {

if ($this->isAlive) {

echo "Being is alive\n";

} else {

echo "Being is not alive\n";

}

public function kill() {

$this->isAlive = false;

}

abstract class Animal extends Being {

protected $age;

public function __construct($age) {

$this->age = $age;

}

protected function setAge($age) {

$this->age = $age;

}

public function getAge() {

return $this->age;

}

class Cat extends Animal {

private $name;

public function __construct($name, $age) {

$this->name = $name;

parent::__construct($age);

}

public function getName() {

return $this->name;

}

$cat = new Cat("Cici", 4);

$cat->isAlive();

echo $cat->getName() . " is " . $cat->getAge() . " years old\n";

$cat->kill();

$cat->isAlive();

Şimdi, burada yeni birkaç tanım kullandık. Öncelikle 2 sınıfımızın olduğunu hatırlayalım Being, Animal ve Cat. Animal sınıfı Being sınıfından kalırım alır, Cat sınıfı da Animal sınıfından kalıtım almakta.

abstract class Being {

1	abstract class Being {

Being sınıfı abstract tanımlanmıştır. Abstract (soyut) nedir? Az sonra…

abstract class Animal extends Being {

1	abstract class Animal extends Being {

Yine burada Animal sınıfını abstract olarak yine diğer bir abstract olan Being sınıfından extends ile miras alıyoruz.

class Cat extends Animal {

1	class Cat extends Animal {

Burada ise artık dışarıdan erişip kullanacağımız ana sınıfımızı tanımlıyoruz. Tabi Cat sınıfından türeterek…

Kodu çalıştırdığımızda göreceğimiz şey söyledir;

Being is alive
Cici is 4 years old
Being is not alive

Being is alive

Cici is 4 years old

Being is not alive

Soyut Sınıflar (abstract)

Soyutlama (Abstraction) sayesinde bir nesne, spesifik tanımlamalar ve sadece o nesneye ait olabilecek detaylardan kaçınarak, ayrıntılarda boğulmadan kullanılabilir.

Soyutlama: Her zaman ve her sartta kullanılmaya uygun, mümkün olan bütün kosullar ve oluşabilecek hatalar göz önünde bulundurularak yazilmis ve özel olmayip genel olarak kullanilabilen fonksiyonlar kullanimi olarak tanimlayabiliriz.

Devamını okumak için tıklayınız…

Bir örnek verirsek;

abstract class Drawing {
    protected $x = 0;
    protected $y = 0;
 
    public abstract function area();
 
    public function getCoordinates() {
        echo "\$x is $this->x\n";
        echo "\$y is $this->y\n";
    }
}
 
class Circle extends Drawing {
 
    private $radius;
 
    public function __construct($x, $y, $r) {
        $this->radius = $r;
        $this->x = $x;
        $this->y = $y;
    }
 
    public function area() {
        return $this->radius * $this->radius * pi();
    }
 
   public function __toString() {
       return "Circle, at x: $this->x, y: $this->y, radius: $this->radius";
   }
 
}
 
$o = new Circle(12, 45, 22);
echo "$o \n";
echo "Area of the circle: " . $o->area() . "\n";
echo $o->getCoordinates();

abstract class Drawing {

protected $x = 0;

protected $y = 0;

public abstract function area();

public function getCoordinates() {

echo "\$x is $this->x\n";

echo "\$y is $this->y\n";

}

class Circle extends Drawing {

private $radius;

public function __construct($x, $y, $r) {

$this->radius = $r;

$this->x = $x;

$this->y = $y;

}

public function area() {

return $this->radius * $this->radius * pi();

}

public function __toString() {

return "Circle, at x: $this->x, y: $this->y, radius: $this->radius";

}

$o = new Circle(12, 45, 22);

echo "$o \n";

echo "Area of the circle: " . $o->area() . "\n";

echo $o->getCoordinates();

Çalıştırdığımızda çıktısı şu şekilde olacaktır;

Circle, at x: 12, y: 45, radius: 22
Area of the circle: 1520.53084434
$x is 12
$y is 45

Circle, at x: 12, y: 45, radius: 22

Area of the circle: 1520.53084434

$x is 12

$y is 45

Soyutlama konusunda internet üzerindeki diğer yazıları okumanızı tavsiye ederim.

Arayüzler (Interfaces)

Nesne arayüzleri, bir sınıfın gerçeklemesi gereken yöntemlerin belirtildiği kodu, bu yöntemlerin nasıl yönetileceğini tanımlamaksızın oluşturmanıza imkan sağlar.

Arayüzler, standart sınıflardan farklı olarak hiçbir yöntemin içeriği tanımlanmaksızın interface anahtar sözcüğü kullanılarak tanımlanırlar.

Bir arayüzdeki tüm yöntemler, arayüzün doğası gereği public olarak bildirilmelidir.

implements işleci

Bir arayüzü gerçeklemek için, implements işleci kullanılır. Arayüzdeki tüm yöntemler bir sınıf içersinde gerçeklenmelidir; aksi takdirde bir ölümcül hata alırsınız. Bir sınıfın, birden fazla arayüz tanımlaması arayüzler virgülle ayrılarak sağlanabilir.

Örnek verirsek;

interface IInfo {
    public function do_inform();
}
 
class Some implements IInfo {
 
    public function do_inform() {
        echo "This is a Some class\n";
    }
}
 
$sm = new Some();
$sm->do_inform();

interface IInfo {

public function do_inform();

}

class Some implements IInfo {

public function do_inform() {

echo "This is a Some class\n";

}

$sm = new Some();

$sm->do_inform();

Burada öncelikle genel programlama yapısı gereği interface tanımlamaları standart olarak “I” harfi ile başlar. Elbet şart değildir ama okunurluk ve alışkanlıklar olarak öyle kullanılsa iyi olur.

interface IInfo {
 public function do_inform();
}

interface IInfo {

public function do_inform();

}

arayüzümüzü tanımlıyoruz ve içine do_inform metod başlığımızı tanımlıyoruz. Bilindiği üzere interface’de sadece metod başlıkları tanımlanır, metodun gövdesi implement edilen sınıfta yazılır. Örnektede bu şekilde, echo metodu implement edilen sınıfımızın içindeki metodda yer almakta.

Çok Biçimlilik (Polymorphism)

Çok biçimlilik (Polymorphism), kalıtım (Inheritance) ile iç içe geçmiş ilk bakışta karışık gibi görünen, hatta ne gerek var bunlara dedirten, bir yapıya sahiptir. Fakat işin içerisine girdikten sonra ne gibi kolaylıklar ve güzellikler sağladığını görünce dil tasarımcılarına hakkını teslim etmek kaçınılmaz oluyor. En genel anlamda, oluşturduğumuz nesnelerin gerektiğinde kılıktan kılığa girip başka bir nesneymiş gibi davranabilmesine çok biçimlilik diyebiliriz.

Örneklersek;

abstract class Shape {
 
    private $x = 0;
    private $y = 0;
 
    public abstract function area();
}
 
class Rectangle extends Shape {
 
    function __construct($x, $y) {
        $this->x = $x;
        $this->y = $y;
    }
 
    function area() {
        return $this->x * $this->y;
    }
}
 
class Square extends Shape {
 
    function __construct($x) {
        $this->x = $x;
    }
 
    function area() {
        return $this->x * $this->x;
    }
}
 
$shapes = array(
    new Square(5),
    new Rectangle(12, 4),
    new Square(8)
);
 
foreach ($shapes as $shape) {
    echo $shape->area() . "\n";
}

abstract class Shape {

private $x = 0;

private $y = 0;

public abstract function area();

}

class Rectangle extends Shape {

function __construct($x, $y) {

$this->x = $x;

$this->y = $y;

}

function area() {

return $this->x * $this->y;

}

class Square extends Shape {

function __construct($x) {

$this->x = $x;

}

function area() {

return $this->x * $this->x;

}

$shapes = array(

new Square(5),

new Rectangle(12, 4),

new Square(8)

);

foreach ($shapes as $shape) {

echo $shape->area() . "\n";

}

Çok biçimlilik konusunda yine internetteki başka kaynaklardan yararlanın.

GİT Kurulumu ve BRANCH

GİT

yüklemek için;
sudo apt-get install git
sudo apt-get install vim(Vim bir metin düzenleyicidir.)

#mkdir git
#cd git
#git init
#vim git.txt (bişeyler yazın kaydedin)
#git add git.txt
#git commit -m “yeni bir git.txt dosyası eklendi”
#git status

BRANCH

#git branch(git init yazıldığında otomatik olarak oluşur)
#git branch new_branch
#git branch(hangi branch de olduğumuzu gösterir)
#git checkout new_branch(branch değişimi için)
#git merge new_branch(branch birleşimi yapar)

Python Programlamaya Giriş (py)

# –– coding:utf-8 –– (türkçe karakterleri kullanmak için yazmalıyız)
dipnot:

Programların dönüş degerlerindeki türkçe karakterler ortak kullanılabilirliği azaltmaktadır.

print "Selam Linux kampı"

1 2	print "Selam Linux kampı"

Selam Linux Kampı

print "Merhaba"

1 2	print "Merhaba"

merhaba

print 5 + 6

1 2	print 5 + 6

11

print 4*5 + 7

1 2	print 4*5 + 7

27

print 15 / 7

1 2	print 15 / 7

2

print 15 /9.0

1 2	print 15 /9.0

1.5306122449

print 15 &gt; 5

1 2	print 15 > 5

True

print 56 &lt; 6

1 2	print 56 < 6

False

print "2 arti 2 nin toplami:", 2 + 2

1 2	print "2 arti 2 nin toplami:", 2 + 2

2 arti 2 nin toplami:4

degisken = "Berna"
degisken

degisken = "Berna"

degisken

Berna

x = "ynin degeri %d" % y
x

x = "ynin degeri %d" % y

‘ynin degeri 15’

b = "merhaba " * 10
print x

b = "merhaba " * 10

print x

10 defa merhaba yazar

PHP Türkçe karakterleri ingilizceye Çevirmek

Aşağıdaki kodları kullanarak türkçe karakterleri temizleyebilirsiniz.

$bul="Türkçe Metin";
$bulunacak = array('ç','Ç','ı','İ','ğ','Ğ','ü','ö','Ş','ş','Ö','Ü',',',' ','(',')','[',']'); 
$degistir  = array('c','C','i','I','g','G','u','o','S','s','O','U','','-','','','',''); 
 
$sonuc=str_replace($bulunacak, $degistir, $bul); 
echo $sonuc;

$bul="Türkçe Metin";

$bulunacak = array('ç','Ç','ı','İ','ğ','Ğ','ü','ö','Ş','ş','Ö','Ü',',',' ','(',')','[',']');

$degistir = array('c','C','i','I','g','G','u','o','S','s','O','U','','-','','','','');

$sonuc=str_replace($bulunacak, $degistir, $bul);

echo $sonuc;

Sonuç: Turkce-Metin

Laravel PHP Framework Kurulumu

Şu sıralar uğraşmaktan zevk aldığım, hakkında yeni şeyler öğrenmek için yanıp tutuştuğum PHP Framework olan Laravel’i sizlere takdim edeyim. Bugün size Laravel‘in Windows üzerinde kurulumunu göstereceğim.

Öncelikle localhost olarak ben WAMP kullanıyorum sizlere de tavsiye ederim. Kurulumuda WAMP üzerinden anlatacağım için yüklemenizde fayda görüyorum.

WAMP’ı da yükledikten sonra Laravel’in son sürümünü sitesinden indiriyoruz.
Devamını Oku →

Merhaba dünya!

WordPress’e hoş geldiniz. Bu sizin ilk yazınız. Bu yazıyı düzenleyin ya da silin. Sonra blog dünyasına adım atın!