public class Araba {
  // Alanlar (fields)
  String marka;
  String model;
  int yil;
  String renk;

  // Metotlar (methods)
  void ilerle() {
    System.out.println(marka + " ilerliyor.");
  }

  void dur() {
    System.out.println(marka + " durdu.");
  }

  void sinyalVer() {
    System.out.println(marka + " sinyal veriyor.");
  }
}

• class anahtar sözcüğü ve sınıf adıyla başlar; gövde { } arasındadır.
• Sınıf adı büyük harfle başlar (Araba, BankaHesabi); public bir sınıf, aynı adlı dosyada (Araba.java) bulunmalıdır.
• Alanlar sınıf gövdesinde, metotların dışında tanımlanır; her metot bu alanları doğrudan kullanabilir.
• Metotların önünde static yok: her biri belirli bir arabanın (nesnenin) metodudur.
• Bu sınıfta main yok; tek başına çalışmaz, başka bir sınıf onu kullanır.

public class AracTesti {
  public static void main(String[] args) {
    Araba araba1 = new Araba();
    araba1.marka = "Toyota";
    araba1.model = "Corolla";
    araba1.yil = 2022;
    araba1.renk = "Gri";

    Araba araba2 = new Araba();
    araba2.marka = "Ford";
    araba2.model = "Mustang";
    araba2.yil = 2023;
    araba2.renk = "Mavi";

    araba1.ilerle();
    araba2.sinyalVer();
    araba1.dur();
  }
}

Toyota ilerliyor.
Ford sinyal veriyor.
Toyota durdu.

• new Araba() bir nesne üretir; araba1 onu gösterir.
• araba1.marka = "Toyota";: nokta (.) ile nesnenin alanına erişilir.
• araba1.ilerle(): metot, araba1'in verileriyle çalışır; araba2.sinyalVer() ise araba2'ninkilerle.
• Alanları dışarıdan böyle doğrudan değiştirmek iyi bir alışkanlık değildir; doğrusu yapıcı ve erişim metotları kullanmaktır.

• Erişim belirleyiciler (public, protected, private, yazılmazsa paket erişimi), bir üyeye sınıfın dışından kimin erişebileceğini belirtir.
• Genel kural: alanlar private, dışarıya sunulan metotlar public.
• Alanın değeri bir erişimci (getter, get...) ile okunur, bir değiştirici (setter, set...) ile değiştirilir; değiştirici geçersiz değeri reddeder.
• Bu düzen veri gizlemedir (data hiding): alanlara yalnızca kendi sınıfının metotları doğrudan erişir. Sarmalamanın (encapsulation) temelidir.

public class BankaHesabi {
  private double hesapBakiyesi;   // gizli alan
  public double getHesapBakiyesi() {
    return hesapBakiyesi;
  }
  public void setHesapBakiyesi(double b) {
    if (b >= 0) hesapBakiyesi = b;  // geçersizi reddet
  }
}
// başka bir sınıfta:
hesap.hesapBakiyesi = -500;

error: hesapBakiyesi has private access in BankaHesabi

• Yapıcı metot (constructor), nesne oluşturmak için kullanılan özel bir metottur; new ile nesne oluşturulduğunda otomatik çağrılır.
• Görevi, alanlara ilk değerlerini vermek ve varsa başka hazırlık işlerini yapmaktır.
• Adı sınıf adıyla aynıdır (büyük-küçük harf dahil).
• Dönüş tipi yoktur, void bile yazılmaz; değer döndüremez.
• Genellikle public tanımlanır; nesne oluşturmayı kısıtlamak için private da olabilir (ör. singleton deseni).
• Bir sınıfın birden çok yapıcısı olabilir (farklı parametrelerle).

public class Ogrenci {
  private String ad;
  private int numara;

  // Yapıcı: sınıfla aynı ad, dönüş türü yok
  public Ogrenci(String ad, int numara) {
    this.ad = ad;
    this.numara = numara;
  }
}

// Kullanımı:
Ogrenci ogr = new Ogrenci("Ali", 2012);

