,

Dart Kodlama

Dart Programlama Dili Eğitimi

Ogr.Gor Keyvan Arasteh İstinye Üniversitesi Bilişim Güvenliği Teknolojisi Bölümü

Dart Nedir?

Dart, Google tarafından geliştirilen, modern ve nesne yönelimli bir programlama dilidir. Flutter framework'ünün temel dili olarak kullanılan Dart, hem web hem de mobil uygulama geliştirmede kullanılır. Özellikle:

  • Hızlı derleme ve yürütme
  • Güçlü tip sistemi
  • Zengin standart kütüphane
  • Cross-platform geliştirme desteği

özellikleriyle öne çıkar.

Değişkenler

Dart'ta değişkenler, veri depolamak için kullanılan temel yapı taşlarıdır.

// Temel veri tipleri
String isim = "Ahmet";  // Metin
int yas = 25;           // Tam sayı
double boy = 1.78;      // Ondalıklı sayı
bool ogrenciMi = true;  // Mantıksal değer

// var kullanımı - tip çıkarımı
var sehir = "İstanbul";  // String olarak çıkarım yapar

// final ve const
final dogumTarihi = "2000";  // Değeri bir kez atanır
const PI = 3.14;             // Derleme zamanında sabit

// Gerçek hayat örneği:
var ogrenciNumarasi = "2024001";
final mezuniyetYili = 2024;

Listeler

Listeler, sıralı veri koleksiyonlarıdır.

// Liste tanımlama
List<String> dersler = ["Matematik", "Fizik", "Kimya"];
var notlar = [85, 90, 75];

// Liste işlemleri
dersler.add("Biyoloji");         // Eleman ekleme
dersler.remove("Fizik");         // Eleman silme
var ilkDers = dersler[0];        // Elemana erişim

// Gerçek hayat örneği: Öğrenci notları takibi
List<Map<String, dynamic>> ogrenciNotlari = [
  {"ders": "Siber Güvenlik", "vize": 85, "final": 90},
  {"ders": "Ağ Temelleri", "vize": 75, "final": 85}
];

Setler

Setler, benzersiz elemanlardan oluşan koleksiyonlardır.

// Set tanımlama
Set<String> renkler = {"kırmızı", "mavi", "yeşil"};
var sayilar = <int>{1, 2, 3, 3};  // 3 sadece bir kez eklenir

// Set işlemleri
renkler.add("sarı");              // Eleman ekleme
renkler.remove("mavi");           // Eleman silme
print(renkler.contains("yeşil")); // Eleman kontrolü

// Gerçek hayat örneği: Unique kullanıcı ID'leri
Set<String> aktifKullanicilar = {"user123", "admin456", "guest789"};

Map

Map, anahtar-değer çiftlerinden oluşan koleksiyonlardır.

// Map tanımlama
Map<String, String> kullaniciBilgileri = {
  "ad": "Mehmet",
  "soyad": "Yılmaz",
  "email": "[email protected]"
};

// Map işlemleri
kullaniciBilgileri["telefon"] = "5551234567";  // Eleman ekleme
kullaniciBilgileri.remove("email");            // Eleman silme

// Gerçek hayat örneği: Ürün kataloğu
Map<String, Map<String, dynamic>> urunKatalogu = {
  "laptop1": {
    "marka": "TechPro",
    "fiyat": 15000,
    "stok": 10
  },
  "telefon1": {
    "marka": "SmartX",
    "fiyat": 8000,
    "stok": 15
  }
};

Fonksiyonlar

Fonksiyonlar, tekrar kullanılabilir kod bloklarıdır.

// Temel fonksiyon
int topla(int a, int b) {
  return a + b;
}

// Ok fonksiyonu (Lambda)
var carp = (int a, int b) => a * b;

// Opsiyonel parametreli fonksiyon
String selamla([String isim = "Misafir"]) {
  return "Merhaba $isim";
}

// Named parametreli fonksiyon
void ogrenciKayit({
  required String ad,
  required String soyad,
  int? yas
}) {
  print("$ad $soyad kaydedildi");
}

// Gerçek hayat örneği: Sipariş toplam hesaplama
double siparisToplamHesapla(List<double> urunFiyatlari, {double vergiOrani = 0.18}) {
  var toplam = urunFiyatlari.reduce((a, b) => a + b);
  return toplam * (1 + vergiOrani);
}

Döngüler

Döngüler, tekrarlı işlemleri gerçekleştirmek için kullanılır.

// for döngüsü
for (var i = 0; i < 5; i++) {
  print(i);
}

// for-in döngüsü
var meyveler = ["elma", "armut", "muz"];
for (var meyve in meyveler) {
  print(meyve);
}

// while döngüsü
var sayac = 0;
while (sayac < 3) {
  print(sayac);
  sayac++;
}

// Gerçek hayat örneği: Stok kontrolü
List<Map<String, dynamic>> urunler = [
  {"ad": "Laptop", "stok": 5},
  {"ad": "Mouse", "stok": 10},
  {"ad": "Klavye", "stok": 3}
];

for (var urun in urunler) {
  if (urun["stok"] < 5) {
    print("${urun["ad"]} için stok uyarısı!");
  }
}

Şartlar

Şart ifadeleri, programın akışını kontrol etmek için kullanılır.

// if-else kullanımı
var not = 75;
if (not >= 90) {
  print("AA");
} else if (not >= 85) {
  print("BA");
} else {
  print("BB");
}

// switch-case kullanımı
var gun = "Pazartesi";
switch (gun) {
  case "Pazartesi":
    print("Haftanın ilk günü");
    break;
  case "Cuma":
    print("Haftanın son iş günü");
    break;
  default:
    print("Diğer gün");
}

