HAFTA 1: PROGRAMLAMANIN TEMELLERİ
HAFTA 1: PROGRAMLAMANIN TEMELLERİ
Önce Visual Studio 2008 ortamında yeni bir proje oluşturalım. File-New Project-Console Application ile yeni bir console uygulaması açalım. İsim olarak ise h1orn1 ismini verelim.
|using System; |
|using System.Collections.Generic; |
|using System.Linq; |
|using System.Text; |
| |
|namespace h1orn1 |
|{ |
|class Program |
|{ |
|static void Main(string[] args) |
|{ |
|Console.WriteLine("Bu ilk uygulamamız"); // Arkadaşlar! Ekrana Bu ilk uygulamamız yazacak. |
|} |
|} |
|} |
Şimdi yukarıdaki kod bloğunun bazı özelliklerini giriş seviyesinde açıklayalım. Çünkü daha sonra bu değindiğimiz konular ayrıntılı olarak incelenecektir.
Namespace (İsim Uzayı): C# ortamında metotların ve değişkenlerin her biri sınıfların içinde yer alır. Bu sınıfların sayıları da çok fazla olmaktadır. Erişimi kolaylaştırmak için sınıflar gruplara ayrılır ve birbiriyle ilgili sınıflar namespace ler içine alınırlar. Örneğin yukarıda console sınıfı içindeki WriteLine( ) metodu çalıştırılmıştır. Biz eğer en tepeye using System; satırı ile system isim uzayının kullanılacağını tanımlamasaydık, program Console sınıfınıda tanımayacağı için WriteLine( ) metodu da çalışmayacaktı.
Eğer programımızda bir namespace eklemek istersek using ile birlikte ekleneceğini de öğrenmiş olduk.
Ayrıca ekrana bir yazı yazmak için yapmamız gereken de çift tırnak içinde yazmak şartıyla Console.WriteLine(""); yada Console.Write (""); metodlarını kullanmak olacaktır. Bu ikisi arasındaki farkı aşağıda görelim.
|using System; |
|using System.Collections.Generic; |
|using System.Linq; |
|using System.Text; |
| |
|namespace h1orn1 |
|{ |
|class Program |
|{ |
|static void Main(string[] args) |
|{ |
|Console.WriteLine("Merhaba"); |
|Console.WriteLine("Nasılsınız?"); |
|Console.Write("Ben iyiyim"); |
|Console.Write("Teşekkürler"); |
| |
|} |
|} |
|} |
[pic]
Sınıf(Class): Nesne yönelimli programlamanın temel taşlarıdır. Program içinde kullanılan her değişken, metot ve deyim mutlaka bir sınıf içinde tanımlanır. Örnekte program adında bir sınıf tanımlanmıştır. Bir sınıfta aynı ismi taşıyan 2 öğe olamaz.
Bloklar: Bloklar {} parantezlerini ifade eder. Açılan her parantez mutlaka yeri gelince kapanmalıdır.
Main( )
{
}
Üstteki blok ana program bloğu olup program işletilmeye başlanınca ilk çalıştırılacak kodlar bu blok içinde yer alır.
Açıklama Satırları: Büyük bir kod bloğundan oluşan programı sizden başka kişilerinde okuduğu zaman anlaması gerekli olabilir. Bu durumlarda açıklama satırları ile kodları tanıtabiliriz.
Açıklama satırı tek satır için ise // işaretlerinden sonra yazılan ifadeleri temsil eder. Eğer tek satır değil de alt alta birçok satırdan oluşan açıklama için /* */ ifadeleri arasına yazmak gerekir.
|using System; |
| |
|namespace h1orn1 |
|{ |
|class Hesap |
|{ |
|static int sonuc; |
|static int hesapla(int a, int b) |
|{ |
|int x, y; |
|x = 3 * a; |
|y = b / 2; |
|return x + y; |
|} |
|public static void Main() |
|{ |
|int n; |
|n = hesapla(4,8); |
|sonuc = n; |
|Console.WriteLine(sonuc); |
|} |
| |
|} |
|} |
Yanda metotların kullanımı ile ilgili bir örnek görülmektedir.
İnteger türünde değişkenler (sonuc,x,y,a,b,n) görülmektedir. Bu örnekte hesapla adında bir metodumuz vardır. Bu metot türü int olan 2 adet parametre almaktadır. Bu parametreleri sırasıyla 3 ile çarpar diğerini de 2 ye bölerek sonuçları toplamaktadır. Return ifadesi sayesinde de elde edilen sonuç isteğin yapıldığı yere iletilmektedir. Peki, istek nereden yapılmıştır? Yani metot nereden çağrılmıştır? Bu sorunun cevabı da Main( ) bloğundadır.
hesapla(4,8);
Satırı ile aslında hesapla metoduna 2 adet parametre gönderilmiştir.
*Peki hesapla (2,4,6); şeklinde bir ifade doğru olur mu?
[pic]
*Peki hesapla (2.9 , 4); şeklinde bir ifade doğru olur mu?
static int sonuc; deyimi sınıfa ait sonuç adlı int türünde bir değişken tanımlar. Bu tür değişkenlere sınıf değişkeni denir. Static olarak nitelendirilmiş değişkenler sınıfa ait bir nesne yaratmadan kullanılabilir.
|// KÜRENİN HACMİNİ VE ALANINI VEREN PROGRAM KODU(4/3 * ח* r3) |
| |
|using System; |
|using System.Collections.Generic; |
|using System.Linq; |
|using System.Text; |
| |
|namespace h1orn1 |
|{ |
|class Hesap |
|{ |
|static void Main() |
|{ |
|double hacim, alan, pi, yaricap, kup; |
|string cikis, yaristr; |
| |
|do |
|{ |
|Console.Write("lütfen kürenin yarıçapı giriniz : "); |
|yaristr = Console.ReadLine(); |
|yaricap = Int64.Parse(yaristr); |
|pi = 3; |
|kup = yaricap * yaricap * yaricap; |
|hacim = 4 / 3.0 * pi * kup; |
|Console.WriteLine("girdiginiz yarıçapa göre kürenin hacmi {0}", hacim); |
|alan = 4 * pi * yaricap * yaricap; |
|Console.WriteLine("girdiginiz yarıçapa göre kürenin alanı {0}", alan); |
|Console.WriteLine("Alan ve hacim toplamı {0} iken çarpımları ise {1} dir",alan+hacim,alan*hacim); |
|Console.WriteLine("cıkmak istiyorsanız veya tuşuna basınız "); |
|cikis = Console.ReadLine(); |
|} while ((cikis != "e") && (cikis != "E")); |
| |
|} |
|} |
|} |
Parse: Kullanıcının girdiği sayısal veri ReadLine( ) metodu tarafından string olarak okunur. Okunan bu veriyi olması gereken sayısal veri tipine dönüştürmek için Parse( ) metodu kullanılır.
Yukarıdaki örnekte Console.WriteLine() metodunun formatlı kullanımını görmektesiniz.
***ŞİMDİ SAYFA 28 DEKİ ÖRNEKLERİ İNCELEYELİM.
HAFTA 2: SINIFLAR VE NESNELER
1. Sınıf(Class) ve Nesne(Object) Kavramları
Sınıf nesneyi tanımlayan bir veri türüdür. Nesne ise bir sınıfın aynısını alıp ondan oluşturduğumuz özelliklerini belirlediğimiz canlı modeldir. Daha sonra tekrar kullanmak üzere oluşturulmuş parçalardır. Sınıfı bir mimarın çizdiği ev projesine, nesneyi de bu projeden yapılmış evlere benzetebiliriz. Bu proje kullanılarak istenildiği kadar ev yapılabilir. Yani bir sınıftan istediğimiz kadar nesne kurabiliriz. O nesnelerin yapıları aynıdır ama öz nitelikleri farklıdır.
[pic]
Üstte Ağaç sınıfı ve ağaç sınıfından türetilmiş 2 tane nesne görülmektedir.
Sınıflar, bir proje geliştirdiğimizde o projede kullanılacak genel taslaklardır. Proje içerisinde o taslakları kullanarak şekillendirdiğimiz canlı modellere de nesne denir. Örneğin bir emlak uygulamasında müşteri satış temsilcisi, gayrimenkul gibi varlıklar daha sonra kendilerinden nesne türetilmek üzere birer sınıf olarak tanımlanır. Sınıf daha önce ki konularda işlediğimiz veri tiplerine ek olarak kullanıcı tarafından tanımlanmış yeni bir tiptir.
Sınıflar; değişken, sabitler, fonksiyonlar, metotlar, özellikler, olaylar, yapıcılar, yıkıcılar ve indeksleyiciler gibi öğeler içermektedirler.
Yanda bir ütü sınıfı görülmektedir. Bu Ütünün markası, modeli, rengi, çalıştığı voltajı, ütülediği kumaş cinsleri gibi özellikleri (property) olabilir. Aynı zamanda ütüyü ısıtabiliriz, soğumaya bırakabiliriz, kullanabiliriz. Bunlar ise ütünün metodları (yordamları) olabilir.
2. Sınıf Tanımlamak
Sınıf Class anahtar kelimesi kullanılarak oluşturulur. Aşağıdaki yapı bir değişken ve metot içeren bir sınıfı oluşturmakta kullanılabilir. .NET Framework ortamında tanımlanan tüm sınıflar default olarak System.Object sınıfından türetilmiştir.
|class Sınıfİsmi |
|{ |
|Erişim dönüş_tipi Metod(Parametreler) metod tanımlama alanı |
|{ |
|} |
| |
|Erişim tip değişken; // Değişken tanımlama |
|} |
Erişim: Erişim belirleyicileri ile nesne sahip olduğu üyelere kimin ve hangi şartla erişilebileceğini belirtir. Bir sınıfın erişim öğeleri aşağıdaki değerler olabilir.
Public: Public olarak tanımlanmış bir metot veya özelliğe herhangi bir yerden ulaşmak mümkündür. Herkese açık olarak tanımlayabiliriz.
Private: Bu sıfat ile tanımlanmış metot veya özelliklere sadece tanımlandığı sınıf içerisinden ulaşabiliriz.
Protected: Protected metotlara veya özelliklere tanımlandıkları sınıftan ve bu sınıftan üretilmiş alt sınıflardan ulaşabiliriz.
2.1. Nesne Tanımlamak
Sınıftan bir örnek (instance) yani bir nesne oluşturmak için new anahtar sözcüğü kullanılır. Aşağıda yapı sınıfına ait ev adında bir nesne oluşturulmuştur.
Sınıf_adı nesne_adı = new sınıf_adı( );
Yapi Ev=new Yapi( );// Yapı sınıfından ev adlı bir nesne oluşturulmuştur.
Nesne tanımlandıktan sonra sınıf içindeki metot ve değişkenlere "." işaretinden sonra metot veya değişken ismini yazarak ulaşabiliriz.
| class yapi |
|{ |
|public int kat; |
|public int alan; |
|public int oturan_sayisi; |
|} |
| |
|class yapi_orn |
|{ |
|public static void Main(string[] args) |
|{ |
|yapi villa = new yapi(); //yapi sınıfından villa adında bir nesne oluştur. |
|int alankb; //Kişi Başına Düşen alan |
|villa.kat = 2; |
|villa.alan = 3000; |
|villa.oturan_sayisi = 10; |
|alankb=villa.alan/villa.oturan_sayisi; //kişi başına düşen alan hesaplanıyor. |
|Console.WriteLine("Villanın kat sayısı{0}dır",villa.kat); |
| |
|Console.WriteLine("Villanın Kişi başına Düşen alanı{0} dır.\n"+ |
|"Ayrıca bu villada {1} kişi oturmaktadır", alankb, villa.oturan_sayisi); |
|} |
|} |
|[pic] |
Örnekte yapı sınıfının içindeki değişkenler public olarak tanımlanmasaydı bir hata ile karşılaşacaktır. Daha sonra da anlatılacağı üzere public tanımlaması değişkenlere dışarıdan erişime izin vermektedir. Programlamada kapsülleme denilen bu yöntem güvenlik için önemli bir yer tutmaktadır.
2.2. İç içe sınıf oluşturmak
Aynı isim uzayında olmak şartıyla iç içe sınıflar(nested classes) oluşturulabilir.
ÖRNEK 2
|public class arabalar { |
|public class binek_arabalar { |
| |
|public class sedan_arabalar { |
|public int motorhacmi = 2000; |
|} |
|public class hb_arabalar { |
|public int motorhacmi = 1600; |
|} |
|} |
| |
|public class ticari_arabalar { |
| |
|public class agir_ticari_araba { |
|public string vergi = "yüksek"; |
|} |
|public class orta_ticari_araba { |
|public string vergi = "orta"; |
|} |
| |
|} |
|class oto_karsilastirma { |
|static void Main() { |
|arabalar.binek_arabalar.sedan_arabalar otobinek = new arabalar.binek_arabalar.sedan_arabalar(); |
|arabalar.ticari_arabalar.orta_ticari_araba ototicari = new arabalar.ticari_arabalar.orta_ticari_araba(); |
|Console.WriteLine("Binek sedan arabaların motor hacmi {0} olabilir", otobinek.motorhacmi); |
|Console.WriteLine("orta ticari arabaların vergisi {0} düzeydedirdir",ototicari.vergi); |
| |
|} |
|} |
| |
|} |
| |
|[pic] |
ÖRNEK:
|using System; |
|using System.Collections.Generic; |
|using System.Linq; |
|using System.Text; |
| |
|namespace h1orn1 |
|{ |
|class uygulama |
|{ |
|class Ev |
|{ |
|public static int kapiNo; |
|public static string sokakAdi; |
|} |
|static public void Main() |
|{ |
|Ev.kapiNo = 123; |
|Ev.sokakAdi = "Menekşe"; |
|Console.WriteLine("ADRES:{0} Sokak, No:{1}",Ev.sokakAdi,Ev.kapiNo); |
| |
|} |
|} |
|} |
[pic]
Örnekte bir nesne yaratılmamış onun yerine Ev sınıfının değişkenlerini public static ifadeleriyle tanımlanmıştır. Ev sınıfına ait bir nesne oluşturmadan ev sınıfının kapiNo ve sokakAdi gibi değişkenlerine nasıl erişildi ve değer ataması yapıldı? Bu sorunun cevabı şudur. Derleyici Ev sınıfı için kendiliğinden bir nesne yarattı ve o nesneye sınıfın adını verdi. Ev.kapiNo = 123; deyiminin başındaki Ev adı sınıfın değil bizden habersiz yaratılan ve sınıf ile aynı adı taşıyan nesnenin adıdır.
NOT: Bir sınıfın bazı öğeleri static bazıları static değilse, static öğelere sınıf işaretçisi ile, static olmayan öğelere de nesne işaretçisi ile erişilebilir.
|using System; |
|using System.Collections.Generic; |
|using System.Linq; |
|using System.Text; |
| |
|namespace h1orn1 |
|{ |
|class uygulama |
|{ |
|class Ev |
|{ |
|public static int kapiNo; |
|public string sokakAdi; |
|} |
|static public void Main() |
|{ |
|Ev.kapiNo = 777; |
|Ev eskiev = new Ev(); |
|eskiev.sokakAdi = "yasemin"; |
|Console.WriteLine("ADRES:{0} Sokak, No:{1}",eskiev.sokakAdi,Ev.kapiNo); |
|} } } |
[pic]
NOT: Sınıf değişkenlerinin değerleri nesnelere aynen gitmektedir. Program çalışırken o değerleri nesne içinde değiştirmek mümkündür; ama nesne içindeki değişiklik, sınıf tanımındaki değerleri etkilemez. Örnekte yazlikev nesnesi içinde yapılan değişiklikler sınıf değişkenine yansımamıştır.
|using System; |
|using System.Collections.Generic; |
|using System.Linq; |
|using System.Text; |
| |
|namespace h1orn1 |
|{ |
|class Ev |
|{ |
|public int kapino = 444; |
|public string sokakadi = "papatya"; |
|public void yaz() |
|{ |
|Console.WriteLine("Adres:{0} Sokak, No:{1}", sokakadi, kapino); |
|} |
|} |
|class uygulama |
|{ |
|public static void Main() |
|{ |
|Ev yazlikEv = new Ev(); |
|yazlikEv.yaz(); |
| |
|yazlikEv.kapino = 334; |
|yazlikEv.sokakadi = "Sümbül"; |
|yazlikEv.yaz(); |
| |
|Ev kislikev = new Ev(); |
|kislikev.yaz(); |
| |
| |
|} |
|} |
|} |
[pic]
2.4 This anahtarı
Metotların içinde tanımlanan yerel değişkenler ancak ait olduğu metot içinden erişilir, kendi sınıfından veya başka sınıflardan erişilemez. Bazı durumlarda yerel değişken adları ile sınıf değişken adları aynı olabilir.
|using System; |
|using System.Collections.Generic; |
|using System.Linq; |
|using System.Text; |
| |
|namespace h1orn1 |
|{ |
|public class ozanlar |
|{ |
|public string ad; |
|public void yaz() |
|{ |
|string ad = "Melih Cevdet Anday"; |
|this.ad = "Orhan Veli Kanık"; |
|Console.WriteLine(ad); |
|Console.WriteLine(this.ad); |
| |
|} |
|} |
|class uygulama |
|{ |
|public static void Main() |
|{ |
|ozanlar a = new ozanlar(); |
|a.yaz(); |
|} |
|} |
|} |
[pic]
Örnekte;
string ad = "Melih Cevdet Anday"; ifadesi ad isimli yerel değişkenimize atama yaparken, this.ad = "Orhan Veli Kanık"; ifadesi ad isimli ozanlar sınıfı değişkenine değer ataması yapar. İki değişkenin adı da aynı olmasına rağmen bellekte farklı yerler tahsis edilir.
3. Yapılandırıcılar(Kurucular-Constructors)
3.1 Static ve Dinamik Öğelere erişim
|using System; |
|using System.Collections.Generic; |
|using System.Linq; |
|using System.Text; |
| |
|namespace h1orn1 |
|{ |
|class Ev |
|{ |
|public int kapino = 444; |
|public static string sokakadi = "NERGİS"; |
|public void kapinoyaz() |
|{ |
|Console.WriteLine("Kapı no:{0} ", kapino); |
|} |
|public static void sokakadiyaz() |
|{ |
|Console.WriteLine("Sokak Adı:{0} ", sokakadi); |
|} |
|} |
|class uygulama |
|{ |
|static public void Main() |
|{ |
|Ev yazlikEv = new Ev(); |
|yazlikEv.kapinoyaz(); |
|Ev.sokakadiyaz(); |
| |
| |
|} |
|} |
|} |
[pic]
Yukarıda ev sınıfı içindeki kapinoyaz( ) metodunu çağırmak için yeni bir sınıf nesnesi tanımlamamız gerekti çünkü kapinoyaz( ) metodu dinamiktir. Sokakadiyaz( ) metoduna nesne içinde değil, nesne dışında onlara ana bellekte ayrılan adreslerde erişilebilir. Burada Ev asıl sınıf değil, söz konusu bellek adresini işaret eden referanstır.
3.2 Kurucular(Yapıcılar)
Bir sınıftan nesne oluşturulduğu zaman nesneyi hazırlayan, şekillendiren özel metodlara yapıcı(yapılandırıcı) denir. Dışarıdan parametre alabilirler ancak geriye değer döndüremezler. Nesneleri oluşturmak için kullanılan new operatörü ile tetiklenirler. Yapıcılar sınıf ile aynı ismi taşır. Public olarak tanımlanmaları gerekir.
C# bir sınıf içinde o sınıfın adını alan bir metodu(kurucuyu) başkasının çalıştırmasına asla izin vermez. Sınıfa ait bir nesne kurulur kurulmaz kurucu kendiliğinden çalışır ve üstüne düşen görevi yerine getirir. Kurucular bizim o an ilgilenmediğimiz ama yapılması gereken işleri yaparlar. Birçok zahmetten bizi kurtarırlar. Kurucular short, int, bool gibi değerler almazlar. Eğer sınıfın bir kurucusu yoksa CLR tarafından kendiliğinden sınıfa ait bir nesne yaratılır buna genkurucu denilir. Bir sınıfın istenildiği kadar kurucusu olabilir.(aşkın kurucular)
Aşağıda 2 parametreli bir kurucu tanımlanmıştır. Örnekte Main( ) metodu hiçbir fonksiyon çağırmadı, yalnızca new operatörü ile ev sınıfına ait bir nesne yarattı. Aynı zamanda yapıcıya 2 adet parametre gönderdi. Yapıcı da bu parametreleri alarak ekrana adresi yazdırdı.
|using System; |
|using System.Collections.Generic; |
|using System.Linq; |
|using System.Text; |
| |
|namespace h1orn1 |
|{ |
|class Ev |
|{ |
|int kapino; |
|string sokakadi; |
|public Ev(int n, string s) |
|{ |
|kapino = n; |
|sokakadi = s; |
|Console.WriteLine("ADRES:{0}Sokak, No:{1}",sokakadi,kapino); |
|} |
|} |
|class uygulama |
|{ |
|static void Main() |
|{ |
|new Ev(123,"menekşe"); |
| |
| |
|} |
|} |
|} |
[pic]
3.2.1 Aşkın Kurucular
Bir kurucu tanımlamak için parametrelerin sayısını, sırasını ve tipini değiştirmek gerekecektir. Bu işi yaparken parametrelere yüklendiğimiz için farklı parametrelerle birden çok kurucu tanımlama işine aşırı yükleme (overloading ) denir.
|using System; |
|using System.Collections.Generic; |
|using System.Linq; |
|using System.Text; |
| |
|namespace h1orn1 |
|{ |
|class Ev |
|{ |
|int kapino=123; |
|string sokakadi="menekşe"; |
| |
|public Ev() |
|{ |
|Console.WriteLine("ADRES:{0}Sokak, No:{1}", sokakadi, kapino); |
|} |
| |
|public Ev(int n) |
|{ |
|kapino = n; |
|Console.WriteLine("ADRES:{0}Sokak, No:{1}", sokakadi, kapino); |
|} |
|public Ev(int n, string s) |
|{ |
|kapino = n; |
|sokakadi = s; |
|Console.WriteLine("ADRES:{0}Sokak, No:{1}",sokakadi,kapino); |
|} |
|} |
|class uygulama |
|{ |
|static void Main() |
|{ |
| |
|new Ev(); |
|new Ev(334); |
|new Ev(123,"papatya"); |
| |
| |
|} |
|} |
|} |
[pic]
Aşağıdaki örnekte; Ev ve ofis nesneleri oluşturulduklarında, yapi( ) yapılandırıcısı ile ilk kullanıma hazırlanırlar. Nesnelerin her birine ilk değerleri, parametrelerde belirtildiği şekliyle kendi yapılandırıcısı tarafından atanır.
|class yapi { |
|public int kat; //kat sayısı |
|public int alan; //toplam bina alanı |
|public int oturanlar; //oturan sayısı |
| |
| |
|public yapi(int k, int a, int o){ |
|kat=k; |
|alan=a; |
|oturanlar=o; |
|} |
|public int kisibasialan() { |
| |
|return alan / oturanlar; |
|} |
|public int maxoturan(int minalan) { |
|return alan / minalan; |
|} |
|} |
|class yapi_uygulama { |
|public static void Main() { |
|yapi ev = new yapi(2, 2500, 4); |
|yapi ofis = new yapi(3,4200,25); |
|Console.WriteLine("Ev için 300 metrekarede oturan maksimum kişi"+ev.maxoturan(300)); |
|Console.WriteLine("Ofis için 300 metrekarede oturan maksimum kişi" + ofis.maxoturan(300)); |
|} |
| |
|} |
3. Yıkıcılar(Destructors)
Oluşturulan nesnenin yüklendiği bellekten yok edilmeden hemen önce çalışan metotlara yıkıcı metot denir. Nesne bellekten silinmeden son kez yapacağı işlemleri(açık olan bir database bağlantısını kapamak gibi) yıkıcı metotlara tanımlarız. Tıpkı yapıcılar gibi yazılırlar tek fark başındaki tilda işaretidir.
Aşağıda sipariş sınıfının yıkıcı metodu tanımlanmıştır.
Public class Siparis{
~Siparis(){
}
}
Bir sınıf en fazla 1 tane yıkıcı metoda sahip olabilir. Yıkıcı metotlar parametre almazlar ve geriye değer döndürmezler. Yıkıcı metotla programcı tarafından değil ancak garbage collection tarafından çalıştırılırlar.
HAFTA 3: VERİ TİPLERİ VE DEĞİŞKENLER
Değişken ana bellekte belli bir veri tipine ait değerlerin girilebileceği bir adrestir. Bir değişken bildirimi yapılırken o değişkenin veri tipi mutlaka belirtilir. Bazı durumlarda bir değişkenin tuttuğu verinin başka tiplere dönüşümü söz konusu olabilir(casting).
Bir değişken aşağıdaki şekilde tanımlanır.
Veri_tipi Değişken_adı = İlk_değer;
Burada ilk değer vermek zorunlu değildir.
*Değişkenler Türkçe karakter içermemelidir.
*Sayı ile başlayamazlar.
*Alt çizgi hariç diğer operatörleri(+/&%.=# gibi) içeremezler
*Aynı tipe ait değişkenler aralarına virgül konarak tanımlanabilirler.
İnt a,b,tutar=0;
String musteriAdi,musteriSoyadi;
Byte fizikNotu1;
String ad=”mustafa”;
Char deger=’E’;
Bool mezun=true;
*Matematiksel anlam taşımayan ifadeleri(tc kimlik no, telefon no) sayısal veri tipi olarak seçmemek gerekmektedir.
* Genellikle bölme ve yüzde işlemlerinin uygulandığı değişkenler ondalıklı sayısal tipler ile tanımlanmalıdır.
* Tek bir simge ile temsil edilemeyen karakterler
\n yeni satır
\t tab kadar boşluk
\r satır başı
Geçerlilik Bölgesi:
Bir değişken sınıfın bir öğesi ise, bütün sınıf içinde geçerlidir. Ona sınıfın her metodu her bloğu erişebilir. Sınıfa ait nesne bellekte kaldığı sürece değişken kendini korur.
Bir metot veya döngü veya {} parantezleri ile belirlenen bir blok içinde tanımlı değişkenlere yerel değişkenler diyoruz. Sınıf içinde olup hiçbir blok içinde olmayan değişkenlere de sınıf değişkenleri denir.
Bilgisayarda Bellek
Bilgisayar ortamında veriler;
1. Cache bellek(işlemci içindeki register alanları)
2. Kayıt Ortamları(Harddisk, CD,DVD,Disket..)
3. RAM Bellek
Ortamlarında tutulurlar.
Ram Bellek içinde Stack(Yığın) ve Heap alanları önemli yer tutar.
Stack : LIFO(last input first output) mantığına göre çalışır. Üst üste yığılmış kutuları andırır, son koyulan kutu önce alınır. Ram de en hızlı erişim sağlanan bölgedir. C# daki değer türleri bu bölgede tutulurlar ve doğrudan veriyi taşırlar.
Heap : Tüm referans tiplerinin tutulduğu bellek bölgesidir. Dolayısıyla bir sınıfa ait türetilen nesneler heap bölgesinde tutulur. Nesne için ayrılan adres, bu nesneyi işaret eden referans(işaretçi, pointer) tarafından bilinir. Referans türleri(class, string, object, array, delegate ve pointer) bu alanda depolanmışlardır. Bunlar doğrudan verinin kendisini değil verilerin adresini tutarlar.
Değişken Türleri
A.BAŞVURU(REFARANS )TÜRLERİ
1.Nesne
2.String
B.DEĞER TÜRLERİ
1.Tamsayı
(byte(System.Byte)-short(System.Int16)-int(System.Int32)-long(System.Int64))
8 bit 16 bit 32 bit 64 bit
2.Kesirli Sayı
(float(System.Single)-double(System.Double)-decimal(System.decimal))
32 bit 64 bit 128 bit
3.Karakter
(char(System.Char))
16 bit
4.Diğer
(bool(System.Boolean)-datetime(System.Datetime))
16 bit 32 bit
İyi bir programcı saklayacağı veriler için doğru türü tercih eder.Örneğin evli-bekar gibi 2 olasılık için bool, yaş bilgisi için byte, borsa, trigonometri gibi hassas mat. İşlemleri için double veya decimal, “A” gibi tek karakter için char veri tipi tercih edilmelidir.
NOT:
C# ta yerel bir değişken tanımlandığında bu değişken kullanılmadan önce kendisine ilk değer atanmalıdır.
|using System; |
|namespace h1orn1 |
|{ |
| |
|class uygulama |
|{ |
|static void Main() |
|{ |
| |
|int x; |
|Console.Write(x.ToString()); |
| |
| |
|} |
|} |
|} |
Üstteki kod bloğu x değişkeninin ilk değeri olmadığı için hata mesajı verecektir.
int x=9; şeklinde değiştirilirse hata ortadan kalkar.
C# ta veri türlerini varsayılan değerleri ile kullanmak için değişkenleri tanımlarken new ile ilgili türün yapıcı yordamı çağrılmalıdır.
|using System; |
|namespace h1orn1 |
|{ |
| |
|class uygulama |
|{ |
|static void Main() |
|{ |
| |
|int x = new int(); |
|Console.Write(x.ToString()); |
| |
| |
|} |
|} |
|} |
Üstte kodu çalıştırdığımızda ekranda sıfır değeri görülecektir.
NOT:
|using System; |
|namespace h1orn1 |
|{ |
| |
|class uygulama |
|{ |
|static void Main() |
|{ |
| |
|int x = 5; |
|Console.Write(x.GetType()); |
| |
| |
|} |
|} |
|} |
[pic]
GetType() metodu ile bir değişkenin türü öğrenilebilir.
NOT: Uzun ifadeler aşağıdaki gibi birleştirilerek yazılabilir.
|string metin1 = "Merhaba bu metin örnek olarak hazırlanmış," + |
|"uzun bir metinden oluşmaktadır." + |
|"tek satırda yazmaktan daha kullanışlıdır"; |
Veri Türleri Arasında Dönüşüm
.Net Framework 2 tür dönüşümü destekler.
1. implicit type conversion(Bilinçsiz tip dönüşüm): Derleyicinin bir değişkenin türünü değişkenin değerinde herhangi bir veri kaybına neden olmadan başka bir türe dönüştürmesidir.
2. explicit type conversion(Bilinçli tip dönüşüm): Derleyici desteklemese de programcının dönüştürme operatör veya yordamlarını kullanarak bilinçli olarak 2 türlü birbirine dönüştürmesidir.
Bu 2 dönüşüm türü küçük türün büyük türe yada tersi biçimde gerçekleşir. Küçük türden büyük türe dönüşümde bir veri kaybı yaşanmaz. Short türünden integer veya long türüne dönüşüm gibi. Bu işleme widening (genişletme )denir. Bu işlemi programcının belirtmesine gerek kalmadan derleyici otomatik olarak yapar.
|using System; |
|namespace h1orn1 |
|{ |
| |
|class uygulama |
|{ |
|static void Main() |
|{ |
| |
|byte x = 37; |
|long y = x; |
|Console.Write(y.ToString()); |
|//implicit conversion |
|} |
|} |
|} |
[pic]
• Her hangi bir türden char türüne implicit conversion gerçekleşmez.
• C# ta büyük türlerin küçük türlere dönüşümüne veri kaybından dolayı izin verilmemektedir. Böyle bir dönüşüm için explicit dönüşüm yapılmalıdır.
Aşağıdaki örnekte y değerinin program çalıştırıldığında 40 değerini aldığı görülmüştür. Bu nasıl gerçekleşmiştir?
CEVAP: Aşağıdaki satırları siyah renk yapalım.
Short 16 bit ve byte 8 bit
296 = 0000 0001 0010 1000
40 = 0010 1000
short türünden byte türüne çevrilince soldaki 8 bit dışarıda kalır. Geriye sağdaki 8 bit kalır buda 40 değerine eşittir.
|using System; |
|namespace h1orn1 |
|{ |
| |
|class uygulama |
|{ |
|static void Main() |
|{ |
| |
|short x = 296; |
|byte y ; |
|y = (byte)(x); |
|Console.Write(y.ToString()); |
| |
|} |
|} |
|} |
Bilinçli dönüştürme yapmanın diğer yolu System.Convert fonksiyonlarını kullanmaktır.
[pic]
Bir sayısal veri türünü string türüne çevirmek için o türün .ToString() metodu kullanılır. String türünden sayısal türe çevirmek için ise Parse() metodu kullanılabilir.
|using System; |
|namespace h1orn1 |
|{ |
|class uygulama |
|{ |
|static void Main() |
|{ |
|int b = 66000; |
|string s = b.ToString(); |
|Console.WriteLine(s); |
|//Burada sonuç 66000 olarak ekrana yazılır. |
|int a = Int32.Parse(s); |
|Console.WriteLine(a); |
|//burada da string değeri integer değere çevirdik ve ekrana 66000 yazdırdık |
|} |
|}} |
ÖDEV: Daire diliminin alanını hesaplayan program.
|using System; |
|using System.Collections.Generic; |
|using System.Linq; |
|using System.Text; |
| |
|namespace h1orn1 |
|{ |
| |
|class uygulama |
|{ |
|static void Main() |
|{ |
| |
|string alfastr, yaristr, cikis; // string degiskenleri tanımladıgım satır |
|double alan, alfa, pi, yaricap, kare; // double degiskenleri tanımladıgım satır |
| |
|do |
|{ |
|Console.Write("Alfa sayısını giriniz "); // sayı girmesini istiyorum |
|alfastr = Console.ReadLine();();// degiskeni okutuyorum |
|alfa = Int32.Parse(alfastr));// degiskeni integer'a ceviriyorum |
|Console.Write("Yarı cap sayısını giriniz ");// sayı girmesini istiyorum |
|yaristr = Console.ReadLine();// degiskeni okutuyorum |
|yaricap = Int32.Parse(yaristr);// degiskeni integer'a ceviriyorum |
| |
|pi = 3;// degiskeni bir sayıya ceviriyorum |
|kare = yaricap * yaricap; |
| |
|alan = alfa / 360 * pi * kare; // islem yaptırdıgım satır |
|Console.WriteLine("Daire diliminin alanı {0}", alan);// sonucu ekrana yazdırdıgım satır |
|Console.WriteLine("Çıkmak istiyorsanız yada tuşuna basınız ");// çıkmak istiyorsa |
|cikis = Console.ReadLine();// degiskeni okutuyorum |
|} while ((cikis != "e") && (cikis != "E"));// burda WHİLE komutu ile kontrol ettiriyorum ve aynı zamanda sart kosuyorum |
| |
|} |
|} |
|} |
OPERATÖRLER
Veriler üzerinde matematiksel işlem gerçekleştirmek, onları birbiriyle karşılaştırmak veya onları hesaplamalarda kullanmak için operatörler kullanılır.
Aritmetiksel Operatörler:
= + - * / % ++ --
Int a,b=100;
a=b++; // b değerini önce a değerine atama yapar, sonra b değerini 1 artırır.
// a=100 b=101
a=++b; // Önce b değerini 1 artırır. Sonra b değerini a ya atar.
// a=101 b=101
a=--b; // Önce b değerini 1 azaltır. Sonra b değerini a ya atar.
// a=99 b=99
A=b--; // b değerini önce a değerine atama yapar, sonra b değerini 1 azaltır.
// a=100 b=99
İşlemli Özel Atama Operatörleri
a+=b a=a+b
a-=b a=a-b
a*=b a=a*b
a/=b a=a/b
a%=b a=a%b
İlişkisel Operatörler
İki operant arasında karşılaştırma yapıp bool türünde(true -false) değer döndürür. Sadece birbirleri ile mukayese edilebilir veriler arasında ilişki kurar. Bir metin ile sayı ya da mantıksal değer ile sayı mukayese edilemez.
a= =b //Eşittir
ab //Büyük
a=b //Büyük eşit
a!=b //Farklı
Mantıksal Operatörler
Belirlenmiş koşulları karşılaştırarak bool türünde değer döndürür.
& ve (true&false=false true&true=true false&false=false)
| veya (true|false=true true|true=true false|false=false)
|| koşula bağlı veya
&& koşula bağlı ve
• Koşula bağlı ve(&&) operatörünün & operatöründen farkı; eğer ilk operatör false ise diğer operatöre bakılmaksızın sonuç false olur. İlk operatör true ise diğer operatöre bakılır. Koşula bağlı veya(||) operatörünün | operatöründen farkı; eğer ilk operatör true ise diğer operatöre bakılmaksızın sonuç true olur. İlk operatör false ise diğer operatöre bakılır. Dolayısı ile işlem süresi olarak daha kısa bir sürede çalışırlar.
Operatör Öncelikleri
1. x++ ,x--
2. --x, ++x
3. *, /, %
4. +, -
5. ,=
6. ==, !=
7. &
8. |
9. &&
10. ||
11. Atama(=,+=,….)
**Şimdi kitabımızın 97. sayfasındaki 6. örneği yapalım.
ÖDEV:1. 2. dereceden denklemin köklerini hesaplayan ifadeyi operatörlerin önceliğini de göz önünde bulundurarak program satırı olabilecek şekilde yazınız.
2. x=10 y=5 ise
a. x=++x*(40+y++)
b. x+=y+x--
c. x%=3+ ++y
3 . x=10 başlangıç değeri için x=x+25-6*8/2+6 işleminde x’in son değeri nedir?
HAFTA 4: KONTROL DEYİMLERİ
A.KOŞUL DEYİMLERİ
Programın, belirlenen koşulun sonucuna göre istediğimiz işlemi tercih etmesini sağlayan deyimlerdir. “Eğer böyleyse şöyle yap aksi taktirde böyle yap” şeklinde özetlenebilir.
1.Yapı
if (mantıksal koşul){
işlem1
}
else{
işlem2
}
2.Yapı
if (mantıksal koşul){
işlem1
}
else if (koşul){
işlem2
}
else if (koşul){
işlem3
}.
.
.
else{
işlem n ;
}
Bu programda if yapısı kullanımına bir örnek görülmektedir.
|using System; |
| |
|namespace h1orn1 |
|{ |
| |
|class uygulama |
|{ |
|static void Main() |
|{ |
|string yas; |
|do |
|{ |
|Console.Write("yaşınızı giriniz : cıkmak istiyorsanız -1 giriniz : "); |
|yas = Console.ReadLine(); |
| |
|if (Int32.Parse(yas) >= 50) |
|Console.WriteLine("yaşlısınız "); |
|else if (Int32.Parse(yas) >= 20) |
|Console.WriteLine("gençsiniz "); |
|else if ((Int32.Parse(yas) >= 0) && (Int32.Parse(yas) sayi2) |
|{ |
|buyuksayi = sayi1; |
|if (sayi1 > sayi3) |
|{ |
|buyuksayi = sayi1; |
|} |
|else |
|{ |
|buyuksayi = sayi3; |
|} |
|} |
|else |
|{ |
|if (sayi2 > sayi3) |
|{ |
|buyuksayi = sayi2; |
|} |
|else |
|{ |
|buyuksayi = sayi3; |
|} |
| |
| |
|} |
|Console.WriteLine(""); |
|Console.WriteLine("E büyük sayi {0} dır",buyuksayi); |
| |
| |
|} |
|} |
|} |
3.Yapı
Bu yapıda koşulun sonucu belirli değer veya değerlerle karşılaştırılır. case satırındaki koşullar sağlanmazsa default bölümü yürütülür.
switch (degisken) {
case deger1:
şunu yap
break;
case deger2:
bunu yap
break;
.
.
.
default:
hiç bir şey yapma
break;
}
* Şimdi kitabımızda sayfa 142 deki 4. örneği yapalım
ÖDEV:
1. Bir üçgenin eşkenar ikizkenar ya da çeşit kenar olup olmadığını bulduran program.
2. Klavyeden 1 tuşuna basınca YTL-TL ve 2 tuşuna basınca TL-YTL dönüştüren programı kodlayınız.(switch yapısı kullanınız)
Örnek YTL_TL dönüştürücü
|using System; |
|using System.Collections.Generic; |
|using System.Linq; |
|using System.Text; |
| |
|namespace h1orn1 |
|{ |
| |
|class uygulama |
|{ |
|static void Main() |
|{ |
|int deger; |
|long paraTL, paraYTL; |
|short paraYKR; |
|Console.WriteLine("Seçiminizi yapınız"); |
|Console.WriteLine("YTL-TL çevirmek için [1]'e basınız"); |
|Console.WriteLine("TL-YTL çevirmek için [2]'e basınız"); |
|deger = Int32.Parse(Console.ReadLine()); |
|switch (deger) |
|{ |
|case 1: |
|Console.WriteLine("PAranızın YTL değerini giriniz"); |
|paraYTL = Int64.Parse(Console.ReadLine()); |
|Console.WriteLine("PAranızın YKR değerini giriniz"); |
|paraYKR = Int16.Parse(Console.ReadLine()); |
|paraTL = paraYTL * 1000000 + paraYKR * 10000; |
|Console.WriteLine("{0} YTL {1} YKR olan paranızın çevrilmiş hali {2} TL dir.", paraYTL, paraYKR, paraTL); |
|break; |
| |
|case 2: |
|Console.WriteLine("PAranızın TL değerini giriniz"); |
|paraTL = Int64.Parse(Console.ReadLine()); |
| |
|paraYTL = paraTL / 1000000; |
|paraYKR = Convert.ToInt16(Math.Round((double)(paraTL % 1000000) / 10000, 2)); |
|Console.WriteLine("{0} TL paranız {1} YTL , {2} YKR dir.", paraTL, paraYTL, paraYKR); |
|break; |
|default: |
|Console.WriteLine("yanlış seçim yaptınız"); |
|break; |
| |
|} |
| |
|} |
|} |
|} |
B. DÖNGÜ DEYİMLERİ
1. While Döngüsü:
Koşul gerçekleştiği sürece döngü tekrarlanır. Koşul döngüye girilmeden sınanır.
while(koşul){
işlem
}
2. Do-while Döngüsü:
Koşul gerçekleştiği sürece döngü tekrarlanır. Koşul döngü sonunda sınanır. Yani döngüye girilir ve ilk çevrimin sonunda koşul sınanır. Koşul doğru ise tekrarlanır. Yanlış ise döngüden çıkılır.
do{
işlem
}while koşul
3. For Döngüsü:
Bir deyim önceden belirlenmiş bir sayıda tekrar edilecek ise for döngüsü kullanmak idealdir.
for(x= ; x ................
................
In order to avoid copyright disputes, this page is only a partial summary.
To fulfill the demand for quickly locating and searching documents.
It is intelligent file search solution for home and business.
Related searches
- 1 or 2 374 374 1 0 0 0 1 168 1 1 default username and password
- 1 or 3 374 374 1 0 0 0 1 168 1 1 default username and password
- 1 or 2 711 711 1 0 0 0 1 168 1 1 default username and password
- 1 or 3 711 711 1 0 0 0 1 168 1 1 default username and password
- 1 or 2 693 693 1 0 0 0 1 168 1 1 default username and password
- 1 or 3 693 693 1 0 0 0 1 168 1 1 default username and password
- 1 or 2 593 593 1 0 0 0 1 or 2dvchrbu 168 1 1 default username and password
- 1 or 3 593 593 1 0 0 0 1 or 2dvchrbu 168 1 1 default username and password
- 1 or 2 910 910 1 0 0 0 1 168 1 1 default username and password
- 1 or 3 910 910 1 0 0 0 1 168 1 1 default username and password
- 192 1 or 2 33 33 1 0 0 0 1 1 1 default username and password
- 1 or 2 364 364 1 0 0 0 1 168 1 1 admin username and password