10 parmak klavye dersi: Java dilinde programlama

Java, güçlü tip güvenliği sağlayan ve nesne yönelimli (object-oriented) bir programlama dilidir. JavaScript'in esnekliğinden veya Python'un girintiye dayalı yapısından farklı olarak Java, katı bir sözdizimine (syntax) sahiptir: paketler, sınıflar, import ifadeleri, görünürlük belirleyiciler, generics ve checked exceptions İng.: checked exceptions. Bu yüzden 10 parmak klavye ile Java yazmak sadece daha hızlı kod yazmayı değil, aynı zamanda daha az hata yapmayı da sağlar. Uzun tanımlayıcıların yazılması, iç içe geçmiş generics ifadelerinin kapatılması ve süslü parantezlerin veya noktalı virgüllerin doğru yerde kullanılması bu beceriyle kolaylaşır. Düzenli 10 parmak klavye pratiği ve hızlı yazma Java'da hem verimliliği artırır hem de odaklanmayı kodun mantığına kaydırır.

İdiomatik Java ve kurallar

Not: "idiomatic Java" İng.: idiomatic Java topluluk tarafından doğal ve doğru kabul edilen kodlama stilini ifade eder. Python'da "pythonic" kavramı kullanılırken, Java'da bu konvansiyonlarla sağlanır: paket adları küçük harfle ve noktayla ayrılarak yazılır (com.example.billing), sınıf ve arayüzler UpperCamelCase, metodlar ve alanlar lowerCamelCase, sabitler ise UPPER_SNAKE_CASE biçimindedir. Kod blokları her zaman süslü parantezle çevrelenir, tek satır olsa bile. Açık API'ler genellikle Javadoc (/** ... */) ile belgelenir. 10 parmak klavye ile Java yazmak bu kurallara uyumu kolaylaştırır.

Paketler, import ve tam adlar

Tam ad İng.: fully qualified name, sınıfın paketle birlikte tüm yolunu içerir. Java dosyaları package ile başlar, ardından import gelir. Küçük bir yazım hatası "cannot find symbol" hatasına yol açar. Hızlı yazma ile uzun adların yazımı kolaylaşır, 10 parmak klavye ile hata riski azalır.

package com.example.payments.service;
import java.math.BigDecimal;
import java.time.LocalDate;
import java.util.List;

public class InvoiceService {
    // ...
}

Tipler, belirleyiciler ve generics

Not: "generics" İng.: generics Java'da tip parametrelerini kullanarak tür güvenliğini sağlar. Görünürlük belirleyiciler (public, private), değişmezlik için final ve tipli koleksiyonlar (List<Order>) sık kullanılır. İç içe geçmiş yapılar Map<String, List<Integer>> gibi karmaşıklaşır. 10 parmak klavye ile bu yapılar otomatikleşir, hızlı yazma ile düzeltmeler hızlanır.

import java.util.*;

public class Repository<T> {
    private final Map<String, T> store = new HashMap<>();

    public void save(String id, T value) { store.put(id, value); }
    public Optional<T> find(String id) { return Optional.ofNullable(store.get(id)); }
}

Constructor, overloading ve record

Not: "overloading" İng.: overloading aynı isimde fakat farklı parametre listelerine sahip metod tanımlamaktır. "record" İng.: record ise immutable sınıfları basitçe tanımlamayı sağlar. Constructor başlangıç kurallarını belirler. 10 parmak klavye kullanımı parantez ve virgül hatalarını azaltır, hızlı yazma kodun hızlı yazılmasını sağlar.

// Constructor içeren sınıf
public class Mail {
    private final String to;
    private final String subject;
    private final String body;

    public Mail(String to, String subject, String body) {
        this.to = to;
        this.subject = subject;
        this.body = body;
    }
}

// Immutable sınıf için record
public record Message(String to, String subject, String body) { }

Checked exceptions ve try-with-resources

Not: "checked exceptions" İng.: checked exceptions derleme anında ele alınması veya bildirilmesi gereken istisnalardır. "try-with-resources" İng.: try-with-resources kaynakları otomatik olarak kapatır. Süslü parantezler ve blok yapıları kesin doğruluk gerektirir. 10 parmak klavye kullanımı bu desenin otomatikleşmesini sağlar.

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class Loader {
    public static String firstLine(String path) throws IOException {
        try (BufferedReader br = new BufferedReader(new FileReader(path))) {
            return br.readLine();
        }
    }
}

Metodlar, overloading ve varargs

Not: Java varsayılan parametreleri desteklemediği için overloading İng.: overloading kullanılır. "varargs" İng.: varargs ise ... ile değişken sayıda argüman almayı sağlar. Bu yapılar sembol yoğunluğu nedeniyle dikkat gerektirir. 10 parmak klavye ile hata riski azalır, hızlı yazma ile hız korunur.

public class Logger {
    public void log(String level, String msg) { System.out.println(level + ": " + msg); }
    public void log(String msg) { log("INFO", msg); }
    public void logf(String fmt, Object... args) { System.out.println(fmt.formatted(args)); }
}

Kontrol yapıları ve modern switch