import java.util.Scanner;
public class Olusturma {
  public static void main(String[] args) {
    Scanner klavye = new Scanner(System.in);
    StringBuilder metin = new StringBuilder("Java");
    String baslik = "Nesneler";           // kısayol
    String yazar = new String("Sercan");  // uzun yol
    metin.append(" 21");
    System.out.println(metin + " / " + baslik);
    System.out.println(yazar.length());
    System.out.println(klavye.nextInt() * 2);
  }
}

Kısayol: String baslik = "Nesneler"; String nesnesi oluşturur; yalnızca String baslik; ise sadece referans tanımlar.

1. new, heap'te nesne için yer ayırır; alanlar varsayılan değerleri alır.
2. Yapıcı metot çağrılır, ilk değerleri verir.
3. new ifadesinin sonucu nesnenin referansıdır; değişkene atanır.

(girdi: 21)
Java 21 / Nesneler
6
42

public class Araba {
  private String model;
  private String renk;

  public Araba(String model, String renk) {
    this.model = model;
    this.renk = renk;
  }

  public void bilgiYazdir() {
    System.out.println(model + " - " + renk);
  }

}

public static void main(String[] args) {
  Araba sporAraba = new Araba("2022", "KIRMIZI");
  Araba klasikAraba = new Araba("2023", "BEYAZ");
  sporAraba.bilgiYazdir();
  klasikAraba.bilgiYazdir();
}

• Sınıfa hiç yapıcı yazılmamışsa derleyici varsayılan yapıcıyı (default constructor) ekler: parametresiz, gövdesi boş. Nesne oluşturulurken her zaman bir yapıcı çağrılır.
• Değer verilmeyen alanlar varsayılan değer alır (yerel değişkenler almaz):

class Nokta3 {
  int x;
  double agirlik;
  boolean gorunur;
  char harf;
  String ad;
}
public class Varsayilan {
  public static void main(String[] args) {
    Nokta3 n = new Nokta3();   // varsayılan yapıcı
    System.out.println(n.x + " " + n.agirlik);
    System.out.println(n.gorunur + " " + n.ad);
    System.out.println((int) n.harf);
  }
}

0 0.0
false null
0

public class Arac {
  private String marka;
  private String model;
  private int yil;
  public Arac() {                 // parametresiz yapıcı
    marka = "Bilinmiyor";
    model = "Bilinmiyor";
    yil = 0;
  }
  public Arac(String marka, String model, int yil) {
    this.marka = marka;
    this.model = model;
    this.yil = yil;
  }
  public void bilgiYazdir() {
    System.out.println(marka + " " + model + " " + yil);
  }
  public static void main(String[] args) {
    Arac a1 = new Arac();
    Arac a2 = new Arac("Renault", "Clio", 2021);
    a1.bilgiYazdir();
    a2.bilgiYazdir();
  }
}

Bilinmiyor Bilinmiyor 0
Renault Clio 2021

• Arac(), kendi yazdığımız parametresiz yapıcıdır; alanları anlamlı başlangıç değerlerine ayarlar.
• İki yapıcı aynı adı taşır, parametreleri farklıdır: yapıcı aşırı yükleme. Hangisinin çalışacağını argümanlar belirler.
• Sınıfa herhangi bir yapıcı yazıldığında derleyici artık varsayılan yapıcı eklemez. Yalnızca parametreli yapıcı varsa new Arac() derlenmez: constructor Arac in class Arac cannot be applied to given types.

public class Kitap {
  // Örneğe ait alanlar
  private String baslik;
  private String yazar;
  private int sayfaSayisi;
  // Sınıfa ait alan
  private static int toplamKitapSayisi;
  // final tanımlanmış bir alan (sabit)
  public static final double PI = 3.14159265359;
}

public class Alanlar {
  public int a;                         // genel
  int b = 1, c = 2;                     // varsayılan (paket)
  private double x;                     // özel
  private static int xx;                // statik, özel
  public static int y;                  // statik, genel
  public final int CONST1 = 5;          // değiştirilemez
  private static final int CONST2 = 6;  // statik sabit
}

