Java Programlama Dili: Temel Bilgiler ve Uygulamalı Örnekler

Herkese merhaba

Java programlama dili, modern yazılım geliştirmede önemli bir rol oynar ve pek çok geliştiricinin ilk tercihidir. Ancak, Java’ya yeni başlayanlar için bu güçlü dilin temellerini kavramak bazen zorlayıcı olabilir. Bu yazının amacı, Java dilinin temellerini basit ve anlaşılır bir şekilde açıklamak, öğrenme sürecinizi kolaylaştırmaktır. Değişkenler, operatörler, döngüler ve metotlar gibi temel konuları ele alacak ve her birini örneklerle destekleyerek açıklayacağım. Böylece, Java’da karşılaşabileceğiniz temel yapı taşlarını net bir şekilde anlayabilecek ve kendi projelerinize kolayca uygulayabileceksiniz.

1. Java Nedir?

Java, Sun Microsystems (şu anda Oracle) tarafından geliştirilen, platformdan bağımsız, nesne yönelimli bir programlama dilidir. (Write Once, Run Anywhere) prensibiyle bilinir, yani bir kez yazılan Java kodu, herhangi bir platformda çalışabilir.

2. Veri Türleri ve Değişkenler

Java’da veri türleri, değişkenlerin alabileceği değerlerin türünü belirler. İki ana kategori vardır: ilkel (primitive) veri türleri ve referans (reference) veri türleri.

-İlkel Veri Türleri-

İlkel veri türleri, Java’da en temel veri türleridir ve doğrudan bellekte saklanır. Java’da 8 ilkel veri türü vardır:

• byte: 8 bit uzunluğunda, -128 ile 127 arasında değer alır.
• short: 16 bit uzunluğunda, -32,768 ile 32,767 arasında değer alır.
• int: 32 bit uzunluğunda, -2³¹ ile 2³¹-1 arasında değer alır.
• long: 64 bit uzunluğunda, -2⁶³ ile 2⁶³-1 arasında değer alır. Değerin sonuna ‘L’ eklenir.
• float: 32 bit uzunluğunda, ondalıklı sayılar için kullanılır. Değerin sonuna ‘f’ eklenir.
• double: 64 bit uzunluğunda, ondalıklı sayılar için kullanılır.
• char: 16 bit uzunluğunda, tek bir karakteri temsil eder. Tek tırnak içinde kullanılır.
• boolean: 1 bit uzunluğunda, doğru (true) veya yanlış (false) değer alır.

İlkel veri Türleri örnekleri

Referans (Reference) Veri Türleri

Referans veri türleri, nesne referanslarını içerir. İlkel veri türlerinden farklı olarak, veri değil veri adresi saklarlar.

• String: Karakter dizilerini saklamak için kullanılır.
• Diziler (Arrays): Aynı veri tipinden birden fazla değeri saklamak için kullanılır.
• Sınıflar ve Nesneler (Classes and Objects): Java’da her şey bir nesnedir. Sınıflar, nesnelerin yapısını tanımlar.

Referans (Reference) Veri Türleri Örnekleri

Değişken Tanımlama ve Kullanma

Değişkenler, veriyi saklamak için kullanılır ve her değişkenin bir adı, veri türü ve başlangıç değeri vardır.

int yas = 30; // "yas" adlı bir tam sayı değişkeni ve başlangıç değeri 30
double maas = 4500.50; // "maas" adlı bir ondalıklı sayı değişkeni ve başlangıç değeri 4500.50
char harf = 'B'; // "harf" adlı bir karakter değişkeni ve başlangıç değeri 'B'
boolean ogrencimi = true; // "ogrencimi" adlı bir boolean değişkeni ve başlangıç değeri true

Değişken Kapsamı (Scope)

Değişkenin kapsamı, tanımlandığı blok ile sınırlıdır. Değişkenler, metot içinde tanımlandığında yerel (local) değişken olarak adlandırılır ve sadece tanımlandıkları blokta erişilebilir.