// Gerçek hayat örneği: Kullanıcı yetki kontrolü
void yetkiKontrol(String kullaniciTipi) {
  if (kullaniciTipi == "admin") {
    print("Tüm yetkilere sahipsiniz");
  } else if (kullaniciTipi == "editor") {
    print("Düzenleme yetkilerine sahipsiniz");
  } else {
    print("Sınırlı yetkilere sahipsiniz");
  }
}

Dart'ın Güvenlik Uygulamalarında Kullanımı

Bilişim güvenliği alanında Dart'ın kullanım örnekleri:

// Basit şifre kontrolü
bool sifreKontrol(String sifre) {
  if (sifre.length < 8) return false;
  if (!sifre.contains(RegExp(r'[A-Z]'))) return false;
  if (!sifre.contains(RegExp(r'[0-9]'))) return false;
  if (!sifre.contains(RegExp(r'[!@#$%^&*(),.?":{}|<>]'))) return false;
  return true;
}

// Basit veri şifreleme örneği
String basitSifrele(String metin, int anahtar) {
  return metin.split('').map((char) {
    var kod = char.codeUnitAt(0) + anahtar;
    return String.fromCharCode(kod);
  }).join('');
}

// Güvenli veri saklama örneği
class GuvenliVeri {
  final Map<String, String> _veri = {};
  
  void veriEkle(String anahtar, String deger) {
    if (anahtar.isEmpty || deger.isEmpty) {
      throw Exception("Boş değer kabul edilmez");
    }
    _veri[anahtar] = basitSifrele(deger, 3);
  }
}

Dart Programlama Ödevleri

Hazırlayan: Ogr.Gor Keyvan Arasteh İstinye Üniversitesi Bilişim Güvenliği Teknolojisi Bölümü

Ödev 1: Temel Değişkenler ve Operatörler

Güvenli Şifre Oluşturucu

Amaç: Kullanıcıdan alınan bilgilerle güvenli bir şifre oluşturma uygulaması geliştirmek.

Gereksinimler:

  1. Kullanıcıdan ad, soyad ve doğum yılı bilgilerini alın

  2. Bu bilgileri kullanarak aşağıdaki kurallara uygun bir şifre oluşturun:

    • En az 8 karakter uzunluğunda
    • En az 1 büyük harf
    • En az 1 özel karakter
    • Doğum yılının son iki rakamı

  3. Oluşturulan şifrenin güvenlik seviyesini kontrol eden bir fonksiyon yazın

  4. Sonucu ekrana yazdırın

Öğrenme Hedefleri:

  • String manipülasyonu
  • Değişken tipleri
  • Temel operatörler
  • print() fonksiyonu kullanımı

Ödev 2: Listeler ve Döngüler

Öğrenci Not Takip Sistemi

Amaç: Bir sınıftaki öğrencilerin notlarını takip eden ve analiz eden bir sistem geliştirmek.

Gereksinimler:

  1. En az 5 öğrencinin bilgilerini içeren bir liste oluşturun:

    • Ad
    • Soyad
    • Vize notu
    • Final notu

  2. Her öğrenci için:

    • Ortalama hesaplayın (Vize %40, Final %60)
    • Harf notu belirleyin

  3. Sınıf için:

    • En yüksek notu bulun
    • En düşük notu bulun
    • Sınıf ortalamasını hesaplayın

  4. Sonuçları düzenli bir şekilde ekrana yazdırın

Öğrenme Hedefleri:

  • Liste oluşturma ve manipülasyonu
  • For döngüleri
  • If-else yapıları
  • Fonksiyon yazımı

Ödev 3: Map ve Set Yapıları

Kütüphane Yönetim Sistemi

Amaç: Basit bir kütüphane yönetim sistemi geliştirmek.

Gereksinimler:

  1. Kitapları tutan bir Map yapısı oluşturun:

    • ISBN numarası (anahtar)
    • Kitap bilgileri (değer: başlık, yazar, yayın yılı, kopya sayısı)

  2. Aşağıdaki işlemleri yapan fonksiyonlar yazın:

    • Yeni kitap ekleme
    • Kitap silme
    • Kitap arama (ISBN ile)
    • Kitap güncelleme
    • Ödünç verme/iade işlemleri

  3. Ödünç alınan kitapları takip etmek için bir Set yapısı kullanın

  4. Menü bazlı bir arayüz oluşturun

Öğrenme Hedefleri:

  • Map kullanımı
  • Set kullanımı
  • Switch-case yapısı
  • Fonksiyon yazımı

Ödev 4: Nesne Yönelimli Programlama

Banka Hesap Yönetimi

Amaç: Basit bir banka hesap yönetim sistemi geliştirmek.

Gereksinimler:

  1. Hesap sınıfı oluşturun:

    • Hesap numarası
    • Hesap sahibi
    • Bakiye
    • İşlem geçmişi

  2. Aşağıdaki metodları implement edin:

    • Para yatırma
    • Para çekme
    • Bakiye sorgulama
    • Hesap özeti

  3. İşlem limitleri ve güvenlik kontrolleri ekleyin

  4. İşlem geçmişini kaydedin ve raporlayın

Öğrenme Hedefleri:

  • Sınıf oluşturma
  • Constructor kullanımı
  • Metod yazımı
  • Exception handling

Ödev 5: Asenkron Programlama

Dosya Şifreleme Uygulaması

Amaç: Dosyaları şifreleyen ve çözen bir uygulama geliştirmek.