• Söz dizimi: [erişim] [static] [final] tür ad [= ilkDeğer];
• Aynı satırda birden çok alan: int b = 1, c = 2;
• PI burada örnek olarak tanımlandı; Java'da hazır bir sabit vardır: Math.PI.
• final alana yeniden değer atamak derleme hatasıdır:
  error: cannot assign a value to final variable CONST1

• Metotlar, sınıf içinde tanımlanan, belirli bir işi yapan kod bloklarıdır; sınıfın davranışını tanımlar.
• Örneğe ait metotlar (instance methods) bir nesneyle ilişkilidir: telefon.aramaYap(...). O nesnenin alanlarını kullanır.
• Sınıfa ait metotlar (static) sınıfın kendisiyle ilişkilidir, tüm nesnelerde ortaktır: CepTelefonu üzerinden.
• Static metotlar belirli bir nesneye bağlı olmadığı için nesneye özgü verilere (model gibi) doğrudan erişemez.

public class CepTelefonu {
  private String model;
  private static String isletimSistemi = "Sürüm 1";

  // Örneğe ait metot
  public void aramaYap(String numara) {
    System.out.println(model + " arıyor: " + numara);
  }

  // Örneğe ait metot
  public void mesajGonder(String alici, String mesaj) {
    System.out.println(alici + " <- " + mesaj);
  }

  // Sınıfa ait metot (static)
  public static void sistemiGuncelle(String yeniSurum) {
    isletimSistemi = yeniSurum;
  }
}

public class Eposta {
  public boolean gonder(String alici, String konu,
             String icerik) {
    // Gerçek gönderim yerine bir benzetim
    if (alici == null || !alici.contains("@")) {
      return false;               // başarısız
    }
    System.out.println(alici + " <- " + konu);
    return true;                    // başarılı
  }

  public static void main(String[] args) {
    Eposta e = new Eposta();
    boolean s1 = e.gonder("ali@ornek.com", "Ödev", "Ek");
    boolean s2 = e.gonder("ali.ornek.com", "Ödev", "Ek");
    System.out.println(s1 + " " + s2);
  }
}

ali@ornek.com <- Ödev
true false

boolean döndüren metodun her yolu bir return ile bitmelidir; gövdesi yalnızca yorum olan bir metot missing return statement hatası verir.

public class Telefon {
  String numara;
  public Telefon(String numara) {
    this.numara = numara;
  }
  public void aramaYap(Telefon telefon) {
    System.out.println(numara + " arıyor: " + telefon.numara);
  }
  public void mesajGonder(Telefon telefon, String mesaj) {
    System.out.println(telefon.numara + " <- " + mesaj);
  }
  public void kameraAc() {
    System.out.println(numara + " kamera açtı.");
  }
  public static void main(String[] args) {
    Telefon telefon1 = new Telefon("5551234567");
    Telefon telefon2 = new Telefon("5051234567");
    telefon1.aramaYap(telefon2);
    telefon2.mesajGonder(telefon1, "Merhaba!");
    telefon1.kameraAc();
  }
}

5551234567 arıyor: 5051234567
5551234567 <- Merhaba!
5551234567 kamera açtı.

• Nesne oluşturulduktan sonra alan ve metotlarına nokta işleci ile erişilir: nesne.metot(...), nesne.alan.
• telefon1.aramaYap(...): telefon1 arar; metotta numara telefon1'in, telefon.numara telefon2'nin numarasıdır.
• Bir nesne başka bir nesneyi parametre olarak alabilir.

public class Dikdortgen {
  private double uzunluk;     // dikdörtgenin uzunluğu
  private double genislik;    // dikdörtgenin genişliği

  // Yapıcı metot
  public Dikdortgen(double uzunluk, double genislik) {
    this.uzunluk = uzunluk;
    this.genislik = genislik;
  }

  public double alanHesapla() {      // alanı hesaplar
    return uzunluk * genislik;
  }

  public double cevreHesapla() {     // çevreyi hesaplar
    return 2 * (uzunluk + genislik);
  }
}

• Alanlar private: dışarıdan yalnızca metotlarla kullanılır.
• Yapıcı, iki kenarı alır ve nesneye kaydeder.
• alanHesapla() ve cevreHesapla() parametre almaz: ihtiyaç duydukları veriler nesnenin içinde.
• Prosedürel karşılığı alanHesapla(5.0, 3.0) olurdu; nesneyle dikdortgen.alanHesapla().