public class Ornek {
    public static void main(String[] args) {
        int yas = 20; // yerel değişken
        if (yas >= 18) {
            boolean resit = true; // yerel değişken
            System.out.println("Reşitsiniz.");
        }
        // System.out.println(resit); // Hata: resit değişkeni bu blokta erişilemez
    }
}

Değişken İsimlendirme Kuralları

• Değişken isimleri harf, rakam, alt çizgi (_) ve dolar işareti ($) ile başlayabilir.
• Değişken isimleri büyük/küçük harf duyarlıdır.
• Değişken isimleri, Java anahtar kelimeleri (if, for, class vb.) olamaz.

int yas = 25;
double maas = 5000.75;
String isim = "ALP";
boolean ogrencimi = false;

Java Operatörleri ve İfadeler

Java’da operatörler, programlama sürecinde çeşitli işlemleri gerçekleştirmek için kullanılır. Operatörler, değişkenler ve değerler üzerinde işlem yaparak yeni değerler üretirler. Java’da operatörler birkaç farklı kategoriye ayrılır: atama operatörleri, aritmetik operatörler, ilişkisel operatörler, mantıksal operatörler, artırma ve azaltma operatörleri ve üçlü (ternary) operatör. Bunları yakından inceleyelim ;

Atama Operatörleri

Atama operatörleri, bir değişkene değer atamak için kullanılır.

• =: Değişkene değer atar.
• +=: Değişkene mevcut değerine ekleyerek yeni değer atar.
• -=: Değişkene mevcut değerinden çıkararak yeni değer atar.
• *=: Değişkene mevcut değeriyle çarparak yeni değer atar.
• /=: Değişkene mevcut değerini bölerek yeni değer atar.
• %=: Değişkene mevcut değerinin modunu alarak yeni değer atar.

int x = 10;  // = operatörü
x += 5;      // x = x + 5;  x şimdi 15
x -= 3;      // x = x - 3;  x şimdi 12
x *= 2;      // x = x * 2;  x şimdi 24
x /= 4;      // x = x / 4;  x şimdi 6
x %= 4;      // x = x % 4;  x şimdi 2

Aritmetik Operatörler

Aritmetik operatörler, matematiksel işlemler yapmak için kullanılır.,

• +: Toplama operatörü
• -: Çıkarma operatörü
• *: Çarpma operatörü
• /: Bölme operatörü
• %: Modül operatörü

int a = 10;
int b = 3;
int toplam = a + b;      // toplam 13
int fark = a - b;        // fark 7
int carpim = a * b;      // carpim 30
int bolum = a / b;       // bolum 3
int mod = a % b;         // mod 1

İlişkisel Operatörler

İlişkisel operatörler, iki değeri karşılaştırmak için kullanılır ve boolean (true veya false) sonuç üretir.

• == : Eşit mi
• != : Eşit değil mi
• > : Büyüklük karşılaştırması
• < : Küçüklük karşılaştırması
• >= : Büyük veya eşit mi
• <= : Küçük veya eşit mi

int c = 5;
int d = 10;
boolean esitmi = (c == d);       // false
boolean farklimi = (c != d);     // true
boolean buyukmü = (c > d);       // false
boolean kucukmü = (c < d);       // true
boolean buyukVeyaEsitmi = (c >= d); // false
boolean kucukVeyaEsitmi = (c <= d); // true 

Mantıksal Operatörler

Mantıksal operatörler, boolean ifadeleri birleştirmek için kullanılır.

• && : Mantıksal VE (and) operatörü
• || : Mantıksal VEYA (or) operatörü
• ! : Mantıksal DEĞİL (not) operatörü

boolean e = true;
boolean f = false;
boolean sonuc = (e && f);    // false (her iki ifade de true olmalı)
boolean sonuc2 = (e || f);   // true (en az biri true olmalı)
boolean sonuc3 = !e;         // false (e'nin değeri tersine çevrilir)

Artırma ve Azaltma Operatörleri

Artırma ve azaltma operatörleri, bir değişkenin değerini 1 artırmak veya azaltmak için kullanılır.

• ++: Artırma operatörü
• — : Azaltma operatörü

