Dart Nesne Tabanlı Programlama Kuralları

Dart Nesne Tabanlı Programlama Kuralları

Dart Sınıf Kavramı Kuralları :
1. Hiç constructor yazılmaz ise varsayılan constructor Sinifadi() dır.
2. Şayet bir constructor yazılmış ise varsayılan constructor “Sinifadi();” devre dışı kalır, bu şekilde çalışması için ayrıca yazmak sorunludur.
3. constructor lar değer döndüremezler fakat gövdelerine işler yazılabilir.
4. Her dart dosyası bir kütüphane kabul edilir.
5. “_degisken” şeklinde alt tire ile yazılan sınıf öğeleri diğer kutuphaneler için private tır fakat aynı kütüphane içindeki diğer sınıflara public tir.
6. get değer döndürür ve dönüş tipi alırken, set döndürmez ve dönüş tipi almaz.
set ise parametre alabilirken get almaz.

 set ve get kısa yazımı: 
 
String get  xdegisken => _xdegisken;
  set  xdegisken(String xdegisken) => _xdegisken = xdegisken ;
  
set ve get uzun yazımı:
 
String get xdegisken { 
 return _xdegisken; 
} 
 
  void set xdegisken(String xdegisken) { 
 _xdegisken = xdegisken; 
  }

7. new anahtar kelimesi opsiyoneldir. Dart 2.2 den itibaren kullanılmasa da olur.
8. Miras alma “extends” kelimesiyle yapılır.
9. Her sınıf sadece bir sınıftan miras(extends) alabilir.
10. extends ile üst sınıfın üyeleri mevcut hali ile miras alınırak genişletilmiş olur. Üst sınıfın üyeleri override edilebilir fakat extends te amaç kalıtımdır.
11. Miras alınan sınıf parent class/super class olarak isimlendirilir. Miras alan sınıf ise child class/subclass olarak isimlendirilir.
12. Child sınıftan super sınıfın constructor’ına ve metodlarına ve değişkenlerine super.parentinmetodu(parente_deger_gec) şeklinde değer geçilebilir.

super.parent(parente_deger_gec);
Mirasalan_sinif(this.childin_degiskeni):super.(childin_degiskeni); // bu şekilde hem child hem parent class ın constructor ına değer geçilebilir.

Örnek Sınıf tanımlama:

 
class Sinifadi {

String _xdegisken;

Sinifadi(String birdeger) { _xdegisken = birdeger ; print("Değer girildi"); }
Sinifadi.adlandirilmis_constructor(this._xdegisken);

//ikisinden biri kullanılır
//kısa yazım
String get xdegisken => _xdegisken;
set xdegisken(String xdegisken) => _xdegisken = xdegisken ;

//yadauzun yazım ikisinden biri kullanılır
String get xdegisken {
return _xdegisken;
}

void set xdegisken(String xdegisken) {
_xdegisken = xdegisken;
}

//ikisinden biri kullanılır bitti

void ornekmetod (String metin ) {
print("$metin");
}

}

Nesne oluşturma ve kullanım:

Sinifadi SinifadiNesnesi = new Sinifadi("Sinifadi nesnesi oluşturuldu!");
SinifadiNesnesi.ornekmetod("Sinifadi nesnesi ornekmetod fonksiyonu çalıştı");

Dart Interface Kavramı Kuralları:
Override işleminde mevcut değişken ve fonksiyonun tüm parametre tipi, dönüş tipi aynı olmak zorundadır.

Interface/arayuz uygulamak için normal bir sınıf yada abstract sınıf kullanabiliriz.

a. normal bir sınıf : “implements” ile miras alınırsa “Interface” haline gelir.
b. abstract bir sınıf : “implements” yada “extends” ile miras alınırsa “Interface” haline gelir.

a. normal bir sinifi interface yapmak :
Normal bir class ı “extends” le miras aldığımızda normal miras almış oluruz. implements ile miras aldığımızda “interface” yapmış oluruz.

Anahtar cümle: Bir sınıfa bir veya birden çok class “implements” anahtar kelimesiyle miras alınırsa bu sınıfa interface uygulanmış olur, miras alınan sınıfların tüm öğelerinin yeniden yazımı zorunludur.

Kurallar:
1. Her sınıf “interface” olarak uygulanabilir. Özel tanımlama şekli yoktur.
2. “implements” anahtar kelimesiyle diğer class “interface” olarak alınır.
3. “implements” edilen sınıfın her bir değişkeni, fonksiyonu miras alan sınıf tarafından yeniden tanımlanmak zorundadır.
4. Bir sınıf birden çok implements/arayüz uygulayabilir. class Sinifadi implements interface-1,interface_2,interface_4…….

b. abstract bir sinifi interface yapmak :
Anahtar cümle: Bir sınıfa bir veya birden çok abstract class “implements” yada “extends” anahtar kelimesiyle miras alınırsa bu sınıfa interface uygulanmış olur, miras alınan abstract class ların tüm öğelerinin yeniden yazımı “implements” te zorunludur fakat “extends” de zorunlu değildir.