public class Matematik {
  // Statik toplama metodu
  public static int toplama(int sayi1, int sayi2) {
    return sayi1 + sayi2;
  }

  public static void main(String[] args) {
    int sonuc = Matematik.toplama(5, 3);
    System.out.println("Toplama Sonucu: " + sonuc);
    System.out.println(Math.max(4, 9));
    System.out.println(Math.sqrt(16.0));
  }
}

• static anahtar sözcüğüyle tanımlanır; sınıfa aittir.
• static üyelere erişmek için nesne oluşturmaya gerek yoktur; sınıf adı ve nokta kullanılır: SinifAdi.alanAdi, SinifAdi.metotAdi(argumanlar).
• Nesne üzerinden de erişilebilir (nesne.alanAdi), ama tercih edilmez: okuyan kişi üyenin nesneye ait olduğunu sanır.
• Hazır örnekler: Math.max(), Math.sqrt(), Math.PI, Integer.parseInt() ve main.

Toplama Sonucu: 8
9
4.0

• Java'da nesneler referanslar (adresler) aracılığıyla işlenir.
• araba2 = araba1; nesneyi kopyalamaz, referansı kopyalar: iki değişken aynı nesneyi işaret eder (takma ad, alias).
• Biri üzerinden yapılan değişiklik diğerinden de görünür.

public class Araba {
  private String marka;

  public Araba(String marka) {
    this.marka = marka;
  }

  public String getMarka() {
    return marka;
  }

  public void setMarka(String marka) {
    this.marka = marka;
  }

}

public class Bos {
  String ad;

  public static void main(String[] args) {
    Bos b = null;
    System.out.println(b.ad.length());
  }
}

Exception in thread "main" java.lang.NullPointerException: Cannot read field "ad" because "<local1>" is null
    at Bos.main(Bos.java:6)

Yerel değişken hiç değer verilmeden kullanılırsa program derlenmez: error: variable sb might not have been initialized

• null, referans değişkeninin hiçbir nesneyi göstermediği anlamına gelir.
• null bir referans üzerinden alan okumak ya da metot çağırmak çalışma zamanında NullPointerException fırlatır.
• Önlem: kullanmadan önce denetim: if (b != null) { ... }
• Hiçbir referansın göstermediği nesneler JVM'in çöp toplayıcısı tarafından otomatik silinir; Java'da nesneyi elle silmek gerekmez.

public class Golge {
  private String ad;

  public Golge(String ad) {
    ad = ad;            // this unutuldu!
  }

  public static void main(String[] args) {
    Golge g = new Golge("Ali");
    System.out.println(g.ad);
  }
}

null

• this, metodun çağrıldığı nesneyi işaret eden referanstır.
• static metotlarda kullanılamaz (orada nesne yoktur).
• En sık yapıcılarda, alan adı ile parametre adı aynı olduğunda kullanılır: this.ad = ad;
• Soldaki kodda this unutulmuş: ad = ad; parametreyi kendine atar, alan null kalır. Derleyici hata vermez!
• this(...) ise aynı sınıfın başka bir yapıcısını çağırır.

public class Takim {
  private String ad;
  public Takim(String ad) {
    this.ad = ad;
  }
  public void oyuncuEkle(Oyuncu oyuncu) {
    oyuncu.takimaKatil(this);   // bu nesne
  }
  public String getAd() {
    return ad;
  }
  public static void main(String[] args) {
    Takim takim = new Takim("Giresunspor");
    Oyuncu oyuncu = new Oyuncu("Mert");
    takim.oyuncuEkle(oyuncu);
  }
}

• this, o anki nesneyi başka bir metoda parametre olarak iletmek için kullanılır.
• takim.oyuncuEkle(oyuncu) içinde this = takim nesnesi; takimaKatil(this) ile oyuncuya verilir.
• Aynı dosyada ikinci sınıf (public değil):

class Oyuncu {
  private String ad;
  Oyuncu(String ad) {
    this.ad = ad;
  }
  void takimaKatil(Takim takim) {
    String t = takim.getAd();
    System.out.println(ad + " -> " + t);
  }
}