Gereksinimler:

  1. Dosya okuma ve yazma işlemleri için asenkron fonksiyonlar yazın

  2. Basit bir şifreleme algoritması implement edin

  3. Aşağıdaki özellikleri ekleyin:

    • Dosya seçme
    • Şifreleme
    • Şifre çözme
    • İlerleme durumu gösterme

  4. Hata kontrolü ve raporlama ekleyin

Öğrenme Hedefleri:

  • async/await kullanımı
  • Future sınıfı
  • Hata yakalama
  • Dosya işlemleri

Ödev 6: Final Projesi

Güvenlik Denetim Uygulaması

Amaç: Bir sistemin güvenlik durumunu analiz eden ve raporlayan bir uygulama geliştirmek.

Gereksinimler:

  1. Aşağıdaki kontrolleri yapan bir sistem geliştirin:

    • Şifre güvenliği kontrolü
    • Dosya bütünlük kontrolü
    • Log analizi
    • Ağ bağlantı kontrolü

  2. Her kontrol için ayrı bir sınıf oluşturun

  3. Sonuçları JSON formatında kaydedin

  4. Detaylı bir rapor oluşturun

  5. Kullanıcı dostu bir arayüz ekleyin

Öğrenme Hedefleri:

  • Tüm Dart kavramlarının entegrasyonu
  • JSON işleme
  • Nesne yönelimli programlama
  • Güvenlik konseptleri

 

Yardımcı Kaynaklar

  1. Dart resmi dokümantasyonu
  2. Flutter.dev
  3. Dart packages (pub.dev)
  4. GitHub örnek projeleri
  5. Stack Overflow

 

 

 

 

Dart Programlama Ödevleri – Örnek Çözümler

Hazırlayan: Ogr.Gor Keyvan Arasteh İstinye Üniversitesi Bilişim Güvenliği Teknolojisi Bölümü

Ödev 1: Güvenli Şifre Oluşturucu – Çözüm

import 'dart:io';
import 'dart:math';

class SifreOlusturucu {
  // Kullanıcı bilgilerini saklayacak değişkenler
  String ad;
  String soyad;
  String dogumYili;

  // Constructor
  SifreOlusturucu(this.ad, this.soyad, this.dogumYili);

  // Özel karakterler listesi
  final List<String> ozelKarakterler = ['!', '@', '#', '$', '%', '&', '*'];

  // Şifre oluşturma metodu
  String sifreOlustur() {
    // Ad ve soyadın ilk harflerini büyük harfe çeviriyoruz
    String adIlkHarf = ad[0].toUpperCase();
    String soyadIlkHarf = soyad[0].toUpperCase();
    
    // Doğum yılının son iki rakamını alıyoruz
    String yilSon = dogumYili.substring(dogumYili.length - 2);
    
    // Random bir özel karakter seçiyoruz
    Random random = Random();
    String ozelKarakter = ozelKarakterler[random.nextInt(ozelKarakterler.length)];
    
    // Şifreyi oluşturuyoruz
    String sifre = adIlkHarf + soyad.toLowerCase() + ozelKarakter + yilSon + 
                   soyadIlkHarf + ad.toLowerCase();
    
    return sifre;
  }

  // Şifre güvenlik kontrolü
  Map<String, dynamic> sifreGuvenlikKontrol(String sifre) {
    int puan = 0;
    List<String> yorumlar = [];

    // Uzunluk kontrolü
    if (sifre.length >= 8) {
      puan += 25;
      yorumlar.add("✓ Şifre uzunluğu yeterli");
    } else {
      yorumlar.add("✗ Şifre en az 8 karakter olmalı");
    }

    // Büyük harf kontrolü
    if (sifre.contains(RegExp(r'[A-Z]'))) {
      puan += 25;
      yorumlar.add("✓ Büyük harf içeriyor");
    } else {
      yorumlar.add("✗ Büyük harf içermeli");
    }

    // Özel karakter kontrolü
    if (ozelKarakterler.any((karakter) => sifre.contains(karakter))) {
      puan += 25;
      yorumlar.add("✓ Özel karakter içeriyor");
    } else {
      yorumlar.add("✗ Özel karakter içermeli");
    }

    // Sayı kontrolü
    if (sifre.contains(RegExp(r'[0-9]'))) {
      puan += 25;
      yorumlar.add("✓ Sayı içeriyor");
    } else {
      yorumlar.add("✗ Sayı içermeli");
    }

    return {
      'puan': puan,
      'yorumlar': yorumlar,
      'seviye': puan < 50 ? 'Zayıf' : puan < 75 ? 'Orta' : 'Güçlü'
    };
  }
}

void main() {
  // Kullanıcıdan bilgileri alıyoruz
  print("Adınızı giriniz:");
  String ad = stdin.readLineSync() ?? "";
  
  print("Soyadınızı giriniz:");
  String soyad = stdin.readLineSync() ?? "";
  
  print("Doğum yılınızı giriniz:");
  String dogumYili = stdin.readLineSync() ?? "";

  // Şifre oluşturucu nesnesini oluşturuyoruz
  var sifreOlusturucu = SifreOlusturucu(ad, soyad, dogumYili);
  
  // Şifreyi oluşturuyoruz
  String sifre = sifreOlusturucu.sifreOlustur();
  
  // Şifre güvenliğini kontrol ediyoruz
  var guvenlikSonuc = sifreOlusturucu.sifreGuvenlikKontrol(sifre);

  // Sonuçları ekrana yazdırıyoruz
  print("\n=== Şifre Analizi ===");
  print("Oluşturulan şifre: $sifre");
  print("Güvenlik puanı: ${guvenlikSonuc['puan']}/100");
  print("Güvenlik seviyesi: ${guvenlikSonuc['seviye']}");
  print("\nKontrol listesi:");
  for (var yorum in guvenlikSonuc['yorumlar']) {
    print(yorum);
  }
}