Not: "switch expressions" İng.: switch expressions ok işareti (->) kullanır ve değer döndürebilir. Kodun kısalmasını sağlar ama sembol hassasiyeti yüksektir. 10 parmak klavye sayesinde bu yazım alışkanlık haline gelir.

public class Classifier {
    public static String label(int score) {
        return switch (score / 10) {
            case 10, 9 -> "A";
            case 8 -> "B";
            case 7 -> "C";
            case 6 -> "D";
            default -> "F";
        };
    }
}

Lambdalar, method references ve streams

Not: "lambda" İng.: lambda anonim fonksiyonlardır ((x) -> x + 1). "method reference" İng.: method reference Tip::metod şeklinde yazılır. "streams" İng.: streams zincirleme operasyonlara izin verir. Çok sembol içerirler. 10 parmak klavye yazımı daha doğru hale getirir, hızlı yazma ise hız kazandırır.

import java.util.List;

class Discounts {
    public static void main(String[] args) {
        List<Integer> prices = List.of(100, 200, 350, 400);
        int total = prices.stream()
                .map(p -> (int)(p * 0.9))
                .filter(p -> p >= 150)
                .reduce(0, Integer::sum);
        System.out.println(total);
    }
}

Eşitlik, sıralama ve contracts

Not: "contracts" İng.: contracts equals, hashCode, toString ve compareTo metodlarının kurallarını ifade eder. Tekrarlı ve dikkat gerektiren yazımlardır. 10 parmak klavye ile doğruluk, hızlı yazma ile hız sağlanır.

public final class Point implements Comparable<Point> {
    private final int x, y;
    public Point(int x, int y) { this.x = x; this.y = y; }
    @Override public int compareTo(Point o) {
        int cx = Integer.compare(this.x, o.x);
        return (cx != 0) ? cx : Integer.compare(this.y, o.y);
    }
}

Stringler, text blocks ve biçimlendirme

Not: "text blocks" İng.: text blocks """ ile tanımlanan çok satırlı stringlerdir. Biçimlendirme String#formatted veya String.format ile yapılır. 10 parmak klavye alıştırması özel karakterleri doğru yazmayı kolaylaştırır.

class Reporter {
    public static void main(String[] args) {
        String report = """
                Orders Report
                -------------
                Total: %d
                """.formatted(42);
        System.out.println(report);
    }
}

Instanceof ile pattern matching

Not: "pattern matching" İng.: pattern matching instanceof kontrolüyle değişkenlerin doğrudan tanımlanmasını sağlar. Kod tekrarını azaltır, fakat doğruluk gerektirir. 10 parmak klavye sayesinde bu desen hızlı ve hatasız yazılabilir.

static int len(Object o) {
    if (o instanceof String s) { return s.length(); }
    if (o instanceof java.util.List<?> list) { return list.size(); }
    return -1;
}

Modüller ve görünürlük

Not: "Java Platform Module System" İng.: JPMS module-info.java dosyasıyla kullanılır. Görünürlük belirleyiciler (public, protected, package-private, private) önemlidir. 10 parmak klavye ile bunların yazımı alışkanlık haline gelir.

module com.example.billing {
    exports com.example.billing.api;
    requires java.sql;
}

Eşzamanlılık ve concurrency

Not: "concurrency" İng.: concurrency threadler, thread pool ve CompletableFuture gibi yapıları içerir. Sembollerin (<>, ->, ::) sık kullanımı hata riskini artırır. 10 parmak klavye bu sembolleri hatasız yazmayı sağlar, hızlı yazma Java'da verimliliği artırır.

import java.util.concurrent.CompletableFuture;

class AsyncDemo {
    public static void main(String[] args) {
        CompletableFuture<String> f =
            CompletableFuture.supplyAsync(() -> "data")
                             .thenApply(String::toUpperCase)
                             .exceptionally(ex -> "fallback");
        System.out.println(f.join());
    }
}

Annotasyonlar

Not: "annotations" İng.: annotations @ işaretiyle belirtilen metaverilerdir. Framework kullanılmasa da en yaygın olanlar @Override, @Deprecated ve @SuppressWarnings'dır. 10 parmak klavye bu sembolleri hızlı ve doğru yazmayı sağlar.

public class User {
    private final String name;
    public User(String name) { this.name = java.util.Objects.requireNonNull(name); }

    @Override
    public String toString() { return "User{name='" + name + "'}"; }
}

Klavye alıştırmaları ve önemi

Java sözdiziminde birçok sembol bulunur: bloklar için süslü parantez, çağrılar için parantez, generics için köşeli parantezler, fonksiyonel öğeler için ok işaretleri ve ::, parametreler için virgül, satır sonu için noktalı virgül. 10 parmak klavye alıştırmaları bu desenleri otomatik hale getirir, hızlı yazma Java'da büyük projelerde bile ritmi korur.

Özet

Java açık tipleri, disiplinli yapısı ve yerleşik kurallarıyla tanınır. Generics, istisna yönetimi, kontrol yapıları ve fonksiyonel bileşenler dikkat ister. 10 parmak klavye Java'da hataları azaltır, hızlı yazma Java'da üretkenliği artırır. Bu ikisi birleştiğinde daha okunabilir, güvenilir ve genellikle ilk çalıştırmada doğru sonuç veren kod ortaya çıkar.