Mert -> Giresunspor

• this(...) aynı sınıfın başka bir yapıcısını çağırır. Ortak ilk değer atamaları tek bir yapıcıda toplanır; öteki yapıcılar ona eksik argümanları ekleyerek devreder.
• this(...) yapıcının ilk satırı olmalıdır; başka bir deyimden sonra yazılırsa derlenmez.
• Çağrılan yapıcının gövdesi önce biter, sonra çağıranın kalan satırları çalışır; zincir kaç yapıcıdan geçerse geçsin tek bir nesne kurulur.
• Yapıcılar birbirini döngüsel çağırırsa derleyici bunu yakalar.

class Calisan {
  private String ad;
  private double maas;
  Calisan(String ad) {
    this(ad, 20000.0);   // aynı sınıfın yapıcısı
  }
  Calisan(String ad, double maas) {
    this.ad = ad;        // ilk değerler tek yerde
    this.maas = maas;
  }
}

İlk satırda değil: A() { x = 1; this(2); }

error: call to this must be first statement in constructor

Döngü: A() { this(1); } ve A(int x) { this(); }

error: recursive constructor invocation

public class Sarmalayici {
  public static void main(String[] args) {
    // int tipinde bir değişken
    int sayi = 42;
    // Integer wrapper sınıfı kullanımı
    Integer wrapperSayi = Integer.valueOf(sayi);
    // Autoboxing (otomatik kutulama)
    Integer wrapperSayi2 = sayi;
    // Unboxing (açık ve otomatik)
    int sayi2 = wrapperSayi2.intValue();
    int sayi3 = wrapperSayi2;
    System.out.println(sayi2 + sayi3);
    System.out.println(wrapperSayi.equals(wrapperSayi2));
    System.out.println(Integer.parseInt("123") + 1);
    System.out.println(Integer.MAX_VALUE);
    System.out.println(Character.isDigit('7'));
    System.out.println(Double.parseDouble("2.5") * 2);
    Integer bos = null;      // int bos = null; derlenmez
    System.out.println(bos);
  }
}

• Autoboxing: ilkel tip → wrapper, otomatik. Unboxing: wrapper → ilkel tip.
• Açık biçimleri: Integer.valueOf(sayi), w.intValue().

84
true
124
2147483647
true
5.0
null

import java.util.ArrayList;
public class Tuzaklar {
  public static void main(String[] args) {
    ArrayList<Integer> liste = new ArrayList<>();
    liste.add(5);                 // autoboxing: 5 -> Integer
    int ilk = liste.get(0);       // unboxing: Integer -> int
    System.out.println(ilk + 1);
    Integer a = 127, b = 127;
    Integer c = 128, d = 128;
    System.out.println(a == b);
    System.out.println(c == d);
    System.out.println(c.equals(d));
    Integer bos = null;
    int x = bos;                  // NullPointerException
  }
}

Exception in thread "main" java.lang.NullPointerException: Cannot invoke "java.lang.Integer.intValue()" because "<local7>" is null

6
true
false
true

• Wrapper nesnelerini == ile karşılaştırmak yanlıştır: == referans karşılaştırır. −128…127 arası değerler önbellekten aynı nesne olarak gelir; 128 için false.
• Karşılaştırmada her zaman equals() kullanılır.
• null bir wrapper'ı açmak (unboxing) NullPointerException fırlatır.

enum HaftaGunleri {
  PAZARTESI, SALI, CARSAMBA, PERSEMBE,
  CUMA, CUMARTESI, PAZAR
}
public class GunTesti {
  public static void main(String[] args) {
    HaftaGunleri[] tumGunler = HaftaGunleri.values();
    HaftaGunleri persembe = HaftaGunleri.valueOf("PERSEMBE");
    System.out.println(tumGunler.length + " gün");
    System.out.println(persembe + " " + persembe.ordinal());
    for (HaftaGunleri gun : tumGunler) {
      boolean haftaSonu = gun == HaftaGunleri.CUMARTESI
          || gun == HaftaGunleri.PAZAR;
      if (haftaSonu) {
        System.out.println(gun + ": hafta sonu");
      }
    }
  }
}