Ödev 2: Öğrenci Not Takip Sistemi – Çözüm

class Ogrenci {
  String ad;
  String soyad;
  double vizeNotu;
  double finalNotu;
  
  Ogrenci(this.ad, this.soyad, this.vizeNotu, this.finalNotu);

  // Ortalama hesaplama metodu
  double ortalamaHesapla() {
    return (vizeNotu * 0.4) + (finalNotu * 0.6);
  }

  // Harf notu hesaplama metodu
  String harfNotuHesapla() {
    double ortalama = ortalamaHesapla();
    if (ortalama >= 90) return 'AA';
    if (ortalama >= 85) return 'BA';
    if (ortalama >= 80) return 'BB';
    if (ortalama >= 75) return 'CB';
    if (ortalama >= 70) return 'CC';
    if (ortalama >= 65) return 'DC';
    if (ortalama >= 60) return 'DD';
    return 'FF';
  }
}

class SinifYonetimi {
  List<Ogrenci> ogrenciler = [];

  // Öğrenci ekleme metodu
  void ogrenciEkle(Ogrenci ogrenci) {
    ogrenciler.add(ogrenci);
  }

  // Sınıf ortalaması hesaplama
  double sinifOrtalamasi() {
    if (ogrenciler.isEmpty) return 0;
    double toplam = ogrenciler.fold(0, (sum, ogrenci) => sum + ogrenci.ortalamaHesapla());
    return toplam / ogrenciler.length;
  }

  // En yüksek notu bulma
  Map<String, dynamic> enYuksekNot() {
    if (ogrenciler.isEmpty) return {'ogrenci': null, 'ortalama': 0};
    
    Ogrenci enYuksek = ogrenciler[0];
    for (var ogrenci in ogrenciler) {
      if (ogrenci.ortalamaHesapla() > enYuksek.ortalamaHesapla()) {
        enYuksek = ogrenci;
      }
    }
    
    return {
      'ogrenci': '${enYuksek.ad} ${enYuksek.soyad}',
      'ortalama': enYuksek.ortalamaHesapla()
    };
  }

  // En düşük notu bulma
  Map<String, dynamic> enDusukNot() {
    if (ogrenciler.isEmpty) return {'ogrenci': null, 'ortalama': 0};
    
    Ogrenci enDusuk = ogrenciler[0];
    for (var ogrenci in ogrenciler) {
      if (ogrenci.ortalamaHesapla() < enDusuk.ortalamaHesapla()) {
        enDusuk = ogrenci;
      }
    }
    
    return {
      'ogrenci': '${enDusuk.ad} ${enDusuk.soyad}',
      'ortalama': enDusuk.ortalamaHesapla()
    };
  }

  // Sınıf durumu raporu
  void sinifRaporuYazdir() {
    print('\n=== SINIF RAPORU ===\n');
    print('Toplam öğrenci sayısı: ${ogrenciler.length}');
    print('Sınıf ortalaması: ${sinifOrtalamasi().toStringAsFixed(2)}');
    
    var enYuksek = enYuksekNot();
    var enDusuk = enDusukNot();
    
    print('En yüksek not: ${enYuksek['ogrenci']} - ${enYuksek['ortalama'].toStringAsFixed(2)}');
    print('En düşük not: ${enDusuk['ogrenci']} - ${enDusuk['ortalama'].toStringAsFixed(2)}\n');
    
    print('ÖĞRENCI LISTESI:');
    print('Ad Soyad'.padRight(20) + 'Vize'.padRight(8) + 'Final'.padRight(8) + 
          'Ortalama'.padRight(10) + 'Harf Notu');
    print('-' * 55);
    
    for (var ogrenci in ogrenciler) {
      print(
        '${ogrenci.ad} ${ogrenci.soyad}'.padRight(20) +
        '${ogrenci.vizeNotu}'.padRight(8) +
        '${ogrenci.finalNotu}'.padRight(8) +
        '${ogrenci.ortalamaHesapla().toStringAsFixed(2)}'.padRight(10) +
        '${ogrenci.harfNotuHesapla()}'
      );
    }
  }
}

void main() {
  var sinifYonetimi = SinifYonetimi();

  // Örnek öğrenciler ekliyoruz
  sinifYonetimi.ogrenciEkle(Ogrenci('Ali', 'Yılmaz', 85, 90));
  sinifYonetimi.ogrenciEkle(Ogrenci('Ayşe', 'Demir', 90, 95));
  sinifYonetimi.ogrenciEkle(Ogrenci('Mehmet', 'Kaya', 75, 80));
  sinifYonetimi.ogrenciEkle(Ogrenci('Zeynep', 'Çelik', 95, 85));
  sinifYonetimi.ogrenciEkle(Ogrenci('Can', 'Öztürk', 70, 75));

  // Sınıf raporunu yazdırıyoruz
  sinifYonetimi.sinifRaporuYazdir();
}

Dart Programlama Ödevleri – Örnek Çözümler

[Previous solutions for Ödev 1 and 2 remain the same…]

Ödev 3: Kütüphane Yönetim Sistemi – Çözüm

class Kitap {
  String baslik;
  String yazar;
  int yayinYili;
  int kopyaSayisi;
  
  Kitap(this.baslik, this.yazar, this.yayinYili, this.kopyaSayisi);
  
  Map<String, dynamic> toJson() {
    return {
      'baslik': baslik,
      'yazar': yazar,
      'yayinYili': yayinYili,
      'kopyaSayisi': kopyaSayisi
    };
  }
}