Kurallar:
1. Bir class “abstract” anahtar sözcüğü ile beraber tanımlandığında “abstract sınıf/ özet sınıf / soyut sınıf “haline gelmiş olur.
2. “abstract” sınıflardan nesne üretilemez. Sadece miras alınarak kullanılabilirler.
3. “abstract” sınıfların değişkenleri ve fonksiyonları örtük ve açık yazılabilirler. (değişkenlere ister değer ataması yapılır isterse yapılmaz. aynı şekilde fonksiyonların gövdesi ister yazılır ister yazılmaz.Serbestir.)
4. “abstract” bir sınıf “implements” veya “extends” şeklinde miras alınabilir. implements ile abstract sınıfın tüm öğeleri yeniden tanımlanmak zorundadır, extens ile yeniden tanımlanma zorunluluğu yoktur.
5. Bir sınıf birden çok abstract sınıf uygulayabilir. class Sinifadi implements AbstractOrnekSinif-1,AbstractOrnekSinif_2,AbstractOrnekSinif_4…….

	Örnek:

	void main() { 
	   ConsolePrinter cp= new ConsolePrinter(); 
	   cp.print_data(); 
	}  
	class Printer { 
	   void print_data() { 
		  print("__________Printing Data__________"); 
	   } 
	}  
	class ConsolePrinter implements Printer { 
	   void print_data() {  
		  print("__________Printing to Console__________"); 
	   } 
	} 

final cost

final
1. Final değişkenleri çalışma zamanında başlatılır. Erişildiğinde değer ataması yapılır. Bu yüzden sınıflar nesne haline getirilirken constructor ile değer atanabilir.
2. Bir kere atama yapılabilir bir daha değiştirilemez.
3. Çalışma zamanı sabitidir.
4. Nesne değişkenleri final olabilir ama cost olamaz. final referans tiplidir.

const
1. Derleme esnasında deger ataması yapılır. Program derlemeye başladığında const değişkenin değerini atamak ister, çalışma zamanına bırakamaz o yüzden değer ataması sonraya çalışma zamanına bırakılamaz.
2. Bir kere atama yapılabilir bir daha değiştirilemez.
3. Derleme zamanı sabitidir.
4. Sınıf içerisinde const sabitine ihtiyaç duyulursa “static const” şeklinde yapılmalıdır.

static değişkenler

1. Statik değişkenler kullanılana kadar başlatılmaz. Çalışma zamanı sabitleri dir.
2. Derleme zamanı static değişken yada metod tanımlamanın bir yolu const constructor a bir static değişkeni parametre olarak vermektir.

const constructor Değişmeyen Nesneler Oluşturmak için:
Hiç değişmeyen nesnelere ihtiyacınız varsa, bu nesneleri derleme zamanı sabitleri yapabilirsiniz.
Bunu yapmak için, bir const constructor tanımlayın ve tüm değişkenlerinin final olduğundan emin olun.

Örnek 1:

class ImmutablePoint {
static final ImmutablePoint origin =
const ImmutablePoint(0, 0);

final num x, y;

const ImmutablePoint(this.x, this.y);
}

var degismez_orijin_noktasi = ImmutablePoint.origin;

var a = const ImmutablePoint(1, 1);
var b = const ImmutablePoint(1, 1);

assert(identical(a, b)); // They are the same instance!

Örnek 2:

class ImmutablePoint {
static final ImmutablePoint origin =
const ImmutablePoint(0, 0);

final num x, y;

const ImmutablePoint(this.x, this.y);
}

main(){

var orijin_1 = ImmutablePoint.origin.x;
var orijin_2 = ImmutablePoint.origin.x;

print(orijin_1); // They are the same instance!
print(orijin_2); // They are the same instance!

var a = const ImmutablePoint(0, 0);
var b = const ImmutablePoint(1, 1);

print(identical(a, ImmutablePoint.origin)); // Aynı nesne

print ("${identityHashCode(ImmutablePoint.origin)} ${identityHashCode(a)}");
//HashCode aynı 159648987 159648987 - cost constructor ile kurulan nesne ile statik nesne aynı.
//const constructor sınıflardan aynı parametrelerle oluşturulan nesneler aynı dır.
}

Örnek 3:

class ImmutablePoint {
static final ImmutablePoint origin =
ImmutablePoint(0, 0);

final num x, y;

ImmutablePoint(this.x, this.y);
}

main(){

var orijin_1 = ImmutablePoint.origin.x;
var orijin_2 = ImmutablePoint.origin.x;

print(orijin_1); // They are the same instance!
print(orijin_2); // They are the same instance!

var a = ImmutablePoint(0, 0);
var b = ImmutablePoint(1, 1);

print(identical(a, ImmutablePoint.origin)); // Aynı nesne

print ("${identityHashCode(ImmutablePoint.origin)} ${identityHashCode(a)}");
//HashCode farklı 867978856 883564527 - cost constructor olamadan kurulan nesne ile statik nesne farklı.
//const constructor olmayan sınıflardan aynı parametrelerle oluşturulan nesneler farklıdır.
}