7 gün
PERSEMBE 3
CUMARTESI: hafta sonu
PAZAR: hafta sonu

• enum, sabit ve sınırlı değerleri temsil eden özel bir türdür.
• values() tüm değerleri dizi olarak verir; üzerinde döngü kurulabilir.
• valueOf metinden değere çevirir; ordinal() 0'dan başlayan sıra. Değerler == ile karşılaştırılır.

public class Outer {
  // Dış sınıfın içinde statik bir iç sınıf
  static class StaticInner {
    void display() {
      System.out.println("Statik İç Sınıf");
    }
  }

  public static void main(String[] args) {
    // Dış sınıf örneği oluşturmadan erişim
    Outer.StaticInner staticInner = new Outer.StaticInner();
    staticInner.display();
  }
}

Statik İç Sınıf

• static anahtar sözcüğüyle tanımlanır.
• Dış sınıfın bir nesnesi olmadan oluşturulabilir: new Outer.StaticInner().
• Dış sınıfın yalnızca static üyelerine doğrudan erişebilir.

public class Outer {
  private int sayi = 5;          // dış sınıfın özel alanı

  class MemberInner {            // üye iç sınıf
    void display() {
      System.out.println("Üye İç Sınıf, sayi = " + sayi);
    }
  }

  public static void main(String[] args) {
    // Dış sınıf örneği üzerinden üye iç sınıfa erişim
    Outer outer = new Outer();
    Outer.MemberInner memberInner = outer.new MemberInner();
    memberInner.display();
  }
}

Üye İç Sınıf, sayi = 5

• Dış sınıfın bir üyesi olarak (static olmadan) tanımlanır.
• Her üye iç sınıf nesnesi bir dış nesneye bağlıdır: outer.new MemberInner(). Bu yüzden private sayi'yi okuyabilir.
• main içinde doğrudan new MemberInner() derlenmez:

error: non-static variable this cannot be referenced from a static context

public class Outer {
  void outerMethod() {
    class LocalInner {         // metodun içinde tanımlanır
      void display() {
        System.out.println("Yerel İç Sınıf");
      }
    }
    // Yerel iç sınıfa yalnızca bu metodun içinden erişilir
    LocalInner localInner = new LocalInner();
    localInner.display();
  }

  public static void main(String[] args) {
    Outer outer = new Outer();
    outer.outerMethod();
  }
}

Yerel İç Sınıf

• Bir metodun içinde tanımlanır; yalnızca o metodun içinden kullanılabilir.
• Metot dışında LocalInner adı bilinmez.
• Bir metodun içinde birkaç kez gereken küçük bir yardımcı tip için kullanılır.

interface MyInterface {
  void myMethod();
}

public class Outer {
  public static void main(String[] args) {
    // Genellikle arayüzleri veya soyut sınıfları uygular
    MyInterface myInterface = new MyInterface() {
      @Override
      public void myMethod() {
        System.out.println("Anonim İç Sınıf");
      }
    };
    myInterface.myMethod();
  }
}

Anonim İç Sınıf

• Adı olmayan sınıftır; tanımlandığı yerde tek bir nesnesi oluşturulur.
• Genellikle bir arayüzü (interface) veya soyut sınıfı uygular: new ArayuzAdi() { ... }; Sondaki ; atama deyimine aittir.
• Tek metotlu arayüzler için Java 8+ lambda daha kısadır: () -> ...

final class Araclar {             // araç ve final sınıf
  private Araclar() { }         // nesne oluşturulamaz
  static int kare(int x) { return x * x; }
}
class Ayarlar {                   // singleton
  private static final Ayarlar TEK = new Ayarlar();
  private Ayarlar() { }
  static Ayarlar getir() { return TEK; }
}
abstract class Sekil {            // soyut sınıf
  abstract double alan();
}
// mühürlü (sealed, Java 17+)
sealed interface Hareket permits Yuru, Kos { }
final class Yuru implements Hareket { }
final class Kos implements Hareket { }
public class Cesitler {           // uygulama sınıfı
  public static void main(String[] args) {
    System.out.println(Araclar.kare(7));
    System.out.println(Ayarlar.getir() == Ayarlar.getir());
  }
}