class KutuphaneYonetimi {
  Map<String, Kitap> kitaplar = {};
  Set<String> oduncKitaplar = {};

  // Kitap ekleme metodu
  void kitapEkle(String isbn, Kitap kitap) {
    if (kitaplar.containsKey(isbn)) {
      throw Exception('Bu ISBN numarası zaten mevcut!');
    }
    kitaplar[isbn] = kitap;
    print('${kitap.baslik} başarıyla eklendi.');
  }

  // Kitap silme metodu
  void kitapSil(String isbn) {
    if (!kitaplar.containsKey(isbn)) {
      throw Exception('Kitap bulunamadı!');
    }
    if (oduncKitaplar.contains(isbn)) {
      throw Exception('Bu kitap şu anda ödünç verilmiş durumda!');
    }
    kitaplar.remove(isbn);
    print('Kitap başarıyla silindi.');
  }

  // Kitap arama metodu
  Kitap? kitapAra(String isbn) {
    return kitaplar[isbn];
  }

  // Kitap güncelleme metodu
  void kitapGuncelle(String isbn, Kitap yeniKitap) {
    if (!kitaplar.containsKey(isbn)) {
      throw Exception('Güncellenecek kitap bulunamadı!');
    }
    kitaplar[isbn] = yeniKitap;
    print('${yeniKitap.baslik} başarıyla güncellendi.');
  }

  // Kitap ödünç verme metodu
  void oduncVer(String isbn) {
    if (!kitaplar.containsKey(isbn)) {
      throw Exception('Kitap bulunamadı!');
    }
    if (oduncKitaplar.contains(isbn)) {
      throw Exception('Bu kitap zaten ödünç verilmiş!');
    }
    if (kitaplar[isbn]!.kopyaSayisi <= 0) {
      throw Exception('Bu kitabın müsait kopyası kalmamış!');
    }
    
    kitaplar[isbn]!.kopyaSayisi--;
    oduncKitaplar.add(isbn);
    print('${kitaplar[isbn]!.baslik} başarıyla ödünç verildi.');
  }

  // Kitap iade metodu
  void kitapIade(String isbn) {
    if (!kitaplar.containsKey(isbn)) {
      throw Exception('Kitap bulunamadı!');
    }
    if (!oduncKitaplar.contains(isbn)) {
      throw Exception('Bu kitap zaten kütüphanede!');
    }
    
    kitaplar[isbn]!.kopyaSayisi++;
    oduncKitaplar.remove(isbn);
    print('${kitaplar[isbn]!.baslik} başarıyla iade edildi.');
  }

  // Kütüphane durumunu görüntüleme
  void durumGoster() {
    print('\n=== KÜTÜPHANE DURUMU ===');
    print('Toplam kitap sayısı: ${kitaplar.length}');
    print('Ödünç verilen kitap sayısı: ${oduncKitaplar.length}\n');
    
    print('KITAP LISTESI:');
    print('ISBN'.padRight(15) + 'Başlık'.padRight(30) + 'Yazar'.padRight(20) + 
          'Yayın Yılı'.padRight(12) + 'Kopya Sayısı');
    print('-' * 80);
    
    kitaplar.forEach((isbn, kitap) {
      print(isbn.padRight(15) + 
            kitap.baslik.padRight(30) + 
            kitap.yazar.padRight(20) + 
            kitap.yayinYili.toString().padRight(12) + 
            kitap.kopyaSayisi.toString());
    });
  }
}

void main() {
  var kutuphane = KutuphaneYonetimi();

  // Örnek kitaplar ekliyoruz
  try {
    kutuphane.kitapEkle('978-0-123456-1', 
        Kitap('Siber Güvenlik Temelleri', 'Ahmet Yılmaz', 2023, 3));
    kutuphane.kitapEkle('978-0-123456-2', 
        Kitap('Ağ Programlama', 'Mehmet Demir', 2022, 2));
    kutuphane.kitapEkle('978-0-123456-3', 
        Kitap('Veri Yapıları', 'Ayşe Kaya', 2024, 5));

    // Kitap ödünç verme ve iade işlemleri
    kutuphane.oduncVer('978-0-123456-1');
    kutuphane.oduncVer('978-0-123456-2');
    kutuphane.kitapIade('978-0-123456-1');

    // Kütüphane durumunu görüntüleme
    kutuphane.durumGoster();
    
  } catch (e) {
    print('Hata: $e');
  }
}

Ödev 4: Banka Hesap Yönetimi – Çözüm

class IslemKaydi {
  DateTime tarih;
  String islemTipi;
  double miktar;
  double bakiye;

  IslemKaydi(this.tarih, this.islemTipi, this.miktar, this.bakiye);

  @override
  String toString() {
    return '${tarih.toString().substring(0, 19)} - $islemTipi: $miktar TL - Bakiye: $bakiye TL';
  }
}

class BankaHesabi {
  final String hesapNo;
  final String hesapSahibi;
  double _bakiye;
  List<IslemKaydi> islemGecmisi = [];
  
  // Günlük para çekme limiti
  static const double GUNLUK_LIMIT = 5000;
  Map<String, double> gunlukCekimler = {};

  BankaHesabi(this.hesapNo, this.hesapSahibi, [this._bakiye = 0]) {
    islemKaydiEkle('Hesap Açılış', _bakiye);
  }

  // Getter method for bakiye
  double get bakiye => _bakiye;

  // İşlem kaydı ekleme yardımcı metodu
  void islemKaydiEkle(String islemTipi, double miktar) {
    islemGecmisi.add(IslemKaydi(DateTime.now(), islemTipi, miktar, _bakiye));
  }