int g = 10;
g++;  // g şimdi 11
g--;  // g şimdi 10

Üçlü (Ternary) Operatör

Üçlü operatör, bir boolean ifadenin sonucuna göre iki değerden birini seçer. Bu biraz karışık olduğu için iki örnek ile açıklamak istedim.

• ? : Şart (ternary) operatörü

int j = 10;
int k = 5;
int max = (j > k) ? j : k;  // max 10 olur çünkü j > k

int x = 10;
int y = 5;
int max = (x > y) ? x : y;
System.out.println(max); // Çıktı: 10
//Bu kodda, x'in değeri y'den büyükse, max değişkenine x'in değeri atanır; 
// aksi takdirde max değişkenine y'nin değeri atanır. 
// Bu, max değişkenine büyük olan sayının atanmasını sağlar.

Koşullu İfadeler ve Döngüler

Java’da koşullu ifadeler ve Döngüler, programın akışını yönlendirmek ve belirli işlemleri tekrar etmek için kullanılır. Java’da bulunan temel Koşullu ifade yapıları şunlardır: if-else ifadeleri, switch-case ifadeleri, ve döngüler (for, while, do-while).

if-else İfadeleri

if-else ifadeleri, bir koşulun doğruluğuna göre farklı kod bloklarının çalıştırılmasını sağlar. Bu yapılar, programın akışını belirli koşullara göre yönlendirir.

int yas = 20;
if (yas >= 18) {
    System.out.println("Reşitsiniz.");
} else {
    System.out.println("Reşit değilsiniz.");
}

Bu kodda, eğer yaş 18'den büyük veya eşitse “Reşitsiniz.” yazdırılır, aksi takdirde “Reşit değilsiniz.” yazdırılır.

Switch-case İfadeleri

switch-case ifadeleri, bir değişkenin değerine göre farklı işlemlerin yapılmasını sağlar. Bu yapılar, birden fazla koşulun karşılaştırılması gerektiğinde kullanışlı hale gelebilir Örneğin ;

int gun = 3;
switch (gun) {
    case 1:
        System.out.println("Pazartesi");
        break;
    case 2:
        System.out.println("Salı");
        break;
    case 3:
        System.out.println("Çarşamba");
        break;
    default:
        System.out.println("Geçersiz gün");
}

Bu kodda, değişkenin değerine göre farklı günlerin adlarını yazdıran bir yapı vardır. Eğer değişkenin değeri case ifadelerinden birine eşitse, o case bloğu çalıştırılır. Eğer hiçbir case bloğu uyuşmazsa, default bloğu çalışır.

For Döngüsü

for döngüsü, belirli bir koşul sağlanana kadar belirli bir kod bloğunu tekrarlar. Bu yapılar, belirli bir aralıkta veya belirli bir koşul altında bir dizi işlemi yinelerken kullanılır. Örneğin:

for (int i = 1; i <= 5; i++) {
    System.out.println("Sayı: " + i);
}

Bu kodda, 1'den 5'e kadar olan sayıları ekrana yazdıran bir döngü vardır. Döngü, i değişkenini 1'den başlatır ve her döngüde 1 artırır.

While Döngüsü

while döngüsü, belirli bir koşul sağlandığı sürece bir kod bloğunu tekrarlar. Bu yapılar, bir koşul doğru olduğu sürece bir dizi işlemi yinelemek için kullanılır.

int sayac = 0;
while (sayac < 5) {
    System.out.println("Sayı: " + sayac);
    sayac++;
}

Bu kodda, sayac değişkeni 5'ten küçük olduğu sürece sayıları ekrana yazdıran bir döngü vardır. Döngü, sayac değişkenini her döngüde bir artırır.

do-while Döngüsü

do-while döngüsü, döngü koşulunu en az bir kez kontrol eder ve ardından koşul doğru olduğu sürece bir kod bloğunu tekrarlar. Bu yapılar, bir işlemi en az bir kez gerçekleştirmek istediğimizde kullanılır.

