Metotlar ve Diziler
Programlar büyüdükçe aynı kodu tekrar tekrar yazmak hem yorucu hem de hataya açıktır. Metotlar, bir işi bir kez tanımlayıp istediğimiz kadar çağırmamızı sağlar; kodu parçalara böler, okunur ve test edilebilir kılar. D…
Metotlar ve Diziler
Programlar büyüdükçe aynı kodu tekrar tekrar yazmak hem yorucu hem de hataya açıktır. Metotlar, bir işi bir kez tanımlayıp istediğimiz kadar çağırmamızı sağlar; kodu parçalara böler, okunur ve test edilebilir kılar. Diziler ise tek bir isim altında çok sayıda değeri tutmamıza imkân verir. Bu ikisi birlikte, gerçek programların iskeletini oluşturur.
Metotlar
Bir metot; bir isim, parametreler (girdi), bir gövde (yapılan iş) ve bir dönüş tipinden (çıktı) oluşur:
static int kare(int x) { // dönüş tipi: int, parametre: int x return x * x; // return ile değeri geri gönderir }
Değer döndürmeyen metotların dönüş tipi void'dir; bunlar yalnızca bir iş yapar (örneğin
ekrana yazar) ve bir şey geri vermez.
Bu örneklerde metotları
statictanımlıyoruz; böylece nesne oluşturmadan doğrudanmainiçinden çağırabiliyoruz.static'in ne anlama geldiğini OOP bölümünde derinlemesine göreceğiz.
Metot aşırı yükleme (overloading)
Aynı isimde, fakat farklı parametre listesiyle birden çok metot tanımlayabilirsin. Derleyici, çağrıdaki argümanlara bakarak hangisini çalıştıracağına karar verir:
int topla(int a, int b) { return a + b; } double topla(double a, double b) { return a + b; } int topla(int a, int b, int c) { return a + b + c; }
Dönüş tipi tek başına ayırt edici değildir; fark parametrelerde olmalıdır.
varargs (değişken sayıda parametre)
Kaç argüman geleceğini bilmiyorsan tip... sözdizimini kullanırsın. İçeride bir dizi gibi
davranır:
static int toplamHepsi(int... sayilar) { ... } toplamHepsi(); // 0 toplamHepsi(1, 2, 3, 4, 5); // 15
Örnek 1 (./Ornek1.java) parametre/dönüş değeri, overloading ve varargs'ı bir arada gösterir.
Diziler
Dizi, aynı tipteki sabit sayıda değeri yan yana tutan bir yapıdır. Bir kez oluşturulduğunda boyutu değişmez ve indeksleri 0'dan başlar:
int[] notlar = {72, 95, 48, 88}; notlar.length; // 4 notlar[0]; // 72 (ilk eleman)
Diziyi gezmenin iki yolu vardır: indekse ihtiyacın yoksa for-each daha temizdir, indeks
gerekiyorsa klasik for kullanırsın:
for (int not : notlar) { ... } // for-each for (int i = 0; i < notlar.length; i++) {} // klasik for
java.util.Arrays sınıfı dizilerle çalışmayı kolaylaştırır: Arrays.toString (yazdırma),
Arrays.sort (sıralama), Arrays.copyOf (kopyalama) gibi. Örnek 2 (./Ornek2.java) bir
not dizisinde toplam, ortalama, en büyük/küçük değeri bulur ve diziyi sıralar.
Çok boyutlu diziler
Bir dizinin elemanları yine dizi olabilir; böylece tablolar (matrisler) elde ederiz:
int[][] a = { {1, 2, 3}, {4, 5, 6} }; a.length; // 2 (satır sayısı) a[0].length; // 3 (sütun sayısı) a[1][2]; // 6
İç içe for döngüleriyle satır ve sütunlar üzerinde geziniriz. Örnek 3 (./Ornek3.java)
iki matrisi toplayan ve yazdıran metotlar yazar, ardından satır toplamlarını hesaplar.
Özet
Metotlarla kodu tekrar kullanılabilir parçalara böldük; overloading ve varargs ile esnek imzalar tanımladık. Dizilerle çok sayıda veriyi tek isim altında topladık, tek ve çok boyutlu dizilerde gezindik. Sırada, verileri ve davranışları bir arada paketleyen asıl büyük adım var: nesne yönelimli programlama.
▶ Kod Örnekleri(3)
Ornek1
çalıştırılabilir1// Ornek1: Metotlar — parametre, dönüş değeri, aşırı yükleme (overloading) ve varargs.
2// Çalıştırma: java Ornek1.java
3public class Ornek1 {
4
5 // Parametre alan ve değer döndüren bir metot.
6 static int kare(int x) {
7 return x * x;
8 }
9
10 // void: değer döndürmez, sadece iş yapar.
11 static void selamla(String isim) {
12 System.out.println("Merhaba, " + isim + "!");
13 }
14
15 // --- Metot aşırı yükleme (overloading) ---
16 // Aynı isim, FARKLI parametre listesi. Derleyici çağrıya göre doğrusunu seçer.
17 static int topla(int a, int b) {
18 return a + b;
19 }
20
21 static double topla(double a, double b) {
22 return a + b;
23 }
24
25 static int topla(int a, int b, int c) {
26 return a + b + c;
27 }
28
29 // --- varargs: değişken sayıda parametre ---
30 // int... bir dizi gibi davranır; 0 veya daha fazla argüman alabilir.
31 static int toplamHepsi(int... sayilar) {
32 int toplam = 0;
33 for (int s : sayilar) {
34 toplam += s;
35 }
36 return toplam;
37 }
38
39 public static void main(String[] args) {
40 selamla("Deniz");
41 System.out.println("kare(7) = " + kare(7));
42
43 System.out.println("\n--- Overloading ---");
44 System.out.println("topla(3, 4) = " + topla(3, 4));
45 System.out.println("topla(2.5, 1.5) = " + topla(2.5, 1.5));
46 System.out.println("topla(1, 2, 3) = " + topla(1, 2, 3));
47
48 System.out.println("\n--- varargs ---");
49 System.out.println("toplamHepsi() = " + toplamHepsi());
50 System.out.println("toplamHepsi(5) = " + toplamHepsi(5));
51 System.out.println("toplamHepsi(1,2,3,4,5) = " + toplamHepsi(1, 2, 3, 4, 5));
52 }
53}Ornek2
çalıştırılabilir1// Ornek2: Tek boyutlu diziler — oluşturma, gezinme, istatistik ve sıralama.
2// Çalıştırma: java Ornek2.java
3import java.util.Arrays;
4
5public class Ornek2 {
6
7 public static void main(String[] args) {
8 // Diziyi doğrudan değerlerle oluşturma.
9 int[] notlar = {72, 95, 48, 88, 63, 100, 55};
10
11 System.out.println("Dizi: " + Arrays.toString(notlar));
12 System.out.println("Eleman sayısı (length): " + notlar.length);
13
14 // for-each ile gezinme (indeks gerekmiyorsa daha temiz).
15 int toplam = 0;
16 int enBuyuk = notlar[0];
17 int enKucuk = notlar[0];
18 for (int not : notlar) {
19 toplam += not;
20 if (not > enBuyuk) enBuyuk = not;
21 if (not < enKucuk) enKucuk = not;
22 }
23 double ortalama = (double) toplam / notlar.length;
24
25 System.out.printf("Toplam=%d, Ortalama=%.2f%n", toplam, ortalama);
26 System.out.println("En büyük=" + enBuyuk + ", En küçük=" + enKucuk);
27
28 // Klasik for ile indeks üzerinden gezinme (indeks gerektiğinde).
29 System.out.println("\nGeçen notlar (>= 60):");
30 for (int i = 0; i < notlar.length; i++) {
31 if (notlar[i] >= 60) {
32 System.out.println(" index " + i + " -> " + notlar[i]);
33 }
34 }
35
36 // Arrays.sort diziyi yerinde (in-place) sıralar.
37 int[] kopya = Arrays.copyOf(notlar, notlar.length);
38 Arrays.sort(kopya);
39 System.out.println("\nSıralanmış: " + Arrays.toString(kopya));
40 System.out.println("Medyan (ortanca): " + kopya[kopya.length / 2]);
41 }
42}Ornek3
çalıştırılabilir1// Ornek3: Çok boyutlu diziler (matris) ve metotlarla işleme.
2// Çalıştırma: java Ornek3.java
3import java.util.Arrays;
4
5public class Ornek3 {
6
7 // İki matrisi toplayan metot. Dizileri parametre olarak alır ve yeni dizi döndürür.
8 static int[][] matrisTopla(int[][] a, int[][] b) {
9 int satir = a.length;
10 int sutun = a[0].length;
11 int[][] sonuc = new int[satir][sutun];
12 for (int i = 0; i < satir; i++) {
13 for (int j = 0; j < sutun; j++) {
14 sonuc[i][j] = a[i][j] + b[i][j];
15 }
16 }
17 return sonuc;
18 }
19
20 // Matrisi düzgün hizalı yazdıran yardımcı metot.
21 static void yazdir(String baslik, int[][] m) {
22 System.out.println(baslik);
23 for (int[] satir : m) {
24 for (int deger : satir) {
25 System.out.printf("%4d", deger);
26 }
27 System.out.println();
28 }
29 }
30
31 public static void main(String[] args) {
32 // 2 boyutlu dizi = satırlardan oluşan dizi.
33 int[][] a = {
34 {1, 2, 3},
35 {4, 5, 6}
36 };
37 int[][] b = {
38 {10, 20, 30},
39 {40, 50, 60}
40 };
41
42 yazdir("A matrisi:", a);
43 yazdir("\nB matrisi:", b);
44
45 int[][] toplam = matrisTopla(a, b);
46 yazdir("\nA + B:", toplam);
47
48 // Her satırın toplamını hesapla.
49 System.out.println("\nToplam matrisinin satır toplamları:");
50 for (int i = 0; i < toplam.length; i++) {
51 int satirToplam = Arrays.stream(toplam[i]).sum();
52 System.out.println(" Satır " + i + " -> " + satirToplam);
53 }
54 }
55}