  // Günlük limit kontrolü
  bool gunlukLimitKontrol(double miktar) {
    String bugun = DateTime.now().toString().substring(0, 10);
    double gunlukToplam = gunlukCekimler[bugun] ?? 0;
    return (gunlukToplam + miktar) <= GUNLUK_LIMIT;
  }

  // Para yatırma işlemi
  void paraYatir(double miktar) {
    if (miktar <= 0) {
      throw Exception('Geçersiz miktar!');
    }
    _bakiye += miktar;
    islemKaydiEkle('Para Yatırma', miktar);
    print('İşlem başarılı. Yeni bakiye: $_bakiye TL');
  }

  // Para çekme işlemi
  void paraCek(double miktar) {
    if (miktar <= 0) {
      throw Exception('Geçersiz miktar!');
    }
    if (miktar > _bakiye) {
      throw Exception('Yetersiz bakiye!');
    }
    if (!gunlukLimitKontrol(miktar)) {
      throw Exception('Günlük para çekme limiti aşıldı!');
    }

    _bakiye -= miktar;
    
    // Günlük çekim miktarını güncelle
    String bugun = DateTime.now().toString().substring(0, 10);
    gunlukCekimler[bugun] = (gunlukCekimler[bugun] ?? 0) + miktar;
    
    islemKaydiEkle('Para Çekme', -miktar);
    print('İşlem başarılı. Yeni bakiye: $_bakiye TL');
  }

  // Hesap özeti görüntüleme
  void hesapOzetiGoster([int sonIslemSayisi = 5]) {
    print('\n=== HESAP ÖZETİ ===');
    print('Hesap No: $hesapNo');
    print('Hesap Sahibi: $hesapSahibi');
    print('Güncel Bakiye: $_bakiye TL\n');
    
    print('SON $sonIslemSayisi İŞLEM:');
    var sonIslemler = islemGecmisi.reversed.take(sonIslemSayisi).toList();
    for (var islem in sonIslemler) {
      print(islem);
    }
  }
}

void main() {
  try {
    // Yeni hesap oluştur
    var hesap = BankaHesabi('1234567890', 'Ali Yılmaz', 1000);
    
    // Çeşitli işlemler gerçekleştir
    hesap.paraYatir(500);
    hesap.paraCek(200);
    hesap.paraYatir(1000);
    hesap.paraCek(300);
    
    // Hesap özetini görüntüle
    hesap.hesapOzetiGoster();
    
  } catch (e) {
    print('Hata: $e');
  }
}

Ödev 5: Dosya Şifreleme Uygulaması – Çözüm

import 'dart:convert';
import 'dart:io';
import 'dart:typed_data';

class SifrelemeAraci {
  // Basit bir şifreleme anahtarı (gerçek uygulamalarda daha güvenli yöntemler kullanılmalı)
  final List<int> _anahtar;
  
  SifrelemeAraci(String anahtar) 
      : _anahtar = utf8.encode(anahtar);

  // Veriyi şifrele
  Future<Uint8List> sifrele(Uint8List veri) async {
    List<int> sifrelenmis = [];
    for (var i = 0; i < veri.length; i++) {
      sifrelenmis.add(veri[i] ^ _anahtar[i % _anahtar.length]);
    }
    return Uint8List.fromList(sifrelenmis);
  }

  // Şifreyi çöz (XOR işlemi simetrik olduğu için aynı metodu kullanabiliriz)
  Future<Uint8List> sifreCoz(Uint8List sifrelenmisVeri) async {
    return sifrele(sifrelenmisVeri);
  }
}

class DosyaIslemleri {
  final SifrelemeAraci _sifrelemeAraci;
  
  DosyaIslemleri(this._sifrelemeAraci);

  // Dosya şifreleme
  Future<void> dosyaSifrele(String kaynak, String hedef) async {
    try {
      // Dosyayı oku
      var dosya = File(kaynak);
      var veri = await dosya.readAsBytes();
      
      print('Dosya okundu: ${veri.length} bytes');
      
      // Veriyi şifrele
      print('Şifreleme işlemi başladı...');
      var sifrelenmisVeri = await _sifrelemeAraci.sifrele(veri);
      
      // Şifrelenmiş veriyi yaz
      await File(hedef).writeAsBytes(sifrelenmisVeri);
      print('Şifreleme tamamlandı: $hedef');
      
    } catch (e) {
      throw Exception('Dosya şifreleme hatası: $e');
    }
  }

  // Dosya şifre çözme
  Future<void> dosyaSifreCoz(String kaynak, String hedef) async {
    try {
      // Şifrelenmiş dosyayı oku
      var dosya = File(kaynak);
      var sifrelenmisVeri = await dosya.readAsBytes();
      
      print('Şifrelenmiş dosya okundu: ${sifrelenmisVeri.length} bytes');
      
      // Şifreyi çöz
      print('Şifre çözme işlemi başladı...');
      var cozulmusVeri = await _sifrelemeAraci.sifreCoz(sifrelenmisVeri);
      
      // Çözülmüş veriyi yaz
      await File(hedef).writeAsBytes(cozulmusVeri);
      print('Şifre çözme tamamlandı: $hedef');
      
    } catch (e) {
      throw Exception('Dosya şifre çözme hatası: $e');
    }
  }
}