49
true

• Araclar: private yapıcı ile nesne oluşturulamaz, yalnızca static metot; final ile türetilemez.
• Ayarlar: tek nesne her seferinde aynıdır, bu yüzden == true.
• new Sekil() derleme hatası verir (soyut); Hareket'i yalnızca Yuru ve Kos uygulayabilir.

public class RasyonelSayi {
  // Temsil: gizli alanlar
  private int pay, payda;
  // Tanımlama: public yapıcı ve metotlar
  public RasyonelSayi(int pay, int payda) {
    int e = ebob(Math.abs(pay), Math.abs(payda));
    this.pay = pay / e;
    this.payda = payda / e;
  }
  public RasyonelSayi topla(RasyonelSayi d) {
    int yeniPay = pay * d.payda + d.pay * payda;
    return new RasyonelSayi(yeniPay, payda * d.payda);
  }
  @Override
  public String toString() { return pay + "/" + payda; }
  // Gerçekleme ayrıntısı: gizli yardımcı metot
  private static int ebob(int a, int b) {
    while (b != 0) { int k = a % b; a = b; b = k; }
    return a;
  }
}

• Tanımlama: public yapıcı, topla, toString.
• Temsil: private int pay, payda; yapıcı kesri sadeleştirir.
• Gerçekleme: metot gövdeleri ve gizli ebob yardımcısı (Öklid algoritması).
• topla mevcut nesneyi değiştirmez, yeni bir nesne döndürür.

a = new RasyonelSayi(8, 10), b = new RasyonelSayi(2, 3); println(a) ve println(a.topla(b)):

4/5
22/15

Problem 1. Ne yazdırır?

class Sayac {
  static int toplam = 0;
  int adet = 0;
  void arttir() { toplam++; adet++; }
}
public class Problem1 {
  public static void main(String[] args) {
    Sayac a = new Sayac(), b = new Sayac();
    a.arttir(); a.arttir(); b.arttir();
    System.out.print(a.adet + " " + b.adet);
    System.out.println(" " + Sayac.toplam);
  }
}

Problem 2. Ne yazdırır?

class Kutu { int deger; }
public class Problem2 {
  public static void main(String[] args) {
    Kutu k1 = new Kutu();
    k1.deger = 5;
    Kutu k2 = k1;
    k2.deger = 9;
    Kutu k3 = new Kutu();
    k3.deger = 9;
    System.out.println(k1.deger);
    System.out.println(k1 == k2);
    System.out.println(k2 == k3);
  }
}

Problem 3. Ne yazdırır?

class A {
  static { System.out.print("S"); }
  { System.out.print("I"); }
  A() { System.out.print("C"); }
}
public class Problem3 {
  public static void main(String[] args) {
    System.out.print("M");
    new A();
    new A();
    System.out.println();
  }
}

Problem 4. Ne yazdırır?

class Kutu { int deger; }
public class Problem4 {
  static void degistir(Kutu k) {
    k.deger = 100;
    k = new Kutu();
    k.deger = 7;
  }
  public static void main(String[] args) {
    Kutu x = new Kutu();
    x.deger = 1;
    degistir(x);
    System.out.println(x.deger);
  }
}

Problem 5. Ne yazdırır?

record Para(int lira) { }
public class Problem5 {
  public static void main(String[] args) {
    Para p1 = new Para(10);
    Para p2 = new Para(10);
    Integer i1 = 1000, i2 = 1000;
    System.out.println(p1.equals(p2));
    System.out.println(p1 == p2);
    System.out.println(i1.equals(i2));
    System.out.println(p1);
  }
}

Problem 6. Ne yazdırır?

class Nokta {
  int x, y;
  Nokta(int x, int y) {
    this.x = x;
    this.y = y;
  }
}
public class Problem6 {
  public static void main(String[] args) {
    Nokta a = new Nokta(1, 2);
    Nokta b = new Nokta(1, 2);
    System.out.println(a.equals(b));
    System.out.println(a.x == b.x);
  }
}