int sayac = 0;
do {
    System.out.println("Sayı: " + sayac);
    sayac++;
} while (sayac < 5);

Bu kodda, sayac değişkeni 5'ten küçük olduğu sürece sayıları ekrana yazdıran bir döngü vardır. Döngü, sayac değişkenini her döngüde bir artırır ve döngü koşulu kontrol edilir.

Break ve continue İfadeleri

break ifadesi, bir döngüyü veya switch-case bloğunu sonlandırmak için kullanılırken, continue ifadesi, döngünün geri kalanını atlayıp bir sonraki döngü adımına geçmek için kullanılır. Bu ifadeler, döngülerin veya switch-case bloklarının akışını kontrol etmek için kullanılır.

for (int i = 0; i < 10; i++) {
    if (i == 5) {
        break; // Döngüyü sonlandırır
    }
    if (i == 3) {
        continue; // Bu adımı atlar ve bir sonraki adıma geçer
    }
    System.out.println("Sayı: " + i);
}

Bu kodda, bir döngü içinde belirli bir koşulda döngüyü sonlandırmak veya belirli bir adımı atlamak için break ve continue ifadeleri kullanılmıştır.

Metotlar (Methods)

Java’da metotlar, belirli bir görevi yerine getirmek için kullanılan bloklardır. Metotlar, kodun yeniden kullanılabilirliğini artırır, karmaşıklığı azaltır ve programları daha okunaklı hale getirir. Bir metot, bir isimle tanımlanır ve bu isimle çağrılır.

Metot Tanımlama ve Kullanma

Metotlar, genellikle aşağıdaki formatta tanımlanır:

erişim_belirleyici dönüş_tipi metot_adı(parametre_listesi) {
    // Metotun işlevi buraya yazılır
    return dönüş_değeri; // Eğer metot bir değer döndürecekse
}

• erişim_belirleyici: Metota erişim seviyesini belirtir. Genellikle public, private veya protected olabilir.
• dönüş_tipi: Metotun geri dönüş değerinin türünü belirtir. Eğer metot bir şey döndürmüyorsa, void kullanılır.
• metot_adı: Metodun ismini belirtir. Bu isimle metot çağrılır.
• parametre_listesi: Metoda giriş parametreleri geçilir. Bu parametreler, metot içinde kullanılabilir.
• dönüş_değeri: Eğer metot bir değer döndürecekse, bu değer dönüş ifadesi ile belirtilir.

Metotlar, bir kez tanımlandıktan sonra başka kod blokları içinde çağrılabilirler.

Metot Parametreleri ve Dönüş Değeri

Metotlar, giriş parametreleri alabilir ve bir değer döndürebilirler. Parametreler, metotun işlevini yerine getirirken kullanılan geçici verilerdir. Dönüş değeri ise metot tarafından üretilen sonucu ifade eder.

public static int toplama(int x, int y) {
    return x + y; 
}

yukarıda ki örnekte , toplama metodu iki tam sayı parametresi alır x ve y ve return döndürerek bu parametrelerin toplamını döndürür (x+y).

Metot Overloading

Java’da bir metot, aynı isme sahip fakat farklı parametre listelerine sahip birden fazla metot tanımlanabilir. Buna metot overloading denir. Java, çağrılan metoda uygun olan parametre listesine sahip metodu otomatik olarak seçer. Yani hangisine ihtiyaç duyuyorsak java bunu otomatik anlar ve ona göre uygun olanı çağırır.

public static int toplama(int x, int y) {
    return x + y;
}

public static double toplama(double x, double y) {
    return x + y;
}

Yukarıda ki örnekte aynı isme sahip iki tane metot tanımlanmıştır. Ama bu metotlar farklı parametrelere sahiptirler. İhtiyacımız doğrultusunda hangisi uygunsa o türde toplama işlemi yapılır.

Metotlar, Java’da kodun modülerliğini artırmanın ve daha kolay anlaşılabilir hale getirmenin önemli bir yoludur. İyi tasarlanmış metotlar, kodun okunabilirliğini artırır ve tekrar kullanılabilirlik sağlar.