// Completing Ödev 5's solution
void main() async {
  try {
    var sifrelemeAraci = SifrelemeAraci('GizliAnahtar123');
    var dosyaIslemleri = DosyaIslemleri(sifrelemeAraci);

    // Örnek dosya işlemleri
    await dosyaIslemleri.dosyaSifrele(
      'gizli_dosya.txt',
      'sifrelenmis_dosya.enc'
    );

    await dosyaIslemleri.dosyaSifreCoz(
      'sifrelenmis_dosya.enc',
      'cozulmus_dosya.txt'
    );
    
    print('Tüm işlemler başarıyla tamamlandı.');
    
  } catch (e) {
    print('Hata oluştu: $e');
  }
}

Ödev 6: Güvenlik Denetim Uygulaması – Çözüm

import 'dart:convert';
import 'dart:io';

// Güvenlik denetimi sonuçlarını temsil eden sınıf
class DenetimSonucu {
  final String kategori;
  final bool basarili;
  final String aciklama;
  final int riskSeviyesi; // 1-5 arası (5 en yüksek risk)
  final List<String> oneriler;

  DenetimSonucu({
    required this.kategori,
    required this.basarili,
    required this.aciklama,
    required this.riskSeviyesi,
    required this.oneriler,
  });

  Map<String, dynamic> toJson() => {
    'kategori': kategori,
    'basarili': basarili,
    'aciklama': aciklama,
    'riskSeviyesi': riskSeviyesi,
    'oneriler': oneriler,
  };
}

// Şifre güvenliği denetimi sınıfı
class SifreGuvenlikDenetimi {
  static DenetimSonucu sifreKontrol(String sifre) {
    int puan = 100;
    List<String> oneriler = [];

    // Uzunluk kontrolü
    if (sifre.length < 8) {
      puan -= 20;
      oneriler.add('Şifre en az 8 karakter olmalıdır');
    }

    // Büyük harf kontrolü
    if (!sifre.contains(RegExp(r'[A-Z]'))) {
      puan -= 20;
      oneriler.add('Şifre en az bir büyük harf içermelidir');
    }

    // Küçük harf kontrolü
    if (!sifre.contains(RegExp(r'[a-z]'))) {
      puan -= 20;
      oneriler.add('Şifre en az bir küçük harf içermelidir');
    }

    // Sayı kontrolü
    if (!sifre.contains(RegExp(r'[0-9]'))) {
      puan -= 20;
      oneriler.add('Şifre en az bir sayı içermelidir');
    }

    // Özel karakter kontrolü
    if (!sifre.contains(RegExp(r'[!@#$%^&*(),.?":{}|<>]'))) {
      puan -= 20;
      oneriler.add('Şifre en az bir özel karakter içermelidir');
    }

    return DenetimSonucu(
      kategori: 'Şifre Güvenliği',
      basarili: puan >= 80,
      aciklama: 'Şifre güvenlik puanı: $puan/100',
      riskSeviyesi: _riskSeviyesiHesapla(puan),
      oneriler: oneriler,
    );
  }

  static int _riskSeviyesiHesapla(int puan) {
    if (puan >= 90) return 1;
    if (puan >= 80) return 2;
    if (puan >= 70) return 3;
    if (puan >= 60) return 4;
    return 5;
  }
}

// Dosya bütünlük kontrolü sınıfı
class DosyaButunlukDenetimi {
  static Future<DenetimSonucu> dosyaKontrol(String dosyaYolu) async {
    try {
      var dosya = File(dosyaYolu);
      if (!await dosya.exists()) {
        return DenetimSonucu(
          kategori: 'Dosya Bütünlüğü',
          basarili: false,
          aciklama: 'Dosya bulunamadı',
          riskSeviyesi: 5,
          oneriler: ['Dosyanın varlığını kontrol edin'],
        );
      }

      var stat = await dosya.stat();
      var sonDegisiklik = stat.modified;
      var boyut = stat.size;

      var oneriler = <String>[];
      if (DateTime.now().difference(sonDegisiklik).inDays > 30) {
        oneriler.add('Dosya 30 günden uzun süredir güncellenmemiş');
      }

      return DenetimSonucu(
        kategori: 'Dosya Bütünlüğü',
        basarili: true,
        aciklama: 'Son değişiklik: $sonDegisiklik, Boyut: $boyut bytes',
        riskSeviyesi: oneriler.isEmpty ? 1 : 2,
        oneriler: oneriler,
      );
    } catch (e) {
      return DenetimSonucu(
        kategori: 'Dosya Bütünlüğü',
        basarili: false,
        aciklama: 'Hata: $e',
        riskSeviyesi: 5,
        oneriler: ['Dosya erişim izinlerini kontrol edin'],
      );
    }
  }
}

// Log analizi sınıfı
class LogAnalizi {
  static DenetimSonucu logKontrol(List<String> loglar) {
    var hataSayisi = 0;
    var uyariSayisi = 0;
    var kritikHatalar = <String>{};
    var oneriler = <String>[];

    for (var log in loglar) {
      if (log.contains('ERROR')) {
        hataSayisi++;
        kritikHatalar.add(log);
      } else if (log.contains('WARNING')) {
        uyariSayisi++;
      }
    }

    if (hataSayisi > 0) {
      oneriler.add('$hataSayisi adet kritik hata tespit edildi');
    }
    if (uyariSayisi > 0) {
      oneriler.add('$uyariSayisi adet uyarı mevcut');
    }

    return DenetimSonucu(
      kategori: 'Log Analizi',
      basarili: hataSayisi == 0,
      aciklama: 'Toplam ${loglar.length} log analiz edildi',
      riskSeviyesi: hataSayisi > 0 ? 4 : uyariSayisi > 0 ? 2 : 1,
      oneriler: oneriler,
    );
  }
}