Factory Constructor Kavramı Kuralları:
1. factory constructor, default constructor veya adlandırılmış constructor şeklinde tanımlanabilir.
2. factory constructor return dönüş tipi kendi sınıf tipinde yada subclass sınıfı tipinde olmak sorundadır.
3. abstract class lara factory constructor yazılabilir ve çağrılabilir.
4. factory constructor tanımlanan sınıf içinde default const devre dışı kalır. default constructor factory constructor değilse çalışması için yeniden yazılması gerekir.
5. factory constructor un dönüş tipi yazılmaz, dönüş dipi kendi class yada subclass tipindedir.
6. factory constructor bir fonksiyon gibi davranır gövdesi kendi classının bir örneğini yada subclassın bir örneğini döndürmüyor ise nesne oluşturmuş olmaz null döner.
7. Bir sınıfı nesne haline getirirken daima yeni bir örneğini oluşturmak istemiyor isek diğer bir ifade ile oluşturup oluşturulmamasını denetlemek gibi bir amacımız varsa istiyor isek factory constructor kullanın.
8. Gövdesi boş bir factory constructor nesne oluşturmaz. Fakat factory olmayan normal bir constructor her zaman sınıfın nesnesini oluşturur.
9. factory constructorının this e erişimi yoktur.

Örnek 1:		
		
		class Logger {
		  final String name;
		  bool mute = false;

		  // _cache is library-private, thanks to
		  // the _ in front of its name.
		  static final Map<String, Logger> _cache =
			  <String, Logger>{};

		  factory Logger(String name) {
			if (_cache.containsKey(name)) {
			  return _cache[name];
			} else {
			  final logger = Logger._internal(name);
			  _cache[name] = logger;
			  return logger;
			}
		  }

		  Logger._internal(this.name);

		  void log(String msg) {
			if (!mute) print(msg);
		  }
		}


		var logger = Logger('UI');
		logger.log('Button clicked');


Örnek 2:

	class Symbol {
	  final String name;
	  static Map<String, Symbol> _cache = new Map<String, Symbol>();

	  factory Symbol(String name) {
		if (_cache.containsKey(name)) {
		  return _cache[name];
		} else {
		  final symbol = new Symbol._internal(name);
		  _cache[name] = symbol;
		  return symbol;
		}
	  }

	  Symbol._internal(this.name);
	}


	main() {
	  var x = new Symbol('X');
	  var alsoX = new Symbol('X');

	  print(identical(x, alsoX));  // true
	}

Örnek 3:

	class Symbol {
	  static final Map<String, Symbol> cache = {};
	  final String name;

	  Symbol(name) {
		cache[name] = new Symbol._internal();
	  }

	  Symbol._internal();
	}

	main(){
	var a = new Symbol('something');
	var b = new Symbol('something');

	print(identical(a, b)); // false!
	print(Symbol.cache); //{something: Instance of 'Symbol'}
	}

Örnek 4:

	abstract class Animal {
	  factory Animal(String type) {
		switch(type) {
		  case "cat":
			return new Cat();
		  case "dog":
			return new Dog();
		  default:
			throw "The '$type' is not an animal";
		}
	  }
	}

	class Cat implements Animal {
	}

	class Dog  implements Animal  {
	 
	}
	
	void main() {
  Cat cat = new Animal("cat");
  Dog dog = new Animal("dog");
}

Singleton Kavramı Kuralları:

Singleton düzeni, yalnızca bir sınıfın bir örneğinin oluşturulmasını sağlar.

1. Factory constructor yöntemi

class Singleton {
static final Singleton _singleton = new Singleton._internal();

factory Singleton() {
return _singleton;
}

Singleton._internal();
}

main() {
var s1 = new Singleton();
var s2 = new Singleton();
print(identical(s1, s2)); // true
print(s1 == s2); // true
}

2. Static field with getter yöntemi

class SingletonTwo {

SingletonTwo._privateConstructor();

static final SingletonTwo _instance = SingletonTwo._privateConstructor();

static SingletonTwo get instance { return _instance;}

}

SingletonTwo two = SingletonTwo.instance;

3. Static field yöntemi

class SingletonThree {

SingletonThree._privateConstructor();

static final SingletonThree instance = SingletonThree._privateConstructor();

}

SingletonThree three = SingletonThree.instance;

4. class FileSystem
{
public:
static FileSystem& instance()
{
// Lazy initialize.
if (instance_ == NULL) instance_ = new FileSystem();
return *instance_;
}

private:
FileSystem() {}

static FileSystem* instance_;
};

Bir cevap yazın

KAPAT
%d blogcu bunu beğendi: