Zonguldak Bülent Ecevit Üniversitesi'nde yürüttüğüm lisans ve önlisans derslerine ait haftalık materyaller, pratik laboratuvar uygulamaları ve proje içerikleri. Öğrencilerimizin teorik bilgileri gerçek dünya senaryolarıyla deneyimlemeleri amaçlanmaktadır.
Kariyer Planlama
Kariyer Planlama dersi, öğrencilerin ilgi alanları, yetenekleri ve mesleki hedefleri doğrultusunda bilinçli kariyer kararları almalarını destekler. Bu eğitim sürecinde öz farkındalık oluşturma, iş dünyasının güncel beklentilerini anlama, etkili özgeçmiş hazırlama teknikleri, mülakat simülasyonları ve uzun vadeli kariyer gelişim stratejileri ayrıntılı olarak ele alınmaktadır. Öğrencilerin akademik eğitimlerini profesyonel hayata entegre etmeleri ve iş yaşamına daha hazırlıklı, özgüvenli ve planlı bir şekilde adım atmaları temel amaçtır.
Bu ders, bilgisayar sistemlerinin temelini oluşturan işletim sistemlerinin yapısını ve işleyişini
incelemeyi amaçlar. Süreç yönetimi, bellek yönetimi, dosya sistemleri ve donanım kaynaklarının
etkin
kullanımı dersin temel konuları arasındadır. Öğrencilerin, farklı işletim sistemlerini
karşılaştırabilmesi ve temel sistem yönetimi becerileri kazanması amaçlanır.
Bilgisayar Donanımı dersi, bir bilgisayar sistemini oluşturan temel donanım bileşenlerini ve bu
bileşenlerin görevlerini açıklamayı hedefler. Anakart, işlemci, bellek, depolama birimleri ve
çevre
birimleri ders kapsamında ayrıntılı olarak incelenir. Öğrencilerin donanım bileşenlerini
tanıyabilmesi, uyumluluk değerlendirmesi yapabilmesi ve temel donanım sorunlarını giderebilmesi
amaçlanır.
Bilgisayarların ve diğer ağ cihazlarının birbirleriyle nasıl iletişim kurduğunu temelden ele
alır. Derste ağ türleri, ağ topolojileri, temel donanımlar (anahtar, yönlendirici, modem) ve
protokoller tanıtılır. Ayrıca OSI ve TCP/IP modelleri, IP adresleme ve temel ağ güvenliği
kavramlarına giriş yapılır.
Programlama, bilgisayarlara veya dijital cihazlara belirli bir işi nasıl yapacaklarını adım adım
anlatma sürecidir. Bu süreçte, bir problemi çözmek veya bir ihtiyacı karşılamak amacıyla
algoritmalar oluşturulur ve bu algoritmalar programlama dilleri (örneğin Python, Java, C#,
JavaScript) kullanılarak bilgisayarın anlayabileceği komutlara dönüştürülür. Programlama
sayesinde yazılımlar, web siteleri, mobil uygulamalar, oyunlar ve yapay zekâ sistemleri
geliştirilebilir. Programlama; mantıksal düşünme, problem çözme ve analitik becerileri
geliştiren temel bir bilişim disiplinidir.
Yapay zekâ; makine öğrenmesi, derin öğrenme, doğal dil işleme, görüntü tanıma ve uzman sistemler
gibi alt alanları kapsar. Günümüzde yapay zekâ, akıllı asistanlar, yüz tanıma sistemleri, öneri
motorları, otonom araçlar, sağlıkta hastalık teşhisi ve eğitim teknolojileri gibi birçok alanda
aktif olarak kullanılmaktadır. Amaç, insanlara yardımcı olan, verimliliği artıran ve karmaşık
sorunlara hızlı çözümler üretebilen akıllı sistemler geliştirmektir.
Mobil uygulama, akıllı telefonlar ve tabletler gibi mobil cihazlarda çalışmak üzere tasarlanmış
yazılımlardır. Bu uygulamalar, kullanıcıların günlük ihtiyaçlarını karşılamak, bilgiye hızlı
erişim sağlamak, eğlence sunmak veya belirli bir hizmeti mobil ortamda kullanılabilir hâle
getirmek amacıyla geliştirilir. Mobil uygulamalar; Android ve iOS gibi mobil işletim sistemleri
için özel olarak üretilir ve genellikle Google Play Store veya Apple App Store üzerinden
kullanıcılara sunulur.
Bu ders, algoritmik düşünme ve problem çözme becerilerinin geliştirilmesini amaçlayan temel
programlama eğitimini kapsar. Değişkenler, kontrol yapıları, döngüler ve temel veri yapıları
dersin
ana konuları arasındadır. Öğrencilerin, seçilen bir programlama dili aracılığıyla mantıksal ve
sistematik çözüm üretebilme yetkinliği kazanması hedeflenir.
Kurumsal Kaynak Planlama (ERP) Sistemleri dersi, modern işletmelerin tüm departmanlarını ve iş
süreçlerini tek bir çatı altında entegre eden yazılım mimarilerini kapsar. Ders boyunca veri
tabanı tasarımı, lojistik, CRM, finansal raporlama, insan kaynakları entegrasyonu ve iş zekası
gibi ERP modülleri teorik ve uygulamalı olarak ele alınmaktadır. Öğrencilerin, kurumsal
kaynakların analitik olarak yönetilmesi ve iş süreçlerinin optimize edilmesi yetkinliklerini
kazanması hedeflenir.
Web Tasarımı dersi, internet ortamında kullanıcı dostu ve işlevsel web siteleri geliştirmeye
yönelik
temel bilgileri kapsar. Ders kapsamında HTML, CSS ve temel istemci tarafı betikleme teknikleri
ele
alınır. Öğrencilerin, görsel tasarım ilkelerine uygun, erişilebilir ve dinamik web sayfaları
oluşturabilmesi hedeflenir.
C# programlama dili ile Windows Form uygulamaları geliştirme, olay tabanlı programlama
(Event-Driven Programming) ve kullanıcı arayüzü tasarımı konularını içerir. Öğrenciler, görsel
araçları kullanarak masaüstü uygulamaları geliştirmeyi ve kullanıcı etkileşimlerini yönetmeyi
öğrenirler.
Bu ders, sunucu sistemlerinin kurulumu, yapılandırılması ve yönetilmesine yönelik temel bilgi ve
becerileri kazandırmayı amaçlar. Ders kapsamında sunucu işletim sistemleri, kullanıcı ve
yetkilendirme yönetimi, yedekleme, sanallaştırma ve temel güvenlik uygulamaları ele alınır.
Öğrenciler, kurumsal bilgi sistemlerinin sürekliliğini sağlayacak sunucu yönetimi yetkinliği
kazanır.
Bu ders, öğrencilerin ofis ortamlarında yaygın olarak kullanılan kelime işlemci, elektronik tablo
ve
sunum yazılımlarını etkin ve verimli biçimde kullanmalarını amaçlar. Ders kapsamında belge
düzenleme, tablo ve grafik oluşturma, veri analizi, raporlama ve sunum hazırlama gibi temel
beceriler kazandırılır. Öğrencilerin hem akademik hem de profesyonel yaşamda ihtiyaç duyacakları
dijital yeterliliklerin geliştirilmesi hedeflenir.
Veritabanı tasarımı, normalizasyon, SQL sorgulama dili, ilişkisel veritabanı mimarisi (RDBMS) ve
NoSQL kavramlarına giriş.
Sunucu İşletim Sistemleri
Windows Server ve Linux dağıtımlarının kurulumu, yönetimi, Active Directory yapılandırması ve
sunucu
sanallaştırma.
İnternet Programcılığı
Web teknolojileri, HTML5, CSS3, JavaScript ile istemci taraflı programlama ve PHP/.NET ile sunucu
taraflı geliştirme.
Sistem Analizi ve Tasarımı
Yazılım geliştirme yaşam döngüsü (SDLC), gereksinim analizi, UML modelleme and proje yönetimi
teknikleri.
Yönlendiriciler
Bu ders, bilgisayar ağlarında veri iletimini sağlayan yönlendiricilerin (router) çalışma
prensiplerini ve yapılandırma süreçlerini öğretmeyi amaçlar. Ders içeriğinde yönlendirme
protokolleri, IP adresleme, paket iletimi, ağ performansı ve temel güvenlik ayarları ele alınır.
Öğrenciler, ağ trafiğini yönetme ve ağ sorunlarını analiz edip çözme becerisi kazanır.
Video İzle
Görsel
Örnek Uygulamalar (OOP)
Sol taraftaki menüden incelemek istediğiniz uygulamayı seçerek sağ tarafta kaynak kodlarını görüntüleyebilirsiniz. Tüm kod satırlarının yanında ne işe yaradıkları // yorum satırları ile detaylıca anlatılmıştır.
using System; // Temel giriş-çıkış (Console) işlemleri için gereklidir.
// Araba sınıfı (Base/Super Class) oluşturuyoruz
class Araba
{
// 'private' dışarıdan (başka sınıflardan) doğrudan değiştirilmesini engeller (Kapsülleme)
private string marka; // Arabanın markası
private string model; // Arabanın modeli
private int hiz; // Arabanın anlık hızı
// 'static' sayac: Bu değişken belirli bir nesneye değil, ARABA sınıfına aittir. Üretilen toplam aracı tutar.
public static int ToplamAraba = 0;
// Yapıcı Metot (Constructor): Araba nesnesi RAM'de (new) oluşturulduğunda ilk çalışacak yer
public Araba(string marka, string model)
{
this.marka = marka; // Dışarıdan gelen marka değerini, sınıfın gizli markasına atıyoruz
this.model = model;
this.hiz = 0; // Üretildiği an hızı sıfırdır
ToplamAraba++; // Sınıf düzeyindeki sayaç her üretilen araba ile bir artar
Console.WriteLine(marka + " üretildi. Toplam Araba: " + ToplamAraba); // Ekrana bilgi basar
}
// Hiz değişkeni özel (private) olduğu için, dışarıya okuması için bu fonksiyonu (Get) kullanıyoruz
public int HizAl()
{
return hiz; // Anlık hız bilgisini dışarı gönderir
}
// Arabanın hızlanmasını sağlayan fonksiyon
public void Hizlan(int miktar)
{
if (miktar < 0) // Hızlanma miktarı eksi olamaz
{
Console.WriteLine("Hız artışı negatif olamaz!");
return; // Metodu burada keser, aşağısı çalışmaz
}
hiz = hiz + miktar; // Güvenli ise hızı arttır
Console.WriteLine(marka + " hızlandı! Mevcut Hız: " + hiz);
}
// 'virtual' (Sanal) metot: Miras (kalıtım) alan diğer alt sınıflar (elektrikli araba vb.) bu metodu isterlerse ezebilir(override)
public virtual void BilgiYaz()
{
// Aracın temel bilgilerini yazar
Console.WriteLine($"Marka: {marka} | Model: {model} | Hız: {hiz}");
}
}
// ElektrikliAraba, Araba sınıfından miraz(kalıtım) alıyor (: Araba kullanılarak)
class ElektrikliAraba : Araba
{
private int batarya; // Elektrikli arabaya has özel değişken
// Alt sınıf yapıcı metodu çalışırken, gelen temel bilgileri (marka, model) 'base' kullanarak üst sınıfa yolluyoruz
public ElektrikliAraba(string marka, string model, int batarya) : base(marka, model)
{
this.batarya = batarya; // Kalan ekstra batarya değişkenini kendisi alır
}
// Elektrikliye özel şarj kontrol metodu
public void SarjDurumu()
{
if (batarya > 50)
Console.WriteLine("Batarya durumu iyi: %" + batarya);
else
Console.WriteLine("Batarya azalmış, şarj edilmesi lazım: %" + batarya);
}
// Üst sınıftaki 'virtual' metodu 'override' ile eziyoruz ve elektrikliye uygun hale getiriyoruz
public override void BilgiYaz()
{
base.BilgiYaz(); // Önce üst sınıfın BilgiYaz() metodunu çağırıp temel araç bilgilerini yazdırıyor
Console.WriteLine("Batarya Seviyesi: %" + batarya); // Sonra altına sadece batarya bilgisini ekliyor
}
}
class Program
{
static void Main()
{
// 1. Standart Araba oluşturuluyor
Araba araba1 = new Araba("Toyota", "Corolla");
araba1.Hizlan(60); // Hızı arttırır
araba1.Hizlan(-10); // Eksili hız geçersiz olduğu için hata uyarısı verecektir
Console.WriteLine("----------------");
// 2. Elektrikli Araba oluşturuluyor
ElektrikliAraba araba2 = new ElektrikliAraba("Tesla", "Model 3", 85);
araba2.Hizlan(100); // Üst sınıftan miras aldığı Hizlan metodunu sorunsuzca kullanır
araba2.SarjDurumu(); // Kendi özel metodunu kullanır
Console.WriteLine("----------------");
// Statik değişkenler nesne adı ile (araba1) değil sınıf adı ile (Araba) çağırılır
Console.WriteLine("Üretilen Toplam Sistemdeki Araç Sayısı: " + Araba.ToplamAraba);
Console.WriteLine("----------------");
// Polymorphism (Çok Biçimlilik) Gösterimi
// Araba tipinde bir diziye hem normal Araba hem de ElektrikliAraba koyabiliyoruz
Araba[] liste = { araba1, araba2 };
foreach (Araba a in liste)
{
// İkisi de BilgiYaz() çalıştıracak fakat Toyota kendi metodunu, Tesla ise kendi override ettiği metodunu seçecek. (Çok Biçimlilik)
a.BilgiYaz();
Console.WriteLine("---");
}
}
}
using System; // Temel giriş-çıkış işlemleri için (Console.WriteLine gibi) gerekli kütüphane
// 1. SINIF: Arabanın özelliklerini ve araç sınıflarını analiz etme mantığını barındıran sınıf modeli
class Araba
{
// Sınıf Özellikleri (Değişkenler)
public string Marka; // Aracın üretici markasını metin (string) olarak saklar
public int BeygirGucu; // Aracın beygir gücünü tam sayı (int) olarak saklar
// Metot: Bu sınıfın (Araba'nın) belirli koşullara göre teknik sonucunu ekrana yazdıran fonksiyon
public void AnalizSonucunuGoster()
{
// Konsolda güzel bir çıktı vermek için ayraç çizgileri
Console.WriteLine("\n------------------------------");
Console.WriteLine("ARAÇ KAYIT ÖZETİ");
Console.WriteLine("Marka: " + Marka); // Araç markasını ekrana basar
Console.WriteLine("Güç : " + BeygirGucu + " HP"); // Aracın gücünü yanına HP ekleyerek ekrana basar
// Karar(If-Else) Yapısı: Girilen beygir gücüne göre aracın kalitesini sınıflandırır
if (BeygirGucu >= 300)
{
// Beygir gücü şartı 300 veya daha büyük ise aracı Süper Spor sınıfına sokar
Console.WriteLine("Sınıf: Süper Spor Araç");
}
else if (BeygirGucu >= 150)
{
// Beygir gücü ilk şartı sağlayamadı ama 150 - 299 arasındaysa Performans aracı sayar
Console.WriteLine("Sınıf: Performans Aracı");
}
else
{
// Yukarıdaki hiçbir şart sağlanmazsa (150'den düşükse) Standart araç sayar
Console.WriteLine("Sınıf: Standart Araç");
}
Console.WriteLine("------------------------------\n"); // Kapanış ayracı
}
}
// 2. SINIF: Programın derlendiği zaman ilk çalışmasını başlatan yönetici sınıf
class Program
{
// Main Metodu: Programın başlangıç yeridir. C# programları ilk buradan okunmaya başlar
static void Main(string[] args)
{
// Araba şablon sınıfından 'yeniAraba' isminde hafızada somut bir nesne(object) üretiyoruz
Araba yeniAraba = new Araba();
// Başlangıç ekran yazıları
Console.WriteLine("=== ARAÇ TAKİP VE ANALİZ SİSTEMİ ===");
Console.WriteLine("Lütfen sisteme işlenecek araç bilgilerini giriniz:\n");
// Kullanıcıdan Marka bilgisini metin olarak veri alma
Console.Write("Araç Markası Nedir?: "); // Ekrana soruyu bırakır (alt satıra geçmez)
yeniAraba.Marka = Console.ReadLine(); // Konsoldan girilen metni okur ve nesnemizin Marka'sına aktarır
// Kullanıcıdan Beygir gücünü matematiksel veri(sayı) olarak alma
Console.Write("Aracın Beygir Gücü (Sayısal): "); // Soruyu bırakır
// Console.ReadLine() normalde harfler için (metin) kullanılır. Biz sayı işleyeceğimiz için
// Convert.ToInt32 aracıyla okuduğumuz bu yazı sayısını bilgisayarın anlayacağı Matematiksel Sayıya dönüştürüyoruz.
yeniAraba.BeygirGucu = Convert.ToInt32(Console.ReadLine());
// Kullanıcı tüm bilgileri doldurduktan sonra, araba nesnesinin analiz yapan yeteneğini (fonksiyonu) göreve çağırıyoruz
yeniAraba.AnalizSonucunuGoster();
// Program işlemi bitirdikten sonra hemen konsol penceresini kapatmaması için, klavyeden bir tuşa basılmasını bekleterek donuk bırakırız
Console.WriteLine("Çıkış yapmak için bir tuşa basın...");
Console.ReadKey(); // Girdi geldiğinde sistemden çıkar
}
}
using System; // Konsol uygulamalarındaki hazır kütüphaneleri (Console.Write vb.) kullanmamızı sağlayan referans eklentisi
// 'BankaHesabi' isimli sınıf: Bir banka hesabını modelleyen taslaktır. Nesne yönelimli programlamanın (OOP) ilk adımıdır.
class BankaHesabi
{
// Özellik (Field): Banka hesabının sahibinin ismini tutan metin (string) veri tutucusu
public string HesapSahibi; // 'public' olduğu için, sisteme dışarıdan (program ana gövdesinden vb.) erişilebilir durumdadır.
// Özellik (Field): Hesaptaki mevcut para miktarını tutan ondalıklı sayı tipindeki veri tutucusu
public decimal Bakiye; // 'decimal': C#'ta mali, para işlemlerinde milimetrik hatalar yapmasını engelleyen kesirli finansal veri türüdür.
// Metot (Function/Method): Bakiye gösterme yeteneğidir. Hesap sahibini ve kalan bakiyesini konsola yazdırır.
public void BakiyeGoster()
{
// Console.WriteLine: Kendisine verilen verileri ekrana yazar ve ardından imleci bir alt satıra indirir
Console.WriteLine(
HesapSahibi + // Değişkenden 'HesapSahibi' bilgisini alıp okur ve cümleye yazar
" Adlı Kullanıcı - Güncel Bakiye: " +
Bakiye + // Değişkenden 'Bakiye' bilgisini alıp cümleye ekler
" TL"
);
}
}
// Programın yürütüldüğü, ana giriş sınıfıdır. Kodlamanın vücududur.
class program
{
// Main() metodu uygulamanın kalbi/kontağı niteliğindedir. Uygulama başlatıldığı anda önce burası çalışır. Dışarıdan veri alıp kullanabilir.
static void Main(string[] args)
{
// Yukarıda şablon olarak tasarladığımız 'BankaHesabi' türünden 'hesap' isminde somut ve gerçek zamanlı yeni (new) bir nesne oluşturur.
// Bu işlem gerçek bir şubeden boş hesap açmak ile aynıdır.
BankaHesabi hesap = new BankaHesabi();
// Daha sonra açık hesaptaki değişken özelliklerin (HesapSahibi) içerisi doldurulur.
hesap.HesapSahibi = "Mehmet Demir"; // İsim metin ataması yapıldı
// (Bakiye) kısmına küsuratlı yeni TL tutarı yüklenir. Sonundaki 'm' harfi sistemde bunun Decimal (finansal sayı) bir para birimi olduğunu kanıtlar.
hesap.Bakiye = 1500.75m;
// Artık bilgisi olan 'hesap' nesnemizin sahip olduğu 'BakiyeGoster' adındaki fonksiyonu (yeteneğini) çağırıp, kendisini tanıtmasını (ekrana basmasını) istiyoruz
hesap.BakiyeGoster();
}
}
using System; // Konsol giriş-çıkış komutları için vazgeçilmez olan temel System kütüphanesini projeye dahil eder.
// Sınıf (Class) Tanımlaması: Araç modellerini yazılım dünyasında temsil etmek için Araba şablonu (Sınıfı) oluşturuluyor.
class Araba
{
// Sınıf Özellikleri (Alanlar - Fields)
public string marka; // Arabanın markasını tutacak olan metinsel(string) değişken tanımı. (Public olduğu için dışarı açık)
public int modelYili; // Arabanın model/üretim yılını tutacak olan tamsayı(integer) değişken tanımı.
// Metot (Fonksiyon): Bu sınıftan üretilen nesnelerin içerisindeki özellikleri ekrana yazıp göstermek için kullanılan özel araç yeteneğidir.
public void BilgiYazdir()
{
Console.WriteLine("Marka: " + marka); // Konsolda bir satıra 'marka' değişkeninin içindekini yazar
Console.WriteLine("Model Yılı: " + modelYili); // Konsolda diğer satıra 'modelYili' sayısını yazar
}
}
// Ana Uygulamanın Derlenip Yürütüldüğü Sınıf (Main System)
class Program
{
// Main Metodu: C# programlarının çalışmaya başladığı start noktasıdır, kodlar burada can bulur.
static void Main()
{
// Taslağını yazdığımız Araba sınıfından RAM hafızasında yaşayacak 'araba1' adında yeni(new) gerçek bir nesne türetiliyor.
Araba araba1 = new Araba();
// 1. Adım: Kullanıcıyla iletişim ve Marka Girişi
Console.Write("Lütfen Aracın Markasını Giriniz: ");// Ekrana soruyu çıkartıyoruz
araba1.marka = Console.ReadLine(); // Kullanıcının siyah konsola yazdığı yanıtı satır olarak okur ve doğrudan nesnenin marka özelliğine çeker(kaydeder).
// 2. Adım: Kullanıcıdan Sayısal Değer İsteme
Console.Write("Lütfen Aracın Model Yılını Giriniz (Örn: 2024): ");
// Normalde klavyeden yazılan her şey metindir (String). Bunu arabamızın model yılı (int - tamsayı) yuvasına sığdırabilmemiz için;
// Convert.ToInt32() aracı ile o metinsel girdiği, saf sayıya çeviriyoruz ki bilgisayar onu anlasın.
araba1.modelYili = Convert.ToInt32(Console.ReadLine());
// Bilgileri göstermeden önce konsolda ayrım sağlayan bir dekoratif bölme oluşturulur (\n bir alt satırdan başlatır)
Console.WriteLine("\n--- Sistemimize Kaydettiğiniz Araç Bilgileri Ekranı ---");
// Nesnenin içindeki yazdırma metodu (BilgiYazdir) tetiklenir, ve kendisinde kayıtlı olan (yukarıda girdiğimiz) markayı ve yılı yazdırarak işi bitirir.
araba1.BilgiYazdir();
}
}
using System; // Ekrana yazı yazdırmak ve giriş okumak için gereken temel Console kütüphanesini projeye dahil (import) eder
// Programın kapsayıcı sınıfı (Her C# uygulamasının bir sınıf içerisinde olması gerekir)
class Program
{
// C# çalıştırıldığında sistemin otomatik olarak bulduğu ve okumaya başladığı 'Main' metodu
static void Main()
{
// ------------------ İSİM GİRİŞ İŞLEMİ ------------------
// Console.Write komutu kullanıcıya mesaj gösterir. (Not: WriteLine alt satıra atar, Write atmaz. Cevap yanına yazılsın diye Write kullandık)
Console.Write("Profil oluşturuluyor, lütfen isminizi girin: ");
// Console.ReadLine() kullanıcının klavyeden girdiği metni alır ve bilgisayar tarafındaki 'isim' isimli String (metin) değişkeninin içine depolar
string isim = Console.ReadLine();
// ------------------ YAŞ GİRİŞ İŞLEMİ ------------------
// Kullanıcıdan bu sefer yaş bilgisini isteyen mesajımız
Console.Write("Şimdi de kayıt için yaşınızı giriniz: ");
// ReadLine() normalde bize harf(string) getirir, fakat kullanıcının yazdığı yaşı matematiksel bir büyüklük küçüklük sınamasına tabi tutacağımız için
// bunu sayıya çevirmeliyiz. 'int.Parse()' komutu metni anında gerçek bir tamsayıya (Integer) dönüştürüp 'yas' içerisine hapseder.
int yas = int.Parse(Console.ReadLine());
// Girilen isim verisi alınıp "Merhaba ..." kalıbıyla hoşgeldiniz minvalinde ekrana basılır
Console.WriteLine("\nMerhaba " + isim + "!");
// ------------------ KARAR (IF-ELSE) YAPISI İLE KONTROL ------------------
// Eğer (if) yaş büyüktür veya eşittir (>=) 18 ise bu parantezin içine gir
if (yas >= 18)
{
// Şart doğruysa bu mesaj ekrana gösterilir
Console.WriteLine("Sistem kontrolü: Erişkin (Reşitsiniz), sisteme tam giriş sağlandı.");
}
else // Eğer yukarıdaki şart sağlanmazsa (Yani 18 yaşından küçük yaş girdiyse)
{
// O zaman zorunlu olarak bu alandaki hatayı/mesajı göster.
Console.WriteLine("Sistem uyarı: Yaşınız 18'den küçük (Reşit değilsiniz). Kısıtlı giriş sağlandı.");
}
}
}
using System; // Tüm temel Console işlemlerinin bağlı bulunduğu kütüphane
// 1. SINIF (CLASS) ŞABLONU OLUŞTURULUYOR: Müşterilerin banka hesaplarını kopyalamak için kullanılacak asıl ana harita (Blueprint)
public class BankaHesabi
{
// --------- 1. BÖLÜM: TEMEL ÖZELLİKLER (Attributes) ---------
public string HesapSahibi; // Hesabın kimin adına olduğunu tutan şeffaf(açık) metinsel kutu
public string HesapNo; // Hesap numarası (TR ile biten IBAN gibi) şeffaf metin kutusu
// Güvenlik (Kapsülleme - Encapsulation): Para durumu 'private' kilitlenmiştir. Kodu yazanın bile buraya direkt "+500 yap" diyememesi için kapalı bir kutudur.
private double Bakiye;
// --------- 2. BÖLÜM: YAPICI METOT (Constructor) ---------
// Class adı ile BİREBİR AYNI isme sahiptir. Bankaya gidip kağıtları imzaladığınızda "Yeni Hesap (new)" oluştuğu an ilk çalışan zorunlu doldurma fonksiyonudur.
public BankaHesabi(string ad, string no, double baslangicBakiyesi)
{
HesapSahibi = ad; // Kağıttan gelen isim hesaba yazıldı
HesapNo = no; // Kağıttan gelen no hesaba yazıldı
Bakiye = baslangicBakiyesi; // Gişeden hesaba konan ilk ana nakit para.
}
// --------- 3. BÖLÜM: HESABIN HAREKET METOTLARI (Yetenekleri) ---------
// A) Gişeden Para Yatırma Fonksiyonu
public void ParaYatir(double miktar)
{
if (miktar > 0) // Eğer verilen yatırılacak tutar 'sıfırdan büyük ise' yani mantıklı gerçek bir para ise
{
Bakiye += miktar; // Kilitli kutumuz olan parayı (private bakiye) güvenli bir şekilde kendi içinden bu miktarla topla (+)
Console.WriteLine($"{miktar} TL başarılı bir şekilde yatırıldı. Güncel kasa bakiyesi: {Bakiye} TL");
}
else // Mantıksız bir para yatırılmaya çalışılıyorsa reddet (-5 TL filan)
{
Console.WriteLine("Güvenlik Uyarısı: Yatırılacak tutar pozitif(geçerli) bir miktar olmalıdır!");
}
}
// B) ATM'den Para Çekme Fonksiyonu
public void ParaCek(double miktar)
{
if (miktar > Bakiye) // Eğer istediği para kasanın dibindeki (Bakiye) parayı AŞIYOR ise (Yetersiz Bakiye)
{
Console.WriteLine("İşlem Başarısız: Yetersiz kredi/bakiye! İşlem maalesef gerçekleştirilemiyor.");
}
else // İstediği para limitin altındaysa rahatça çekiş sağlayan Else kısmı
{
Bakiye -= miktar; // Kutudaki asıl parayı güvenle kendi yuvamız içinde azalt (-)
Console.WriteLine($"{miktar} TL çekildi. Cebinizde kalan: {Bakiye} TL");
}
}
// C) Bankamatiğin Ekrana Hesap Özetini Verme Fonksiyonu
public void BilgileriGoster()
{
// Tüm güncel durum şık ve dekoratif bir dille ekrana yansıtılır.
Console.WriteLine($"Hesap Sahibi Kurum/Kişi: {HesapSahibi} | IBAN No: {HesapNo} | Aktif Bakiye: {Bakiye} TL");
}
}
// 4. PROGRAM GÖVDESİ (Her Yerin Toplandığı ve Sistemi Çalıştıran Kısım)
class Program
{
static void Main()
{
// Yukarda bir banka mantığı yazmıştık. 'BankaHesabi' ismindeki fabrikamızdan Ahmet Yılmaz adında gerçek "hesap1" nesnesini basıyoruz. Hesaba baştan 1000 yatırıldı.
BankaHesabi hesap1 = new BankaHesabi("Ahmet Yılmaz", "TR123456", 1000);
// Şimdi Ahmet bey ATM'ye geçiyor ve nesneye ait yetenek tuşlarını kullanıyor;
hesap1.BilgileriGoster(); // Sisteme bakıyor (1000 gözüküyor)
hesap1.ParaYatir(500); // Ahmet bey ATM yuvasına 500TL sıkıştırdı (Kasa 1500 oldu)
hesap1.ParaCek(2000); // Ahmet bey 2000TL çekmeye çalışıyor (Ekran hata verecektir çünkü 1500'ü var)
hesap1.ParaCek(300); // İnadı bırakıp 300 TL girip çekti (İşlem onaylı, kalan: 1200)
Console.WriteLine("------------------------------------------");
hesap1.BilgileriGoster(); // Gün sonu fişi çıktısını gösteriyoruz.
}
}
using System;
// 'KutuphaneUygulamasi' projenin ve sınıfların düzenli klasörlenmesi (isim alanı) amacını taşır
namespace KutuphaneUygulamasi
{
// Kitaplarla ilgili tüm verileri içerecek olan KİTAP Nesne Kalıbımız (Sınıfı) oluşturuluyor
public class Kitap
{
// Nesne özelliklerini herkese açık (public) bırakıp, farklı metin (string) ve sayı (int) kapsayıcılarını tanımladık
public string Ad; // Kitabın manşet adı
public string Yazar; // Yazar adı ve soyadı
public int SayfaSayisi; // Kalınlığını sayılarla(int) ölçen değişken
public string Tur; // Türü(Roman) veya Fiziksel biçimini tutacak metin alanı
// Sınıfın İçindeki Yetenek Düşüncesi (Method - Metot)
// Kitabın çok sayfalı veya standart hacimde (kalın/ince) olup olmadığını kendi kendine analiz eden otomasyon
public void KategorizeEt()
{
if (SayfaSayisi >= 300) // 300 sayfayı aşanları ağırdır, çoktur, kalındır sayar
{
Tur = "Kalın/Büyük Boy Eser Kitap";
}
else // Geriye diğer (altı) kalır, o zaman bu işlemi yap:
{
Tur = "İnce/Standart Okuma Kitabı";
}
}
}
// Programın iskeleti ve konsol çalıştırma yöneticisi class alanı
class Program
{
// 1. Yardımcı Dış Metot: Sadece kitap verisi girmek için özel bir kod bloğudur, kafa karıştırmamak için Main'den koptu.
// Parametre olarak (Kitap k): Bu parantez içinden gelen X kitabının içine sorma işlemi gerçekleştireceği anlaşılır.
static void KitapBilgisiAl(Kitap k)
{
Console.Write("Kitabın Adını Yazınız: ");
k.Ad = Console.ReadLine(); // Konsoldan girilen yazıyı alır
Console.Write("Kitabın Yazarını Belirtin: ");
k.Yazar = Console.ReadLine();
Console.Write("Son Olarak Tam Sayfa Sayısını Giriniz: ");
k.SayfaSayisi = int.Parse(Console.ReadLine()); // Metni, kitaptaki sayfa değişkenine atabilmek için sayıya (parse ile) çevirir
}
// 2. Yardımcı Dış Metot: Gelen kitabı özet fişine döndüren ekrana çizim işlemlerini barındırır.
static void OzetiYazdir(Kitap k)
{
// Güzel bir başlık için alt alta dekorasyon boşluklarını
Console.WriteLine("\n--- SİSTEME KAYITLANAN KİTAP ÖZETİ ---");
Console.WriteLine("Kitap İsmi: " + k.Ad);
Console.WriteLine("Tam Yazar Adı: " + k.Yazar);
Console.WriteLine("Ağırlığı (Sayfa): " + k.SayfaSayisi);
Console.WriteLine("Genel Kategori Sınıflandırılması: " + k.Tur);
}
// Ana Metot (Kontak)
static void Main(string[] args)
{
// Gerçek yaşamda hafızada yer bulan yeni bir kitap varlığı nesnesi doğurtulur (myKitap isimli)
Kitap myKitap = new Kitap();
// Parça parça yaptığımız dış kuralları artık sırasıyla çalıştırıyoruz:
KitapBilgisiAl(myKitap); // "Gidip myKitap nesnesiyle soru sırasını çalıştır" der (1. İşlem Veri girişi)
myKitap.KategorizeEt(); // "Kullanıcının girdiği sayfalara bakıp kalın olup olmadığına otomatik karar ver/Tur adını güncelle" (2. Hesaplama/Mantık)
OzetiYazdir(myKitap); // "Son olarak bütün sonuca ait o çıktıyı Console üzerinden bastır" (3. Çıktı/Output)
// Konsol penceresinin işlemler aniden bittikten sonra kendi kendine direkt kapanmasını engeller
Console.ReadKey();
}
}
}
using System; // Klasik ve asıl komutlarımız
using System.Collections.Generic; // 'List<>' verisi yani uzayıp artabilen esnek dinamik küme oluşturmamız için gerekli zorunlu kütüphanedir
// Uygulamanın bağlı olduğu kök grup dosyası
namespace OOPSinavUygulamasi
{
// ÖĞRENCİ NESNESİ MODELİ (Class): Sistemin özüne indik.
public class Ogrenci
{
// ENCAPSULATION (Kapsüllemeler): Özel not kilit mekanizmaları kuruluyor. _adında_ değişkenler private'dir ki kimse dışardan bozamasın.
private string _ad;
private string _numara;
private List<int> _notlar; // İçine dilediğimiz sayıda sınav notu sayıları atabileceğimiz sınırsız özel bir liste kabı.
// Constructor Yapıcı Blok: Bu kalıptan ne zaman yeni(new) çocuk doğsa adını ve numarasını kaydettirir.
public Ogrenci(string ad, string numara)
{
_ad = ad; // Gelen adı dış gizli duvardaki klasöre kilitle
_numara = numara;
_notlar = new List<int>(); // Liste kaplarını boş olarak hafızada hazırlayıp kullanıma açıyoruz
}
// Dışarıdan _notlar kutusuna puan atma anahtarı (Güvenlik Görevlisi Metot)
public void NotEkle(int notDegeri)
{
// Not mantıksız (eksili) olmasın ve 100'ü geçmesin diye kapıda güvenlik (if) kontrolü ile korunak sağlıyoruz
if (notDegeri >= 0 && notDegeri <= 100)
{
_notlar.Add(notDegeri); // Not güvenilirse listede ona yer ver
}
}
// Eklenenlerin karnesini (ortalamam) hesaplama merkezi
public double OrtalamaHesapla()
{
if (_notlar.Count == 0) return 0; // Hiç not girilmediyse bölecek bir şey olamayacağı için sisteme kafa dağıtmaması için hemen '0' ortalama ile yolla.
double toplam = 0; // Başta sıfır puandayız
// Foreach döngüsü: Listedeki sayısız notu teker teker 'n' harfinde barındırıp içeri gezdirir.
foreach (var n in _notlar)
{
toplam += n; // Her gelen yeni not, toplam kumbarasına atılır.
}
// Kumbaradaki parayı (toplam) listedeki not sayısına (_notlar.Count) böler (aritmetik ortalama)
return toplam / _notlar.Count;
}
// Raporu güzel bir metin haline çevirme ambalajı
public string BilgileriGetir()
{
// Ortalamayı bulmak için OrtalamaHesapla() fonksiyonu çağrılır, ardından ':F2' ifadesi sayesinde küsürat ne kadar uzarsa uzasın ekranda sadece virgül sonrası '2' basamak bırakılır
return $"Öğrenci No: {_numara} | İsim: {_ad} | Durum: {OrtalamaHesapla():F2}";
}
}
// 2. SINIF: OKUL YÖNETİMİ MÜDÜRLÜĞÜ MODELİ
public class OkulSistemi
{
// Yöneticiye ait listemizin içinde bu sefer 'sayılar' değil, 'Öğrenci KARTLARI' birikecek
private List<Ogrenci> _ogrenciler = new List<Ogrenci>();
// Yeni oluşturulan öğrenci kişilerini okula kayıt ettiren fonksiyon parçası
public void OgrenciKaydet(Ogrenci ogrenci)
{
_ogrenciler.Add(ogrenci); // Listeye ekle (Kayıt işlemini tamamla)
}
// Tüm müdürlük panosundaki kişileri bastıran metot
public void Listele()
{
Console.WriteLine("===== Mevcut Okula Kayıt Yaptıran Öğrenci Panosu Listesi =====");
foreach (var o in _ogrenciler) // Listeden her Öğreten(o)'yu çek
{
// 'o' varlığının paketlenmiş o güzel string yazdırma şeklini al ve bas.
Console.WriteLine(o.BilgileriGetir());
}
}
}
// Gerçek simülasyon sisteminin ayağa kalktığı Main(Motor) kısmı
class Program
{
static void Main(string[] args)
{
// Evrenimizde bir müdürlük makamı bina ediyoruz
OkulSistemi sistem = new OkulSistemi();
// 101 Numaralı bir Ahmet Yılmaz adında gerçek nesnemiz sınıfımıza girdi
Ogrenci ogr1 = new Ogrenci("Ahmet Yilmaz", "101");
ogr1.NotEkle(85); // 1. Sınavdan 85 aldı
ogr1.NotEkle(90); // 2. Sınavdan 90 notunu ekledik
// Kapıdan başka biri girdi
Ogrenci ogr2 = new Ogrenci("Ayse Demir", "102");
ogr2.NotEkle(75);
ogr2.NotEkle(95);
// Bireyler hazırlandı, şimdi bunları okul resmi sistemine (yukarıdaki fabrikaya) devredip kayıt etmemiz lazım:
sistem.OgrenciKaydet(ogr1);
sistem.OgrenciKaydet(ogr2);
// Hepsi listelerde (veritabanında vb) olduğu için, müdürlük sistemindeki son listeyi masaya döküp istiyoruz
sistem.Listele();
}
}
}
using System; // Hazır C# dil ve sistem kuralları kütüphanesi aktif edildi.
namespace NotUygulamasi // Not sistemi projemizin ana isim çatısı (klasörü).
{
// Temel bir varlık (Öğrenci) için tasarım planı şablonu çiziliyor (Class)
public class Ogrenci
{
// --------- ÖĞRENCİNİN PARÇALARI ---------
public string Ad; // Metin tabanlı adı ve soyadı bilgisini tutacağı klasör
public double Vize; // Sayısal virgüllü ve büyük veri tipleri olan notlar için Vize
public double Final; // Diğer sınav final not tutucusu
public double Ortalama; // Hesaplama yapıldıktan sonraki sonucu yansıtacağı cep
public string Durum; // "Aferin Geçtin" veya "Maalesef Kaldın" diyebilmesi için kelimelik durum tespiti kutusu
// --------- ÖĞRENCİNİN YETENEĞİ (Metot) ---------
// Bütün özelliklere sahip öğrencinin en önemli fonksiyonu: Sınav hesaplama aksiyonu.
public void Hesapla()
{
// Vize sınavının %40'ı + Final sınavının %60 oranı toplanıp asıl genel Ortalamada duracak.
Ortalama = (Vize * 0.4) + (Final * 0.6);
// Eğer yeni hesaplanmış ortalama puanı 50 barajından BÜYÜK veya EŞİT ise geçmesine müsaade et.
if (Ortalama >= 50)
{
Durum = "GEÇTİ - Başarılar (Harf/D: Mükemmel)";
}
else // Asla yukarıdaki 50 kuralına takılmadıysa otomatik olarak tek seçeneği vardır: Kalmak!
{
Durum = "KALDI - Başarısızlık (Dersten çekilmiş olabilirsiniz)";
}
}
}
// Uygulamanın Başlangıç Formu Gibi Bir Ana Denetleyici Gövdesi
class Program
{
// Helper Metot 1: Dışarıdan sadece kullanıcının sorularını soran, ortalığı karıştırmayan yardımcı kod bloğu
// Parametresi var (Ogrenci ogr): Bu işleme kimin girdiği bildiriliyor ki nesneyi karıştırmasın.
static void BilgileriAl(Ogrenci ogr)
{
Console.Write("Lütfen Kimlik/Ad Belirtiniz: "); // Ekrana uyarı çıkart
ogr.Ad = Console.ReadLine(); // Yanıta basılan değeri sistemdeki Ad'a gönderip depola
Console.Write("1. Vize Sınavınız İçin Puanınız: ");
// ReadLine girdiği cümledir (String), Fakat vizesi küsüratlı sayısal 'Double'. Bunu dönüştürmemiz şart: double.Parse() dönüştürücü
ogr.Vize = double.Parse(Console.ReadLine());
Console.Write("Final Sınavı İçin Nihai Puan: ");
ogr.Final = double.Parse(Console.ReadLine()); // Final için değerleri double'a parse ederek kaydet.
}
// Helper Metot 2: İşlemler bitmişse bu kodları derleyerek bir döküm çıktısında rapor basım yapan son aşama
static void RaporuYazdir(Ogrenci ogr)
{
Console.WriteLine("\n======================== SONUÇ ========================"); // Süsleme
Console.WriteLine("Talebe Kimliği/Öğrenci: " + ogr.Ad);
Console.WriteLine("Dönemlik Toplam Ortalama Not: " + ogr.Ortalama); // Toplamı hesaplamıştı, yazdır
Console.WriteLine("Transkript Geçerli Durumu: " + ogr.Durum); // Metne dönüştürdüğü geçme durumu.
}
static void Main(string[] args)
{
// Uygulama RUN denildiği an ilk olarak ruhu üfleyecek Ogrenci nesnemizi canlandırıyoruz
Ogrenci ogr = new Ogrenci();
BilgileriAl(ogr); // Soruları sor, verilerini al görevlisi
ogr.Hesapla(); // Sayısal hesap ve if else mantığını ayarla/hesapla görevlisi çalışsın
RaporuYazdir(ogr); // En sonda ekrana yazdırma kuryesi çağrılır
// İşlemlerin komut anında silinmemesi için ekranda kitleyici klavye vuruşunu kapatır
Console.ReadKey();
}
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
// ConsoleApp5 adında bir proje (isim alanı - namespace)
namespace ConsoleApp5
{
// Programın ana sınıfı
internal class Program
{
// Araba adında iç içe (nested) bir sınıf oluşturuluyor
class Araba
{
// Başlangıç değeri atanmış özellikler (fields)
public string marka = "Togg"; // Arabanın başlangıç markası Togg yapıldı
public int hiz = 0; // Duran bir araç olduğu için hız 0 olarak belirlendi
// Arabanın hızını artıran fonksiyon (metot)
public void Hizlan()
{
hiz = hiz + 10; // Araba her hızlandığında hızı 10 birim artar
// Yeni hızı anlık olarak ekrana yazdırır
Console.WriteLine(marka + " hızlandı. Yeni hız: " + hiz);
}
// Arabanın anlık durumunu ekrana yazdıran fonksiyon
public void DurumuGoster()
{
// Markayı yazar
Console.WriteLine("Araba Markası: " + marka);
// O anki güncel hızı yazar
Console.WriteLine("Mevcut Hızı: " + hiz);
}
}
// Programın yürütüldüğü ikinci sınıf parçası
class program
{
// Programın ana giriş noktası (Başlangıç Metodu)
static void Main()
{
// Araba şablonundan 'benimArabam' adında gerçek bir nesne üretilir
Araba benimArabam = new Araba();
// Henüz hareket etmediği için ilk durumu (Hız: 0) gösterecektir
benimArabam.DurumuGoster();
// Araba hızlandırılıyor (hız değişkeni 10 olacak)
benimArabam.Hizlan();
// Hızlandıktan sonraki yeni durum gösteriliyor (Hız: 10)
benimArabam.DurumuGoster();
}
}
}
}
using System; // Temel C# kod sistemi
using System.Collections.Generic; // 'List' dediğimiz esnek dizi ve küme yapıları için vazgeçilmez grup kütüphanesidir.
// 1. KİTAP MODELİ: Alışveriş yapmak üzere dijital rafa koyacağımız Kitap nesnesini tanımlayan şablon
class Kitap
{
// Kitaplara ait metin özelliklerini herkes görebilsin/alabilisin (Public)
public string Ad;
// Kitaplara ait para cinsi (Ondalıklı Decimal ile milimetrik para kuruş hatası bırakmaz)
public decimal Fiyat;
// Kendini dışarıya tanıtan 'Yazdir' adında bir görselleştirme fonksiyonu (Metot)
public void Yazdir()
{
// Ekrana kendi Adını ve yanına - koyarak Fiyat rakamını yazdırıp birim (TL) ekler.
Console.WriteLine(Ad + " - " + Fiyat + " TL");
}
}
// 2. SEPET MODELİ: Müşterinin sanal alışveriş arabası. İçerisine birden fazla 'Kitap' nesnesi sığabilir.
class Sepet
{
// Kapsülleme (Encapsulation): Sepet listesi 'Private' yapılarak korsan müdahalelere/elle kitap eklemelerine karşı güvenli izole kilit altına alındı
private List<Kitap> kitaplar = new List<Kitap>();
// Güvenlik kapısı açan Ekle metodu. "Sadece bu metodu kullanarak listeye erişebilirsin, kendin bodoslama listeye ulaşamazsın" mantığı içerir.
public void Ekle(Kitap kitap)
{
kitaplar.Add(kitap); // Gelen kitabı alıp sepetteki (Private List) arka listeye güvenlikçe Add ile kaydederiz.
}
// Kasaya geldiğindeki borcunu (Toplam Fiyatı) otomatik okuyan tarayıcı fonksiyon
public decimal Toplam()
{
decimal toplam = 0; // Kasada sayaç başlangıçta sıfırdır
// Foreach döngüsü sayesinde sepet(kitaplar) klasöründeki her bir varlık 'k' harfi ile dolaşılarak kontrol edilir,
foreach (Kitap k in kitaplar)
{
toplam += k.Fiyat; // 'k' isimli her bir kitabın etiket fiyatı yığılarak sıfır(0) olan ana kasadaki fiyata(+) eklenir. (Toplama)
}
return toplam; // Fişin borcu olarak en sondaki miktarı yetkili fonksiyona geri gönder(return).
}
// Fişi komple ekrana döküman olarak basan yetenek (Sepet içindeki özet)
public void Yazdir()
{
Console.WriteLine("\nAlışveriş Sepetinin İçeriği:");
foreach (Kitap k in kitaplar) // Sepetteki tüm mallarını dön
{
k.Yazdir(); // O malın kendi içindeki özellik basma(isim ve fiyat basma) metodu tetiklensin
}
// Tüm döngü yani barkod okumalar bittikten sonra tam Toplam kasayı yazdır:
Console.WriteLine("Ödenecek Net Tutar Miktarı: " + Toplam() + " TL");
}
}
// 3. SİPARİŞ ANA SİSTEM MODELİ: Kargo adımları / Sepetin Siparişe dönüşümü
class Siparis
{
// Kompozisyon (Composition): Bir sınıfın başkasını içermesi. Sepet olmadan sipariş olmaz.
public Sepet Sepet; // Siparişimizin koli halinde içeriği (Sepet nesnesi formunda)
// Nakliye kağıdı yazdırma (sipariş fişi tam özet)
public void Yazdir()
{
Console.WriteLine("\n--- ONAYLANAN GÜNCEL SİPARİŞ BİLGİSİ ---");
Sepet.Yazdir(); // Alt dalında çalışan sepetimizin zaten fiş yazdırabilme yeteneği var, aynen onu devreye sok(kullan) diyoruz
}
}
// 4. MÜŞTERİ HAREKETLERİNİN DERLENDİĞİ MAIN BLOĞU
class Program
{
static void Main(string[] args)
{
// Birinci nesne ürün oluşturuluyor
Kitap k1 = new Kitap();
k1.Ad = "C# OOP Öğreniyorum";
k1.Fiyat = 250;
// İkinci nesne ürün oluşturuluyor
Kitap k2 = new Kitap();
k2.Ad = "Yapay Zeka ve Algoritma Temelleri Kitabı";
k2.Fiyat = 500;
// Müşteri alışverişe başladı ve yeni bir sepet arabası (Object) kaptı
Sepet sepet = new Sepet();
// Ürünleri okutarak sepetin içine salıyor (Ekle fonksiyonu güvenlikten dolayı arka listeye paslıyor)
sepet.Ekle(k1);
sepet.Ekle(k2);
// Kasa görevlisi bu sepeti onaylanıp barkodlayarak tam olarak Siparişe bağlı yeni koliye kargoya geçiriyor
Siparis siparis = new Siparis();
siparis.Sepet = sepet; // Alınanlar kutuya paketlendi
// Sipariş belgesi çıktı edilip her detay (Sepet detayı, ürün detayı vb hiyerarşiyle) yazılıyor
siparis.Yazdir();
}
}
using System; // Standart giriş ve çıkış metotları (Console vs) tanımlamaları için kütüphane eki
// Sınıf (Class) : Bir banka modülü kuruyoruz. Para tutan bir hesabın fabrikası görevi görecek.
class BankaHesabi
{
// Özellik (Field): Bankanın kullanıcısı. Herhangi bir güvenlik ayarı olmadan (Public) herkese açık şekilde.
public string MusteriAdi;
// Özellik (Field): Hesabın aktif maddi para tutarını kaplayacak sayısal değişken. Decimal ondalıklı paralar için altın değerindedir.
public decimal HesapBakiyesi;
// Metot: Yeteneği, sadece gidip değişkenleri okuyup fiş olarak ekrana sunmaktır
public void BilgiGoster()
{
// 4 Parçayı "+" operatörleriyle sanki lehimler gibi birleştirip (Concatenation) tek bir güçlü cümle yapısı çıkartıyor
Console.WriteLine(
MusteriAdi + // 1. Parça : Ayşe Yılmaz (isim gelecek)
" - Aktif Hesap Özeti/Bakiye Durumunuz: " + // 2. Parça : Açıklama cümlesi
HesapBakiyesi + // 3. Parça : 2750.50 (sayısal miktar kısımları)
" Türk Lirası (TL)" // 4. Parça : Birim ve son nokta.
);
}
}
// Tüm projeyi ayağa kaldıran can suyu niteliğindeki Program Ana Sınıfı
class Program
{
// Uygulama RAM'ine yüklendiği vakit Windows ilk olarak nerede başlayacağını bu komuttan anlar
static void Main(string[] args)
{
// Yukarı haritasını çizdiğimiz şablondan (class) bir tane somut varlık türetmek istiyoruz (Object Creation).
// Şu an null (boş) bir cüzdan oluştu.
BankaHesabi hesap = new BankaHesabi();
// Artık sadece "Ayşe" ye has yeni cüzdana dışarıdan ulaşıp adını (string) giriyoruz
hesap.MusteriAdi = "Ayşe Yılmaz";
// Parasal değer girilir. Yazılımda Decimal sayılar sonunda küçük/büyük her zaman 'm' veya 'M' karakterini belirtteç olarak barındırmak zorundadır. Aksi halde Double sanıp hata verir.
hesap.HesapBakiyesi = 2750.50m;
// Varlığını doldurduğumuz bu kişinin bilgilerini (yeteneği var sınıfın içinde) gidip konsola atamasını emrediyoruz (Call the Method)
hesap.BilgiGoster();
}
}
using System;
namespace GuzellikSalonuOOP // Salon ile ilintili işlemler bu isim çatısı altındadır
{
// Gelen misafirleri kapsayan şablon (Sınıf)
class Musteri
{
// Müşterinin kişisel verileri olan değişkenler (String yani metin olarak tutulurlar)
public string AdSoyad, Gun, Saat;
// Müşterinin fişi yani yapacağı toplam ücret hesaplaması (Double tipindeki ondalıklı tutar)
public double Toplam = 0; // Sıfırdan bir kasaya başlar
// Müşteri Yapıcı Metodu (Constructor): Nesne randevu oluştuğunda direkt bu metot ilk çalışacağı için, adamı listeye mecburen bir tarihle atması sağlanır!
public Musteri(string adSoyad, string gun, string saat)
{
// Alınan yeni bilgiler, nesnenin kendi ana belleğine (AdSoyad, Gun...) eşitlenerek aktarılır
AdSoyad = adSoyad;
Gun = gun;
Saat = saat;
}
// Müşteri bir işlem yaptıracağında kullanılacak sepete hizmet ekleme fonksiyonu (Örn: Saç Kestirme)
public void Hizmet(string ad, double fiyat)
{
Toplam += fiyat; // Mevcut var olan fişine yeni sepet ücreti (fiyat) biniyor eksi hesaba göre + yazar
Console.WriteLine(ad + " işleminiz sepete eklendi (" + fiyat + " TL tutarında)");
}
// Çıkış yaparken Müşterinin hesap özetini yani randevusunu kanıtlayan dekont yazdırma işlevi
public void Yazdir()
{
Console.WriteLine("\n*** SİSTEM ONAYI VERİLDİ ***");
Console.WriteLine("Sayın Onaylı Müşterimiz ✔");
Console.WriteLine("Bilgiler: " + AdSoyad + " - Taraması: " + Gun + " / Vakti: " + Saat);
Console.WriteLine("Kasadaki Net Toplam Tutar: " + Toplam + " TL");
}
}
// Uygulamamızı simüle çalıştıran yer
class Program
{
static void Main()
{
// Salonumuzda çalışılan belirli günlerin listesi (Dizi/Array sistemi kullanılmıştır [1 Boyutlu])
string[] gun = { "Pzt", "Sal", "Çar" };
// Her güne tekabül eden özel saat odaları/dilimleri dizisi (Çok Boyutlu / Dizi içinde Diziler [Array of Arrays])
string[][] saat =
{
new[] { "10:00", "12:00", "14:00" }, // Pazartesi(0) programındaki saatler
new[] { "11:00", "13:00", "15:00" }, // Salı(1) programındaki saatler
new[] { "09:00", "11:00", "16:00" } // Çarşamba(2) programındaki saatler
};
// Rezervasyon İsim Girişi
Console.Write("Lütfen Sıra Alacak Müşterinin Ad ve Soyadını Yazın: ");
string ad = Console.ReadLine(); // Yanıttan alınan veri
// Konsola menü edasında tüm günlerin listesini Loop (Döngü) yordamıyla bastırma
Console.WriteLine("\n--- Lütfen Randevu Alınacak Günü Seçin ---");
for (int i = 0; i < gun.Length; i++)
{
Console.WriteLine((i + 1) + "- " + gun[i]); // Ekran çıktısı örn : "1- Pzt"
}
// Seçim (İndeks sıfırdan başladığı için, kullanıcı 1 dediğinde arkada 0 olmalıdır. O sebeple - 1 atarız)
int g = int.Parse(Console.ReadLine()) - 1;
// Seçilen "g" gününe ait alt diziye dalış yaparak, o güne has vakitleri listeliyoruz
Console.WriteLine("\n--- O Güne Ait Saat Seçenekleri Aşağıdadır ---");
for (int i = 0; i < saat[g].Length; i++)
{
Console.WriteLine((i + 1) + "- " + saat[g][i]);
}
// Saat seçimi indeks mantığıyla alınır ve 's' içerisine atılır
int s = int.Parse(Console.ReadLine()) - 1;
// Tamamen veri ile doldurulmuş özel "Musteri" sınıfından ilk gerçek kişi nesnesi ayağa kaldırılır(New)
var m = new Musteri(ad, gun[g], saat[g][s]);
// Misafire uygulayabileceğimiz operasyonlar ve menü taslağı
Console.WriteLine("\nHizmetler\n1- Saç Kesimi (150TL)\n2- Cilt/Spa Bakımı (200TL)\n3- Gelin Düğün Makyajı (250TL)\n4- SİPARİŞİ BİTİR(Onay)");
// while (true) -> Sonsuz Kısır Döngü (Ta ki içeriden kişi "break/kırmak" isteyene kadar sürer)
while (true)
{
Console.Write("Hangi hizmeti istiyorsunuz (1,2,3,4): ");
string sec = Console.ReadLine();
// if blokları şartlar silsilesidir. Kullanıcı tuşlara bastıkça işlemler tetiklenir:
if (sec == "1") m.Hizmet("Saç Kesimi", 150);
else if (sec == "2") m.Hizmet("Cilt Bakımı", 200);
else if (sec == "3") m.Hizmet("Makyaj Uygulamaları", 250);
else if (sec == "4") // İşlemi tamamen sonlandırıp hesabı kesme vuruşudur
{
m.Yazdir(); // Çıktıyı kağıda döken metot çalışır, gösterir.
Console.WriteLine("\nTebrikler Randevunuz Onaylanmıştır. Güzel ve mutlu günler dileriz :)");
break; // Sistemi kısır döngü hapishanesinden çıkartır ve bitirir (Break=Kır / Çık).
}
else
{
Console.WriteLine("Uyarı: Hatalı bir tuşlama yaptınız.");
}
}
}
}
}
using System; // Ana System kılıfı eklentisi.
namespace NotUygulamasi // NotApp
{
// Temel nesne kalıbı (Sınıf/Class)
public class Ogrenci
{
// ----------- DEĞİŞKENLER (Alanlar) -----------
public string Ad; // Metin tabanlı ismi tutan bellek
public double Vize; // Sayısal virgüllü Vize Sınavı notu (%40'lık kısmı vs)
public double Final; // Diğer sınav (Final) puanının barındırıldığı yer
public double Ortalama; // Matematikten elde edilen karne puanı
public string Durum; // Ortalamaya endeksli 'Kalmak / Geçmek' metnini yansıtacak yer
// ----------- ANA İŞLEV YETENEĞİ (Metot) -----------
// Ogrenci notları belirlendikten sonra puanları işleyen fonksiyon.
public void Hesapla()
{
// Aritmetik mantık: Vize sınavının 0.4 oranında(%40) etkisi + Finalin 0.6(%60) etkisi alınarak toplanmıştır.
Ortalama = (Vize * 0.4) + (Final * 0.6);
// Koşul Mekanizması: Çıkan değer puan hesabı 50'den BÜYÜK veya tam 50 ise? (true döner)
if (Ortalama >= 50)
{
Durum = "Öğrenci Dersi Başarmıştır (GEÇTİ)"; // Durum içine zafer metnini yapıştırır
}
else // Başaramadıysa ve kural eksi/küçük ise:
{
Durum = "Maalesef Kurul Kararınca Başarısız Oldu (KALDI)"; // İnfaz metnini yapıştırır
}
}
}
class Program // Gidişatı yöneten sistem
{
// STATIC KULLANIMI: Main() bir statik olduğu için oradan gelecek diğer yetenekleri sınıf adına gerek duymamak için static yaparız.
// Bu blok içerisinde ogrenci objesi gelerek sorulara tabi tutulup veri alımı sağlanır
static void BilgileriAl(Ogrenci ogr)
{
Console.Write("T.C Nüfustaki Adınız ve Soyadınız: "); // Görsel bir veri sorusu basar
ogr.Ad = Console.ReadLine(); // Beklenilen yazıyı okuyup nesne içi o haneye yazdırır
Console.Write("Dönem İçi (Vize) Notunuz Nedir?: ");
// Normal metinsel sorulardan dönecek cevapların (ReadLine) bizim Vize (Double) alanımıza girebilmesi imkansızdır.
// Sayıları Metne çeviren metot olarak Parse() tekniği ile köprü (Cast) dönüşümü kurulmuştur
ogr.Vize = double.Parse(Console.ReadLine());
Console.Write("Yılsonu (Final) Notunuz Nedir?: ");
ogr.Final = double.Parse(Console.ReadLine()); // Vizedeki gibi çevirme işlemi ve ataması
}
// Aynı yapıda sadece işleri son noktaya bırakan raporlama ve konsol süsleme departmanı kodu (Void: işlem yapar ama geriye ekstra döndürme ataması yapmaz demek)
static void RaporuYazdir(Ogrenci ogr)
{
Console.WriteLine("\n---------------- SONUÇ İLAMI ----------------"); // Estetik boşluklu panel
Console.WriteLine("Sistemdeki İsim Soyisim: " + ogr.Ad); // Kullanıcı girdiği ada bakar
Console.WriteLine("Harfiyen Sonuç Ortalaması: " + ogr.Ortalama); // Çıkan net hesabı basar
Console.WriteLine("Gelecek Sene Konumu (Durum): " + ogr.Durum); // Yazı halindeki Karar
Console.WriteLine("--------------------------------------------");
}
static void Main(string[] args)
{
// Yeni bir temiz kapı aralar ve 0 kilometre Ogrenci varlığını doğurur
Ogrenci ogr = new Ogrenci();
BilgileriAl(ogr); // Veri girişi simülatörü kodu nesnemizi çalıştırırak devre alır
ogr.Hesapla(); // Veriler ile arkaplan hesabı yapılır
RaporuYazdir(ogr); // Dekont olarak sonlandırıcı sistem çıkar
// Siyah kutuda yazılım kapanıp ziyan olmasın diye tuş beklemesi (Pause) yaşatır!
Console.ReadKey();
}
}
}
using System; // Tüm komut satırlarını besleyen ana çekirdek dosyaların yüklendiğini belirtir (import eder).
namespace BankaUygulamasi // Yazılımdaki karışıklığı önlemek için projeleri klasörlere bölen alan(hacim) kavramı (Namespace).
{
// Temel Finansal Uygulamamızın Çatısını Kuran Class (Sınıf Modeli)
public class BankaServisi
{
// === SİSTEMDE VE VERİTABANINDA KULLANILACAK KUTULAR (Alanlar-Fields) ===
public string kullaniciAdi; // Belirlediği orijinal kullanıcı hesap metnini saklayacağımız gizli bir kasa
public int sifre; // Çoğunlukla sayısal (PIN) tabanlı işlem yapan orijinal Şifre tutucumuz
public string girisAd; // Uygulamayı başlattığında klavyeden tuşlayıp anında girmeye çalıştığı sahte/deneme isim hanesi
public int girisSifre; // Girmeye çalıştığı sahte/deneme şifre
public bool kontrol; // Bu bir mantık yapısıdır 'Bool', olayın 1(doğru) mu 0(yanlış/hatalı) mı olduğunu denetleme bayrağı rolü oynar.
public double bakiye = 5000; // Bankanın kampanya dahilinde verdiği sabit taze ana para (5 bin) başlangıcım.
// ==== YETENEK 1: (Metot) Hukuken ilk adım, Hesap Oluşturma Sistemi ====
public void HesapOlustur()
{
Console.WriteLine("--- MERKEZ HESAP OLUŞTURMA BAŞVURU EKRANI ---");
Console.Write("Ağa Bağlanmak İçin Yeni Kullanıcı Adınızı Belirleyiniz: ");
kullaniciAdi = Console.ReadLine(); // Verdiği ismi şablondaki o ilk klasöre eker. Paha biçilemez bir temelidir projenin.
Console.Write("Bir PİN (Sayısal Düzeyli Şifre) Tanımlayınız: ");
// İstersen uzun uzun metin girsin ama bu "Convert.ToInt32()" filtresinden sayesinde o metin direk Sayı(Int32) formatına bürünecektir! (Dönüşüm / Cast)
sifre = Convert.ToInt32(Console.ReadLine());
Console.WriteLine("Mükemmel, Hesabınız Güvenle Veritabanımıza Oluşturuldu!\n"); // Boşluk (\n) ile tamamlandı de...
}
// ==== YETENEK 2: (Metot) Sisteme Gerçekten Giriş Ve Oturum Açabilme ====
public void GirisYap()
{
Console.WriteLine("--- OTURUM GİRİŞ MERKEZİ ---");
Console.Write("Sistemde Kayıtlı Kullanıcı Adınızı Tuşlayın: ");
girisAd = Console.ReadLine(); // İlk baştaki girdiğimiz değil, burası sadece form olarak (dış kapıda bekleyen değişken 'girisAd') için alıp dener.
Console.Write("Parolanız (Şifreniz): ");
girisSifre = Convert.ToInt32(Console.ReadLine()); // Şifreyi sayısal okur ve dış kapı dener (girisSifre).
}
// ==== YETENEK 3: Siber Güvenlik Kontrolcü Sistemi (Deneme=Gerçek Eşleme) ====
public void Dogrula()
{
// Mantıksal Kapılar Döngüsü: Eğer asıl sistem kaydı ile(kullanicAdi); kullanıcının atm'de o an yazdığı şey(girisAd) == İLE AYNIYSA
// VE (&& işareti çift taraflı katılık demektir) asıl sifremiz atm de girdiği sifresiyle(girisSifre) == tamamen AYNI ŞİFREYSE:
if (kullaniciAdi == girisAd && sifre == girisSifre)
{
kontrol = true; // Evet, bizdendir. Kapıları aç (true bayrağını çek).
Console.WriteLine("✔ İşlem Onaylandı, Güvenli Giriş Başarılı! Panelinize Geçildi.");
Console.WriteLine($"Paneldeki Aktif Varlığınız:" + bakiye + "TL\n"); // Paramızı sunar
}
else // Ama yukarıdaki şart zinciri ufak bir şifre hatasıyla bozulursa o zaman yancısı olan sahte(Else) kapısına düşer kişi:
{
kontrol = false; // Hayır! Kapıları sıkı sıkı kitle.(bayrak = false indi).
Console.WriteLine("❌ Yetki Reddedildi: Hatalı giriş yapıldı, Lütfen sistem yöneticilerinizle temasa geçiniz. İşlem sonlandırıldı.");
}
}
// ==== YETENEK 4: Sivil Para Hareketleri Merkezi ====
public void ParaCek()
{
// Yukarıdaki siber kural onaylandıysa bu bir Boolean'dır (İçi True'dur). Direkt "Eğer Kontrol İçerisi True ise paranteze atla(gir)" demek oluyor
if (kontrol)
{
Console.Write("Çıkartmak/Nakde Tahvil Etmek istediğiniz TL Tutarını giriniz: ");
double miktar = Convert.ToDouble(Console.ReadLine()); // Çekilecek parayı double(ondalıklı paralık rakam) formatına dökerek miktar sepetine yığ
// Kasamızda para var mı? Bu durumu çekilen 'miktar' kasadaki 'bakiyeden' küçük(<) veya aynısı kadar eşitse(=/Sınır) karşılayabilir.
if (miktar <= bakiye)
{
bakiye -= miktar; // Kasanın içinden eksi = eksi kadar çıkart(Bakiyeden miktar kadar kıs, erit).
Console.WriteLine("İşlem onaydan geçti. Cihazdan Paranızı lütfen temas etmeden alınız.");
Console.WriteLine($"Ekranda Kalan Kullanılabilir Bakiyeniz: {bakiye} TL"); // Bakiye son halini ekleyerek yasar...
}
else // Açgözlü olduysa ve Kasadaki paradan yüzlerce kat büyüğünü çekmeye kalktıysa (Bakiye yetersiz durumu):
{
Console.WriteLine("Bankamatik Limit Hatası: Hesabınız bu miktarda çıkış için Yetersiz Bakiye barındırmaktadır!");
Console.WriteLine($"Size verebileceğimiz Mevcut Bakiyeniz: {bakiye} TL 'dir."); // Kasada asıl kaç TL kalmış açıkla...
}
}
}
}
// Uygulamamızın Ruhunun Cisim Bulduğu Ve Start Butonuna Basılan Derleme Gövdesi
class Program
{
static void Main(string[] args)
{
BankaServisi banka = new BankaServisi(); // Sınıftan artık dokunup işletebileceğimiz sanal/varlık bankamız şubesi kurulmuştur. (new obj/nesne).
// Tüm yukarı yetenek komut zincirleme halinde fonksiyonel (hukuki) sırayla çalıştırılır;
banka.HesapOlustur(); // Önce Adam Bankaya Abone Olsun Gelsin (Sistem kayıtları)
banka.GirisYap(); // Tamam kayıt oldu, Hadi Şimdi Atm'den Uygulamadan Bi Bilgi ve Giriş yapmaya Çalışsın (Oturum Girişi)
banka.Dogrula(); // Tamam girdi ama bir saniye, bu doğru kişi mi? Eşleşme var mı ona bakalım (Doğrulama Check İşlemleri)
if (banka.kontrol) // Eğer üst taraf true çektiyse ve adam bizdense,
{
banka.ParaCek(); // Hadi artık onu panelinde özgür bırak, parasını harcayıp çekebilsin! (Serbest bölge).
} // Hatalıysa if komutu asla ve asla bu kısma para çekme yuvasına yaklaştırmayacak :)
// Uygulama donmasın veya ekranda pat diye bitip kaybolmasın diye bekleme paneli 1 sn'lik yansır.
Console.WriteLine("\nOturumdan Çıkış yapmak ve Kapatmak için lütfen herhangi bir tuşa basınız.");
Console.ReadKey(); // İllaki klavyeye bas denmesi
} // Ana Metot Tüketimi Bitişi
} // Program Yönetimi sonu...
}
using System;
// Abstract Class (Soyut Sınıf): Doğrudan nesnesi oluşturulamaz, sadece diğer sınıflara kalıtımla miras (şablon) verir.
abstract class BankaHesabi
{
// Özellik (Property) tanımı: Hesap sahibini kapsüller (Encapsulation)
public string HesapSahibi { get; set; }
// Protected: Sadece bu sınıf ve bu sınıftan türeyenler (miras alanlar) erişebilir.
protected double Bakiye;
// Sınıf yapıcı metodu (Constructor)
public BankaHesabi(string hesapSahibi, double baslangicBakiye)
{
HesapSahibi = hesapSahibi;
Bakiye = baslangicBakiye;
}
// Her hesap türü için aynı olan genel para yatırma metodu
public void ParaYatir(double miktar)
{
Bakiye += miktar;
Console.WriteLine($"{miktar} TL yatırıldı. Yeni bakiye: {Bakiye}");
}
// Abstract (Soyut) Metot: Gövdesi yoktur. Miras alan her sınıf bunu kendi kurallarına göre mecbur DOLDURMAK(override) zorundadır.
public abstract void ParaCek(double miktar);
// Her hesaptan bakiyeyi gösteren metot
public void BakiyeGoster()
{
Console.WriteLine($"Bakiye: {Bakiye} TL");
}
}
// Vadesiz hesap sınıfı BankaHesabi sınıfından miras(Inheritance) alır
class VadesizHesap : BankaHesabi
{
// Base ile üst sınıfın (BankaHesabi) yapıcı metoduna parametreler gönderilir
public VadesizHesap(string ad, double bakiye) : base(ad, bakiye) { }
// Üst sınıftaki zorunlu (abstract) metot Vadesiz Hesap mantığına göre kurgulanıyor (Polymorphism - Çok Biçimlilik)
public override void ParaCek(double miktar)
{
if (miktar <= Bakiye) // Sadece bakiye varsa çekilir
{
Bakiye -= miktar;
Console.WriteLine($"{miktar} TL çekildi.");
}
else
{
Console.WriteLine("Yetersiz bakiye!");
}
}
}
// Vadeli hesap sınıfı yine BankaHesabi sınıfından miras(Inheritance) alır
class VadeliHesap : BankaHesabi
{
private double FaizOrani = 0.10; // %10 Faiz oranı
public VadeliHesap(string ad, double bakiye) : base(ad, bakiye) { }
// Vadeli hesaba özel faiz uygulama metodu
public void FaizUygula()
{
double faiz = Bakiye * FaizOrani; // Faiz hesaplanır
Bakiye += faiz; // Bakiyeye eklenir
Console.WriteLine($"Faiz eklendi: {faiz} TL");
}
// Üst sınıftaki zorunlu (abstract) metot Vadeli hesaba göre tasarlanıyor
public override void ParaCek(double miktar)
{
// Vadeli hesap dönemi bitmeden para çekilemeyeceği simüle ediliyor
Console.WriteLine("Vadeli hesaptan direkt para çekilemez!");
}
}
// Ana çalışma sınıfı
class Program
{
static void Main()
{
// Polymorphism gücü ile BankaHesabi referansına VadesizHesap nesnesi atıyoruz
BankaHesabi hesap1 = new VadesizHesap("Ahmet", 1000);
BankaHesabi hesap2 = new VadeliHesap("Mehmet", 2000);
// Ahmet'in vadesiz hesabı işlemleri
hesap1.ParaYatir(500);
hesap1.ParaCek(300);
hesap1.BakiyeGoster(); // Çıktı Bakiye: 1200 TL olur
Console.WriteLine("------");
// Mehmet'in vadeli hesap işlemleri
hesap2.ParaYatir(1000);
hesap2.ParaCek(500); // Abstract metodun vadeli hesap override'ı çalışır ve "Çekilemez" hatası verir
hesap2.BakiyeGoster(); // Bakiye dokunulmaz: 3000
// Downcasting (Tip Dönüşümü): Üst sınıf referansını, alt sınıfın özel metodunu kullanmak için çeviriyoruz
VadeliHesap vadeli = (VadeliHesap)hesap2;
vadeli.FaizUygula(); // Faiz %10 -> 300 TL eklendi
vadeli.BakiyeGoster(); // Son bakiye : 3300 TL oldu
}
}
using System; // Sistem kütüphanesini projeye dahil ediyoruz
//
class Urun // Sınıf tanımlaması, ürün nesneleri oluşturmak için yardımcı sınıf
{ // Sınıf bloğu başlangıcı
public string ad; // Ürünün adını tutacak metinsel değişken (her yerden erişilebilir)
public double fiyat; // Ürünün fiyatını tutacak ondalıklı değişken
//
public Urun(string a, double f) // Sınıfın yapıcı metodu, nesne oluşurken ilk değerleri atar
{ // Yapıcı metot bloğu başlangıcı
ad = a; // Dışarıdan gelen "a" parametresini ad değişkenine atar
fiyat = f; // Dışarıdan gelen "f" parametresini fiyat değişkenine atar
} // Yapıcı metot bloğu sonu
} // Sınıf bloğu sonu
//
class Program // Programın çalıştırılacağı ana sınıf
{ // Ana sınıf bloğu başlangıcı
static void Main() // Programın başlangıç noktası (ana metot)
{ // Ana metot bloğu başlangıcı
// Ürünleri oluşturup bir dizi içinde tanımlıyoruz
Urun[] urunler = new Urun[] // Urun tipinde bir dizi oluşturuyoruz
{ // Dizi elemanları başlangıcı
new Urun("Çikolata", 30), // 1. ürün nesnesini oluşturur ve diziye ekler
new Urun("Çilekli Süt", 45), // 2. ürün nesnesini oluşturur ve diziye ekler
new Urun("Jelibon", 50), // 3. ürün nesnesini oluşturur ve diziye ekler
new Urun("Pamuk Şeker", 70) // 4. ürün nesnesini oluşturur ve diziye ekler
}; // Dizi tanımlaması sonu
//
double toplam = 0; // Müşterinin ödeyeceği toplam tutarı tutacak değişken başlangıçta 0
//
Console.WriteLine("Eylül Market"); // Ekrana marketin adını başlık olarak yazdırır
//
// Tüm ürünleri ekrana listelemek için for döngüsü başlatıyoruz
for (int i = 0; i < urunler.Length; i++) // 0'dan ürün sayısına kadar döner
{ // Döngü bloğu başlangıcı
// Ürünün numarasını, adını ve fiyatını formatlı bir şekilde ekrana yazdırır
Console.WriteLine((i + 1) + " - " + urunler[i].ad + " : " + urunler[i].fiyat + " TL");
} // Döngü bloğu sonu
//
Console.Write("Kaç farklı ürün alacaksın: "); // Kullanıcıya kaç ürün alacağını sorar
int adet = Convert.ToInt32(Console.ReadLine()); // Kullanıcının girdiği metni tam sayıya çevirir ve kaydeder
//
// Kullanıcının belirttiği ürün çeşidi sayısı kadar seçim alacak for döngüsü
for (int i = 0; i < adet; i++) // 0'dan alınacak adet sayısına kadar döner
{ // Döngü bloğu başlangıcı
Console.Write("Ürün numarası: "); // Kullanıcıdan ürün numarasını girmesini ister
int secim = Convert.ToInt32(Console.ReadLine()); // Girilen metni sayıya dönüştürür ve seçime kaydeder
//
// Girilen ürün numarasının listede olup olmadığını kontrol eder
if (secim < 1 || secim > urunler.Length) // Eğer seçim 1'den küçük veya liste uzunluğundan büyükse
{ // If bloğu başlangıcı
Console.WriteLine("Hatalı seçim yaptın!"); // Kullanıcıya hata mesajı gösterir
i--; // Döngü sayacını bir azaltır ki aynı ürün sırasını tekrar sorsun
continue; // Döngünün geri kalanını atlayıp bir sonraki turuna (başına) döner
} // If bloğu sonu
//
Console.Write("Kaç adet: "); // Seçilen üründen kaç adet alınacağını sorar
int miktar = Convert.ToInt32(Console.ReadLine()); // Girilen adet miktarını tam sayıya çevirir
//
// Yeni alınan ürünlerin toplam fiyatını hesaplayıp mevcut toplama ekler
toplam = toplam + (urunler[secim - 1].fiyat * miktar); // Seçilen ürünün fiyatını miktar ile çarpıp toplama ekler
} // Döngü bloğu sonu
//
Console.WriteLine("Toplam tutar: " + toplam + " TL"); // Alışverişin genel toplamını ekrana yazdırır
} // Ana metot bloğu sonu
} // Ana sınıf bloğu sonu
using System; // Konsol işlemleri ve temel araçlar için System kütüphanesini dahil eder
//
class Soru // Soruları temsil etmek için bir Soru sınıfı oluşturuyoruz
{ // Sınıf bloğu başlangıcı
public string soruMetni; // Sorunun içeriğini (metnini) tutacak değişken
public string cevap; // Sorunun doğru yanıtını tutacak değişken
//
public Soru(string s, string c) // Soru sınıfının yapıcı (constructor) metodu, nesne oluşurken çalışır
{ // Yapıcı metot bloğu başlangıcı
soruMetni = s; // Dışarıdan parametre olarak gelen soruyu sınıftaki soruMetni değişkenine atar
cevap = c; // Dışarıdan parametre olarak gelen cevabı sınıftaki cevap değişkenine atar
} // Yapıcı metot bloğu sonu
} // Sınıf bloğu sonu
//
class Program // Programın başlangıç noktası olan ana sınıf
{ // Ana sınıf bloğu başlangıcı
static void Main() // Uygulamanın çalışmaya başladığı yer olan Main metodu
{ // Main metodu bloğu başlangıcı
// Soru nesnelerini tutacak bir dizi oluşturuyoruz ve içini dolduruyoruz
Soru[] sorular = new Soru[] // Soru tipinde bir dizi tanımlanıyor
{ // Dizi elemanlarının başlangıcı
new Soru("Türkiye'nin başkenti neresidir?", "ankara"), // 1. soru nesnesini oluşturur ve ekler
new Soru("Annen babandan olupta kardeşin olmayan kişi kimdir?", "ben"), // 2. soru nesnesini oluşturur ve ekler
new Soru("Dünyanın en büyük okyanusu hangisidir?", "pasifik") // 3. soru nesnesini oluşturur ve ekler
}; // Dizi tanımlamasının sonu
//
int puan = 0; // Kullanıcının doğru cevap sayısını tutacak puan değişkenini 0 ile başlatıyoruz
//
Console.WriteLine("=== Soru Cevap Uygulaması ==="); // Ekrana uygulamanın başlığını yazdırır
//
// Tüm soruları sırayla kullanıcıya sormak için bir for döngüsü başlatıyoruz
for (int i = 0; i < sorular.Length; i++) // 0'dan sorular dizisinin uzunluğuna kadar döner
{ // Döngü bloğu başlangıcı
// Mevcut sorunun numarasını ve metnini ekrana yazdırır
Console.WriteLine("\nSoru " + (i + 1) + ": " + sorular[i].soruMetni); // "\n" bir alt satıra geçmek içindir
//
Console.Write("Cevabın: "); // Kullanıcıdan cevabını yazmasını beklediğimizi belirten metin
string kullaniciCevap = Console.ReadLine().ToLower(); // Kullanıcının girdiği metni alır ve küçük harflere dönüştürür (ToLower)
//
// Kullanıcının verdiği cevabın doğru olup olmadığını kontrol eder
if (kullaniciCevap == sorular[i].cevap) // Eğer girilen cevap dizideki doğru cevapla birebir aynıysa
{ // If bloğu başlangıcı
Console.WriteLine("Doğru!"); // Ekrana tebrik mesajı yazdırır
puan = puan + 1; // Kullanıcının toplam puanını (doğru sayısını) 1 artırır
} // If bloğu sonu
else // Eğer verilen cevap doğru cevaba eşit değilse
{ // Else bloğu başlangıcı
Console.WriteLine("Yanlış! Doğru cevap: " + sorular[i].cevap); // Kullanıcıya cevabın yanlış olduğunu ve doğrusunu gösterir
} // Else bloğu sonu
} // Döngü bloğu sonu
//
// Döngü tamamlandıktan (tüm sorular bittikten) sonra sonucu yazdırır
Console.WriteLine("\nToplam doğru sayın: " + puan); // Toplam elde edilen puanı ekrana basar
} // Main metodu bloğu sonu
} // Ana sınıf bloğu sonu
using System; // Konsol ekranı ve veri giriş çıkışı için gerekli System kütüphanesi
//
class Program // Programın derlenip çalışacağı ana sınıf tanımlaması
{ // Sınıf bloğu başlangıcı
static void Main() // Kodların okunmaya başladığı ana (Main) başlangıç fonksiyonu
{ // Main fonksiyonu bloğu başlangıcı
string gizliKelime = "portakal"; // Bulunması istenen doğru kelimeyi değişkene atıyoruz
string tahmin; // Kullanıcının yapacağı tahmini tutacak metin değişkenini tanımlıyoruz
//
int hak = 3; // Kullanıcının toplamda sahip olduğu tahmin hakkı sayısını (3) belirtiyoruz
//
Console.WriteLine("=== Kelime Tahmin Oyunu ==="); // Oyunun başlığını ekrana yazdırır
Console.WriteLine("Bir meyve tahmin et!"); // Kullanıcıya ne yapması gerektiğini anlatan ipucu mesajı
//
// Kullanıcıya 3 kez tahmin hakkı vermek için kurulan for döngüsü
for (int i = 0; i < hak; i++) // 0'dan başlayarak hak sayısına kadar (3 kez) döngüyü çalıştırır
{ // Döngü bloğu başlangıcı
Console.Write("Tahminin: "); // Kullanıcıdan tahmin girmesi için ekranda yazı bekletir
tahmin = Console.ReadLine().ToLower(); // Kullanıcının girdiği kelimeyi okur ve küçük harfe dönüştürür (büyük/küçük harf sorununu çözer)
//
if (tahmin == gizliKelime) // Eğer kullanıcının girdiği tahmin ile gizli kelime eşleşiyorsa (Doğruysa)
{ // If bloğu başlangıcı
Console.WriteLine("Tebrikler! Bildin 🎉"); // Kullanıcıya başardığını belirten mesaj gösterir
break; // Doğru bildiği için döngüyü (kalan hakları) tamamen sonlandırıp çıkar
} // If bloğu sonu
else // Eğer kullanıcının tahmini gizli kelime ile aynı değilse (Yanlışsa)
{ // Else bloğu başlangıcı
Console.WriteLine("Yanlış tahmin!"); // Tahminin hatalı olduğunu ekrana yazar
//
// Kullanıcıya yardım etmek için kelime uzunluğu üzerinden ipucu verilir
if (tahmin.Length < gizliKelime.Length) // Eğer tahmin edilen kelimenin uzunluğu, gizli kelimeden kısa ise
{ // İç if bloğu başlangıcı
Console.WriteLine("Kelime daha uzun."); // Kullanıcıya kelimenin daha uzun bir kelime olduğunu söyler
} // İç if bloğu sonu
else // Eğer tahmin edilen kelimenin uzunluğu gizli kelimeden uzun veya eşit uzunlukta ise
{ // İç else bloğu başlangıcı
Console.WriteLine("Kelime daha kısa."); // Kullanıcıya kelimenin daha kısa olduğunu söyler
} // İç else bloğu sonu
} // Else bloğu sonu
} // Döngü bloğu sonu
//
Console.WriteLine("Oyun bitti."); // Haklar bitince veya doğru bilinip çıkılınca oyunun bittiğini yazar
} // Main fonksiyonu bloğu sonu
} // Sınıf bloğu sonu
using System; // Konsol fonksiyonlarını kullanabilmek için zorunlu kütüphane
//
class Program // Kodlarımızı çalıştıran sınıf kapsayıcısı
{ // Sınıf başlangıç süslü parantezi
static void Main() // Uygulama çalışınca ilk olarak okunacak olan ana giriş fonksiyonu
{ // Ana fonksiyon başlangıç süslü parantezi
int gizliSayi = 7; // Tahmin edilmesi gereken doğru sayıyı belirliyoruz (7)
int tahmin; // Kullanıcının her adımda gireceği sayısal değeri tutacak değişken
int hak = 3; // Kullanıcının oyunu kazanmak için kullanabileceği toplam deneme hakkı
//
Console.WriteLine("=== Sayı Tahmin Oyunu ==="); // Ekrana oyunun adını içeren bir başlık yazdırır
Console.WriteLine("1 ile 10 arasında bir sayı tahmin et!"); // Oyunun kuralını ekrana yazdırır
//
// Kullanıcıya belirlediğimiz hak kadar deneme şansı veren for döngüsü
for (int i = 0; i < hak; i++) // Sayaç 0'dan başlar ve hak sayısına (3) kadar döngü çalışır
{ // Döngü başlangıç süslü parantezi
Console.Write("Tahminin: "); // Kullanıcıdan sayı girmesini isteyen metni yazar
tahmin = Convert.ToInt32(Console.ReadLine()); // Kullanıcının yazdığı metni okur ve bir tam sayıya (integer) dönüştürür
//
if (tahmin == gizliSayi) // Eğer kullanıcının tahmini ile belirlediğimiz gizli sayı birebir aynıysa
{ // Doğru tahmin bloğu başlangıcı
Console.WriteLine("Tebrikler! Doğru bildin 🎉"); // Kullanıcıya başarılı olduğunu bildirir
break; // Doğru tahmin yapıldığı için döngüyü kırıp oyunu erken bitirir
} // Doğru tahmin bloğu sonu
else // Eğer tahmin edilen sayı ile gizli sayı eşit değilse
{ // Yanlış tahmin bloğu başlangıcı
Console.WriteLine("Yanlış tahmin!"); // Tahminin yanlış olduğunu belirten bir mesaj yazar
//
// Oyuncuya yardımcı olmak amacıyla sayının büyük/küçük olmasıyla ilgili yönlendirme yapılır
if (tahmin < gizliSayi) // Eğer girilen tahmin, gerçek gizli sayıdan küçük kalıyorsa
{ // İpucu yönlendirme başlangıcı
Console.WriteLine("Daha büyük bir sayı gir."); // Kullanıcının bir sonraki adımda daha büyük bir sayı denemesi istenir
} // İpucu yönlendirme sonu
else // Eğer girilen tahmin gizli sayıdan büyükse (Geriye kalan tek ihtimal)
{ // Else bloğu başlangıcı
Console.WriteLine("Daha küçük bir sayı gir."); // Kullanıcının bir sonraki adımda daha küçük bir sayı denemesi istenir
} // Else bloğu sonu
} // Yanlış tahmin bloğu sonu
} // Döngü bitiş süslü parantezi
//
Console.WriteLine("Oyun bitti."); // Tüm haklar kullanıldığında veya doğru bilinip döngüden çıkıldığında yazar
} // Ana fonksiyon bitiş süslü parantezi
} // Sınıf bitiş süslü parantezi
using System; // Konsoldan girdi almak ve çıktı vermek için gereken sistem kütüphanesini içeri aktarır
//
// Koruma altındaki bir hayvanı temsil eden ve ona ait bilgileri tutan sınıf
class HayvanBilgi // Hayvan özellikleri için oluşturulmuş şablon sınıf
{ // Sınıf gövdesi başlangıcı
// Hayvanın türünü tutacak metinsel değişken (Örn: Kedi, Köpek, Kaplumbağa vb.)
public string HayvanTuru; // Dışarıdan kolayca erişilebilmesi için public (açık) olarak tanımlanmıştır
//
// Hayvanın yaşını tutacak sayısal tam sayı (integer) değişken
public int HayvanYasi; // Hayvanın kaç yaşında olduğu bilgisini saklar
//
// Sınıfın sahip olduğu özellikleri kullanarak bilgileri ekrana estetik bir şekilde yazdıran yetenek (metot)
public void BilgiGoster() // Geriye değer döndürmeyen (void) metot tanımı
{ // Metot gövdesi başlangıcı
Console.WriteLine("\n--- Kayıt Başarıyla Tamamlandı ---"); // Kaydın tamamlandığına dair bir bilgilendirme metni yazar
Console.WriteLine( // Cümleyi oluşturmak için Console.WriteLine içine parçalar gönderilir
HayvanTuru + // Özelliklerden çekilen hayvanın türü
" dostumuzun yaşı: " + // Cümleyi birleştiren açıklama yazısı
HayvanYasi + // Özelliklerden çekilen hayvanın yaşı
" olarak sisteme işlendi. Onları koruyalım!" // Anlamlı mesaj ile birleşimi tamamlayan son kelimeler
); // Ekrana basma işlemi biter
} // Metot gövdesi sonu
} // HayvanBilgi sınıfı sonu
//
class Program // Uygulamayı başlatacak olan ve ana metodu barındıran temel sınıf
{ // Program sınıfı başlangıcı
static void Main(string[] args) // Program çalıştırıldığında işletilecek olan start (başlangıç) fonksiyonu
{ // Main metodu başlangıcı
// Bellekte 'HayvanBilgi' şablonuna dayanarak 'yeniHayvan' isminde somut bir varlık (nesne) oluşturuluyor
HayvanBilgi yeniHayvan = new HayvanBilgi(); // Bellekte yeni (new) bir yer ayrıldı
//
Console.WriteLine("=== Hayvanları Koruma Kayıt Sistemine Hoş Geldiniz ==="); // Sistemin hoş geldin mesajını gösterir
//
// Kullanıcıdan koruma altına alınan hayvanın ne tür olduğunu soruyoruz
Console.Write("Lütfen koruma altına alınan hayvanın türünü giriniz: "); // Ekrana soru metnini yazar
yeniHayvan.HayvanTuru = Console.ReadLine(); // Kullanıcının girdiği metni alır ve nesnemizin HayvanTuru özelliğine kaydeder
//
// Kullanıcıdan aynı hayvanın yaşıyla ilgili bilgiyi alıyoruz
Console.Write("Hayvanın yaşını giriniz: "); // Kullanıcıya yaş ile ilgili soruyu ekrana yazar
// Klavyeden girilen her değer metin (string) olduğu için onu int.Parse() ile gerçek bir sayıya (integer) çeviriyoruz
yeniHayvan.HayvanYasi = int.Parse(Console.ReadLine()); // Metinden sayıya dönen veriyi nesnemizin HayvanYasi alanına kaydeder
//
// Verileri alınan hayvan nesnesi üzerinden sınıf içindeki yazdırma yeteneğini (metodu) çağırıyoruz
yeniHayvan.BilgiGoster(); // Nesne gidip kaydettiği bilgileri ekrana güzelce formüle ederek basacaktır
//
// İşlemler biter bitmez konsol penceresinin aniden kapanmasını önlemek için klavyeden bir hamle bekliyoruz
Console.WriteLine("\nÇıkmak için bir tuşa basın..."); // Çıkış yapılacağını belirten mesaj
Console.ReadKey(); // Kullanıcı herhangi bir tuşa basana kadar sistemi askıda (beklemede) tutar
} // Main metodu sonu
} // Program sınıfı sonu
using System; // Konsol uygulamalarının temel gereksinimi olan System kütüphanesini dahil eder
using System.Collections.Generic; // Listeler ve koleksiyonlar (Dictionary vb.) için gerekli olan kütüphane
using System.Linq; // Veri sorgulama, dizilerde gelişmiş arama ve filtreleme yapmayı sağlayan kütüphane
using System.Text; // Metin dönüştürme ve işleme fonksiyonlarını içeren kütüphane
using System.Threading.Tasks; // Asenkron programlama ve görev yönetimi süreçlerini kolaylaştıran kütüphane
//
class Program // Bütün komutların içerisinde barınacağı yönetici şablon (Sınıf)
{ // Program sınıfının başlangıç bloğu
static void Main() // Kodun ilk çalışmaya başladığı (Start noktası) ana metot
{ // Main metodu başlangıç bloğu
// Hava durumu varyasyonlarını tutacak olan metinsel (string) bir dizi oluşturuluyor
string[] durumlar = { "Güneşli", "Bulutlu", "Yağmurlu", "Karlı", "Rüzgarlı", "Sisli" }; // İçinde 6 farklı seçenek olan dizi tanımlandı
//
Random rnd = new Random(); // Rastgele değerler (sayı veya dizi indisi) üretmek için Random sınıfından 'rnd' nesnesi oluşturuluyor
//
Console.Write("Soru yaz: "); // Kullanıcıya sorusunu yöneltmesini isteyen bir mesaj çıkarır
string soru = Console.ReadLine().ToLower(); // Kullanıcının girdiği cümlenin tamamını okuyup küçük harfe (ToLower) dönüştürerek değişkene atar
//
if (soru.Contains("hava")) // Eğere kullanıcının sorduğu cümlenin (soru) içerisinde "hava" kelimesi geçiyorsa (Contains fonksiyonu kontrol eder)
{ // Eğer koşul sağlanırsa (Cümlede hava geçiyorsa) çalışacak blok
int derece = rnd.Next(-5, 36); // -5 ile 36 (36 dahil değil) arasında tamamen rastgele bir hava sıcaklığı sayısı üretir
string durum = durumlar[rnd.Next(durumlar.Length)]; // durumlar dizisindeki (0 ile dizinin uzunluğu arasında) rastgele bir indeks seçerek oradaki hava durumunu alır
//
Console.WriteLine("Cevap: " + derece + "°C ve " + durum); // Üretilen rastgele derece ve durumu birleştirerek anlamlı bir cevap yazar
} // Koşul bloğunun sonu
else // Eğer kullanıcının yazdığı sorunun hiçbir yerinde "hava" kelimesi yoksa
{ // Else bloğu başlangıcı
Console.WriteLine("Cevap: Sadece hava sorularına cevap veriyorum."); // Botun sadece hava ile ilgilendiğini belirten bir hata/uyarı mesajı yazar
} // Else bloğu sonu
} // Main metodu bitişi
} // Program sınıfının bitişi
Giriş Yap
Ders materyallerine erişmek için hesabınıza giriş yapın.