// Ağ bağlantı kontrolü sınıfı
class AgBaglantiKontrol {
  static Future<DenetimSonucu> baglantiKontrol(String hedef) async {
    try {
      var sonuc = await Process.run('ping', ['-c', '4', hedef]);
      var basarili = sonuc.exitCode == 0;

      var oneriler = <String>[];
      if (!basarili) {
        oneriler.add('Ağ bağlantısını kontrol edin');
        oneriler.add('Firewall ayarlarını kontrol edin');
      }

      return DenetimSonucu(
        kategori: 'Ağ Bağlantısı',
        basarili: basarili,
        aciklama: basarili ? 'Bağlantı başarılı' : 'Bağlantı başarısız',
        riskSeviyesi: basarili ? 1 : 4,
        oneriler: oneriler,
      );
    } catch (e) {
      return DenetimSonucu(
        kategori: 'Ağ Bağlantısı',
        basarili: false,
        aciklama: 'Hata: $e',
        riskSeviyesi: 5,
        oneriler: ['Sistem ağ ayarlarını kontrol edin'],
      );
    }
  }
}

// Güvenlik denetimi rapor sınıfı
class GuvenlikDenetimRaporu {
  final List<DenetimSonucu> sonuclar;
  final DateTime tarih;

  GuvenlikDenetimRaporu(this.sonuclar) : tarih = DateTime.now();

  // JSON formatında rapor oluştur
  Future<void> jsonRaporOlustur(String dosyaAdi) async {
    var rapor = {
      'tarih': tarih.toIso8601String(),
      'sonuclar': sonuclar.map((s) => s.toJson()).toList(),
      'ozet': {
        'toplamTest': sonuclar.length,
        'basarili': sonuclar.where((s) => s.basarili).length,
        'basarisiz': sonuclar.where((s) => !s.basarili).length,
        'ortalamaRisk': sonuclar.map((s) => s.riskSeviyesi).reduce((a, b) => a + b) / sonuclar.length,
      }
    };

    var dosya = File(dosyaAdi);
    await dosya.writeAsString(JsonEncoder.withIndent('  ').convert(rapor));
  }

  // Konsola rapor yazdır
  void raporYazdir() {
    print('\n=== GÜVENLİK DENETİM RAPORU ===');
    print('Tarih: $tarih\n');

    for (var sonuc in sonuclar) {
      print('${sonuc.kategori}:');
      print('  Durum: ${sonuc.basarili ? "✓ Başarılı" : "✗ Başarısız"}');
      print('  Risk Seviyesi: ${"🔴" * sonuc.riskSeviyesi}${"⚪" * (5 - sonuc.riskSeviyesi)}');
      print('  Açıklama: ${sonuc.aciklama}');
      
      if (sonuc.oneriler.isNotEmpty) {
        print('  Öneriler:');
        for (var oneri in sonuc.oneriler) {
          print('    - $oneri');
        }
      }
      print('');
    }

    var basariliTestSayisi = sonuclar.where((s) => s.basarili).length;
    var toplamTest = sonuclar.length;
    print('ÖZET:');
    print('Toplam Test: $toplamTest');
    print('Başarılı: $basariliTestSayisi');
    print('Başarısız: ${toplamTest - basariliTestSayisi}');
    print('Başarı Oranı: ${(basariliTestSayisi / toplamTest * 100).toStringAsFixed(2)}%');
  }
}

// Ana uygulama
void main() async {
  try {
    // Örnek denetimler
    var sifreSonuc = SifreGuvenlikDenetimi.sifreKontrol('Zayif123');
    var dosyaSonuc = await DosyaButunlukDenetimi.dosyaKontrol('test.txt');
    var logSonuc = LogAnalizi.logKontrol([
      '2024-01-26 10:00:00 INFO: Sistem başlatıldı',
      '2024-01-26 10:01:23 WARNING: Disk kullanımı %80',
      '2024-01-26 10:02:45 ERROR: Bağlantı hatası'
    ]);
    var agSonuc = await AgBaglantiKontrol.baglantiKontrol('localhost');

    // Rapor oluştur
    var rapor = GuvenlikDenetimRaporu([
      sifreSonuc,
      dosyaSonuc,
      logSonuc,
      agSonuc
    ]);

    // Raporu yazdır ve kaydet
    rapor.raporYazdir();
    await rapor.jsonRaporOlustur('guvenlik_raporu.json');
    
  } catch (e) {
    print('Hata: $e');
  }
}

Bu çözümler, Dart programlama dilinin temel ve ileri düzey özelliklerini kullanarak gerçek dünya problemlerine çözümler sunmaktadır. Her bir ödev, öğrencilerin farklı programlama kavramlarını öğrenmelerini ve uygulamalarını sağlar:

  1. Ödev 1: Temel veri tipleri ve string manipülasyonu
  2. Ödev 2: Sınıflar, listeler ve temel algoritmalar
  3. Ödev 3: Map ve Set veri yapıları, dosya işlemleri
  4. Ödev 4: Nesne yönelimli programlama, exception handling
  5. Ödev 5: Asenkron programlama, dosya işlemleri
  6. Ödev 6: Güvenlik konseptleri, raporlama, JSON işleme

Her ödev çözümünde, kodun okunabilirliği ve maintainability'si için:

  • Açıklayıcı değişken ve fonksiyon isimleri
  • Kapsamlı hata kontrolü
  • Detaylı kod yorumları
  • Modüler ve yeniden kullanılabilir kod yapısı kullanılmıştır.

Öğrenciler bu çözümleri inceleyerek:

  • Dart syntax'ını
  • Nesne yönelimli programlama prensiplerini
  • Veri yapılarının kullanımını
  • Hata yönetimini
  • Asenkron programlamayı
  • Güvenlik konseptlerini pratik olarak öğrenebilirler.