├── .idea ├── .gitignore ├── vcs.xml ├── misc.xml └── modules.xml ├── src ├── _27_exceptionHandling │ ├── AttemptException.java │ ├── AttempSample.java │ ├── AttempFileReader.java │ ├── test.txt │ ├── UncheckedExceptionSample.java │ ├── CheckedExceptions.java │ ├── CheckedExceptionSample.java │ ├── UncheckedExceptions.java │ └── ExceptionHandling.java ├── _26_polymorphism │ ├── ParametricDemo.java │ ├── Employee.java │ ├── _3_parametric.java │ ├── ParametricTest.java │ ├── CoercionTest.java │ ├── Person.java │ ├── _2_overloading.java │ ├── _1_Coercion.java │ └── _4_subtype.java ├── _19_arraysSinifi │ ├── _sortMethodu.java │ ├── _toStringMethodu.java │ ├── _fillMethodu.java │ ├── _binarySearchMethodu.java │ ├── _copyOf_copyOfRange.java │ └── _equalsMethodu.java ├── _31_collections │ ├── Main.java │ ├── text.text │ └── CreateCode.java ├── _01_veriTipleriVeDegiskenler │ ├── Double.java │ ├── Short.java │ ├── Boolean.java │ ├── Integer.java │ ├── Char.java │ ├── VeriTipleri.java │ ├── Long.java │ ├── Byte.java │ └── Float.java ├── _29_arraysSinifi │ ├── Arrays_equals.java │ ├── Arrays_binarySearchMethodu.java │ ├── Arrays_toStringMethodu.java │ └── Arrays_copyOfRange_Arrays_copyOfRange.java ├── _21_NesneVeSinifYapisi_GetterSetter │ ├── ArabaTest.java │ ├── GetterVeSetterMethodlar.java │ └── Araba.java ├── _21_NesneVeSinifYapisi │ ├── Sinif.java │ ├── NesneSinifi.java │ ├── _25_inheritance │ │ ├── Person.java │ │ ├── Employee.java │ │ ├── SuperClassVeSubClass.java │ │ ├── ObjectSinifi.java │ │ └── Inheritance.txt │ ├── ArabaNotlu.java │ ├── Araba.java │ ├── NesneVeSinifYapisi.java │ ├── Constructor_YapiciMethod.java │ └── ArabaTest.java ├── _23_nesneYönelimProgramlama │ ├── Encapsulation.java │ ├── Polymorphism.java │ ├── Abstraction.java │ └── Inheritance.java ├── _02_javaStringVeriTipi │ ├── replace.java │ ├── JavaString.java │ ├── toUpperCase_toLowerCase.java │ ├── substring_charAt.java │ ├── equals_equalsIgnoreCase.java │ └── son.java ├── _18_dizilerdeSiralama_ArraySort │ ├── SortOrnek.java │ └── SelectionSort.java ├── _13_methodYapisi │ ├── Overloading2.java │ ├── Overloading.java │ ├── Ornek2.java │ └── Method.java ├── _28_composition │ ├── Test.java │ ├── Resolution.java │ ├── Kasa.java │ ├── Bilgisayar.java │ ├── Monitor.java │ ├── Anakart.java │ ├── CompositionOrnegi.java │ └── composition.java ├── _11_forDongusu │ ├── IcIceDonguler_For.java │ ├── ForDongusu.java │ └── ForDongusuKullanimi.java ├── _09_whileDongusu │ ├── WhileDongusuOrnek_Toplama.java │ ├── WhileDongusuOrnek_SayiTahmin.java │ └── whileDongusu.java ├── _22_erisimBelirleyiciler │ ├── ErişimBelirleyiciler.txt │ ├── AracKullanicisi.java │ ├── OzelArac.java │ └── Yolcu.java ├── _25_abstraction │ ├── Person.java │ ├── FirstFirmEmployee.java │ ├── Employee.java │ ├── Abstraction.java │ ├── SecondFirmEmployee.java │ └── AbstractClassTeknikÖzellikleri.txt ├── _24_encapsulation │ ├── Encapsulation.java │ ├── EncapsulationDemo1.java │ └── EncapsulationDemo2.java ├── _20_MultidimensionalArrays_cokBoyutluDiziler │ ├── MultidimensionalArrayOrnek.java │ ├── KarmaşıkDiziler.java │ └── MultidimensionalArrays.java ├── _16_diziler_ForeachKullanimi │ ├── LengthKullanimi.java │ ├── ForDongusuKullanimi.java │ └── ForeachDongusuKullanimi.java ├── _17_dizilerdeArama_ArraySearch │ ├── BinarySearch_2.java │ ├── LinearSearch.java │ └── BinarySearch.java ├── _30_MultidimensionalArrays │ ├── CokBoyutluDiziler.java │ ├── MultidimensionalArray.java │ ├── RobotRonGrubu.java │ └── KarmasikDiziler.java ├── _07_javaOperatorlari │ ├── BasitAtamaOperatorlari.java │ ├── TekliOperatorler.java │ ├── AritmatikOperatorler.java │ ├── EsitlikVeIliskiselOperatorler.java │ ├── KarsilastirmaOperatorlari.java │ └── KosulOperatorlari.java ├── _05_switchCase │ ├── SwitchCaseOrnek.java │ └── SwitchCase.java ├── _06_scanner │ ├── Import.java │ └── ScannerSinifi.java ├── _04_ifElseKosulYapisi_AndOr │ ├── and_or_ornek.java │ └── and_or.java ├── _12_breakContinueDeyimleri │ ├── Continue.java │ └── Break.java ├── _03_ifElseKosulYapisi │ ├── ifElse.java │ └── ifElseOrnek.java ├── _10_doWhileDongusu │ └── DoWhileDongusu.java ├── _08_mathSinifi │ └── MathSinifi.java ├── _15_tekBoyutluDiziler_Array │ └── Array.java └── _14_methodYapisi_MainMethod │ └── MainMethod.java ├── javaKonuTekrari.iml └── out └── production └── javaKonuTekrari ├── _22_erisimBelirleyiciler └── ErişimBelirleyiciler.txt ├── _27_exceptionHandling └── test.txt ├── _21_NesneVeSinifYapisi └── _25_inheritance │ └── Inheritance.txt └── _25_abstraction └── AbstractClassTeknikÖzellikleri.txt /.idea/.gitignore: -------------------------------------------------------------------------------- 1 | # Default ignored files 2 | /shelf/ 3 | /workspace.xml 4 | -------------------------------------------------------------------------------- /.idea/vcs.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | -------------------------------------------------------------------------------- /src/_27_exceptionHandling/AttemptException.java: -------------------------------------------------------------------------------- 1 | package _27_exceptionHandling; 2 | 3 | public class AttemptException extends Exception { 4 | 5 | public AttemptException(String message){ 6 | super(message); 7 | } 8 | 9 | 10 | } 11 | -------------------------------------------------------------------------------- /.idea/misc.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | -------------------------------------------------------------------------------- /.idea/modules.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | -------------------------------------------------------------------------------- /src/_26_polymorphism/ParametricDemo.java: -------------------------------------------------------------------------------- 1 | package _26_polymorphism; 2 | 3 | import java.util.ArrayList; 4 | import java.util.List; 5 | 6 | public class ParametricDemo { 7 | 8 | private List listItem = new ArrayList(); 9 | 10 | public void add(T item) { 11 | listItem.add(item); 12 | } 13 | 14 | public T get(int index) { 15 | return listItem.get(index); 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /src/_27_exceptionHandling/AttempSample.java: -------------------------------------------------------------------------------- 1 | package _27_exceptionHandling; 2 | 3 | public class AttempSample { 4 | 5 | public static void main(String[] args) { 6 | 7 | AttempFileReader fileReader = new AttempFileReader(); 8 | 9 | try { 10 | fileReader.read("test.txt"); 11 | } catch (AttemptException e) { 12 | e.printStackTrace(); 13 | } 14 | 15 | } 16 | 17 | 18 | } 19 | -------------------------------------------------------------------------------- /src/_19_arraysSinifi/_sortMethodu.java: -------------------------------------------------------------------------------- 1 | package _19_arraysSinifi; 2 | 3 | import java.util.Arrays; 4 | 5 | public class _sortMethodu { 6 | public static void main(String[] args) { 7 | int[] liste = {1, 4, 99, 2, 5, -3, 6, 2, -49, 52};//Dizi'mizi oluşturuyoruz 8 | 9 | //Diziyi sıralamak için Arrays.sort() kullanırız 10 | Arrays.sort(liste); 11 | System.out.println(Arrays.toString(liste)); 12 | 13 | 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /src/_19_arraysSinifi/_toStringMethodu.java: -------------------------------------------------------------------------------- 1 | package _19_arraysSinifi; 2 | 3 | import java.util.Arrays; 4 | 5 | public class _toStringMethodu { 6 | public static void main(String[] args) 7 | { 8 | 9 | int[] liste = {1, 4, 99, 2, 5, -3, 6, 2,-49,52};//Dizi'mizi oluşturuyoruz 10 | 11 | // dizimizi direk konsola yazdırabilmek için Arrays.toString() kullanılır 12 | System.out.println(Arrays.toString(liste)); 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /javaKonuTekrari.iml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | -------------------------------------------------------------------------------- /src/_31_collections/Main.java: -------------------------------------------------------------------------------- 1 | package _31_collections; 2 | 3 | public class Main { 4 | public static void main(String[] args) { 5 | CreateCode createCode = new CreateCode(); 6 | String ayrac = "---------------"; 7 | System.out.println(ayrac + "\n\n" + ayrac); 8 | for (int i = 0; i < 5; i++) { 9 | System.out.println("-> Oluşturulan " + (i + 1) + ". Lisans Anahtarı: " + createCode.newCode() + "\n" + ayrac); 10 | } 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /src/_01_veriTipleriVeDegiskenler/Double.java: -------------------------------------------------------------------------------- 1 | package _01_veriTipleriVeDegiskenler; 2 | 3 | public class Double { 4 | public static void main(String[] args) { 5 | 6 | /* 7 | DOUBLE: double veri tipi 64 bitlik büyüklüğe sahiptir 8 | ve 4.9×10^-324 ile 1.8×10^308 arasında bir değer tanımlanabilir. 9 | Kod geliştirirken double anahtar kelimesi ile tanımlama yapılır. 10 | */ 11 | 12 | double doubleDeger = 34.5; 13 | System.out.println(doubleDeger); 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /src/_27_exceptionHandling/AttempFileReader.java: -------------------------------------------------------------------------------- 1 | package _27_exceptionHandling; 2 | 3 | import java.io.FileInputStream; 4 | import java.io.FileNotFoundException; 5 | 6 | public class AttempFileReader { 7 | 8 | public void read(String fileName) throws AttemptException{ 9 | 10 | try { 11 | FileInputStream fileInputStream = new FileInputStream(fileName); 12 | } catch (FileNotFoundException e) { 13 | throw new AttemptException("Dosya bulunamadi!"); 14 | } 15 | 16 | } 17 | 18 | 19 | } 20 | -------------------------------------------------------------------------------- /src/_26_polymorphism/Employee.java: -------------------------------------------------------------------------------- 1 | package _26_polymorphism; 2 | 3 | public class Employee extends Person { 4 | 5 | private String jobTitle;//İş ismi 6 | private long salary;//aylık maaş 7 | 8 | public String getJobTitle() { 9 | return jobTitle; 10 | } 11 | 12 | public void setJobTitle(String jobTitle) { 13 | this.jobTitle = jobTitle; 14 | } 15 | 16 | public long getSalary() { 17 | return salary; 18 | } 19 | 20 | public void setSalary(long salary) { 21 | this.salary = salary; 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /src/_29_arraysSinifi/Arrays_equals.java: -------------------------------------------------------------------------------- 1 | package _29_arraysSinifi; 2 | 3 | import java.util.Arrays; 4 | 5 | public class Arrays_equals { 6 | 7 | public static void main(String[] args) 8 | { 9 | int[] list1 = {1, 5, 52}; 10 | int[] list2 = {1, 5, 52}; 11 | int[] list3 = {1, 5, 53}; 12 | 13 | //İki dizi birbirinin aynısı olup olmadığını kontrol etmek için Arrays.equals() metotu kullanılır 14 | System.out.println(Arrays.equals(list1, list2)); // true 15 | System.out.println(Arrays.equals(list2, list3)); // false 16 | 17 | } 18 | 19 | } 20 | -------------------------------------------------------------------------------- /src/_21_NesneVeSinifYapisi_GetterSetter/ArabaTest.java: -------------------------------------------------------------------------------- 1 | package _21_NesneVeSinifYapisi_GetterSetter; 2 | 3 | public class ArabaTest { 4 | 5 | public static void main(String[] args) { 6 | Araba arabaNesnesi = new Araba(); 7 | arabaNesnesi.calistir(); 8 | 9 | Araba baskaArabaNesnesi = new Araba(2990); 10 | baskaArabaNesnesi.calistir(); 11 | 12 | System.out.println(baskaArabaNesnesi.getVarsayilanMotorHacmi()); 13 | 14 | baskaArabaNesnesi.setVarsayilanMotorHacmi(5990); 15 | 16 | System.out.println(baskaArabaNesnesi.getVarsayilanMotorHacmi()); 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /src/_21_NesneVeSinifYapisi/Sinif.java: -------------------------------------------------------------------------------- 1 | package _21_NesneVeSinifYapisi; 2 | 3 | public class Sinif { 4 | /* 5 | Sınıf 6 | Java Nesne ve Sınıf Yapısı’nda “Nesneler sınıflardan oluşur” 7 | demiştik, o halde öncelikle sınıf yapısı nasıl oluşur ona bakalım; 8 | */ 9 | 10 | 11 | 12 | /* 13 | 14 | public degiskenTuru degiskenTuru; 15 | //constructor 16 | Sinif() { 17 | } 18 | //constructor 19 | Sinif(degiskenTuru yeniDegiskenTuru) { 20 | degiskenTuru = yeniDegiskenTuru; 21 | } 22 | //metot 23 | void metotAdi() { 24 | } 25 | 26 | */ 27 | 28 | 29 | 30 | } 31 | -------------------------------------------------------------------------------- /src/_23_nesneYönelimProgramlama/Encapsulation.java: -------------------------------------------------------------------------------- 1 | package _23_nesneYönelimProgramlama; 2 | 3 | public class Encapsulation { 4 | 5 | //Kapsülleme (Encapsulation) 6 | 7 | /* 8 | Oluşturduğumuz bir sınıftaki değişkenlerin setter ve getter 9 | metotları kullanılarak ve bu setter ve getter metotlarına 10 | erişim belirleyicilerle belli sınıflardan erişim sağlanmasına 11 | izin vermek belli sınıflardan erişim sağlanmasına izin vermemek 12 | gibi kontroller Kapsülleme ile mümkündür. Kapsülleme yazılımcıya 13 | oluşturduğu sınıftaki değişkenlerin erişimlerini kontrol yetkisi verir. 14 | */ 15 | 16 | 17 | } 18 | -------------------------------------------------------------------------------- /src/_02_javaStringVeriTipi/replace.java: -------------------------------------------------------------------------------- 1 | package _02_javaStringVeriTipi; 2 | 3 | public class replace { 4 | public static void main(String[] args) { 5 | 6 | /* 7 | String tipinin bir başka özelliği de değer olarak atanmış 8 | metin içerisinde istediğimiz bir karakteri yine istediğimiz 9 | bir karakterle değiştirebiliyor olmamızdır. 10 | */ 11 | 12 | String stringDeger = "Hello Java, Hello Word"; 13 | System.out.println(stringDeger.replace("e", "i")); //Hillo Java, Hillo Word 14 | System.out.println(stringDeger.replace("Hello", "Merhaba")); //Merhaba Java, Merhaba Word 15 | 16 | 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /src/_26_polymorphism/_3_parametric.java: -------------------------------------------------------------------------------- 1 | package _26_polymorphism; 2 | 3 | import java.util.ArrayList; 4 | import java.util.List; 5 | 6 | public class _3_parametric { 7 | 8 | /* 9 | Parametric Polymorphism Java’da diğer bir adıyla Generic 10 | olarak bilinmektedir. Bu konu başlığı altında çok detayına inmeden 11 | basitçe anlatarak bir örnek vermeye çalışacağım. Java’da bir alan 12 | String bir değer alarak yine String bir değer dönerken, yine aynı 13 | şekilde integer bir değer alarak yine integer bir değer dönebilir. 14 | Basitçe bir örnek üzerinden anlatmak gerekirse; 15 | 16 | Örneği ParametricDemo ve ParametricTest class larında 17 | */ 18 | 19 | } 20 | -------------------------------------------------------------------------------- /src/_18_dizilerdeSiralama_ArraySort/SortOrnek.java: -------------------------------------------------------------------------------- 1 | package _18_dizilerdeSiralama_ArraySort; 2 | 3 | import java.util.Arrays; 4 | 5 | public class SortOrnek { 6 | public static void main(String[] args) { 7 | /* 8 | Karışık verilen sayıları ve kelimeleri sıralayan Java kodunun yazınız. 9 | */ 10 | 11 | 12 | int[] liste = {1232, 1134, 2345, 1022}; 13 | 14 | Arrays.sort(liste); 15 | System.out.println(Arrays.toString(liste)); 16 | 17 | String [] kelime = {"Java", "Python", "PHP", "C#", "C Programming", "C++"}; 18 | 19 | Arrays.sort(kelime); 20 | System.out.println(Arrays.toString(kelime)); 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /src/_13_methodYapisi/Overloading2.java: -------------------------------------------------------------------------------- 1 | package _13_methodYapisi; 2 | 3 | public class Overloading2 { 4 | public static void toplama(int sayi1, int sayi2){ 5 | int sonucInt = sayi1+sayi2; 6 | System.out.println(sayi1 + " + " + sayi2 + "= " + sonucInt); 7 | } 8 | public static void toplama(double sayi1, double sayi2){ 9 | double sonucDouble = sayi1+sayi2; 10 | System.out.println(sayi1 + "+ " + sayi2 + "= " + sonucDouble); 11 | } 12 | 13 | public static void main(String[] args){ 14 | System.out.println("Tamsayı Toplama :"); 15 | toplama(15,20); 16 | System.out.println("Küsüratlı Toplama :"); 17 | toplama(20.52,20.49); 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /src/_21_NesneVeSinifYapisi/NesneSinifi.java: -------------------------------------------------------------------------------- 1 | package _21_NesneVeSinifYapisi; 2 | 3 | public class NesneSinifi { 4 | 5 | /* 6 | Java Nesne ve Sınıf Yapısında nesnelerin sınıflardan oluştuğunu 7 | daha önce söylemiştim. Sınıf yapısını gördüğümüze göre artık 8 | sınıflardan nasıl nesne oluşturulduğunu görebiliriz. 9 | En basit ve genel yöntemle; 10 | */ 11 | 12 | NesneSinifi nesne = new NesneSinifi(); 13 | 14 | /* 15 | şeklinde bir tanımlama ile "nesne" nesnesi oluşturulabilir. 16 | Yine daha iyi anlaşılması için Araba sınıfımız üzerinden 17 | devam edelim. 18 | Öncelikle Araba sınıfımızda biraz değişiklik yapalım ve 19 | araba nesnemizi oluşturalım. 20 | */ 21 | } 22 | -------------------------------------------------------------------------------- /src/_28_composition/Test.java: -------------------------------------------------------------------------------- 1 | package _28_composition; 2 | 3 | public class Test { 4 | 5 | public static void main(String[] args) { 6 | 7 | Resolution resolution = new Resolution(1920,1080); 8 | Monitor monitor = new Monitor("VS197DE","ASUS","25",resolution); 9 | Kasa kasa = new Kasa("Shadow Blade", "Shadow", "Temperli Cam"); 10 | Anakart anakart = new Anakart("B250-PRO","ASUS",10,"Windows 10"); 11 | Bilgisayar bilgisayar = new Bilgisayar(monitor,kasa,anakart); 12 | 13 | bilgisayar.getKasa().bilgisayariAc(); 14 | bilgisayar.getMonitor().monitoruKapat(); 15 | bilgisayar.getAnakart().isletimSistemi_yukle("Linux Mint"); 16 | 17 | 18 | } 19 | 20 | } 21 | -------------------------------------------------------------------------------- /src/_19_arraysSinifi/_fillMethodu.java: -------------------------------------------------------------------------------- 1 | package _19_arraysSinifi; 2 | 3 | import java.util.Arrays; 4 | 5 | public class _fillMethodu { 6 | public static void main(String[] args) { 7 | int[] liste = {1, 4, 99, 2, 5, -3, 6, 2,-49,52};//Dizi'mizi oluşturuyoruz 8 | //Diziyi Belirli Bir Değerle ile Doldurmak için Arrays.fill() 9 | 10 | Arrays.fill(liste,5); 11 | System.out.println(Arrays.toString(liste)); 12 | 13 | int[] liste2 = {1, 4, 99, 2, 5, -3, 6, 2,-49,52};//Dizi'mizi oluşturuyoruz 14 | //Diziyi Belirli Bir değerle, belirli bir aralıkta doldurma 15 | 16 | Arrays.fill(liste2,2,5,6); 17 | System.out.println(Arrays.toString(liste2)); 18 | } 19 | } 20 | 21 | -------------------------------------------------------------------------------- /src/_21_NesneVeSinifYapisi/_25_inheritance/Person.java: -------------------------------------------------------------------------------- 1 | package _21_NesneVeSinifYapisi._25_inheritance; 2 | 3 | public class Person { 4 | 5 | private int id; 6 | private String name; 7 | private String surname; 8 | 9 | public int getId() { 10 | return id; 11 | } 12 | 13 | public void setId(int id) { 14 | this.id = id; 15 | } 16 | 17 | public String getName() { 18 | return name; 19 | } 20 | 21 | public void setName(String name) { 22 | this.name = name; 23 | } 24 | 25 | public String getSurname() { 26 | return surname; 27 | } 28 | 29 | public void setSurname(String surname) { 30 | this.surname = surname; 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /src/_01_veriTipleriVeDegiskenler/Short.java: -------------------------------------------------------------------------------- 1 | package _01_veriTipleriVeDegiskenler; 2 | 3 | public class Short { 4 | public static void main(String[] args) { 5 | 6 | /* 7 | SHORT: Büyüklüğü 16 bit olan short veri tipi -32768 ile 8 | +32767 arasında bir değer alabilir. Kod geliştirirken 9 | short anahtar kelimesi ile tanımlama yapılır. 10 | */ 11 | short shortDeger =64; 12 | 13 | /* 14 | Yukarıda görmüş olduğunuz kod satırında short veri tipiyle değeri 15 | 64 olan “shortDeger” değişken adıyla bir tanımlama yapılmıştır. 16 | Eğer değer olarak -32769 veya 32678 verseydik geliştirme anında 17 | hata ile karşılaşacaktık. 18 | */ 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /src/_11_forDongusu/IcIceDonguler_For.java: -------------------------------------------------------------------------------- 1 | package _11_forDongusu; 2 | 3 | public class IcIceDonguler_For { 4 | public static void main(String[] args) { 5 | 6 | //nested loop 7 | for(int i = 0; i<10; i++) { 8 | System.out.println("i: " + i); 9 | for(int j=10; j>0; j--) { 10 | System.out.println("i: " + i + " j: " + j); 11 | } 12 | } 13 | 14 | //Sonsuz For Döngüsü 15 | 16 | /* 17 | For Döngüsü ile sonsuz döngü oluşturmak istenirse 18 | aşağıdaki gibi bir kod yazmak yeterli olacaktır; 19 | */ 20 | 21 | /* 22 | //sonsuz dongu 23 | for( ;1; ) { 24 | 25 | } 26 | */ 27 | 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /src/_09_whileDongusu/WhileDongusuOrnek_Toplama.java: -------------------------------------------------------------------------------- 1 | package _09_whileDongusu; 2 | 3 | public class WhileDongusuOrnek_Toplama { 4 | public static void main(String[] args) { 5 | 6 | //1’den 20’ye kadar olan tam sayıların toplamı: 7 | 8 | int toplam =0; 9 | int i =0; 10 | 11 | while (i<20){ 12 | toplam = toplam+i; 13 | i++; 14 | } 15 | System.out.println("Toplam : " + toplam); 16 | 17 | /* 18 | NOT: Yukarıdaki kodda eğer i ‘yi i++; şeklinde 1 arttırmazsak, 19 | i her zaman 0 olarak kalacak ve her zaman 20 den küçük kalacaktır. 20 | Dolayısıyla sonsuz döngü oluşacaktır. 21 | */ 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 30 | 31 | 32 | 33 | 34 | 35 | } 36 | } 37 | -------------------------------------------------------------------------------- /src/_01_veriTipleriVeDegiskenler/Boolean.java: -------------------------------------------------------------------------------- 1 | package _01_veriTipleriVeDegiskenler; 2 | 3 | public class Boolean { 4 | public static void main(String[] args) { 5 | 6 | 7 | /* 8 | BOOLEAN: Java mantıksal değerlerini saklamak için boolean 9 | veri tipi kullanılmaktadır. Boolean veri tipi true ve false 10 | olmak üzere iki farklı değer alabilmektedir. boolean veri tipi 11 | genellikle koşul belirtirken veya bir döngüde kullanılabilir. 12 | Kod geliştirirken boolean anahtar kelimesi ile tanımlama yapılır. 13 | */ 14 | 15 | boolean booleanDogru = true; 16 | System.out.println(booleanDogru); 17 | boolean booleanYanlis = false; 18 | System.out.println(booleanYanlis); 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /src/_19_arraysSinifi/_binarySearchMethodu.java: -------------------------------------------------------------------------------- 1 | package _19_arraysSinifi; 2 | 3 | import java.util.Arrays; 4 | 5 | public class _binarySearchMethodu { 6 | public static void main(String[] args) 7 | { 8 | int[] liste = {1, 4, 5, 11, 15,22, 33,66,67,68,75};//Dizi'mizi oluşturuyoruz 9 | 10 | //Dizide bir elemanın indeksini bulmak için Arrays.binarySearch() kullanırız 11 | //!!!!! Arrays.binarySearch() kullanabilmemiz için dizimiz SIRALI olmalıdır. !!!! 12 | //Eğer sıralı değilse Arrays.sort ile sıralayabilirsiniz 13 | 14 | int index = Arrays.binarySearch(liste,5); //bulunduğu indeksi döner,aradığımız sayı dizide mevcut değilse negatif bir sayı döner 15 | System.out.println("5'in indeksi :"+index); 16 | 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /src/_22_erisimBelirleyiciler/ErişimBelirleyiciler.txt: -------------------------------------------------------------------------------- 1 | Erişim Belirleyiciler 2 | Nesne Yönelimli Programlamada erişim belirleyiciler ufak bir yere sahip 3 | olsalarda, hatta bir çok derste bahsi geçmesede bence önemli konulardan 4 | bir tanesidir. Java’da proje oluştururken paket mantıksal yapıları sınıf 5 | bazında ayırmanın yanı sıra paket yapısıyla da ayırmamız mümkündür. 6 | Java ile proje geliştirirken paket yapısı olmazsa olmaz denilebilir. 7 | Paket yapısı projenin geliştirildiği web sitesi veya firmanın domain 8 | adını içerecek şekilde tersten oluşturulur. 9 | Ne demek istediğimi aşağıdaki örnekte daha iyi anlayacaksınız. 10 | 11 | Java’da erişim belirleyiciler 4 çeşittir; 12 | 13 | 1-public 14 | 2-protected 15 | 3-private 16 | 4-friendly(erişim belirleyici yok) 17 | 18 | -------------------------------------------------------------------------------- /src/_27_exceptionHandling/test.txt: -------------------------------------------------------------------------------- 1 | Sonuç 2 | Java Exception Handling kod geliştirme işlemlerinde büyük önem taşımaktadır. 3 | Hataları yakalamak veya hataları fırlatmak ile kod üzerinde kurulan kontrol 4 | mekanizmaları sonucunda, kullanıcının önüne onlarca belki de yüzlerce satır 5 | hata log u getirmek yerine bir tool box içerisinde işlemin başarısız olduğu 6 | belirtilebilir. Örneğin uygulamanın loglamasıyla ilgili bir hata oluştu, 7 | bu kullanıcıyı ilgilendiren bir durum değil, sistemin bu hata sebebiyle 8 | kullanıcı tarafına hata log u basması yerine bu hatayı bypass ederek sadece 9 | yazılımcının haberi olmasını sağlayarak çalışmasına devam edebilir. 10 | Bu gibi kritik durumların çözülmesi için geliştirdiğimiz kodlarda 11 | Java Exception Handling konusuna büyük önem verilmelidir. -------------------------------------------------------------------------------- /out/production/javaKonuTekrari/_22_erisimBelirleyiciler/ErişimBelirleyiciler.txt: -------------------------------------------------------------------------------- 1 | Erişim Belirleyiciler 2 | Nesne Yönelimli Programlamada erişim belirleyiciler ufak bir yere sahip 3 | olsalarda, hatta bir çok derste bahsi geçmesede bence önemli konulardan 4 | bir tanesidir. Java’da proje oluştururken paket mantıksal yapıları sınıf 5 | bazında ayırmanın yanı sıra paket yapısıyla da ayırmamız mümkündür. 6 | Java ile proje geliştirirken paket yapısı olmazsa olmaz denilebilir. 7 | Paket yapısı projenin geliştirildiği web sitesi veya firmanın domain 8 | adını içerecek şekilde tersten oluşturulur. 9 | Ne demek istediğimi aşağıdaki örnekte daha iyi anlayacaksınız. 10 | 11 | Java’da erişim belirleyiciler 4 çeşittir; 12 | 13 | 1-public 14 | 2-protected 15 | 3-private 16 | 4-friendly(erişim belirleyici yok) 17 | 18 | -------------------------------------------------------------------------------- /out/production/javaKonuTekrari/_27_exceptionHandling/test.txt: -------------------------------------------------------------------------------- 1 | Sonuç 2 | Java Exception Handling kod geliştirme işlemlerinde büyük önem taşımaktadır. 3 | Hataları yakalamak veya hataları fırlatmak ile kod üzerinde kurulan kontrol 4 | mekanizmaları sonucunda, kullanıcının önüne onlarca belki de yüzlerce satır 5 | hata log u getirmek yerine bir tool box içerisinde işlemin başarısız olduğu 6 | belirtilebilir. Örneğin uygulamanın loglamasıyla ilgili bir hata oluştu, 7 | bu kullanıcıyı ilgilendiren bir durum değil, sistemin bu hata sebebiyle 8 | kullanıcı tarafına hata log u basması yerine bu hatayı bypass ederek sadece 9 | yazılımcının haberi olmasını sağlayarak çalışmasına devam edebilir. 10 | Bu gibi kritik durumların çözülmesi için geliştirdiğimiz kodlarda 11 | Java Exception Handling konusuna büyük önem verilmelidir. -------------------------------------------------------------------------------- /src/_21_NesneVeSinifYapisi/_25_inheritance/Employee.java: -------------------------------------------------------------------------------- 1 | package _21_NesneVeSinifYapisi._25_inheritance; 2 | 3 | public class Employee extends Person{ 4 | 5 | private String jobtitle; 6 | 7 | public String getJobtitle() { 8 | return jobtitle; 9 | } 10 | 11 | public void setJobtitle(String jobtitle) { 12 | this.jobtitle = jobtitle; 13 | } 14 | 15 | /* 16 | Employee sınıfı ise işyerine ait iş ünvan bilgisini tutmaktadır. 17 | İş ünvanı ile birlikte ad ve soyad gibi kişi,sel bilgileri 18 | Person sınıfının yanında Employee sınıfı içersinde de tutmak 19 | yerine Person sınıfı superclass, Employee sınıfı ise Person 20 | sınıfını miras alarak subclass görevi görmektedir. 21 | */ 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 30 | 31 | 32 | 33 | 34 | } 35 | -------------------------------------------------------------------------------- /src/_25_abstraction/Person.java: -------------------------------------------------------------------------------- 1 | package _25_abstraction; 2 | 3 | public class Person { 4 | 5 | /* 6 | Person.java sınıfı içerisinde bir kişiye ait isim, soyisim ve 7 | id bilgileri tutulmaktadır. 8 | */ 9 | 10 | private int id; 11 | private String name; 12 | private String surname; 13 | 14 | public int getId() { 15 | return id; 16 | } 17 | 18 | public void setId(int id) { 19 | this.id = id; 20 | } 21 | 22 | public String getName() { 23 | return name; 24 | } 25 | 26 | public void setName(String name) { 27 | this.name = name; 28 | } 29 | 30 | public String getSurname() { 31 | return surname; 32 | } 33 | 34 | public void setSurname(String surname) { 35 | this.surname = surname; 36 | } 37 | } 38 | -------------------------------------------------------------------------------- /src/_24_encapsulation/Encapsulation.java: -------------------------------------------------------------------------------- 1 | package _24_encapsulation; 2 | 3 | public class Encapsulation { 4 | 5 | 6 | //Java Encapsulation 7 | 8 | /* 9 | Encapsulation kelimesinin Türkçe yazılım dilinde karşılığı, 10 | Kapsülleme veya Sarmalama olarak belirtilebilir. Java Encapsulation 11 | aslında java sınıfı içerisinde tanımladığımız değişkenlerimizi 12 | korumak veya saklamak anlamanına gelmektedir. Tanımladığımız bir 13 | sınıf içerisindeki değişkenin direk olarak değiştirilememesi, 14 | bunun yerine bizim izin verdiğimiz ölçüde, metotlar aracılığıyla 15 | değiştirilmesi gerekmektedir. Bir değişkene sadece okuma yetkisi 16 | verebilir, sadece yazma yetkisi verebilir veya hem okuma hem yazma 17 | yetkisi verebiliriz. 18 | 19 | Örneklerle devam edelim: 20 | */ 21 | 22 | } 23 | -------------------------------------------------------------------------------- /src/_26_polymorphism/ParametricTest.java: -------------------------------------------------------------------------------- 1 | package _26_polymorphism; 2 | 3 | public class ParametricTest { 4 | 5 | public static void main(String[] args) { 6 | 7 | ParametricDemo parametricDemo = new ParametricDemo(); 8 | parametricDemo.add("Robot Ron"); 9 | parametricDemo.add(1500); 10 | parametricDemo.add(100.011); 11 | parametricDemo.add(10.56f); 12 | 13 | System.out.println(parametricDemo.get(0)); 14 | System.out.println(parametricDemo.get(1)); 15 | System.out.println(parametricDemo.get(2)); 16 | System.out.println(parametricDemo.get(3)); 17 | 18 | /* 19 | * Output: 20 | * mobilhanem 21 | * 1500 22 | * 100.011 23 | * 10.56 24 | */ 25 | 26 | 27 | 28 | 29 | 30 | 31 | 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /src/_28_composition/Resolution.java: -------------------------------------------------------------------------------- 1 | package _28_composition; 2 | 3 | public class Resolution { 4 | 5 | private int en; 6 | private int boy; 7 | 8 | public Resolution(int en, int boy) { 9 | this.setEn(en); 10 | this.setBoy(boy); 11 | } 12 | 13 | public int getEn() { 14 | return en; 15 | } 16 | 17 | public void setEn(int en) { 18 | this.en = en; 19 | } 20 | 21 | public int getBoy() { 22 | return boy; 23 | } 24 | 25 | public void setBoy(int boy) { 26 | this.boy = boy; 27 | } 28 | 29 | /* 30 | Monitör Objesi içerisinde bir de Resolution objesini eklenmisti. 31 | Resolution sınıfında en ve boy tanımlaması yaptıktan sonra monitör 32 | sınıfında bu sınıfı çağırarak composition örneğini de tekrarlamış olacağız. 33 | */ 34 | 35 | 36 | } 37 | -------------------------------------------------------------------------------- /src/_19_arraysSinifi/_copyOf_copyOfRange.java: -------------------------------------------------------------------------------- 1 | package _19_arraysSinifi; 2 | 3 | import java.util.Arrays; 4 | 5 | public class _copyOf_copyOfRange { 6 | public static void main(String[] args) { 7 | 8 | int[] liste = {1, 4, 5, 11, 15,22, 33,66,67,68,75};//Dizi'mizi oluşturuyoruz 9 | 10 | //Mevcut diziden belli bir uzunlukta yeni bir dizi oluşturmak için 11 | // Arrays.copyOf metotu kullanılır 12 | 13 | int[] copyArray = Arrays.copyOf(liste,3); 14 | System.out.println(Arrays.toString(copyArray)); //[1, 4, 5] 15 | 16 | //Mevcut diziden belli bir aralıkta yeni bir dizi oluşturmak için 17 | 18 | int [] copyOfRangeArray = Arrays.copyOfRange(liste,3,9);//3-9 aralığı 19 | System.out.println(Arrays.toString(copyOfRangeArray));//[11, 15, 22, 33, 66, 67] 20 | 21 | 22 | 23 | 24 | 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /src/_29_arraysSinifi/Arrays_binarySearchMethodu.java: -------------------------------------------------------------------------------- 1 | package _29_arraysSinifi; 2 | 3 | import java.util.Arrays; 4 | 5 | public class Arrays_binarySearchMethodu { 6 | 7 | public static void main(String[] args) 8 | { 9 | int[] liste = {1, 4, 5, 11, 15,22, 33,66,67,68,75};//Dizi'mizi oluşturuyoruz 10 | 11 | //Dizide bir elemanın indeksini bulmak için Arrays.binarySearch() kullanırız 12 | //!!!!! Arrays.binarySearch() kullanabilmemiz için dizimiz SIRALI olmalıdır. !!!! 13 | //Eğer sıralı değilse Arrays.sort ile sıralayabilirsiniz 14 | 15 | int index = Arrays.binarySearch(liste,5); //bulunduğu indeksi döner,aradığımız sayı dizide mevcut değilse negatif bir sayı döner 16 | System.out.println("5'in indeksi :"+index); 17 | 18 | } 19 | 20 | /* 21 | OUTPUT: 22 | 5'in indeksi :2 23 | */ 24 | 25 | } 26 | -------------------------------------------------------------------------------- /src/_24_encapsulation/EncapsulationDemo1.java: -------------------------------------------------------------------------------- 1 | package _24_encapsulation; 2 | 3 | public class EncapsulationDemo1 { 4 | 5 | private Object ad; 6 | 7 | public static void main(String[] args) { 8 | 9 | EncapsulationDemo1 ed = new EncapsulationDemo1(); 10 | ed.ad = "All is well"; 11 | 12 | } 13 | } 14 | 15 | class EncapsulationDemo { 16 | public String ad; 17 | } 18 | 19 | /* 20 | Yukarıda ki örnekte görüleceği üzere encapsulation 21 | yapısından faydalanılmamış, bu sebeple EncapsulationDemo 22 | sınıfı içerisinde tanımlanan ad değişkeni kontrolden uzak kalmıştır. 23 | EncapsulationDemo sınıfından nesne üreten tüm kullanıcılar 24 | ad değişkenini istedikleri gibi kullanacaklar, ayrıca ad değişkenine 25 | değer verirken karışıklık yaşayacaklardır. Bu gibi durumların önüne 26 | geçilmesi için Java Encapsulation yapısından faydalanılmalıdır. 27 | */ 28 | -------------------------------------------------------------------------------- /src/_01_veriTipleriVeDegiskenler/Integer.java: -------------------------------------------------------------------------------- 1 | package _01_veriTipleriVeDegiskenler; 2 | 3 | public class Integer { 4 | public static void main(String[] args) { 5 | 6 | /* 7 | INTEGER: En çok kullanılan veri tipidir. 32 bitlik veri tipi, 8 | -2.147.483.648 ile 2.147.483.647 arasında bir değer alabilir. 9 | Kod geliştirirken int anahtar kelimesi ile tanımlama yapılır. 10 | */ 11 | 12 | int integerDeger = 75; 13 | System.out.println(integerDeger); 14 | 15 | /* 16 | Yukarıda görmüş olduğunuz kod satırında integer veri tipiyle değeri 17 | 75 olan, “integerDeger” değişken adıyla bir tanımlama yapılmıştır. 18 | Eğer yukarıda belirttiğimiz değer aralığından daha küçük veya daha 19 | büyük bir tanımlama yapılırsa geliştirme anında hata ile karşılaşılır. 20 | */ 21 | 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /src/_02_javaStringVeriTipi/JavaString.java: -------------------------------------------------------------------------------- 1 | package _02_javaStringVeriTipi; 2 | 3 | public class JavaString { 4 | public static void main(String[] args) { 5 | 6 | char[] chars = {'M','e','r','h','a','b','a'}; 7 | String stringDeger = new String(chars); 8 | System.out.println(stringDeger); //Konsol Çıktısı: Merhaba 9 | 10 | /* 11 | Yukarıda ki örnekten de görebileceğiniz gibi kodu koşturduğumuzda 12 | konsol ekranına “Merhaba” yazdığını göreceksiniz. Elbette kod yazarken 13 | Java String veri tipi bu şekilde karakterleri tek tek yazarak 14 | elde edilmiyor. Bunu yerine aşağıdaki şekilde bir Java String veri tipi 15 | tanımlaması yapabiliriz. 16 | */ 17 | 18 | String stringDeger2 ="Merhaba Java :)"; 19 | System.out.println(stringDeger2); //Merhaba Java :) 20 | 21 | 22 | 23 | 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /src/_20_MultidimensionalArrays_cokBoyutluDiziler/MultidimensionalArrayOrnek.java: -------------------------------------------------------------------------------- 1 | package _20_MultidimensionalArrays_cokBoyutluDiziler; 2 | 3 | public class MultidimensionalArrayOrnek { 4 | public static void main(String[] args) { 5 | 6 | for (int i = 0; i < getrobotRonGrubu().length; i++) { 7 | for (int j = 0; j = 0){ //method 0 dan küçük dönmüyorsa aradığımız sayıyı bulmuşuz demektir 21 | System.out.println("Aranan sayinin index'i :"+sayiIndex); 22 | 23 | }else{ //sayı 0 dan küçük döndüğünde aradığımız sayı dizi içinde değildir. 24 | System.out.println("Aranan sayi bulunamadi."); 25 | } 26 | 27 | 28 | 29 | 30 | 31 | 32 | 33 | 34 | } 35 | } 36 | -------------------------------------------------------------------------------- /src/_01_veriTipleriVeDegiskenler/VeriTipleri.java: -------------------------------------------------------------------------------- 1 | package _01_veriTipleriVeDegiskenler; 2 | 3 | public class VeriTipleri { 4 | public static void main(String[] args) { 5 | 6 | byte byteDeger = 4; 7 | short shortDeger = 7; 8 | int integerDeger = 234; 9 | long longDeger = 12332; 10 | 11 | float floatDeger = 34.5f; 12 | double doubleDeger = 345.2; 13 | 14 | char charDeger1 = 65; 15 | char charDeger2 = 'A'; 16 | 17 | boolean dogruDeger = true; 18 | boolean yanlisDeger = false; 19 | 20 | System.out.println("Byte Değer: " + byteDeger); 21 | System.out.println("Short Değer: " + shortDeger); 22 | System.out.println("Integer Değer: " + integerDeger); 23 | System.out.println("Long Değer: " + longDeger); 24 | 25 | System.out.println("Float Deger: " + floatDeger); 26 | System.out.println("Double Deger: " + doubleDeger); 27 | 28 | System.out.println("Char Deger 1: " + charDeger1); 29 | System.out.println("Char Deger 2: " + charDeger2); 30 | 31 | System.out.println("Boolean Dogru: " + dogruDeger); 32 | System.out.println("Boolean Yanlis: " + yanlisDeger); 33 | 34 | 35 | } 36 | } 37 | -------------------------------------------------------------------------------- /src/_21_NesneVeSinifYapisi/_25_inheritance/SuperClassVeSubClass.java: -------------------------------------------------------------------------------- 1 | package _21_NesneVeSinifYapisi._25_inheritance; 2 | 3 | public class SuperClassVeSubClass { 4 | 5 | 6 | 7 | 8 | //Superclass ve Subclass 9 | 10 | /* 11 | Sınıfların birbirlerinden türemeleri sonucunda superclass 12 | ve subclass kavramları ortaya çıkar. Bir sınıf başka bir 13 | sınıftan türüyorsa yani başka bir sınıfın değişkenlerini 14 | ve metotlarını miras alıyorsa subclass olarak adlandırılır. 15 | Eğer bir sınıftan başka bir sınıf miras alınıyor veya 16 | türetiliyorsa o sınıf superclass olarak adlandırılır. 17 | 18 | Kısacık bir örnekle superclass ve subclass ‘ın nasıl gözüktüğüne 19 | aşağıdaki kod parçasından gözatabiliriz. 20 | */ 21 | 22 | public int intValue; 23 | public void testMethod(){ 24 | } 25 | 26 | class SubClassTest extends SuperClassVeSubClass{ 27 | public void subMethods(){ 28 | super.testMethod(); 29 | int value = super.intValue; 30 | } 31 | } 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | } 58 | -------------------------------------------------------------------------------- /src/_01_veriTipleriVeDegiskenler/Long.java: -------------------------------------------------------------------------------- 1 | package _01_veriTipleriVeDegiskenler; 2 | 3 | public class Long { 4 | public static void main(String[] args) { 5 | /* 6 | LONG: En büyük tam sayı değeridir. 64 bitlik büyüklüğe sahiptir 7 | ve -9,223,372,036,854,775,808 ile 9,223,372,036,854,775,807 arasında 8 | bir değer alabilir. Kod geliştirirken long anahtar kelimesi ile 9 | tanımlama yapılır. Integer veri tipinin yetersiz olduğu durumlarda 10 | kullanılabilir. Bu duruma en güzel örnek ise bilimsel hesaplamalar 11 | veya Türkiye Cumhuriyeti Vatandaşlık Numarası tanımlamaları verilebilir. 12 | */ 13 | 14 | long longDeger =234; 15 | System.out.println(longDeger); 16 | 17 | /* 18 | Elbetteki bu tipleri sahip oldukları değer aralıklarına göre kullanmak 19 | çok mantıklı olmayacaktır. Bunun yerine tecrübe ettikçe hangi işlem 20 | için hangi veri tipi kullanılır rahatlıkla karar verebilirsiniz. 21 | Örneğin programda kullanıcının yaşıyla işlem yapacaksanız 22 | int veya bir dosyadaki verileri okuyacaksanız byte veri tipini 23 | kullanmanız en mantıklı yöntem olacaktır. 24 | */ 25 | 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /src/_23_nesneYönelimProgramlama/Polymorphism.java: -------------------------------------------------------------------------------- 1 | package _23_nesneYönelimProgramlama; 2 | 3 | public class Polymorphism { 4 | 5 | //Çok Biçimlilik (Polymorphism) 6 | 7 | /* 8 | Çok Biçimliliği, ana sınıf içerisinde tanımlanan bir metodun 9 | alt sınıflarda değiştirilerek kullanılması olarak tanımlayabiliriz. 10 | Kalıtım başlığında verdiğimiz örnekte, Araba sınıfı içerisinde 11 | benzinDepoBuyuklugu nü dönen bir metot olsun. Bu metot binek ve 12 | ticari araç için farklı değerler dönerek birden fazla nesne 13 | tarafından farklı değerler şeklinde kullanılabilir, 14 | bu şekilde çok biçimlilik sağlanmış olur. 15 | 16 | */ 17 | 18 | /* 19 | public class Araba { 20 | 21 | public double getBenzinDepoBuyuklugu() { 22 | return 50.0; 23 | } 24 | } 25 | */ 26 | 27 | /* 28 | public class BinekAraba extends Araba { 29 | 30 | @Override 31 | public double getBenzinDepoBuyuklugu() { 32 | return 60.0; 33 | } 34 | } 35 | */ 36 | 37 | /* 38 | public class TicariAraba extends Araba { 39 | 40 | @Override 41 | public double getBenzinDepoBuyuklugu() { 42 | return 100.0; 43 | } 44 | } 45 | */ 46 | 47 | 48 | } 49 | -------------------------------------------------------------------------------- /src/_28_composition/Bilgisayar.java: -------------------------------------------------------------------------------- 1 | package _28_composition; 2 | 3 | public class Bilgisayar { 4 | 5 | private Monitor monitor; 6 | private Kasa kasa; 7 | private Anakart anakart; 8 | 9 | public Bilgisayar(Monitor monitor, Kasa kasa, Anakart anakart) { 10 | this.setMonitor(monitor); 11 | this.setKasa(kasa); 12 | this.setAnakart(anakart); 13 | } 14 | 15 | 16 | public Monitor getMonitor() { 17 | return monitor; 18 | } 19 | 20 | public void setMonitor(Monitor monitor) { 21 | this.monitor = monitor; 22 | } 23 | 24 | public Kasa getKasa() { 25 | return kasa; 26 | } 27 | 28 | public void setKasa(Kasa kasa) { 29 | this.kasa = kasa; 30 | } 31 | 32 | public Anakart getAnakart() { 33 | return anakart; 34 | } 35 | 36 | public void setAnakart(Anakart anakart) { 37 | this.anakart = anakart; 38 | } 39 | 40 | /* 41 | Bilgisayar sınıfına baktığımızda anakart, kasa, monitör sınıflarını 42 | eklemiş olduğumuzu görüyoruz. Burada ki asıl amaç; Bir sınıfı 43 | oluşturduktan sonra başka bir sınıf içerisinde o sınıfı kullanmamızı 44 | sağlayan yapıya composition denildiğini görmektir. 45 | */ 46 | 47 | 48 | } 49 | -------------------------------------------------------------------------------- /src/_30_MultidimensionalArrays/CokBoyutluDiziler.java: -------------------------------------------------------------------------------- 1 | package _30_MultidimensionalArrays; 2 | 3 | public class CokBoyutluDiziler { 4 | 5 | /* 6 | Çok boyutlu diziler ise birden fazla sütunda verileri tutmaktadır. 7 | Bu şekilde tanımlanan array tiplerinde daha çok matriksler veya tablo 8 | yapıları tutulmaktadır. Genel olarak çok boyutlu diziler 9 | şu şekilde tanımlanmaktadır: 10 | 11 | DegiskenTipi[][] degiskenAdi; 12 | DegiskenTipi degiskenAdi[][]; //geçerli fakat tercih edilmeyen kullanım. 13 | 14 | Yukarıdaki koddan da göreceğiniz gibi iki şekildede tanılama yapmak mümkün, 15 | ikinci satırdaki tanımlama kodu okurken karmaşıklığa sebebiyet vermesinden 16 | dolayı kullanımı tavsiye edilmemektedir. Genel tanımlamalar yapının nasıl 17 | kurulacağıyla ilgili bilgi vermektedir. Şimdi ise aşağıda Java değişken 18 | tipleri ile nasıl çok boyutlu diziler tanımlanacağına bakalım; 19 | 20 | int[][] matriks; 21 | String[][] tablo; 22 | double[][] degerler; 23 | 24 | Yukarıdaki şekilde java değişlen tipinde çok boyutlu diziler 25 | tanımlanabilir. Tanımladığımız çok boyutlu diziler içersine farklı 26 | şekillerde değer atayabiliriz. Şöyle ki; (RobotRonGrubu class'ına bakınız.) 27 | 28 | 29 | */ 30 | 31 | 32 | 33 | 34 | } 35 | -------------------------------------------------------------------------------- /src/_26_polymorphism/Person.java: -------------------------------------------------------------------------------- 1 | package _26_polymorphism; 2 | 3 | public class Person { 4 | 5 | private String name; 6 | private String surname; 7 | private String identityNum;//kimlik numarasi 8 | private int birthYear;//doğum yılı 9 | 10 | public String getName() { 11 | return name; 12 | } 13 | 14 | public void setName(String name) { 15 | this.name = name; 16 | } 17 | 18 | public String getSurname() { 19 | return surname; 20 | } 21 | 22 | public void setSurname(String surname) { 23 | this.surname = surname; 24 | } 25 | 26 | public String getIdentityNum() { 27 | return identityNum; 28 | } 29 | 30 | public void setIdentityNum(String identityNum) { 31 | this.identityNum = identityNum; 32 | } 33 | 34 | public int getBirthYear() { 35 | return birthYear; 36 | } 37 | 38 | public void setBirthYear(int birthYear) { 39 | this.birthYear = birthYear; 40 | } 41 | 42 | 43 | public String toString() { 44 | return "Person{" + 45 | "name='" + name + '\'' + 46 | ", surname='" + surname + '\'' + 47 | ", identityNum='" + identityNum + '\'' + 48 | ", birthYear=" + birthYear + 49 | '}'; 50 | } 51 | 52 | 53 | 54 | } 55 | -------------------------------------------------------------------------------- /src/_23_nesneYönelimProgramlama/Abstraction.java: -------------------------------------------------------------------------------- 1 | package _23_nesneYönelimProgramlama; 2 | 3 | public class Abstraction { 4 | public static void main(String[] args) { 5 | 6 | //Soyutlama (Abstraction) 7 | 8 | /* 9 | Soyutlama konusunu en iyi örnek vererek anlatabilirim. Şöyle ki; 10 | 11 | Kullandığımız arabaların içerisindeki mekanik yapının nasıl 12 | çalıştığını bilmemize gerek yoktur, motor benzini nasıl alıyor 13 | nasıl yakıyor, oluşan enerjiyi tekerleri döndürmek için nasıl 14 | kullanıyor gibi konular arabayı kullanan kişiyi ilgilendirmez. 15 | Bu durum yazılım içinde geçerlidir. Kullandığımız bizim 16 | tarafımızdan yazılmamış tüm sınıfların içerisinde işlemlerin 17 | nasıl yapıldığını bilmemize gerek yoktur. Bir araba sınıfı 18 | olduğunu düşünelim, araba sınıfı marşa basıldığında arabayı 19 | çalıştıracak bir metoda ve bunun yanında anlık benzin veya 20 | motorin tüketimi hesaplayan bir metoda sahip. 21 | Biz Araba sınıfını kullanan bir kullanıcı olarak marşa basıldığında 22 | arabayı çalıştıran metodun ne yaptığıyla veya araba çalışırken 23 | benzin veya motorin tüketiminin nasıl hesaplandığıyla değil de 24 | sonuçlarıyla ilgileniyor olmalıyız. 25 | */ 26 | 27 | 28 | 29 | 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /src/_07_javaOperatorlari/BasitAtamaOperatorlari.java: -------------------------------------------------------------------------------- 1 | package _07_javaOperatorlari; 2 | 3 | public class BasitAtamaOperatorlari { 4 | public static void main(String[] args) { 5 | 6 | /* 7 | Java ile yazılım geliştirirken Java Operatörlerden oldukça 8 | çok faydalanırız. Java Operatörler bir çok farklı sitede bir çok 9 | farklı grup altında birleştirilmişse de Oracle sitesinde 10 | 7 ana başlığa ayrılmıştır; 11 | 12 | 1-Basit Atama Operatörü 13 | 2-Aritmetik Operatörler 14 | 3-Tekli Operatörler 15 | 4-Eşitlik ve İlişkisel Operatörler 16 | 5-Koşul Operatörleri 17 | 6-Karşılaştırma Operatörü 18 | 7-Bitwise Operatörler 19 | */ 20 | 21 | //Basit Atama Operatörü 22 | /* 23 | Basit atama operatörleri kod geliştirmeye ilk başladığımız andan 24 | itibaren kullandığımız ve (=) ile gösterilen operatördür. 25 | Bu operatöre yazdığımız kodlarda değişkenlere değer atarken 26 | kullandığımız operatörü örnek verebiliriz. 27 | 28 | */ 29 | 30 | int intDeger = 1453; 31 | System.out.println("intDeger = " + intDeger); 32 | 33 | String strDeger = "Java bugun cok eglenceli"; 34 | System.out.println("strDeger = " + strDeger); 35 | 36 | 37 | 38 | 39 | 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /src/_28_composition/Monitor.java: -------------------------------------------------------------------------------- 1 | package _28_composition; 2 | 3 | public class Monitor { 4 | 5 | private String model; 6 | private String uretici; 7 | private String boyut; 8 | private Resolution resolution; // composition 9 | 10 | public Monitor(String model, String uretici, String boyut, Resolution resolution) { 11 | this.setModel(model); 12 | this.setUretici(uretici); 13 | this.setBoyut(boyut); 14 | this.setResolution(resolution); 15 | } 16 | public void monitoruKapat(){ 17 | System.out.println("Monitor kapatiliyor..."); 18 | } 19 | 20 | public String getModel() { 21 | return model; 22 | } 23 | 24 | public void setModel(String model) { 25 | this.model = model; 26 | } 27 | 28 | public String getUretici() { 29 | return uretici; 30 | } 31 | 32 | public void setUretici(String uretici) { 33 | this.uretici = uretici; 34 | } 35 | 36 | public String getBoyut() { 37 | return boyut; 38 | } 39 | 40 | public void setBoyut(String boyut) { 41 | this.boyut = boyut; 42 | } 43 | 44 | public Resolution getResolution() { 45 | return resolution; 46 | } 47 | 48 | public void setResolution(Resolution resolution) { 49 | this.resolution = resolution; 50 | } 51 | 52 | 53 | 54 | 55 | 56 | 57 | } 58 | -------------------------------------------------------------------------------- /src/_26_polymorphism/_2_overloading.java: -------------------------------------------------------------------------------- 1 | package _26_polymorphism; 2 | 3 | public class _2_overloading { 4 | 5 | /* 6 | Java Polymorphism yapısında işimizi kolaylaştıran bir diğer 7 | yapıda Overloading’ dir. Java’da oluşturulan sınıf içerisinde 8 | aynı isme sahip birden fazla metodun olabilme özelliğidir. 9 | Burada dikkat edilmesi gereken özellik, aynı isme sahip 10 | metotların parametre sayıları veya parametre tiplerinde 11 | farklılıklar olmalıdır. 12 | Şöyle ki; 13 | */ 14 | 15 | public class OverloadingDemo{ 16 | public int method(int a){ 17 | return a; 18 | 19 | } 20 | 21 | public int method(String b){ 22 | return Integer.parseInt(b); 23 | } 24 | 25 | public int sum(int a, int b){ 26 | return a+b; 27 | 28 | } 29 | 30 | public int sum(double c, double d){ 31 | Double sum = c+d; 32 | return sum.intValue(); 33 | } 34 | 35 | } 36 | 37 | /* 38 | Bu şekilde overload özelliğinden faydalanarak bir çok metot yazılabilir 39 | ve istediğimiz metodu istediğimiz şekilde özelleştirebiliriz. Böylelikle 40 | yaptığımız aynı işlem için farklı isimde metodlar oluşturmak yerine aynı 41 | isimde farklı parametrelerle aynı işlemi yapan metotlar elde etmiş oluruz. 42 | */ 43 | 44 | 45 | 46 | 47 | 48 | 49 | } 50 | -------------------------------------------------------------------------------- /src/_07_javaOperatorlari/TekliOperatorler.java: -------------------------------------------------------------------------------- 1 | package _07_javaOperatorlari; 2 | 3 | public class TekliOperatorler { 4 | public static void main(String[] args) { 5 | 6 | //Tekli Operatörler 7 | 8 | /* 9 | Tekli operatörler bir değişkenin sağına veya soluna gelerek 10 | tek başına değişkenin değerini değiştirebilen operatörlerdir. 11 | +(artı), -(eksi), ++(1 değer arttırma), –(1 değer düşürme), 12 | !(boolean tipi tersine çevirme) operatörleri mevcuttur. 13 | Şimdi bu operatörleri aşağıdaki örnek ile pekiştirelim 14 | */ 15 | 16 | int deger = +1; 17 | System.out.println("deger = " + deger); 18 | 19 | deger = -deger; 20 | System.out.println("deger = " + deger); 21 | 22 | deger++; 23 | System.out.println("deger = " + deger); 24 | 25 | deger--; 26 | System.out.println("deger = " + deger); 27 | 28 | boolean durum = true; 29 | System.out.println("durum = " + durum); 30 | System.out.println("durum = " + !durum); // ! degildir demek 31 | 32 | /* 33 | OUTPUT: 34 | deger = 1 35 | deger = -1 36 | deger = 0 37 | deger = -1 38 | durum = true 39 | durum = false 40 | 41 | */ 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | } 58 | } 59 | -------------------------------------------------------------------------------- /src/_07_javaOperatorlari/AritmatikOperatorler.java: -------------------------------------------------------------------------------- 1 | package _07_javaOperatorlari; 2 | 3 | public class AritmatikOperatorler { 4 | public static void main(String[] args) { 5 | 6 | //Aritmetik Operatörler 7 | /* 8 | Aritmetik operatörler klasik matematiksel işlemleri yapılamasını 9 | sağlayan operatörlerdir. +(toplama), -(çıkarma), *(çarpma), /(bölme) 10 | ve %(mod alma) işlemlerinin yapılmasını sağlayan operatörlerdir. 11 | Örnek vermek gerekirse; 12 | */ 13 | 14 | int deger1 = 33; 15 | int deger2 = 12; 16 | 17 | int toplama = deger1+deger2; 18 | System.out.println("Toplama sonuc :" + toplama); 19 | int cikarma = deger1-deger2; 20 | System.out.println("Cikarma sonuc : " + cikarma); 21 | int capma = deger1*deger2; 22 | System.out.println("Capma sonuc : " + capma); 23 | int bolme = deger1/deger2; 24 | System.out.println("Bolme sonuc : " + bolme); 25 | int modulus = deger1%deger2; 26 | System.out.println("Modulus sonuc : " + modulus); 27 | 28 | /* 29 | Output: 30 | Toplama sonuc :45 31 | Cikarma sonuc : 21 32 | Capma sonuc : 396 33 | Bolme sonuc : 2 34 | Modulus sonuc : 9 35 | */ 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | 50 | } 51 | 52 | } 53 | -------------------------------------------------------------------------------- /src/_30_MultidimensionalArrays/MultidimensionalArray.java: -------------------------------------------------------------------------------- 1 | package _30_MultidimensionalArrays; 2 | 3 | public class MultidimensionalArray { 4 | 5 | public static void main(String[] args) { 6 | 7 | for(int row = 0; row < getBarcelonaFutbolTakimKadro().length; row++) { 8 | for(int column = 0; column strList = new ArrayList(); 10 | 11 | 12 | strList.add("Zeliha"); //0. value 13 | strList.add("Deniz"); //1. value 14 | strList.add("Lale"); //2. value 15 | strList.add("Sumeyye"); //3. value 16 | strList.add("Ismail"); //4. value 17 | 18 | String val = strList.get(5); 19 | System.out.println(val); 20 | 21 | } 22 | 23 | /* 24 | Kodda gelistirme asamasinda herhangi bir hata gözükmese bile çalıstirildigi zaman : 25 | 26 | Exception in thread "main" java.lang.IndexOutOfBoundsException: Index 5 out of bounds for length 5 27 | at java.base/jdk.internal.util.Preconditions.outOfBounds(Preconditions.java:100) 28 | at java.base/jdk.internal.util.Preconditions.outOfBoundsCheckIndex(Preconditions.java:106) 29 | at java.base/jdk.internal.util.Preconditions.checkIndex(Preconditions.java:302) 30 | at java.base/java.util.Objects.checkIndex(Objects.java:359) 31 | at java.base/java.util.ArrayList.get(ArrayList.java:427) 32 | at _27_exceptionHandling.UncheckedExceptionSample.main(UncheckedExceptionSample.java:18) 33 | 34 | Hatasi alinir. 35 | */ 36 | 37 | 38 | 39 | 40 | } 41 | -------------------------------------------------------------------------------- /src/_25_abstraction/Abstraction.java: -------------------------------------------------------------------------------- 1 | package _25_abstraction; 2 | 3 | public class Abstraction { 4 | 5 | //Java Abstraction 6 | 7 | /* 8 | Abstraction yapısı kurularak kullanıcıya yapılacak işlemin 9 | fonksiyonelliği sunulur. Bu şekilde kullanıcı kullandığı metodun 10 | ne yaptığıyla ilgilenirken, nasıl yaptığıyla ilgilenmez. 11 | Bu durumda fonksiyonellik ön plana çıkarken, işin nasıl yapıldığı 12 | gizlenir. Yani kullanıcı bir arabayı çalıştırır, o arabanın ilk 13 | tetiklemeden sonra hangi aşamalardan geçtiği, arka tarafta neler 14 | olduğu konularıyla ilgilenmez. 15 | 16 | Java’da Abstraction interface (arayüz) ve abstract class (soyut sınıf) 17 | yapıları ile sağlanır. Abstract sınıflarla yapılan tanımlamalara ve 18 | kullanım durumuna göre soyutlama oranı fark yaratırken, 19 | Interface ler kullanılarak %100 soyutlama sağlanır. 20 | 21 | Önemli: Interface ve Abstract Sınıflardan nesne üretilmez. 22 | */ 23 | 24 | /* 25 | Interface ler aşağıdaki şekilde tanımlanırlar. 26 | 27 | public interface IClass { 28 | } 29 | 30 | Java8 öncesinde Java’da interface ler içerisindeki metotların 31 | gövdeleri olmaz diyebiliriz. Java8 ile birlikte default metot 32 | ve static metot yapıları eklenmiş ve interface ler içerisinde 33 | bu yapılar sayesinde gövdeli metotlar yazılabilmeye başlanmıştır. 34 | 35 | */ 36 | 37 | 38 | 39 | 40 | } 41 | -------------------------------------------------------------------------------- /src/_11_forDongusu/ForDongusu.java: -------------------------------------------------------------------------------- 1 | package _11_forDongusu; 2 | 3 | public class ForDongusu { 4 | public static void main(String[] args) { 5 | 6 | int i = 0; 7 | 8 | //for dongusu kullanmadan 9 | System.out.println("Deger: " + i); 10 | System.out.println("Deger: " + (i+1)); 11 | System.out.println("Deger: " + (i+2)); 12 | System.out.println("Deger: " + (i+3)); 13 | System.out.println("Deger: " + (i+4)); 14 | System.out.println("Deger: " + (i+5)); 15 | System.out.println("Deger: " + (i+6)); 16 | System.out.println("Deger: " + (i+7)); 17 | System.out.println("Deger: " + (i+8)); 18 | System.out.println("Deger: " + (i+9)); 19 | 20 | 21 | System.out.println("*********************"); 22 | 23 | //for dongusu kullanarak 24 | for(i = 0; i < 10; i++) { 25 | System.out.println("Value: " + i); 26 | } 27 | 28 | 29 | /* 30 | görmüş olduğunuz gibi for döngüsü 31 | ile çok daha kolay bir şekilde yazdırabildik. 32 | */ 33 | 34 | /* 35 | Önemli Not: “System.out.println(“Deger: ” + (i+2));” 36 | satırında değişkeni (i+2) şeklinde yazmamızın sebebi, 37 | “Deger: ” + dan sonrasını String tipinde göreceği için 38 | eğer matematiksel işlemi parantez içerisinde yapmazsak 39 | ekrana verileri 0, 01, 02, 03 … şeklinde yazdırdığını görürüz. 40 | */ 41 | 42 | } 43 | } 44 | -------------------------------------------------------------------------------- /src/_25_abstraction/SecondFirmEmployee.java: -------------------------------------------------------------------------------- 1 | package _25_abstraction; 2 | 3 | public class SecondFirmEmployee extends Employee{ 4 | 5 | private static final int CONST_ALES = 2; 6 | private static final int CONST = 10000; 7 | 8 | public static void main(String[] args) { 9 | 10 | SecondFirmEmployee firstFirmEmployee = new SecondFirmEmployee(); 11 | firstFirmEmployee.setId(1); 12 | firstFirmEmployee.setName("Zeliha"); 13 | firstFirmEmployee.setSurname("Oznuk"); 14 | firstFirmEmployee.setJobtitle("QA"); 15 | 16 | System.out.println(firstFirmEmployee.getName()+ " " + firstFirmEmployee.getSurname()); 17 | System.out.println(firstFirmEmployee.getJobtitle()); 18 | System.out.println(firstFirmEmployee.calculateSalary() + "₺"); 19 | } 20 | 21 | @Override 22 | public float calculateSalary() { 23 | return CONST * (CONST_ALES * 0.75f); 24 | } 25 | } 26 | 27 | 28 | /* 29 | SecondFirmEmployee ile FirstFirmEmployee sınıflarında maaş bilgileri farklı 30 | hesaplanmasına rağmen diğer bilgiler aynı tutulduğu için kodun birden çok 31 | kere yazılmasına gerek kalmadan abstraction yapısından faydalanılarak bir 32 | çözüm bulunmuştur. Abstract bir metot oluşturularak her sınıf içerisinde 33 | bu metot farklı işlemleri yapacak şekilde tasarlanmıştır. 34 | Aslında biz abstraction class tanımlayarak bu sınıfı extends eden 35 | sınıfların neleri @override etmesi gerektiği bilgisini vermiş olduk. 36 | */ 37 | -------------------------------------------------------------------------------- /src/_01_veriTipleriVeDegiskenler/Byte.java: -------------------------------------------------------------------------------- 1 | package _01_veriTipleriVeDegiskenler; 2 | 3 | public class Byte { 4 | 5 | public static void main(String[] args) { 6 | /* 7 | Tam Sayılar Reel Sayılar Karakterler Mantıksal Değerler 8 | byte float char boolean 9 | short double 10 | integer 11 | long 12 | Java Veri Tipleri ve Değişkenler ‘in detaylı anlatımlarına geçmeden 13 | önce genel olarak bir değişkenin nasıl tanımlandığını göstermeye çalışalım. 14 | 15 | MainClass.javaJava 16 | veriTipi değişkenAdi = değişkenDeğeri; 17 | 1 18 | veriTipi değişkenAdi = değişkenDeğeri; 19 | Veri tipleri yukarıdaki tabloda gördüğünüz 20 | byte, short, int, long, float, double, char veya boolean olabilir. 21 | Değişken adı tamamen geliştiriciye kalmış değişkene verilen isimdir. 22 | */ 23 | 24 | /* 25 | BYTE: byte en küçük tam sayı tipidir. Büyüklüğü 8 bit tir ve 26 | -128 ile +127 arası değer alır. Kod geliştirirken byte 27 | anahtar kelimesi ile tanımlama yapılır. 28 | */ 29 | 30 | byte byteDeger =45; 31 | System.out.println(byteDeger); 32 | 33 | /* 34 | Yukarıda görmüş olduğunuz kod satırında byte veri tipiyle değeri 35 | 45 olan “byteDeger” değişken adıyla bir tanımlama yapılmıştır. 36 | Yukarıda tanımlanan byteDeger değişkenine -128’den küçük veya 37 | +127’den büyük bir değer tanımlandığı takdirde geliştirme anında 38 | hata ile karşılaşılacaktır. 39 | */ 40 | 41 | } 42 | } 43 | -------------------------------------------------------------------------------- /src/_13_methodYapisi/Overloading.java: -------------------------------------------------------------------------------- 1 | package _13_methodYapisi; 2 | 3 | public class Overloading { 4 | //Overloading (Aşırı yükleme) 5 | 6 | /* 7 | Java’nın güzel özelliklerinden bir tanesi de metotları 8 | aşırı yükleme özelliğidir. Aşırı yükleme bir metodun 9 | aynı isimle fakat parametrik olarak farklı veri tipleriyle 10 | çağrılması durumuna denilir. Yukarıda vermiş olduğumuz 11 | örnekler üzerinden gidersek, muhasebe programımızda toplama 12 | işlemleri tam sayılar üzerinden yani int veri tipleriyle 13 | gerçekleştirilmektedir. Fakat bu bazı sıkıntılara yol açabilir 14 | ve bu işlemlerin küsuratlı ve daha büyük sayıları yani double 15 | veri tiplerini desteklemesi gerekebilir. Bu gibi durumlarda 16 | metot aşırı yüklenir ve verilen iki tipi de kabul edecek 17 | şekle getirilir. 18 | Aşağıda bunun bir örneğini görebilirsiniz; 19 | */ 20 | 21 | 22 | public static int toplama(int sayi1, int sayi2) { 23 | int sonuc = sayi1 + sayi2; 24 | return sonuc; 25 | } 26 | 27 | public static double toplama(double sayi1, double sayi2) { 28 | double sonuc = sayi1 + sayi2; 29 | return sonuc; 30 | } 31 | 32 | public static void main(String[] args) { 33 | int tamSayi = toplama(5, 6); 34 | System.out.println("5 + 6 = " + tamSayi); 35 | 36 | double kusurluSayi = toplama(5.5, 6.5); 37 | System.out.println("5.5 + 6.5 = " + kusurluSayi); 38 | } 39 | 40 | 41 | 42 | 43 | 44 | 45 | } 46 | -------------------------------------------------------------------------------- /src/_28_composition/Anakart.java: -------------------------------------------------------------------------------- 1 | package _28_composition; 2 | 3 | public class Anakart { 4 | 5 | 6 | private String model; 7 | private String uretici; 8 | private int yuva_sayisi; 9 | private String isletim_sistemi; 10 | 11 | public Anakart(String model, String uretici, int yuva_sayisi, String isletim_sistemi) { 12 | this.setModel(model); 13 | this.setUretici(uretici); 14 | this.setYuva_sayisi(yuva_sayisi); 15 | this.setIsletim_sistemi(isletim_sistemi); 16 | } 17 | 18 | public void isletimSistemi_yukle(String isletim_sistemi) { 19 | this.isletim_sistemi = isletim_sistemi; 20 | System.out.println("Isletim Sisteminiz :" + isletim_sistemi); 21 | } 22 | 23 | public String getModel() { 24 | return model; 25 | } 26 | 27 | public void setModel(String model) { 28 | this.model = model; 29 | } 30 | 31 | public String getUretici() { 32 | return uretici; 33 | } 34 | 35 | public void setUretici(String uretici) { 36 | this.uretici = uretici; 37 | } 38 | 39 | public int getYuva_sayisi() { 40 | return yuva_sayisi; 41 | } 42 | 43 | public void setYuva_sayisi(int yuva_sayisi) { 44 | this.yuva_sayisi = yuva_sayisi; 45 | } 46 | 47 | public String getIsletim_sistemi() { 48 | return isletim_sistemi; 49 | } 50 | 51 | public void setIsletim_sistemi(String isletim_sistemi) { 52 | this.isletim_sistemi = isletim_sistemi; 53 | } 54 | 55 | 56 | 57 | 58 | } 59 | -------------------------------------------------------------------------------- /src/_21_NesneVeSinifYapisi/ArabaTest.java: -------------------------------------------------------------------------------- 1 | package _21_NesneVeSinifYapisi; 2 | 3 | public class ArabaTest { 4 | public static void main(String[] args) { 5 | 6 | Araba arabaNesnesi = new Araba(); 7 | arabaNesnesi.calistir(); 8 | 9 | Araba baskaArabaNesnesi = new Araba(2998); 10 | baskaArabaNesnesi.calistir(); 11 | } 12 | 13 | /** 14 | OUTPUT: 15 | Araba nesnesi olusturuldu, yeni varsayilan motor hacmi degeri : 1399.0 16 | Araba calismaya basladi! 17 | Araba nesnesi olusturuldu, yeni varsayilan motor hacmi degeri :2998.0 18 | Araba calismaya basladi! 19 | */ 20 | 21 | /* 22 | Araba arabaNesnesi = new Araba(); şeklinde oluşturduğumuz nesnemizde 23 | sizlerin de dikkatinden kaçmayacağı gibi parametre almayan constructor 24 | kullanılarak bir nesne oluşturuldu. Sınıftan yeni bir 25 | nesne oluşturulurken constructor devreye girdi ve görevini yerine 26 | getirdi. 27 | Aynı şekilde Araba baskaArabaNesnesi = new Araba(2998); 28 | şeklinde oluşturulan nesnede ikinci constructor yani içerisine 29 | double yeniMotorHacmi değerini alan constructor devreye girdi ve 30 | görevini tamamladı. Araba sınıfından nesne oluşturduktan sonra 31 | calistir() methodunu yine bizim tetiklememiz gerekti, 32 | işte metotlarla constructor farkı burada ortaya çıkıyor. 33 | Kısaca toparlamak gerekirse; constructor lar sınıflardan 34 | nesne oluşturuluğu esnada tetiklenmekte, metotlar ise nesne 35 | oluşturulup çağırıldıktan sonra tetiklenmektedir. 36 | */ 37 | } 38 | -------------------------------------------------------------------------------- /src/_23_nesneYönelimProgramlama/Inheritance.java: -------------------------------------------------------------------------------- 1 | package _23_nesneYönelimProgramlama; 2 | 3 | public class Inheritance { 4 | public static void main(String[] args) { 5 | 6 | //Kalıtım (Inheritance) 7 | 8 | /* 9 | Aslında yazılım veya teknolojik olarak düşünmeden sadece 10 | günlük hayatta duyduğumuz kalıtım sözcüğünün tam karşılığı 11 | yazılımda nesne yönelimli programlamada da mevcut. 12 | Gerçek hayatta nasıl canlı -> hayvan -> kuş -> güvercin gibi 13 | genelden özele inebiliyorsak, aynı şekilde yazılımda da 14 | bu bahsettiğim kavramları birer nesne gibi düşünerek oluşturabiliriz. 15 | Şimdi iki örnek oluşturalım; 16 | 17 | Araba -> Volkswagen -> Binek -> Jetta 18 | Araba -> Ford -> Ticari -> Ranger 19 | 20 | Şimdi bu örneği kalıtım olarak cümlede oturtalım, aslında Jetta, 21 | volkswagen marka binek bir arabadır. Aynı şekilde Ranger, 22 | Ford marka ticari bir arabadır. Jetta’nın ve Ranger’ın 23 | ortak özellikleri olduğu gibi birbirlerinden farklı özellikleri de 24 | mevcuttur. Yine aynı şekilde binek ve ticari araçların 25 | aynı özellikleri olduğu gibi farklı özellikleri de mevcuttur. 26 | 27 | Java dilinde Kalıtım sağlanırken “extends” anahtar kelimesi kullanılmaktadır. 28 | 29 | public class BinekAraba extends Araba { 30 | 31 | } 32 | 33 | Bu örnekte BinekAraba sınıfından oluşturulacak nesne 34 | Araba sınıfı içindeki tüm özelliklere ulaşma hakkına sahiptir. 35 | */ 36 | 37 | 38 | 39 | 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /src/_21_NesneVeSinifYapisi/_25_inheritance/ObjectSinifi.java: -------------------------------------------------------------------------------- 1 | package _21_NesneVeSinifYapisi._25_inheritance; 2 | 3 | public class ObjectSinifi { 4 | 5 | //Object Sınıfı 6 | 7 | /* 8 | Java Inheritance aslında temelde var olan hatta yazılımcıların 9 | farkında olmadan kullandıkları bir yapıdır. Java’da kullanılan 10 | tüm sınıflar Object sınıfından türetilmiştir. Bir sınıfın tipi 11 | bilinmiyorsa bu sınıf new operatörüyle Object sınıfına eşitlenebilir. 12 | Bu bir problem yaratmayacaktır, çünkü temelde 13 | Object sınıfından türemektedir. Tüm sınıflar Object sınıfından 14 | türedikleri için de Object sınıfı içindeki değişken ve metotları 15 | miras alırlar. 16 | */ 17 | 18 | public ObjectSinifi(){ 19 | super(); 20 | } 21 | 22 | public int hashCode(){ 23 | return super.hashCode(); 24 | } 25 | 26 | public boolean equals(Object obj){ 27 | return super.equals(obj); 28 | } 29 | 30 | protected Object clone() throws CloneNotSupportedException{ 31 | return super.clone(); 32 | } 33 | 34 | public String toString(){ 35 | return super.toString(); 36 | } 37 | 38 | /* protected void finalize() throws Throwable { 39 | super.finalize(); 40 | } 41 | */ 42 | 43 | /* 44 | Yukarıdaki örnekte görüldüğü gibi oluşturulan sınıf Object 45 | sınıfındaki tüm metotları miras almıştır. Object sınıfı 46 | tüm sınıfların superclass ‘ı diyebiliriz. 47 | */ 48 | 49 | 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | } 64 | -------------------------------------------------------------------------------- /src/_05_switchCase/SwitchCaseOrnek.java: -------------------------------------------------------------------------------- 1 | package _05_switchCase; 2 | 3 | public class SwitchCaseOrnek { 4 | public static void main(String[] args) { 5 | 6 | String ayDegeriStr = "Temmuz"; 7 | int ayDeger = -1; 8 | 9 | switch(ayDegeriStr.toLowerCase()) { 10 | case "ocak": 11 | ayDeger = 1; 12 | break; 13 | case "subat": 14 | ayDeger = 2; 15 | break; 16 | case "mart": 17 | ayDeger = 3; 18 | break; 19 | case "nisan": 20 | ayDeger = 4; 21 | case "mayis": 22 | ayDeger = 5; 23 | break; 24 | case "haziran": 25 | ayDeger = 6; 26 | break; 27 | case "temmuz": 28 | ayDeger = 7; 29 | break; 30 | case "agustos": 31 | ayDeger = 8; 32 | break; 33 | case "eylul": 34 | ayDeger = 9; 35 | break; 36 | case "ekim": 37 | ayDeger = 10; 38 | break; 39 | case "kasim": 40 | ayDeger = 11; 41 | break; 42 | case "aralik": 43 | ayDeger = 12; 44 | break; 45 | default: 46 | break; 47 | } 48 | System.out.println(ayDegeriStr + " ayi yilin " + ayDeger + ". ayidir."); 49 | 50 | //OUTPUT : Temmuz ayi yilin 7. ayidir. 51 | 52 | 53 | 54 | } 55 | } 56 | -------------------------------------------------------------------------------- /src/_01_veriTipleriVeDegiskenler/Float.java: -------------------------------------------------------------------------------- 1 | package _01_veriTipleriVeDegiskenler; 2 | 3 | public class Float { 4 | public static void main(String[] args) { 5 | 6 | /* 7 | FLOAT: float veri tipi 32 bitlik büyüklüğe sahiptir ve 8 | 1.4×10^-45 ile 3.4×10^38 aralığında bir değer tanımlanabilir. 9 | float olarak belirlenmiş olan veri tipine integer bir değer 10 | atandığı takdirde java tarafından direk olarak 1.0 şeklinde algılanır. 11 | Geliştirme aşamasında hata oluşmaz. Fakat float veri tanımlarken 12 | (.) noktadan sonra değişken değerinin sonuna “f” veya “F” koyulmadığı 13 | takdirde geliştirme esnasında hata alınacaktır. Sebebi ise javanın 14 | bu değişkeni double olarak algılayacak olmasıdır. 15 | Aşağıdaki örneklerle konuya biraz daha açıklık getirmeye çalışalım. 16 | */ 17 | 18 | float floatDeger1 = 35.4f; //dogru tanim 19 | System.out.println(floatDeger1); 20 | float floatDeger2 = 4.5F; //dogru tanim 21 | System.out.println(floatDeger2); 22 | float floatDeger3 = 67; //dogru tanim 23 | System.out.println(floatDeger3); 24 | //float floatDeger4 = 45.0; //hatali tanim 25 | //float floatDeger5 = 34.65; //hatali tanim 26 | 27 | /* 28 | float veri tipinin sonuna “f” veya “F” koyulmadığında Java bu 29 | tanımlamadaki veri tipini double olarak algılayacağı için geliştirme 30 | anında hata verecektir. Kod geliştirirken float anahtar kelimesi ile 31 | tanımlama yapılır. 32 | */ 33 | 34 | } 35 | } 36 | -------------------------------------------------------------------------------- /src/_28_composition/CompositionOrnegi.java: -------------------------------------------------------------------------------- 1 | package _28_composition; 2 | 3 | public class CompositionOrnegi { 4 | 5 | 6 | public class Motor { 7 | private static int motor_gucu = 3600; 8 | 9 | public void calis() { 10 | System.out.println("Motor Calisiyor") ; 11 | } 12 | 13 | public void dur() { 14 | System.out.println("Motor Durdu") ; 15 | } 16 | } 17 | 18 | 19 | //Şimdi bu Motor sınıfını, arabamızın içerisine yerleştirelim; 20 | 21 | public class AileArabasi { 22 | private Motor m = new Motor(); 23 | public void hareketEt() { 24 | m.calis(); 25 | System.out.println("Aile Arabasi Calisti"); 26 | } 27 | public void dur() { 28 | m.dur(); 29 | System.out.println("Aile Arabasi Durdu"); 30 | } 31 | public void main(String args[]) { 32 | AileArabasi aa = new AileArabasi() ; 33 | aa.hareketEt(); 34 | aa.dur(); 35 | } 36 | } 37 | 38 | /* 39 | AileArabası sınıfının içerisine, Motor tipinde global bir alan 40 | yerleştirilerek, bu iki sınıf birbirine bağlanmış oldu. 41 | AileArabası sınıfının hereketEt() ve dur() metotlarında, önce 42 | Motor sınıfına ait yordamlar (methods) direkt olarak çağrıldı. 43 | 44 | Motor sınıfının private erişim belirleyicisine sahip olan motor_gucu 45 | alanına, AileArabasi sınıfının içerisinde ulaşamayız. 46 | AileArabasi sınıfı Motor sınıfının sadece iki adet public 47 | yordamına (method) erişebilir: calis() ve dur(). 48 | */ 49 | 50 | } 51 | -------------------------------------------------------------------------------- /src/_31_collections/text.text: -------------------------------------------------------------------------------- 1 | 2 | Oluşturacağım lisans anahtarı örneğini yaparken uyguladığım aşamalar şu şekildedir: 3 | 4 | #1 Öncelikle örneği oluştururken Collection başlığı altında, List kısmında 5 | bulunan ArrayList kavramını kullanmaya karar verdim. Bu işlem esnasında 6 | Non-Generic bir tanımlama gerçekleştirme kararı aldım 7 | (Generic kavramını anlatacağımız konumuzda değineceğiz bu kelimeye). 8 | 9 | #2 İşlemi nasıl gerçekleştireceğime karar verdikten sonra CreateCode isminde 10 | bir sınıf tanımlaması gerçekleştirerek içerisine Random sınıfını ve ArrayList 11 | kavramını kullanmak için gerekli yapıları import ederek tanımlama işlemini 12 | gerçekleştirdim. 13 | 14 | #3 Tanımlamaları gerçekleştirdikten sonra geriye String veri tipinde bir değer 15 | döndüren newCode isminde bir metot tanımlamasını yaptım. 16 | 17 | #4 Metot içerisinde Random sınıfını kullanarak elde ettiğim değerleri Ascii 18 | tablosuna göre karakterlere dönüştürerek oluşturduğum ArrayList üzerine 19 | atamasını gerçekleştirecek if-else kontrol yapısı inşa ettim. 20 | 21 | #5 İnşa ettiğim bu if-else kontrol yapısı içerisinde lisans anahtarının 22 | kaçıncı indisi olduğunu, dizi içerisinde bulunup bulunmadığını kontrol 23 | ettirerek eğer belirlediğim koşullar çerçevesine uyuyorsa diziye eklenmesini, 24 | uymuyorsa yeni bir değer üretildikten sonra eklenmesini isteyen bir sistem 25 | oluşturdum. 26 | 27 | #6 Atama işlemlerim bittikten sonra basit bir foreach tanımlaması yaparak 28 | oluşturduğum lisenceCode ismindeki değişkenime dizi elemanlarımı ve belirli 29 | aralıklarda “–” atamasını yapmak için döngü içerisinde if-else kontrol yapısı 30 | yazdım. 31 | -------------------------------------------------------------------------------- /src/_07_javaOperatorlari/EsitlikVeIliskiselOperatorler.java: -------------------------------------------------------------------------------- 1 | package _07_javaOperatorlari; 2 | 3 | public class EsitlikVeIliskiselOperatorler { 4 | public static void main(String[] args) { 5 | 6 | //Eşitlik ve İlişkisel Operatörler 7 | 8 | /* 9 | Eşitlik ve İlişkisel Operatörler iki farklı değişkenin eşitliğini 10 | veya arasındaki ilişkiye yönelik farklılıkları ortaya çıkarmaya yarayan 11 | operatörlerdir. 12 | ==(eşittir), !=(eşit değildir), > (büyüktür), <(küçüktür), 13 | >=(büyük eşittir), <= (küçük eşittir) operatörlerinden oluşur. 14 | Operatörleri aşağıdaki örnekle daha iyi anlayabilirsiniz: 15 | */ 16 | 17 | int deger1 = 32; 18 | int deger2 = 32; 19 | 20 | if (deger1 == deger2){ 21 | System.out.println(deger1 + " esittir " + deger2); 22 | } 23 | 24 | int deger3 = 32; 25 | int deger4 = 33; 26 | 27 | if (deger3 != deger4){ 28 | System.out.println(deger3 + " esit degildir " + deger4); 29 | } 30 | 31 | int deger5 = 32; 32 | int deger6 = 12; 33 | 34 | if (deger5>deger6){ 35 | System.out.println(deger5 +" buyuktur " +deger6); 36 | } 37 | 38 | int deger7 = 13; 39 | int deger8 = 13; 40 | 41 | if(deger7 >= deger8) { 42 | System.out.println(deger7 + " buyuk veya esittir " + deger8); 43 | } 44 | 45 | /* 46 | OUTPUT: 47 | 32 esittir 32 48 | 32 esit degildir 33 49 | 32 buyuktur 12 50 | 13 buyuk veya esittir 13 51 | */ 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | } 64 | } 65 | -------------------------------------------------------------------------------- /src/_06_scanner/Import.java: -------------------------------------------------------------------------------- 1 | package _06_scanner; 2 | 3 | public class Import { 4 | public static void main(String[] args) { 5 | /* 6 | Öncelikle dersime geçmeden önce Java’da import kullanımından bahsedelim. 7 | import Java’da dahil etmek anlamında kullanılmaktadır. 8 | Bizde import anahtar kelimesini kullanarak programımıza farklı 9 | kütüphaneler ve classlar dahil edebiliriz. 10 | */ 11 | 12 | // import paketadi; 13 | 14 | /* 15 | İki çeşit kullanımı vardır. Birinci kullanımı direk kullanacağımız 16 | Class’ı dahil etmek. Mesala java.util paketi altında onlarca 17 | Class bulunmaktadır.(List,ArrayList,Scanner,Random,Date ..). 18 | Bunları tek tek uygulamamıza aşağıdaki gibi dahil edebiliriz. 19 | */ 20 | 21 | /* 22 | import java.util.List; 23 | import java.util.ArrayList; 24 | import java.util.Scanner; 25 | import java.util.Date; 26 | */ 27 | 28 | /* 29 | İkinci kullanımı ise direk paketi dahil edebiliriz. 30 | Böylelikle o paket altındaki tüm class’ları kullanabiliriz. 31 | Bunuda aşağıdaki şekilde yapabiliriz. 32 | 33 | import java.util.*; 34 | */ 35 | 36 | /* 37 | NOT: Java’da paket yapısı ve import kullanımını daha detaylı olarak 38 | ilerleyen derslerimizde anlatacağız. 39 | 40 | Biz bu dersimizde sadece Scanner sınıfını kullanacağımız için 41 | aşağıdaki şekilde ekleyebiliriz. 42 | 43 | import java.util.Scanner; 44 | */ 45 | 46 | 47 | 48 | 49 | 50 | 51 | 52 | 53 | 54 | 55 | } 56 | } 57 | -------------------------------------------------------------------------------- /src/_06_scanner/ScannerSinifi.java: -------------------------------------------------------------------------------- 1 | package _06_scanner; 2 | 3 | import java.util.Scanner; 4 | public class ScannerSinifi { 5 | public static void main(String[] args) { 6 | 7 | Scanner scan = new Scanner(System.in);//Kullanıcıdan string değer alabilmek için Scanner sınıfını kullandık 8 | System.out.println("Lutfen mesajinizi giriniz :"); 9 | String mesaj = scan.nextLine(); //String değeri burda alıyoruz 10 | System.out.println("Mesajiniz : " + mesaj); 11 | 12 | /* 13 | Girmiş olduğunuz mesajı konsola bastıracaktır. 14 | Şimdi kullanıcıdan dört sayı isteyelim ve bu sayıların toplamını 15 | konsola bastıralım. 16 | */ 17 | 18 | Scanner input = new Scanner(System.in); 19 | System.out.println("Lutfen 1. sayiyi giriniz"); 20 | int sayi1 = input.nextInt(); 21 | System.out.println("Lutfen 2. sayiyi giriniz"); 22 | int sayi2 = input.nextInt(); 23 | System.out.println("Lutfen 3. sayiyi giriniz"); 24 | int sayi3 = input.nextInt(); 25 | System.out.println("Lutfen 4. sayiyi giriniz"); 26 | int sayi4 = input.nextInt(); 27 | System.out.println("Toplam :" +(sayi1+sayi2+sayi3+sayi4)); 28 | 29 | /* 30 | Yukarıdaki iki örnekten gördüğümüz gibi nextLine() ile string değerini nextInt() ile int değerini aldık. Diğer tiplerde değerler alabilmek için aşağıdaki şekillerde kullanabiliriz. 31 | nextLine() -> String 32 | nextInt() -> Integer 33 | nextByte() -> Byte 34 | nextFloat -> Float 35 | nextDouble -> Double 36 | */ 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | } 46 | 47 | } 48 | -------------------------------------------------------------------------------- /src/_04_ifElseKosulYapisi_AndOr/and_or_ornek.java: -------------------------------------------------------------------------------- 1 | package _04_ifElseKosulYapisi_AndOr; 2 | 3 | public class and_or_ornek { 4 | public static void main(String[] args) { 5 | 6 | int x = 55; 7 | 8 | if (x>5 && x<10){ 9 | System.out.println("5'den buyuk 10'dan kucuk"); 10 | }else { 11 | System.out.println("5'den buyuk 10'dan kucuk degil"); 12 | } 13 | //Output : 5'den buyuk 10'dan kucuk degil 14 | 15 | /* 16 | Yukarıda AND kullanımına basit bir örnek verdik. 17 | x değerimiz 8 olduğunu varsayarsak x 5 ten büyük olduğu için 18 | x>5 koşulu true dönecektir aynı şekilde x<10 true dönecektir. 19 | AND kullanımında tüm değerler true ise if bloğuna girecektir. 20 | x değerimizin 13 olduğunu varsayalım. x>5 koşulu true ancak 21 | x<10 değeri false dönecektir. Dolayısıyla koşulumuz false dönecek 22 | else bloğu çalışacaktır. 23 | */ 24 | 25 | int y =8; 26 | 27 | if (y>5 || y<10){ 28 | System.out.println("5'den buyuk 10'dan kucuk"); 29 | }else { 30 | System.out.println("5'den buyuk 10'dan kucuk degil"); 31 | } 32 | //Output : 5'den buyuk 10'dan kucuk 33 | 34 | /* 35 | Yukarıdaki kodda ise OR kullanımına örnek verdik. x değerimiz 7, 36 | y değerimiz 9 olsun. x>5 true, y<10 true dönecek true || true => true 37 | dönecektir. 38 | 39 | x değerimiz 7, y değerimiz 13 olsun. x>5 true, y <10 false dönecek , 40 | true || false => true dönecek 41 | 42 | x değerimiz 3, y değerimiz 13 olsun. x>5 false,y < 13 false dönecek , 43 | false || false => false dönecek ve else bloğu çalışacak 44 | */ 45 | 46 | 47 | 48 | } 49 | } 50 | -------------------------------------------------------------------------------- /src/_21_NesneVeSinifYapisi/_25_inheritance/Inheritance.txt: -------------------------------------------------------------------------------- 1 | //Java Inheritance 2 | 3 | /* 4 | Java Inheritance temel seviyede kodlama yaparken bile ihtiyaç 5 | duyulan bir yapıdır. Bir çok projede farklı sınıflar birbirleriyle 6 | aynı değişkenleri veya aynı metotları içerebilirler. Bu gibi 7 | durumlarda aynı kodların tekrar tekrar yaratılmasını önlemek 8 | için Java’da sınıflar birbirinden türeyebilirler. 9 | */ 10 | 11 | 12 | 13 | Teorik olarak; 14 | 15 | 1- Subclass, paket yapısı farketmeksizin tüm protected ve public 16 | üyeleri superclass’tan miras alabilir. 17 | 18 | 2- Miras alınan alanlar sınıf içerisindeki diğer üyelerin kullanıldığı 19 | gibi direk olarak kullanılabilirler. 20 | 21 | 3- Superclass içerisindeki bir değişken ile aynı isimde bir değişken 22 | subclass içerisinde üretildiğinde bu olay hiding(gizleme) olarak 23 | adlandırılır. (önerilmez) 24 | 25 | 4- Superclass içerisindeki bir metot ile aynı isimde bir metot subclass 26 | içerisinde üretildiğinde bu olay overriding olarak adlandırılır. 27 | 28 | 5- Superclass içerisindeki static bir metot ile aynı isimde bir static 29 | metot subclass içerisinde üretildiğinde bu olay hiding olarak adlandırılır. (önerilmez) 30 | 31 | Sonuç 32 | Java Inheritance yapısından faydalanılarak kod tekrarının önlendiği, 33 | temiz kodlar yazılabilir. Büyük projelerde bir çok sınıfta kullanılan 34 | metotta bir dğeişiklik yapıldığında tek bir yerde değişikliği uygulama 35 | çoğu zaman yeterli olacaktır. Bu şekilde Java’da önem arzeden bakımı 36 | kolay, esnek ve geliştirmeye ve değiştirmeye açık kodlar yazmak daha 37 | kolay hale gelecektir. -------------------------------------------------------------------------------- /out/production/javaKonuTekrari/_21_NesneVeSinifYapisi/_25_inheritance/Inheritance.txt: -------------------------------------------------------------------------------- 1 | //Java Inheritance 2 | 3 | /* 4 | Java Inheritance temel seviyede kodlama yaparken bile ihtiyaç 5 | duyulan bir yapıdır. Bir çok projede farklı sınıflar birbirleriyle 6 | aynı değişkenleri veya aynı metotları içerebilirler. Bu gibi 7 | durumlarda aynı kodların tekrar tekrar yaratılmasını önlemek 8 | için Java’da sınıflar birbirinden türeyebilirler. 9 | */ 10 | 11 | 12 | 13 | Teorik olarak; 14 | 15 | 1- Subclass, paket yapısı farketmeksizin tüm protected ve public 16 | üyeleri superclass’tan miras alabilir. 17 | 18 | 2- Miras alınan alanlar sınıf içerisindeki diğer üyelerin kullanıldığı 19 | gibi direk olarak kullanılabilirler. 20 | 21 | 3- Superclass içerisindeki bir değişken ile aynı isimde bir değişken 22 | subclass içerisinde üretildiğinde bu olay hiding(gizleme) olarak 23 | adlandırılır. (önerilmez) 24 | 25 | 4- Superclass içerisindeki bir metot ile aynı isimde bir metot subclass 26 | içerisinde üretildiğinde bu olay overriding olarak adlandırılır. 27 | 28 | 5- Superclass içerisindeki static bir metot ile aynı isimde bir static 29 | metot subclass içerisinde üretildiğinde bu olay hiding olarak adlandırılır. (önerilmez) 30 | 31 | Sonuç 32 | Java Inheritance yapısından faydalanılarak kod tekrarının önlendiği, 33 | temiz kodlar yazılabilir. Büyük projelerde bir çok sınıfta kullanılan 34 | metotta bir dğeişiklik yapıldığında tek bir yerde değişikliği uygulama 35 | çoğu zaman yeterli olacaktır. Bu şekilde Java’da önem arzeden bakımı 36 | kolay, esnek ve geliştirmeye ve değiştirmeye açık kodlar yazmak daha 37 | kolay hale gelecektir. -------------------------------------------------------------------------------- /src/_27_exceptionHandling/CheckedExceptions.java: -------------------------------------------------------------------------------- 1 | package _27_exceptionHandling; 2 | 3 | import java.io.FileWriter; 4 | import java.io.IOException; 5 | 6 | public class CheckedExceptions { 7 | 8 | //Checked Exceptions 9 | 10 | /* 11 | Checked Exception Java’da kod geliştirme esnasında try-catch-finally 12 | bloğu içerisinde yakalanan ve daha sonra işlem yapılabilen, istenildiği 13 | takdirde bypass edilerek programın çalışmasına belkide kullanıcının 14 | hiç haberi olmadan devam edilmesini sağlayan exception çeşitleridir. 15 | Checked Exception alındığında çalışma anında düzeltme yapıp düzgün 16 | parametrelerle kodun çalışmasına devam edilebilir. Checked Exception 17 | sınıflarının tamamı Exception sınıfından türetilmiştir. 18 | Gelişmiş IDE’ler sayesinde checked exceptionların kontrolleri daha 19 | kolay bir şekilde sağlanmaktadır. Eğer kodunuzu notepad ile değilde 20 | daha gelişmiş bir IDE ile geliştiriyorsanız (örn: intellij idea, 21 | eclipse, netbeans) ve yazdığınız kodda Checked Exception varsa IDE 22 | sizi uyarıyor ve bu fırlatılan exception’ ı handle etmeniz yani 23 | yakalayıp gerekli işlemi yapmanız gerektiğini söylüyor. 24 | İşte bu durumda yazılımcılar olarak bizler, ya exception’ ın fırlatıldığı 25 | satırı try-catch bloğu içine alıyoruz ya da bir üst metoda throws ediyoruz. 26 | */ 27 | 28 | //ORNEK: 29 | 30 | public static void main(String[] args) { 31 | try { 32 | //FileWriter class'i checked exception. 33 | FileWriter fw = new FileWriter("file.txt"); 34 | } catch (IOException e) { 35 | // TODO Auto-generated catch block 36 | e.printStackTrace(); 37 | } 38 | } 39 | public void throwsExample() throws IOException { 40 | 41 | FileWriter fw = new FileWriter("file.txt"); 42 | } 43 | } 44 | 45 | 46 | 47 | 48 | 49 | 50 | 51 | 52 | 53 | 54 | 55 | -------------------------------------------------------------------------------- /src/_27_exceptionHandling/CheckedExceptionSample.java: -------------------------------------------------------------------------------- 1 | package _27_exceptionHandling; 2 | 3 | import java.io.FileInputStream; 4 | import java.io.FileNotFoundException; 5 | 6 | public class CheckedExceptionSample { 7 | 8 | /* 9 | * readFile metodu projenin bulundugu pathten test.txt adinda bir dosya 10 | * okumaya calisiyor. 11 | * Bu kodu gelistirirken IDE bizi dosyanın orda bulunamama durumuna karsi 12 | * uyariyor ve bir hata olabilecegini bunu kontrol altina almamiz 13 | * gerektigini belirtiyor. 14 | */ 15 | 16 | public void readFile(){ 17 | try { 18 | FileInputStream inputStream = new FileInputStream("test.txt"); 19 | } catch (FileNotFoundException e) { 20 | e.printStackTrace(); 21 | } 22 | } 23 | 24 | 25 | 26 | /* 27 | * readAnotherFile metodunda ise readFile metodundaki islemin aynisi 28 | * yapiliyor fakat olusabilecek hatanin kontrol edilme yetkisi bir üst 29 | * sinifa veriliyor. 30 | * @throws FileNotFoundException 31 | */ 32 | 33 | public void readAnotherFile() throws FileNotFoundException { 34 | FileInputStream inputStream = new FileInputStream("test1.txt"); 35 | } 36 | 37 | 38 | /* 39 | * readFile metodu kendi icinde hata ile ilgilendigi için direkt 40 | * kullanilabilirken, readAnotherFile metodu hata ile ilgilenme 41 | * yetkisini bir üst sinifa verdigi icin cagrildigi sinif icinde 42 | * gerekli kontrol islemlerinin yapilmasi gerekiyor. 43 | * @param args 44 | */ 45 | 46 | public static void main(String[] args) { 47 | 48 | CheckedExceptionSample ces = new CheckedExceptionSample(); 49 | ces.readFile(); 50 | 51 | try { 52 | ces.readAnotherFile(); 53 | } catch (FileNotFoundException e) { 54 | e.printStackTrace(); 55 | } 56 | } 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | } 67 | -------------------------------------------------------------------------------- /src/_26_polymorphism/_1_Coercion.java: -------------------------------------------------------------------------------- 1 | package _26_polymorphism; 2 | 3 | public class _1_Coercion { 4 | public static void main(String[] args) { 5 | 6 | 7 | /* 8 | Java’nın sahip olduğu bir özellik olan Implicit Type Conversion 9 | (Örtük Türde Dönüştürme) polymorphism in alt başlıklarından Coercion 10 | yapısını anlatmada en iyi yöntem olabilir. Veri tiplerinin 11 | birbirine dönüştürülmesi konusunu ele alıp temel tiplerden bir 12 | örnek oluşturalım. Örnek Java kodumuzda bir int değişken 13 | oluşturalım bir de float değişken oluşturalım. Oluşturduğumuz 14 | bu değişkenlere değer atayalım. Ardından int olarak 15 | tanımladığımız değişkeni float olarak tanımladığımız değişkene 16 | bölelim. Burada derleyici hata ile karşılaşılmasını önlemek 17 | için integer tipte tanımlanan değişkeni float tipinde bir 18 | değişkene çevirerek işlemi yapar. Aşağıdaki kod ile ne anlatmaya 19 | çalıştığımı daha iyi anlayabilirsiniz. 20 | */ 21 | 22 | int intDeger = 2; 23 | float floatDeger = 2.5f; 24 | //intDeger derleyici tarafından float tipinde bir degiskene donusturuluyor. 25 | 26 | float sonuc = intDeger/floatDeger; 27 | System.out.println(sonuc); 28 | 29 | /* 30 | Yukarıdaki kodda konsola yazdırılan sonuç “0.8” olacaktır. 31 | int tipindeki intDeger işlem sırasında derleyici tarafından 32 | float tipine dönüştürülerek işlem yapılmıştır. 33 | 34 | Temel tipteki bu yapıyı örnek alarak kendi sınıflarımızla bir 35 | örnek oluşturabiliriz. Vereceğim örneği açıklayacak en güzel 36 | cümle şu olacaktır. “Derleyici işlemleri yaparken, subclass 37 | türünü superclass türüne dönüştürür ve yapılabilecek işlemleri 38 | superclass’ ın özellikleriyle sınırlandırır.” 39 | */ 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | 50 | 51 | 52 | 53 | 54 | } 55 | } 56 | -------------------------------------------------------------------------------- /src/_30_MultidimensionalArrays/RobotRonGrubu.java: -------------------------------------------------------------------------------- 1 | package _30_MultidimensionalArrays; 2 | 3 | public class RobotRonGrubu { 4 | 5 | public static void main(String[] args) { 6 | 7 | 8 | String[][] robotRonGrubu = { 9 | 10 | {"Lale", "Gozudeli"}, 11 | {"Ismail", "Akdogan"}, 12 | {"Zeliha", "Oznuk"}, 13 | {"Deniz", "Taskiran"}, 14 | {"Sumeyye", "Gecici"}, 15 | }; 16 | 17 | stringArrayPrinter(robotRonGrubu); 18 | 19 | String[][] robotRonGrubuListesi = new String[8][2]; 20 | robotRonGrubuListesi[0][0] = "Lale"; 21 | robotRonGrubuListesi[0][1] = "Gozudeli"; 22 | robotRonGrubuListesi[1][0] = "Ismail"; 23 | robotRonGrubuListesi[1][1] = "Akdogan"; 24 | robotRonGrubuListesi[2][0] = "Zeliha"; 25 | robotRonGrubuListesi[2][1] = "Oznuk"; 26 | robotRonGrubuListesi[3][0] = "Deniz"; 27 | robotRonGrubuListesi[3][1] = "Taskiran"; 28 | robotRonGrubuListesi[4][0] = "Sumeyye"; 29 | robotRonGrubuListesi[4][1] = "Gecici"; 30 | 31 | stringArrayPrinter(robotRonGrubuListesi); 32 | } 33 | 34 | 35 | 36 | private static void stringArrayPrinter(String[][] strArray) { 37 | int rowSize = strArray.length; 38 | for (int row = 0; row < rowSize; row++) { 39 | int columnSize = strArray[row].length; 40 | for (int column = 0; column < columnSize; column++) { 41 | System.out.print(strArray[row][column] + " "); 42 | } 43 | System.out.println(); 44 | } 45 | System.out.println("------------------------------"); 46 | } 47 | 48 | 49 | } 50 | 51 | /* 52 | Yukarıdaki örnekte “robotRonGrubu” ve “robotRonGrubuListesi” 53 | değişkenleri farklı yöntemlerle tanımlanmış olsa da aynı verileri 54 | içermektedir. Metotları örnek bir sınıf içerisinde çalıştırdığımızda 55 | çıktılarının aynı olduğunu görebiliriz. 56 | */ 57 | 58 | -------------------------------------------------------------------------------- /src/_22_erisimBelirleyiciler/AracKullanicisi.java: -------------------------------------------------------------------------------- 1 | package _22_erisimBelirleyiciler; 2 | 3 | public class AracKullanicisi { 4 | 5 | public static void main(String[] args) { 6 | 7 | /** 8 | * OzelArac sınıfından bir nesne olusturuldu. 9 | */ 10 | 11 | OzelArac ozelArac = new OzelArac(); 12 | 13 | /** 14 | * protected erişim tipi ile tanımlanan metot aynı paket içinden çağrıldı. 15 | */ 16 | 17 | ozelArac.arabayiCalistir(); 18 | 19 | /** 20 | * setter yapısı protected olarak tanımlanan camlarAcilabilir değişkeni aynı paket içindeki 21 | * AracKullainicisi tarafından setlenebildi. 22 | */ 23 | 24 | ozelArac.setCamlarAcilabilir(true); 25 | 26 | /** 27 | * setter yapısı protected olarak tanımlanan kapilarAcilabilir değişkeni aynı paket içindeki 28 | * AracKullainicisi tarafından setlenebildi. 29 | */ 30 | 31 | ozelArac.setKapilarAcilabilir(false); 32 | 33 | Yolcu yolcu = new Yolcu(); 34 | System.out.println("If-Else yapisi ile yaz:"); 35 | yolcu.yolcununYapabilecekleriniYazdir(ozelArac); 36 | System.out.println("? : yapisi ile yaz:"); 37 | yolcu.yolcununYapabilecekleriniYazdir1(ozelArac); 38 | 39 | 40 | /* 41 | AracKullanicisi sınıfı benim ana sınıfım yapıyı buradan 42 | çalıştırıyorum, bu sebeple AracKullanicisi sınıfı içerisinde 43 | main metodum var. Bu main metot içerisinde bir tane OzelArac 44 | nesnesi tanımlıyorum ve arabayı çalıştırmak için arabayiCalistir 45 | metodunu tetikliyorum. Arabayı çalıştırdıktan sonra araç 46 | kullanıcısı olarak yolcuları düşünüyorum ve onlar için ufak 47 | bazı önlemler alıyorum. Sadece OzelArac sınıfı ve 48 | AracKullanicisi sınıflarından erişim sağlanabilecek 49 | setCamlarAcilabilir ve setKapilarAcilabilir metotlarına değer atıyorum. 50 | */ 51 | 52 | 53 | 54 | 55 | } 56 | } 57 | -------------------------------------------------------------------------------- /src/_28_composition/composition.java: -------------------------------------------------------------------------------- 1 | package _28_composition; 2 | 3 | public class composition { 4 | 5 | //Composition nedir? 6 | 7 | /* 8 | Bir classı oluşturduktan sonra başka bir class içerisinde kullanmamızı 9 | sağlayan yapıya composition denir. Bu sayede her kodlamada aynı kodu 10 | yazmak zorunda kalmayacak ve oluşabilecek kod kirliliğinin önüne geçmiş 11 | olacaksınız. 12 | 13 | Composition da sahiplik ilişkisi vardır. Bizim bir masaüstü 14 | bilgisayarımızın olduğunu düşünelim. Bu bilgisayarı oluştururken kasa, 15 | monitor, anakart, ram vs. alıyoruz. 16 | Tüm bunları birleştirerek bir bilgisayar ortaya çıkarıyoruz. 17 | Bu bilgisayarı OOP ile tasarlayacağımızı düşünürsek bu bilgisayar 18 | objesinin içinde aslında bir tane kasa objesi, bir tane anakart objesi, 19 | bir tane ram objesi , bir tane monıtor objesi vs. olacak. 20 | Yani bunlar birleşerek bir tane bilgisayar objesi oluşturuyorlar. 21 | Compositionun tam olarak anlamı budur. 22 | */ 23 | 24 | /* 25 | Composition düşünürken gerçek dünya ile bağlantı kurarak birden 26 | fazla ilişki kurabilir konuyu daha iyi kavrayabiliriz. Peki Composition 27 | oluşturduktan sonra bunun bize faydası ne olacaktır diye düşündüğümüz zaman 28 | durumu şöyle izah edebilirim. Esas faydaları bizim çoğu projemizde 29 | yaşamış olduğumuz sıkıntıları giderebilecek durumdadır. Bunlar ; 30 | 31 | ** Mevcut kodu tekrar kullanabiliriz, 32 | ** Genişletebiliriz, 33 | ** Kod tekrarını önleyebiliriz ve bunun sayesinde temiz kod elde etmiş oluruz. 34 | 35 | */ 36 | 37 | 38 | 39 | 40 | 41 | /* 42 | Burada bir kasa sınıfı oluşturup obje yaratacağız. Yaratmış olduğumuz 43 | kasa objesini ise direkt bilgisayar objesine yerleştireceğiz. Anakart 44 | ve Monitör içinde aynısını yaptıktan sonra Monitör sınıfı içerisinde 45 | bir tane daha composition uygulamaya çalışacağız. Gelelim bu anlatmış 46 | olduğumuz örneği koda dökmeye : 47 | */ 48 | 49 | 50 | 51 | 52 | } 53 | -------------------------------------------------------------------------------- /src/_11_forDongusu/ForDongusuKullanimi.java: -------------------------------------------------------------------------------- 1 | package _11_forDongusu; 2 | 3 | public class ForDongusuKullanimi { 4 | public static void main(String[] args) { 5 | 6 | /* 7 | For Döngüsü ‘nün bir çok farklı kullanımı olabilir. 8 | Örneğin verileri sadece arttırarak yazmamız gerekmemektedir, 9 | veya döngüyü 0 (sıfır) dan başlatmak zorunda değilizdir. 10 | For Döngüsü nün bir kaç farklı kullanım örneğini vermek gerekirse; 11 | */ 12 | 13 | System.out.println("standart kullanim"); 14 | System.out.print("i: "); 15 | for(int i = 0; i < 10 ; i++) { 16 | System.out.print(i + " "); 17 | } 18 | 19 | 20 | System.out.println("azaltarak kullanım"); 21 | System.out.print("\nj: "); 22 | for(int j = 10; j >= 0 ; j--) { 23 | System.out.print(j + " "); 24 | } 25 | 26 | System.out.println("5ten 10a kadar"); 27 | System.out.print("\nk: "); 28 | for(int k = 5; k <= 10; k++) { 29 | System.out.print(k + " "); 30 | } 31 | 32 | System.out.println("0dan 100 e 10ar 10ar"); 33 | System.out.print("\nl: "); 34 | for(int l = 0 ; l <= 100; l+=10) { 35 | System.out.print(l + " "); 36 | } 37 | 38 | System.out.println("50den 0a 5er 5er"); 39 | System.out.print("\nm: "); 40 | for(int m = 50; m >= 0; m-=5) { 41 | System.out.print(m + " "); 42 | } 43 | 44 | /* 45 | Burada gözden kaçabilecek bir kaç ufak ama önemli bilgi vermek 46 | faydalı olacaktır. Kodun herhangi bir yerinde for içinde 47 | tanımladığımız değişkeni kullanmayacaksak yukardaki örneklerde 48 | olduğu gibi for içerisinde tanımlayabiliriz. 49 | System.out.println ve System.out.print komutları farklı 50 | komutlardır. Baştaki komut her yazılanı yeni bir satırda 51 | yazarken sonraki komut yazılanları aynı 52 | satırda yazmak için kullanılır. 53 | */ 54 | 55 | 56 | 57 | } 58 | } 59 | -------------------------------------------------------------------------------- /src/_04_ifElseKosulYapisi_AndOr/and_or.java: -------------------------------------------------------------------------------- 1 | package _04_ifElseKosulYapisi_AndOr; 2 | 3 | public class and_or { 4 | public static void main(String[] args) { 5 | 6 | /* 7 | 8 | Bu dersimizde bir önceki derse ek olarak AND ve OR kullanımını 9 | anlatacağız. Nedir bu AND ve OR kullanımı diye sorarsanız şöyle 10 | anlatayım. Bir önceki dersimde kullandığımız tüm if koşulları 11 | sadece tek koşul içeriyordu. Örneğin sadece x ‘in 5 ten büyük 12 | olmasına bakıyorduk. Ama tek koşul olması bazen yetmeyebilir, 13 | x’in 5’ten büyük olmasının yanında 10’dan küçük olmasıda gerekebilir. 14 | Bu durumda aşağıdaki gibi iç içe if yapısı kurabiliriz. 15 | 16 | */ 17 | 18 | /* 19 | 20 | if(x>5){ 21 | if(x<10){ 22 | //işlemler 23 | } 24 | } 25 | 26 | */ 27 | 28 | /* 29 | Yukarıda gördüğümüz gibi iç içe if kullandık ve gerekli koşulu sağladık. 30 | Ama bu kullanım pratik bir kullanım değildir. Bu gibi birden çok koşul 31 | için AND (ve) ve OR (veya) yapısını kullanırız. 32 | Java’da AND için kullanılan işaret -> “&&” , OR için kullanılan işaret 33 | ise “||” bu ikisidir. Bunlara logical operator adı verilmektedir. 34 | 35 | Bir önceki dersimizden de bildiğimiz üzere if koşulunun içi true ise 36 | if bloğuna girer,false ise sıradaki else if veya direk else bloğuna girer. 37 | AND ve OR işlemlerinde ise hangi durumlarda true ,hangi durumlarda false 38 | geldiğini aşağıdaki tabloda görebilirsiniz. 39 | 40 | A = true ,B=true olsun 41 | */ 42 | 43 | /* 44 | 45 | Logical Operatör Açıklama/Örnek Kullanım 46 | && (AND) İf içindeki tüm koşullar true ise true, değilse false 47 | (A && B) => true 48 | (A && !B) => false 49 | 50 | || (OR) İf içinde tek bir koşul true ise true, değilse false 51 | (A || B) => true 52 | (A || !B) => true 53 | (!A || !B) => false 54 | 55 | */ 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | } 65 | } 66 | -------------------------------------------------------------------------------- /src/_09_whileDongusu/WhileDongusuOrnek_SayiTahmin.java: -------------------------------------------------------------------------------- 1 | package _09_whileDongusu; 2 | 3 | import java.util.Scanner; 4 | 5 | public class WhileDongusuOrnek_SayiTahmin { 6 | public static void main(String[] args) { 7 | 8 | //Math.random() ile ürettiğimiz random bir sayıyı tahmin etme programı: 9 | 10 | int sayi = (int)(Math.random() * 101); //0 ile 100 arasında bir sayı üretir 100'de olabilir 11 | 12 | Scanner input = new Scanner(System.in); //Kullanıcıdan sayı alabilmek için Scanner sınıfını kullandık 13 | 14 | int tahmin = -1; //0 ile 100 arasında olmaması için -1 verdik 15 | 16 | while(sayi != tahmin){ // sayı tahmine eşit olmadığı sürece true dönecek ve bu işlem tekrarlanacak . 17 | // Sayı işleme eşit olduğunda false dönecek ve döngüye girmiyecek 18 | 19 | System.out.print("Tahmin ettiğiniz sayıyı giriniz: "); 20 | 21 | tahmin = input.nextInt(); // Sayı kullanıcıdan alınır 22 | 23 | if(tahmin == sayi){ 24 | System.out.println("Doğru Tahmin"); 25 | 26 | }else if(tahmin > sayi){ 27 | System.out.println("Tahmininizi Azaltın"); 28 | 29 | }else{ 30 | System.out.println("Tahmininizi Arttırın"); 31 | 32 | } 33 | } 34 | 35 | /* 36 | Yukarıdaki kodu açıklamak gerekirse kod çalışır çalışmaz 37 | 0 ile 100 arasında bir sayıyı random olarak oluşturuyor. 38 | Sonrasında while döngüsü içinde kullanıcıdan klavyeden tahmin 39 | girmesini istiyor. Eğer bu tahmin random oluşturulan 40 | sayıya eşitse “Doğru Tahmin “, büyükse “Tahmininizi Azaltın” 41 | ,küçükse “Tahmininizi Arttırın” mesajı veriyor. 42 | Girilen tahmin zaten sayıya eşitse “Doğru Tahmin” 43 | mesajı verildikten sonra sayi != tahmin koşulunu sağlamayacağı 44 | için tekrardan döngüye girmiyecek ve bu kodumuzda başka işlem 45 | olmadığı için programımızı sonlandıracaktır. 46 | */ 47 | 48 | 49 | 50 | 51 | 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/_07_javaOperatorlari/KarsilastirmaOperatorlari.java: -------------------------------------------------------------------------------- 1 | package _07_javaOperatorlari; 2 | 3 | public class KarsilastirmaOperatorlari { 4 | public static void main(String[] args) { 5 | 6 | //Karşılaştırma Operatörleri 7 | 8 | /* 9 | Karşılaştırma operatörü insteadOf olarak bilinmektedir. 10 | bir sınıfı bir sınıfla veya interface ile karşılaştırma yaparken 11 | kullanılmaktadır. Vereceğimiz örnek nesne yönelimli proglama 12 | bilmek gerektirdiği için üzerinde çok durmayacağız. 13 | Ayrıca aşağıda verdiğimiz örneği direk olarak çalıştırmaya 14 | çalıştığınızda hata verecektir. kodun düzgün çalışması için 15 | ilgili sınıfların oluşturulması gerekmektedir. 16 | Bu konuya ilerki derslerimizde daha detaylı yer verilecektir. 17 | */ 18 | 19 | /* 20 | Parent obj1 = new Parent(); 21 | Parent obj2 = new Child(); 22 | 23 | System.out.println("obj1 instanceof Parent: " 24 | + (obj1 instanceof Parent)); 25 | System.out.println("obj1 instanceof Child: " 26 | + (obj1 instanceof Child)); 27 | System.out.println("obj1 instanceof MyInterface: " 28 | + (obj1 instanceof MyInterface)); 29 | System.out.println("obj2 instanceof Parent: " 30 | + (obj2 instanceof Parent)); 31 | System.out.println("obj2 instanceof Child: " 32 | + (obj2 instanceof Child)); 33 | System.out.println("obj2 instanceof MyInterface: " 34 | + (obj2 instanceof MyInterface)); 35 | */ 36 | 37 | /* 38 | class Parent {} 39 | class Child extends Parent implements MyInterface {} 40 | interface MyInterface {} 41 | */ 42 | 43 | 44 | /* 45 | OUTPUT: 46 | obj1 instanceof Parent: true 47 | obj1 instanceof Child: false 48 | obj1 instanceof MyInterface: false 49 | obj2 instanceof Parent: true 50 | obj2 instanceof Child: true 51 | obj2 instanceof MyInterface: true 52 | */ 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | } 70 | } 71 | -------------------------------------------------------------------------------- /src/_13_methodYapisi/Ornek2.java: -------------------------------------------------------------------------------- 1 | package _13_methodYapisi; 2 | 3 | public class Ornek2 { 4 | 5 | 6 | public static int toplama(int sayi1, int sayi2) { 7 | int sonuc = sayi1 + sayi2; 8 | return sonuc; 9 | } 10 | 11 | public static int cikarma(int sayi1, int sayi2) { 12 | int sonuc = sayi1 - sayi2; 13 | return sonuc; 14 | } 15 | 16 | //eger cikarma isleminde negatif deger cikmasini istemiyorsak 17 | public static int cikarma2(int sayi1, int sayi2) { 18 | if(sayi1 > sayi2) { 19 | int sonuc = sayi1 - sayi2; 20 | return sonuc; 21 | } else { 22 | System.out.println(sayi1 + " küçüktür " + sayi2); 23 | int sonuc = sayi2 - sayi1; 24 | return sonuc; 25 | } 26 | } 27 | 28 | public static int carpma(int sayi1, int sayi2) { 29 | int sonuc = sayi1 * sayi2; 30 | return sonuc; 31 | } 32 | 33 | public static int bolme(int sayi1, int sayi2) { 34 | int sonuc = sayi1 / sayi2; 35 | return sonuc; 36 | } 37 | 38 | public static void main(String[] args) { 39 | System.out.println("Toplama"); 40 | System.out.println("5 + 6 = " + toplama(5, 6)); 41 | System.out.println("Çıkarma"); 42 | System.out.println("10 - 2 = " + cikarma(10, 2)); 43 | System.out.println("12 - 8 = " + cikarma2(8, 12)); 44 | System.out.println("Çarpma"); 45 | System.out.println("5 x 6 = " + carpma(5, 6)); 46 | System.out.println("Bölme"); 47 | System.out.println("10 / 2 = " + bolme(10, 2)); 48 | } 49 | 50 | /* 51 | Bu örneğimizde metot içerisinde işlemi yaptıktan sonra çıkan sonucu 52 | return anahtar kelimesi ile metot dışına döndürdük. 53 | Bu şekilde main metodumuz içerisinde toplama, çıkarma, çarpma 54 | ve bölme metotlarımızı direk çağırarak sonuçları yazdırabildik. 55 | Daha öncede bahsettiğimiz gibi metotlar ile istediğimiz tipte 56 | nesneyi döndürebiliriz, String, long, int, float, double vs. hiç farketmez. 57 | */ 58 | 59 | 60 | 61 | 62 | 63 | 64 | } 65 | -------------------------------------------------------------------------------- /src/_17_dizilerdeArama_ArraySearch/LinearSearch.java: -------------------------------------------------------------------------------- 1 | package _17_dizilerdeArama_ArraySearch; 2 | 3 | public class LinearSearch { 4 | public static void main(String[] args) { 5 | 6 | /* 7 | Dizilerde genel olarak 2 şekilde arama yapabiliriz. 8 | 1.si Linear Search, ikincisi ise Binary Search‘tür. 9 | Öncelikle şunu bildirelim ki Binary Search yapabilmemiz 10 | için dizimiz sıralı olmalıdır. Ya büyükten küçüğe 11 | ya da küçükten büyüğe sıralanmış olmalıdır. 12 | Gelelim nasıl yapacağımıza. Ben direk kod üzerinden 13 | anlatmaya çalışacağım. 14 | */ 15 | 16 | 17 | //1- Linear Search 18 | 19 | /* 20 | Linear Search , sıralı olmayan dizilerde ve küçük olan sıralı 21 | dizilerde arama yaparken kullanılır. Sıralı olup büyük olan 22 | dizilerde ise Binary Search kullanmak daha etkilidir. 23 | 24 | Gelelim Linear Search kullanımına. Direk örnek üzerinden anlatacağım. 25 | */ 26 | 27 | int[] liste = {1, 4, 99, 2, 5, -3, 6, 2,-49,52};//Dizi'mizi oluşturuyoruz 28 | 29 | int sayiIndex = linearSearchh(liste,52); //linearSearch methoduna dizimizi ve aradığımız sayıyı gönderiyoruz 30 | if (sayiIndex != -1){ //method -1 dönmediyse sayı bulunmuştur 31 | System.out.println("Aranan sayinin index'i :"+sayiIndex); 32 | }else { //-1 döndüğünde -1 dönecek ve else düşecek 33 | System.out.println("Aranan sayi bulunamadi"); 34 | } 35 | 36 | 37 | 38 | 39 | } 40 | 41 | private static int linearSearchh(int[] liste, int arananSayi) { 42 | 43 | for (int i = 0; i < liste.length; i++) {//döngümüz dizimizin uzunluğu kadar dönüyor 44 | if (liste[i] == arananSayi){//sırası ile tüm elemanlara bakıyourz 45 | return i; //eğer aradığımız elemanı bulduysak index'ini geri gönderiyoruz 46 | } 47 | } 48 | return -1;//Herhangi bir değer bulunamadıysa -1 dönderiyoruz 49 | 50 | } 51 | } 52 | 53 | //Yukarıda da gördüğünüz gibi Linear yani doğrusal arama yaptık. Sırası ile tüm elemanlara baktık. 54 | -------------------------------------------------------------------------------- /src/_12_breakContinueDeyimleri/Continue.java: -------------------------------------------------------------------------------- 1 | package _12_breakContinueDeyimleri; 2 | 3 | public class Continue { 4 | public static void main(String[] args) { 5 | 6 | //continue Komutu 7 | 8 | /* 9 | break continue deyimleri arasında continue deyimi yine 10 | break deyiminde olduğu gibi for, while ve do-while 11 | döngülerinde kullanılmaktadır. break deyiminden 12 | farklı olarak continue döngüyü sonlandırmamakta 13 | fakat döngüde ilgili tekrarı atlamaktadır (es geçmektedir). 14 | Örneğin bir veritabanından yine tüm kayıtları çektiniz ve 15 | bu kayıtlar arasından 5. kayıdı atlamak istiyor ve 16 | döngünün devam etmesini istiyorsunuz. Bu gibi durumlarda 17 | continue kullanılabilecek en güzel tercihtir. 18 | Şimdi bu örneği kod üzerinde gösterelim; 19 | */ 20 | 21 | int veritabaniKayitSayisi = 15; 22 | for(int i =1; i<=veritabaniKayitSayisi; i++) { 23 | if(i == 5) { 24 | continue; 25 | } 26 | System.out.println(i + ". kayit"); 27 | } 28 | 29 | /* 30 | Yukarıdaki örnekte for döngüsü içerisinde if bloğunu tanımlayarak 31 | i değeri 5 olduğunda continue ile döngünün bir sonraki değer 32 | için başa dönmesini sağladık. Bu şekilde konsol ekranına 33 | 5. kayıt şeklinde yazılmasının önüne geçmiş olduk. 34 | İlgili örneğin konsol çıktısı şu şekildedir; 35 | 36 | 1. kayit 37 | 2. kayit 38 | 3. kayit 39 | 4. kayit 40 | 6. kayit 41 | 7. kayit 42 | 8. kayit 43 | 9. kayit 44 | 10. kayit 45 | 11. kayit 46 | 12. kayit 47 | 13. kayit 48 | 14. kayit 49 | 15. kayit 50 | */ 51 | 52 | /* 53 | Yine diğer örneklerde olduğu gibi continue deyimi 54 | while içerisinde ve do-while döngüsü içerisinde kullanılabilmektedir. 55 | 56 | break continue deyimleri hakkında anlatacaklarımız bu kadar, 57 | Java dilinde döngüleri kullanırken bu deyimler oldukça büyük önem 58 | kazanmaktadırlar. Kullanım alanları ise oldukça geniştir. 59 | */ 60 | 61 | 62 | 63 | } 64 | 65 | } 66 | -------------------------------------------------------------------------------- /src/_07_javaOperatorlari/KosulOperatorlari.java: -------------------------------------------------------------------------------- 1 | package _07_javaOperatorlari; 2 | 3 | public class KosulOperatorlari { 4 | public static void main(String[] args) { 5 | 6 | //Koşul Operatörleri 7 | 8 | /* 9 | Koşul operatörleri verilen parametrelerin birden fazla eşitlik 10 | veya ilişkisel koşulu sağlayıp sağlamadığını kontrol ederken kullanılır. 11 | &&(ve), ||(veya), ?:(üçlü) operatör seçenekleri mevcuttur. 12 | Bu operatörleri örnekle kısaca anlatmak gerekirse; 13 | */ 14 | 15 | int deger1 = 2; 16 | int deger2 = 4; 17 | String strDeger1 = "zelihaoznuk"; 18 | String strDeger2 = "zeliha"; 19 | if((deger1 < deger2) && (strDeger1.contains(strDeger2))) { 20 | System.out.println(deger1 + " kucuktur " + deger2 21 | + " ve " + strDeger1 + " " + strDeger2 + " String degerini icermektedir."); 22 | } 23 | 24 | if((deger1 == deger2) || (strDeger1.contains(strDeger2))) { 25 | System.out.println(deger1 + " esittir " + deger2 26 | + " veya " + strDeger1 + " " + strDeger2 + " String degerini icermektedir."); 27 | } 28 | 29 | if((deger1 < deger2) || (strDeger1.equals(strDeger2))) { 30 | System.out.println(deger1 + " kucuktur " + deger2 31 | + " veya " + strDeger1 + " " + strDeger2 + " String degerini icermektedir."); 32 | } 33 | 34 | int deger3 = 23; 35 | 36 | //deger3 23'e esitse deger4'un degerini 24 yap degilse 22 yap 37 | 38 | int deger4 = (deger3 == 23) ? 24 : 22; 39 | System.out.println("deger4: " + deger4); 40 | 41 | //deger3 22'ye esitse deger4'un degerini 24 yap degilse 22 yap 42 | 43 | deger4 = (deger3 == 22) ? 24 : 22; 44 | System.out.println("deger4: " + deger4); 45 | 46 | /* 47 | OUTPUT: 48 | 2 esittir 4 veya zelihaoznuk zeliha String degerini icermektedir. 49 | 2 kucuktur 4 veya zelihaoznuk zeliha String degerini icermektedir. 50 | deger4: 24 51 | deger4: 22 52 | */ 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | } 65 | } 66 | -------------------------------------------------------------------------------- /src/_16_diziler_ForeachKullanimi/ForDongusuKullanimi.java: -------------------------------------------------------------------------------- 1 | package _16_diziler_ForeachKullanimi; 2 | 3 | public class ForDongusuKullanimi { 4 | public static void main(String[] args) { 5 | 6 | //Diziler for döngüsü kullanımı: 7 | 8 | /* 9 | Dersimiz forach döngüsü kullanımı , ancak dizilerin for döngüsü 10 | ile kullandımdan da bahsetmemiz gerekiyor. Anlatımı örnekler 11 | üzerinden yapacağım. 12 | Gelelim örnek kullanımlara: 13 | 14 | Dizinin tüm elemanlarına 1-100 arasında random değerler atama. 15 | */ 16 | 17 | int[] sayi = new int[10];//uzunluğu 10 olan diziyi oluşturduk 18 | 19 | for (int i = 0; i < sayi.length; i++) { 20 | sayi[i] = (int) (Math.random()*100); //tek tek değer atıyoruz 21 | } 22 | 23 | //Atadığımız bu değerleri ekrana yazdıralım: 24 | 25 | for (int i = 0; i < sayi.length; i++) { 26 | System.out.println(sayi[i] + " ");//9 67 98 7 52 85 68 77 84 13 27 | } 28 | 29 | System.out.println("***************"); 30 | 31 | /* 32 | Şimdi küçük bir örnekle for döngüsünü pekiştirelim. 33 | Örnek: Uzunluğu 100 olan int bir diziye önce 1-999 arasında 34 | random değerler atayalım. Sonra atadığımız bu değerler arasında 35 | en büyük olan sayıyı ve o sayının dizideki index’ini bulalım. 36 | */ 37 | 38 | int[] sayi2 = new int[100];//Uzunluğu 100 olan diziyi oluşturduk 39 | 40 | for (int i = 0; i < sayi2.length; i++) { 41 | sayi2[i] = (int) (Math.random()*1000); ////Tüm elemanlarına 0-999 arasında değerler atıyoruz 42 | } 43 | 44 | int index = 0;//başlangıç değerleri 45 | int max = 0;//başlangıç değerleri 46 | 47 | for (int i = 0; i < sayi2.length; i++) { 48 | if (sayi2[i]>max){ //max sayıdan büyük ise 49 | max=sayi2[i]; //max sayı değiştiriliyor 50 | index=i; //ve index alınıyor 51 | } 52 | } 53 | System.out.println("En buyuk sayi :" +max+" index :"+index);//En buyuk sayi :980 index :80 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | } 62 | } 63 | -------------------------------------------------------------------------------- /src/_20_MultidimensionalArrays_cokBoyutluDiziler/KarmaşıkDiziler.java: -------------------------------------------------------------------------------- 1 | package _20_MultidimensionalArrays_cokBoyutluDiziler; 2 | 3 | public class KarmaşıkDiziler { 4 | 5 | /* 6 | Çok boyutlu dizilerin bir özelliğide karmaşık yapıda tanımlanabilmesidir. 7 | Karmaşık dizilere örneğimizi int veri tipi üzerinden yazacağımız 8 | kod parçasıyla vereceğiz. 9 | */ 10 | 11 | 12 | private void multiDimensionalArrayTest() { 13 | int[][] arr = { 14 | {0}, 15 | {1,2}, 16 | {3,4,5}, 17 | {6,7,8,9}, 18 | }; 19 | 20 | } 21 | 22 | private void intArrayPrinter(int[][] intArray){ 23 | int rowSize = intArray.length; 24 | for (int i = 0; i < rowSize; i++) { 25 | int columSize =intArray[i].length; 26 | for (int j = 0; j < columSize; j++) { 27 | System.out.println("int["+i+"]["+j+"]: " +intArray[i][j]); 28 | } 29 | } 30 | } 31 | 32 | 33 | /* 34 | Yukarıdaki örneğin kodunu inceledikten sonra çıktısını 35 | incelediğimizde rahat bir şekilde hangi indekse hangi değerin 36 | atadığını görebiliriz. Burada dikkat edilmesini gereken nokta, 37 | çok boyutlu dizi de sütun sayısının değişken olduğudur. 38 | Önceki çok boyutlu String dizi örneğimizde sütun sayısı 39 | değişmezken bu örnekte rastgele sütun sayıları ile işlem yapılmıştır. 40 | Yalnız Java’da çok boyutlu dizilerde değişken tanımlaması 41 | yaparken satır sayısını sabit verip sütun sayısını vermeden 42 | işlem yapabilirken, sütun sayısını sabit verip satır sayısını 43 | vermeden tanımlama yaptığımızda hata ile karşılaşacağımızı 44 | aklımızın bir köşesine yazmamız gerekmektedir. Kısa bir kod 45 | parçasıyla açıklamak gerekirse; 46 | */ 47 | 48 | /* 49 | int[][] foo = new int[3][]; //doğru tanımlama 50 | int[][] foo1 = new int[][3]; // hatalı tanımlama 51 | int[][] foo2 = new int[][]; //hatalı tanımlama 52 | 53 | */ 54 | 55 | /* 56 | Java’da çok boyutlu diziler tanımlanırken mutlaka initialize 57 | edilmelidir. Aksi takdirde geliştirme anında hata ile karşılaşılır. 58 | */ 59 | 60 | } 61 | -------------------------------------------------------------------------------- /src/_30_MultidimensionalArrays/KarmasikDiziler.java: -------------------------------------------------------------------------------- 1 | package _30_MultidimensionalArrays; 2 | 3 | public class KarmasikDiziler { 4 | 5 | 6 | 7 | /* 8 | Çok boyutlu dizilerin bir özelliğide karmaşık yapıda tanımlanabilmesidir. 9 | Karmaşık dizilere örneğimizi int veri tipi üzerinden yazacağımız kod 10 | parçasıyla vereceğiz. 11 | */ 12 | 13 | private void multiDimensionalArrayTest() { 14 | int[][] numberArray = { 15 | {0}, 16 | {1, 2}, 17 | {3, 4, 5}, 18 | {6, 7, 8, 9}, 19 | }; 20 | } 21 | 22 | private void intArrayPrinter(int[][] intArray) { 23 | int rowSize = intArray.length; 24 | for (int row = 0; row < rowSize; row++) { 25 | int columnSize = intArray[row].length; 26 | for (int column = 0; column < columnSize; column++) { 27 | System.out.println("int[" + row + "][" + column + "]: " + intArray[row][column]); 28 | } 29 | } 30 | 31 | } 32 | 33 | /* 34 | Yukarıdaki örneğin kodunu inceledikten sonra çıktısını incelediğimizde 35 | rahat bir şekilde hangi indekse hangi değerin atadığını görebiliriz. 36 | Burada dikkat edilmesini gereken nokta, çok boyutlu dizi de sütun 37 | sayısının değişken olduğudur. Önceki çok boyutlu String dizi örneğimizde 38 | sütun sayısı değişmezken bu örnekte rastgele sütun sayıları ile işlem 39 | yapılmıştır. Yalnız Java’da çok boyutlu dizilerde değişken tanımlaması 40 | yaparken satır sayısını sabit verip sütun sayısını vermeden işlem 41 | yapabilirken, sütun sayısını sabit verip satır sayısını vermeden 42 | tanımlama yaptığımızda hata ile karşılaşacağımızı aklımızın bir 43 | köşesine yazmamız gerekmektedir. Kısa bir kod parçasıyla açıklamak 44 | gerekirse; 45 | 46 | int[][] foo = new int[3][]; //doğru tanımlama 47 | int[][] foo1 = new int[][3]; // hatalı tanımlama 48 | int[][] foo2 = new int[][]; //hatalı tanımlama 49 | 50 | Java’da çok boyutlu diziler tanımlanırken mutlaka initialize edilmelidir. 51 | Aksi takdirde geliştirme anında hata ile karşılaşılır. 52 | 53 | */ 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | } 63 | 64 | 65 | 66 | 67 | 68 | 69 | -------------------------------------------------------------------------------- /src/_03_ifElseKosulYapisi/ifElse.java: -------------------------------------------------------------------------------- 1 | package _03_ifElseKosulYapisi; 2 | 3 | public class ifElse { 4 | public static void main(String[] args) { 5 | 6 | /* 7 | if ingilizcede eğer anlamına gelmektedir. Aynı şekilde programlama 8 | dillerinde de eğer anlamına gelmektedir. Genel yapısı aşağıdaki gibidir. 9 | */ 10 | 11 | /* 12 | if (boolean) //true veya false 13 | true ise yapılacak işlemler 14 | else 15 | false ise yapılacak işlemler 16 | */ 17 | 18 | 19 | /* 20 | Bir java uygulaması yazdığımızı farz edelim. 21 | (İf koşulunun mantığı tüm programlama dillerinde aynıdır, 22 | sadece syntax farklı olabilir). Bu uygulama içinde bir kod bloğunun 23 | çalışması için bir şart gerekli diyelim. Örneğin çarpma işlemi yapacağız 24 | klavyeden girilen bir sayıyı 5 ile çarpacağız, ama girilen sayının 25 | 0’dan büyük olmasını istiyoruz. Bu ve buna benzer durumlarda kullanılan 26 | if koşulunun kullanımına geçmeden önce if koşulunu oluştururken 27 | sıkça kullanacağımız karşılaştırma operatörlerinden bahsedeceğim. 28 | */ 29 | 30 | /* 31 | Operatör Açıklama/Örnek Kullanım 32 | == (eşit) İki değer eşitse true, değilse false 33 | (A==B) => false 34 | 35 | != (eşit değil) İki değer eşit değilse true, eşitse false 36 | (A!=B) => true 37 | 38 | > (büyüktür) ilk değer ikincisinden büyükse true,değilse false 39 | (A>B) => false 40 | 41 | < (küçüktür) ilk değer ikincisinden küçükse true, değilse false 42 | (A true 43 | 44 | >= (büyük eşitse) ilk değer ikincisinden büyük veya eşitse true,değilse false 45 | (A>B) => false 46 | 47 | <= (küçük eşitse) ilk değer ikincisinden küçük veya eşitse true,değilse false 48 | (A true 49 | */ 50 | 51 | /* 52 | Yukarıdaki operatörleri if koşullarını oluştururken kullanacağız. 53 | Bunlara ek olarak string karşılaştırmaları yapacağımız 54 | .equals methodu bulunmaktadır. 55 | */ 56 | 57 | String x = "IfElse"; 58 | String y = "Zeliha Oznuk"; 59 | 60 | if (x.equals(y)){ // //return false çünkü farklı stringler 61 | 62 | } 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 | 72 | 73 | 74 | 75 | 76 | } 77 | } 78 | -------------------------------------------------------------------------------- /src/_22_erisimBelirleyiciler/OzelArac.java: -------------------------------------------------------------------------------- 1 | package _22_erisimBelirleyiciler; 2 | 3 | public class OzelArac { 4 | 5 | private boolean camlarAcilabilir; 6 | private boolean kapilarAcilabilir; 7 | 8 | public OzelArac(){ 9 | motorDegerleriniKontrolEt(); 10 | } 11 | 12 | private void motorDegerleriniKontrolEt() { 13 | System.out.println("Arabanin motor degerlerinin kontrol edilmesi tamamlandi."); 14 | } 15 | 16 | protected boolean arabayiCalistir(){ 17 | System.out.println("Arabayi calistirmak icin tetikleme yapildi"); 18 | System.out.println("Araba basarili bir sekilde calisti"); 19 | 20 | return true; 21 | } 22 | 23 | public boolean isCamlarAcilabilir(){ 24 | return camlarAcilabilir; 25 | } 26 | 27 | protected void setCamlarAcilabilir(boolean camlarAcilabilir){ 28 | this.camlarAcilabilir = camlarAcilabilir; 29 | } 30 | 31 | public boolean isKapilarAcilabilir() { 32 | return kapilarAcilabilir; 33 | } 34 | 35 | protected void setKapilarAcilabilir(boolean kapilarAcilabilir){ 36 | this.kapilarAcilabilir =kapilarAcilabilir; 37 | } 38 | 39 | 40 | /* 41 | Bu sınıfta ne yaptığımı hemen anlatayım. Öncelikle camlarAcilabilir 42 | ve kapilarAcilabilir olarak iki tane boolean veri tipine sahip 43 | değişken tanımladım. Bu değişkenlere başka sınıflardan erişim 44 | olmasın diye erişim belirleyici olarak private tanımladım. 45 | 46 | Sadece OzelArac’ın kendisini ilgilendiren motorDegerleriniKontrolEt 47 | adında bir metot tanımladım ve bu metodun erişim belirleyicisini de 48 | private olarak tanımladım. Çünkü bunu OzelArac kendi içerisinde 49 | yapacak ve AracKullanicisi’na sadece bilgi verecek. 50 | Bu metodu constructor içerisinde tetikleyerek OzelArac nesnesi 51 | her oluştuğunda motor kontrollerinin yapılmasını sağladım. 52 | 53 | AracKullanicisi sınıfını OzelArac sınıfı ile aynı paket içinde 54 | oluşturacağım için , arabayiCalistir metodunun erişim belirleyicisini 55 | protected olarak belirledim. Ardından aynı mantıkla boolean 56 | veri tipine sahip değişkenlerimin değerlerini sadece 57 | AracKullanicisi değiştirebileceği için setter metotlarını 58 | protected tanımlarken getter metotlarına herkes erişebilsin 59 | diye public olarak tanımladım. 60 | */ 61 | } 62 | -------------------------------------------------------------------------------- /src/_22_erisimBelirleyiciler/Yolcu.java: -------------------------------------------------------------------------------- 1 | package _22_erisimBelirleyiciler; 2 | 3 | public class Yolcu { 4 | 5 | //Diğer sınıflardan erişilemeyecek sadece 6 | // bu sınıf içerisinden erişilebilen değişkenler. 7 | 8 | private String yolcuCamlariAcabilir = "Yolcu camlari acabilir"; 9 | 10 | private String yolcuCamlariAcamaz = "Yolcu camlari acamaz!"; 11 | 12 | private String yolcuKapilariAcabilir = "Yolcu kapilari acabilir"; 13 | 14 | private String yolcuKapilariAcamaz = "Yolcu kapilari acamaz!"; 15 | 16 | /** 17 | * Yolcunun yapabileceklerinin AracKullanicisi sınıfında belirlenen yapıya göre tanımlandığı 18 | * detayları yazdırır. 19 | */ 20 | 21 | public void yolcununYapabilecekleriniYazdir(OzelArac ozelArac){ 22 | 23 | if (ozelArac.isCamlarAcilabilir()){ 24 | System.out.println(yolcuCamlariAcabilir); 25 | }else { 26 | System.out.println(yolcuCamlariAcamaz); 27 | } 28 | 29 | if (ozelArac.isKapilarAcilabilir()){ 30 | System.out.println(yolcuKapilariAcabilir); 31 | }else { 32 | System.out.println(yolcuKapilariAcamaz); 33 | } 34 | } 35 | 36 | /** 37 | * yolcununYapabilecekleriniYazdir metodu ile aynı işlemi yapmakta olan bu metot 38 | * if-else kullanımının farklı bir versiyonudur. 39 | */ 40 | 41 | public void yolcununYapabilecekleriniYazdir1(OzelArac ozelArac){ 42 | System.out.println(ozelArac.isCamlarAcilabilir()?yolcuCamlariAcabilir:yolcuCamlariAcamaz); 43 | System.out.println(ozelArac.isKapilarAcilabilir() ? yolcuKapilariAcabilir : yolcuKapilariAcamaz); 44 | } 45 | 46 | } 47 | 48 | 49 | /* 50 | Burada ilk dikkat etmemiz gereken, OzelArac ve AracKullanicisi 51 | sınıflarının paketleri aynı iken Yolcu sınıfının paketi farklıdır. 52 | Bu sınıf içerisinde de diğer sınıfları ilgilendirmeyen yolcunun neler 53 | yapabileceği hakkında bilgi verecek değişkenler tanımladım. 54 | Bu değişkenlere getter ve setter yazmadım ve erişim belirleyici 55 | olarak private kullandım. Bu demek oluyor ki bu değişkenlere bu 56 | sınıf haricinde hiçbir sınıftan erişim sağlanamaz 57 | (okunamaz ve değiştirilemez). yolcununYapabilecekleriniYazdir 58 | metodunda erişim belirleyici olarak public kullandım çünkü 59 | AracKullanicisi sınıfı ile farklı paketlerde oldukları için 60 | AracKullanicisi sınıfından erişilebilmeli. 61 | */ 62 | -------------------------------------------------------------------------------- /src/_12_breakContinueDeyimleri/Break.java: -------------------------------------------------------------------------------- 1 | package _12_breakContinueDeyimleri; 2 | 3 | public class Break { 4 | public static void main(String[] args) { 5 | //break Komutu 6 | 7 | /* 8 | break continue deyimleri arasında break deyimi 9 | daha önceden anlattığımız for, while ve do-while 10 | döngüleriyle birlikte kullanılabilir. 11 | break deyimi döngülerden ansızın çıkmanızı ve döngüyü 12 | istediğiniz durumlarda sonlandırmanızı sağlamaktadır. 13 | Örneğin, bir veritabanından tüm id değerlerini çektiniz 14 | ve id değerlerinden ilk 15 tanesini listeleyeceksiniz. 15 | Eğer elinizde 15’ten fazla kayıt varsa döngüyü bir şekilde 16 | sonlandırmanız gerekmektedir. 17 | bu örneği bir de kod ile anlatalım; 18 | */ 19 | 20 | int veritabaniKayitSayisi = 35; 21 | 22 | for(int i=1; i= 0) { 63 | System.out.println(count + ". kayit"); 64 | if(count == 15) { 65 | break; 66 | } 67 | count++; 68 | veritabaniKayitSayisi2--; 69 | } 70 | 71 | /* 72 | Kullanım olarak hiç bir fark yok, döngü içinden ne zaman çıkmak 73 | istediğimize karar verdikten sonra bir if bloğu ile kolay bir 74 | şekilde döngüyü sonlandırabiliyoruz. 75 | */ 76 | 77 | 78 | 79 | 80 | 81 | 82 | } 83 | 84 | } 85 | -------------------------------------------------------------------------------- /src/_24_encapsulation/EncapsulationDemo2.java: -------------------------------------------------------------------------------- 1 | package _24_encapsulation; 2 | 3 | /** 4 | * Encapsulation kullanılarak oluşturulan bir değişken ve kullanımı 5 | **/ 6 | 7 | public class EncapsulationDemo2 { 8 | public static void main(String[] args) { 9 | 10 | encapsulationDemo ed = new encapsulationDemo(); 11 | ed.setAd("All is well"); 12 | System.out.println(ed.getAd()); 13 | 14 | } 15 | 16 | } 17 | 18 | class encapsulationDemo { 19 | private String ad; 20 | public void setAd(String ad) { 21 | this.ad = ad; 22 | } 23 | public String getAd() { 24 | return ad; 25 | } 26 | } 27 | 28 | /* 29 | İkinci örnekte rahatlıkla görebileceğiniz gibi ad değişkeni private 30 | olarak tanımlandığı için direk olarak değiştirilemez. 31 | Bunun yerine public erişim belirtecine sahip getter ve setter 32 | metotları aracılığı ile değiştirilip kullanılabilir. Bu da bizim 33 | veri güncellerken veya kullanırken yaşanabilecek karışıklıkların 34 | önüne geçmemizi sağlar. 35 | 36 | Bunların yanı sıra kullanıcıların ad değişkenine ait değeri 37 | değiştirmesini istemediğimiz takdirde, public void setAd(String ad) 38 | şeklinde tanımladığımız metodumuzun erişim belirtecini private 39 | olarak değiştirdiğimizde artık ad değişkeni kullanıcılar 40 | için sadece-okuma (read-only) yetkisine sahip oldukları 41 | bir değişken olacaktır. Bu şekilde erişim belirteçlerini 42 | değiştirerek sınıflar içerisinde değişkenlerimizi 43 | okuma-yazma (read-write), sadece okuma (read-only), 44 | sadece yazma (write-only) şeklinde yetkilendirebiliriz. 45 | 46 | Java Encapsulation ile yazılan kodların bakımı çok daha kolay 47 | hale gelecektir. Örnek vermek gerekirse bir class yazdınız. 48 | Sadece o class’ın içinde kullandığınız bir değişkeni ve ya 49 | metodu public yaptınız. Bu metoda ve ya değişkene başka 50 | class’lardan rahatça erişilecek. Bu class’ı tekrar 51 | güncellerken public metod ve değişkenimizi istediğimiz 52 | gibi değiştiremeyiz. Çünkü başka class’lardan bu değişkene 53 | ve ya metoda erişilmiş olabilir. Dolayısıyla en baştan 54 | kodumuzu yazarken Class’ın içindeki değişken ve ya metodumuzu 55 | private (Encapsulation yaparak) tutarak ilerleyen zamanlarda ki 56 | değişikliklerde daha rahat olalım. 57 | 58 | Sonuç 59 | 60 | ava Encapsulation yapısından faydalanılarak yazılan kodlar bakımı 61 | daha kolay, değiştirmeye ve geliştirmeye daha açık ve daha esnek 62 | hale gelmektedir. 63 | */ 64 | -------------------------------------------------------------------------------- /src/_27_exceptionHandling/UncheckedExceptions.java: -------------------------------------------------------------------------------- 1 | package _27_exceptionHandling; 2 | 3 | public class UncheckedExceptions { 4 | 5 | //Unchecked Exceptions 6 | 7 | /* 8 | Unchecked exception tipinde Runtime Exception Java’da yine kod geliştirme 9 | esnasında try-catch-finally bloğuyla yakalanabilir ve checked exception 10 | tipinde olduğu gibi istenildiği gibi işlem devam ettirilebilir. 11 | Fakat kodu geliştirme esnasında IDE yazılımcıyı uyarmaz. Yani orada bir 12 | hata olacağı geliştirme esnasında değil çalışma esnasında ortaya çıkar. 13 | Bir ArrayList nesnesi oluşturup içerisine 5 adet değer koyulduktan sonra, 14 | ArrayList nesnesi içinden 6. değer çağrıldığında, ExceptionHandling class'ında 15 | gördüğünüz (**) işaretli IndexOutBoundException sınıfından türetilmiş, 16 | ArrayIndexOutOfBoundException sınıfından hata fırlatılır. 17 | Elbette geliştirme esnasında buradaki ArrayList nesnesinden elemanın 18 | çekildiği satır try-catch bloğuyla kontrol edilebilir, fakat bunu 19 | geliştiricinin ön görmesi gerekmektedir. 20 | 21 | Bir diğer unchecked exception türü olan Error sınıfları ise kod geliştirme 22 | esnasında veya çalışma esnasında yazılımcının yakalayamacağı, problemin 23 | diğer Exception türlerine göre daha ciddi olduğu durumları yansıtmaktadır. 24 | Kodun çalışması esnasında Java virtual machine içinde uygulamanın 25 | çalıştırılması için ayrılmış bellek alanın dolması sonucu OutOfMemoryError 26 | fırlatılır. Bu hatayı kod içinden yakalamamız mümkün değildir. 27 | Önüne geçmek için çalışmalar yapabiliriz, mesela belliği kontrollü 28 | kullanırız veya uygulamayı ayağa kaldırırken bellek alanını genişletiriz 29 | fakat eğer bu hata alınmışsa uygulamanın kapanmaktan başka çaresi kalmamıştır. 30 | 31 | */ 32 | 33 | //ORNEK: 34 | 35 | public static void main(String[] args) { 36 | String name = null; 37 | 38 | //kotu yaklasim. 39 | 40 | try { 41 | if(name.equals("zeliha")) { 42 | System.out.println("name : zeliha"); 43 | } 44 | }catch(NullPointerException e) { 45 | System.out.println("catch!"); 46 | } 47 | 48 | // guzel bir yaklasim. 49 | 50 | if(name != null && name.equals("zeliha")) { 51 | System.out.println("name : zeliha"); 52 | } 53 | 54 | //En iyi yaklasim. 55 | if("zeliha".equals(name)) { 56 | System.out.println("name : zeliha"); 57 | } 58 | 59 | } 60 | 61 | 62 | 63 | 64 | } 65 | -------------------------------------------------------------------------------- /src/_02_javaStringVeriTipi/son.java: -------------------------------------------------------------------------------- 1 | package _02_javaStringVeriTipi; 2 | 3 | public class son { 4 | public static void main(String[] args) { 5 | 6 | String stringDeger = "Hello Java, Hello Word"; 7 | 8 | String[] stringDegerler = stringDeger.split(" "); 9 | 10 | System.out.println(stringDegerler[0]); //Hello 11 | System.out.println(stringDegerler[1]); //Java, 12 | System.out.println(stringDegerler[2]); //Hello 13 | System.out.println(stringDegerler[3]); //Word 14 | 15 | /* 16 | Yukarıda ki örnekte “Hello Java, Hello Word” metnini boşluk 17 | ” ” olan yerden iki ayrı string e bölerek split işlemi 18 | gerçekletirmiş oluyoruz. Bu özellikler günlük hayatta kod yazarken 19 | bir çok kez işinize yarayacaktır. Aşağıda ki methodlar burada 20 | örneklendirmediğimiz fakat String tipi ile en çok kullanılan 21 | methodlardan bazıları aşağıdaki gibidir; 22 | 23 | */ 24 | 25 | /* 26 | charAt(int index) String içerisinde belirtilen index 27 | değerindeki karakter değeri döner. 28 | lenght() String değerin uzunluğunu döner. 29 | substring(int beginIndex) Verilen beginIndex değerindeki 30 | indexten sonrasını döner. 31 | substring(int beginIndex, int endIndex) Verilen begin index ile endIndex 32 | değeri rasındaki bölümü döner. 33 | equals(Object another) Object olarak verilen değerin varolan 34 | değerle eşitliğini kontrol eder. 35 | true|false döner. 36 | isEmpty() String değer boş mu dolumu kontrolü 37 | yapar. true|false döner. 38 | concat(String str) String değerin sonuna farklı bir 39 | string değer eklemek için kullanılır. 40 | replace(char old, char new) String metin içerisinde belirtilen 41 | oldChar değerlerini newChar 42 | değeri ile değiştirir. 43 | */ 44 | 45 | /* 46 | Yukarıdaki methodlardan concat() string’leri birleştirmek için 47 | kullanılır, fakat string birleştirme yani bir stringin peşine 48 | başka bir string ekleme işlemini aşağıdaki şekildede yapabiliriz. 49 | */ 50 | 51 | String a ="Hello Java,"; 52 | String b ="Hello Word"; 53 | 54 | System.out.println(a+b); 55 | 56 | String c = a+b; 57 | System.out.println(c); 58 | 59 | System.out.println("Hello Java," + "Hello Word"); 60 | 61 | /* 62 | Hello 63 | Java, 64 | Hello 65 | Word 66 | Hello Java,Hello Word 67 | Hello Java,Hello Word 68 | Hello Java,Hello Word 69 | */ 70 | 71 | 72 | 73 | 74 | 75 | 76 | 77 | 78 | } 79 | } 80 | -------------------------------------------------------------------------------- /src/_25_abstraction/AbstractClassTeknikÖzellikleri.txt: -------------------------------------------------------------------------------- 1 | Abstract Class Teknik Özellikleri 2 | 3 | Abstract sınıfların teknik yapılarından bahsetmek gerekirse; 4 | 5 | 1- Java’da Abstract sınıflar “abstract class” anahtar kelimeleri ile oluşturulur. 6 | 7 | AbstractClassDemo.javaJava 8 | public abstract class AbstractClassDemo { 9 | } 10 | 11 | 12 | 2- Java’da bir sınıf abstract olarak tanımlandıysa, abstract bir metot içerir 13 | veya içermez. 14 | 15 | AbtractClassDemo.javaJava 16 | public abstract class AbstractClassDemo { 17 | 18 | public abstract int calculateSum(int a, int b); 19 | 20 | public double calculateDivide(int a, int b) { 21 | double result = a/b; 22 | System.out.println("Result: " + result); 23 | return result; 24 | } 25 | } 26 | 27 | 28 | 3- Java’da bir sınıf içerisinde abstract metot varsa o sınıf abstract sınıf 29 | olmak zorundadır. 30 | 31 | 4- Java’da tanımlanan abstract metotların gövdeleri olamaz 32 | (Gövdeden kasıt içinde işlem yapacak kodlar olmak zorundadır). 33 | 34 | 5- Java’da tanımlanan abstract sınıfların içerisindeki abstract olmayan 35 | metotların gövdeleri olmalıdır. 36 | 37 | 6- Java’da tanımlanan bir sınıf abstract bir sınıf tarafından genişletilirse 38 | (extend edilirse) abstract sınıfın tüm abstract metotlarını implement 39 | etmek yani kendi bünyesinde bu metotlara gövde oluşturmak zorundadır. 40 | Eğer bu metotlara sınıf içerisinde gövde yazılmayacaksa tanımlanan 41 | sınıfın yapısı abstract class olarak tanımlanmalıdır. 42 | 43 | AbstractClassDemo1.javaJava 44 | public class AbstractClassDemo1 extends AbstractClassDemo{ 45 | @Override 46 | public int calculateSum(int a, int b) { 47 | return 0; 48 | } 49 | } 50 | 51 | 52 | AbstractClassDemo1.javaJava 53 | public abstract class AbstractClassDemo1 extends AbstractClassDemo{ 54 | } 55 | 56 | 57 | Yukarıdaki iki kod örneği 49. madde de bahsedilen yapıya göre tanımlanmıştır 58 | ve hata vermezler. 59 | 60 | Sonuç 61 | Java Nesne Yönelimli Programlamanın önemli paydaşlarından biri olan 62 | Abstraction ile esnek ve rahatlıkla değiştirilebilir kodlar yazılabilir. 63 | Kod tekrarlarının önüne geçileceği için için ve her sınıfa özelleştirilmiş 64 | metotlar oluşturulabileceği için bakım kolay projeler ortaya çıkacaktır. 65 | 66 | Ayrıca biz 10’larca farklı class’ı tek bir abstract class’dan extend 67 | edebiliriz. Böylelikle şunu biliyoruz ki bu 10 farklı class içinde aynı 68 | method (yukarıdaki örnekte calculateSalary methodu ) override edildi ve 69 | biz bu methodu çağırabiliriz. Böylelikle Abstraction bize Object Orianted’ın 70 | olmazsa olmazı Polymorphism’i sağlamış oldu. -------------------------------------------------------------------------------- /out/production/javaKonuTekrari/_25_abstraction/AbstractClassTeknikÖzellikleri.txt: -------------------------------------------------------------------------------- 1 | Abstract Class Teknik Özellikleri 2 | 3 | Abstract sınıfların teknik yapılarından bahsetmek gerekirse; 4 | 5 | 1- Java’da Abstract sınıflar “abstract class” anahtar kelimeleri ile oluşturulur. 6 | 7 | AbstractClassDemo.javaJava 8 | public abstract class AbstractClassDemo { 9 | } 10 | 11 | 12 | 2- Java’da bir sınıf abstract olarak tanımlandıysa, abstract bir metot içerir 13 | veya içermez. 14 | 15 | AbtractClassDemo.javaJava 16 | public abstract class AbstractClassDemo { 17 | 18 | public abstract int calculateSum(int a, int b); 19 | 20 | public double calculateDivide(int a, int b) { 21 | double result = a/b; 22 | System.out.println("Result: " + result); 23 | return result; 24 | } 25 | } 26 | 27 | 28 | 3- Java’da bir sınıf içerisinde abstract metot varsa o sınıf abstract sınıf 29 | olmak zorundadır. 30 | 31 | 4- Java’da tanımlanan abstract metotların gövdeleri olamaz 32 | (Gövdeden kasıt içinde işlem yapacak kodlar olmak zorundadır). 33 | 34 | 5- Java’da tanımlanan abstract sınıfların içerisindeki abstract olmayan 35 | metotların gövdeleri olmalıdır. 36 | 37 | 6- Java’da tanımlanan bir sınıf abstract bir sınıf tarafından genişletilirse 38 | (extend edilirse) abstract sınıfın tüm abstract metotlarını implement 39 | etmek yani kendi bünyesinde bu metotlara gövde oluşturmak zorundadır. 40 | Eğer bu metotlara sınıf içerisinde gövde yazılmayacaksa tanımlanan 41 | sınıfın yapısı abstract class olarak tanımlanmalıdır. 42 | 43 | AbstractClassDemo1.javaJava 44 | public class AbstractClassDemo1 extends AbstractClassDemo{ 45 | @Override 46 | public int calculateSum(int a, int b) { 47 | return 0; 48 | } 49 | } 50 | 51 | 52 | AbstractClassDemo1.javaJava 53 | public abstract class AbstractClassDemo1 extends AbstractClassDemo{ 54 | } 55 | 56 | 57 | Yukarıdaki iki kod örneği 49. madde de bahsedilen yapıya göre tanımlanmıştır 58 | ve hata vermezler. 59 | 60 | Sonuç 61 | Java Nesne Yönelimli Programlamanın önemli paydaşlarından biri olan 62 | Abstraction ile esnek ve rahatlıkla değiştirilebilir kodlar yazılabilir. 63 | Kod tekrarlarının önüne geçileceği için için ve her sınıfa özelleştirilmiş 64 | metotlar oluşturulabileceği için bakım kolay projeler ortaya çıkacaktır. 65 | 66 | Ayrıca biz 10’larca farklı class’ı tek bir abstract class’dan extend 67 | edebiliriz. Böylelikle şunu biliyoruz ki bu 10 farklı class içinde aynı 68 | method (yukarıdaki örnekte calculateSalary methodu ) override edildi ve 69 | biz bu methodu çağırabiliriz. Böylelikle Abstraction bize Object Orianted’ın 70 | olmazsa olmazı Polymorphism’i sağlamış oldu. -------------------------------------------------------------------------------- /src/_03_ifElseKosulYapisi/ifElseOrnek.java: -------------------------------------------------------------------------------- 1 | package _03_ifElseKosulYapisi; 2 | 3 | public class ifElseOrnek { 4 | public static void main(String[] args) { 5 | 6 | //Kosul saglayan durum 7 | 8 | int x = 3; 9 | 10 | if (x>0){ 11 | int z = x*5; 12 | System.out.println("z degeri : " + z); //z degeri : 15 13 | } 14 | 15 | //Kosul saglamayan durum 16 | 17 | int xx = 0; 18 | 19 | if (xx>0){ 20 | int yy = xx*5; 21 | System.out.println("yy degeri : " + yy); ////Herhangi konsol çıktısı olmuyacaktır. 22 | } 23 | 24 | /* 25 | 26 | Yukarıda gördüğünüz gibi x’imiz 0 olduğu için x>0 koşulu false dönecektir. 27 | Yani if bloğundaki kodun çalışabilmesi için if koşulunun true olması gerekmektedir. 28 | Aslında if(true) ise if bloğundaki kodlar çalışır. 29 | 30 | Peki diyelim ki if koşulu sağlanamazsada başka bir kod bloğu çalıştırmak istiyorsak, 31 | yani yukarıdaki örnekten yola çıkarak x’imiz 0 dan büyük değilse başka bir işlem yaptırmak 32 | istiyorsak, bu durumda else bloğu çalışacaktır. Zaten yapı genel olarak if-else olarak kullanılır. 33 | Yani koşul sağlanırsa if bloğu içindeki kodlar çalışır, sağlanmazsa else bloğu içindeki kodlar çalışır. 34 | 35 | Yukarıda if else yapısının dışında birden çok kontrol sağlayacağımız 36 | if – else if – else yapımızda bulunmaktadır. Onuda aşağıdaki kod ile 37 | anlatmaya çalışacağım. 38 | 39 | 40 | */ 41 | 42 | int a = 55; 43 | 44 | if (x>90){ 45 | System.out.println("a 90'dan buyuktur"); 46 | }else if (a>=80){ 47 | System.out.println("a 90 ile 80 arasında"); 48 | }else if (a>=70){ 49 | System.out.println("a 80 ile 70 arasında"); 50 | }else if (a>=60){ 51 | System.out.println("a 70 ile 60 arasında"); 52 | }else if (a>=50){ 53 | System.out.println("a 60 ile 50 arasında"); 54 | }else if (a>=40){ 55 | System.out.println("a 50 ile 40 arasında"); 56 | }else if (a>=30){ 57 | System.out.println("a 40 ile 30 arasında"); 58 | }else if (a>=20){ 59 | System.out.println("a 30 ile 20 arasında"); 60 | }else if (a>=10){ 61 | System.out.println("a 20 ile 10 arasında"); 62 | }else if (a>=0){ 63 | System.out.println("a 10 ile 0 arasında"); 64 | }else { 65 | System.out.println("a 0'dan kucuktur"); 66 | } 67 | 68 | //Output : a 60 ile 50 aras�nda 69 | 70 | 71 | 72 | 73 | 74 | 75 | 76 | 77 | } 78 | } 79 | -------------------------------------------------------------------------------- /src/_17_dizilerdeArama_ArraySearch/BinarySearch.java: -------------------------------------------------------------------------------- 1 | package _17_dizilerdeArama_ArraySearch; 2 | 3 | public class BinarySearch { 4 | public static void main(String[] args) { 5 | 6 | //2- Binary Search 7 | 8 | /* 9 | Sıralı olan büyük dizilerde Binary Search yapmak daha etkili 10 | bir yöntemdir. Binary Search için dizimiz sıralı olmak zorundadır. 11 | 12 | Binary Search çalışma mantığını kısaca anlatmaya çalışayım. 13 | Öncelikle dizinin ortanca elementinin değeri alınır. 14 | Dizimiz sıralı olduğu için ortanca değer , aranan değerden büyük mü , 15 | küçük mü ve ya eşit mi diye bakılır. Eğer ortanca değer aranan 16 | değerden büyükse dizinin ortanca değerden sonraki değerlerine 17 | artık bakılmaz. Çünkü değerimiz başlangıç değeri ile ortanca 18 | değer arasındadır. Tam tersi olarak ortanca değer aranan 19 | değerden küçük ise dizinin ortanca değerinden önceki değerlerine 20 | bakılmaz. Bu işlem ortanca değer aranan değere eşit olana kadar 21 | devam eder. 22 | 23 | Kod üzerinden anlatım yapacağım. 24 | 25 | */ 26 | 27 | int[] liste = {2, 4, 7, 10, 11, 45, 50, 52, 59, 60, 66, 69, 70, 79}; //Arrayimizi Sıralı biçimde oluşturduk 28 | 29 | int sayiIndex = binarySearchh(liste,52); //binarySearch methoduna dizimizi ve aradığımız sayıyı gönderiyoruz 30 | if (sayiIndex != -1){//method -1 dönmediyse sayı bulunmuştur 31 | System.out.println("Aranan sayinin index'i :" +sayiIndex); 32 | }else {//-1 döndüğünde -1 dönecek ve else düşecek 33 | System.out.println("Aranan sayi bulunamadi."); 34 | } 35 | 36 | 37 | } 38 | 39 | private static int binarySearchh(int[] liste, int key) { 40 | int baslangic = 0;//dizinin başlangıç index'i 41 | int son = liste.length-1;//dizinin bitiş index'i 42 | int orta;//dizinin ortanca index'i 43 | 44 | while (baslangic<=son){//baslangic sondan büyük olana kadar devam edecek , zaten başlangıç değeri sondan büyğk olursa aradığımız eleman dizide yok demektir 45 | orta = (int) (baslangic+son)/2; //her seferinde ortanca değer bulunucak 46 | if (liste[orta]>key){//ortanca değer aranan değerden büyükse array ikiye bölünecek 47 | son = orta-1;//son değer, ortanca değerden 1 önceki değer olacak 48 | 49 | }else if (liste[orta]==key){//aranan bulundu 50 | return orta;//indexi dön 51 | }else {//ortanca değer aranan değerden küçükse 52 | baslangic =orta+1;//baslangıç değeri, ortanca değerden 1 sonraki değer olacak 53 | } 54 | } 55 | return -1;//sonuç bulunamazsa -1 dönecek 56 | } 57 | } 58 | -------------------------------------------------------------------------------- /src/_31_collections/CreateCode.java: -------------------------------------------------------------------------------- 1 | package _31_collections; 2 | 3 | import java.util.ArrayList; 4 | import java.util.Random; 5 | 6 | public class CreateCode { 7 | 8 | //text.text File kisminda acıklamasi bulunuyor 9 | 10 | Random random = new Random(); // Random değerlere ulaşmak için gerekli işlem. 11 | ArrayList lisenceKey = new ArrayList(); // Non-Generic --> Sonraki konularda generic kavramını işleyeceğiz. 12 | // Değişkenler: 13 | String lisenceCode; 14 | int randomValue; 15 | public String newCode(){ 16 | lisenceCode=""; // Her işlem başladığında değişkenin temizlenmesini istiyorum. 17 | for(int i=0;i<16;i++){ 18 | if(i==0 || i==4 || i==8 || i==12){ // Oluşturulan anahtarın her zaman ilk harflerinin bir metin olmasını istediğimden sorgulama yaptırıyorum. 19 | randomValue = random.nextInt(26)+65; 20 | if(lisenceKey.contains((char)randomValue) == true) // ArrayList üzerinde atanan değerin olup olmadığını kontrol ediyor. 21 | randomValue = random.nextInt(20)+71; 22 | if(lisenceKey.contains((char)randomValue)==true) // Contains bir Collection metodudur. 23 | randomValue = random.nextInt(25)+66; 24 | lisenceKey.add((char)randomValue); 25 | } 26 | else{ 27 | randomValue = random.nextInt(25); 28 | if(randomValue < 10){ 29 | if(lisenceKey.contains(randomValue) == true) 30 | randomValue = random.nextInt(10); 31 | lisenceKey.add(randomValue); 32 | } 33 | else if(randomValue>10 && randomValue<35){ 34 | randomValue = random.nextInt(15)+76; 35 | if(lisenceKey.contains((char)randomValue)==true) 36 | randomValue = random.nextInt(26)+65; 37 | lisenceKey.add((char)randomValue); 38 | } 39 | else { 40 | randomValue = random.nextInt(20)+71; 41 | if(lisenceKey.contains((char)randomValue)==true){ 42 | randomValue = random.nextInt(10); 43 | lisenceKey.add(randomValue); 44 | } 45 | else 46 | lisenceKey.add((char)randomValue); 47 | } 48 | } 49 | } 50 | int sp=0; 51 | for(var a : lisenceKey){ 52 | lisenceCode += a; 53 | if(sp==3 || sp==7 || sp==11) 54 | lisenceCode += " - "; 55 | sp++; 56 | } 57 | lisenceKey.clear(); // Değişkene atama gerçekleştirdikten sonra diziyi temizliyorum bir sonraki oluşturma için. 58 | return lisenceCode; 59 | } 60 | } 61 | -------------------------------------------------------------------------------- /src/_10_doWhileDongusu/DoWhileDongusu.java: -------------------------------------------------------------------------------- 1 | package _10_doWhileDongusu; 2 | 3 | public class DoWhileDongusu { 4 | public static void main(String[] args) { 5 | 6 | /* 7 | Burada bahsetmemiz gereken ilk konu herkesin kafasında soru işareti 8 | olarak beliren, do while döngüsü ile while döngüsü arasındaki fark nedir? 9 | 10 | Bu sorunun en basit cevabı, while döngüsü ne verilen ifade doğru değil 11 | ise kod while döngüsü içerisine hiç girmeden sonraki satır 12 | ile işlemlere devam eder, do while döngüsü nde ise ifadenin 13 | doğru olup olmamasına bakmaksızın döngü bir sefer çalışır. 14 | Dilerseniz bu yapıyı daha iyi anlayabilmeniz için örnekle anlatalım; 15 | */ 16 | 17 | int count = 1; 18 | while(count < 11) { 19 | System.out.println("Count is: " + count); 20 | count++; 21 | } 22 | 23 | int doCount = 1; 24 | do{ 25 | System.out.println("DoCount is: " + doCount); 26 | doCount++; 27 | } while(doCount < 11); 28 | 29 | /* 30 | yukarıda görmüş olduğunuz while döngüsüne ve do while döngüsüne ait 31 | konsol çıktıları aynı olacaktır. 32 | */ 33 | 34 | /* 35 | Count is: 1 36 | Count is: 2 37 | Count is: 3 38 | Count is: 4 39 | Count is: 5 40 | Count is: 6 41 | Count is: 7 42 | Count is: 8 43 | Count is: 9 44 | Count is: 10 45 | DoCount is: 1 46 | DoCount is: 2 47 | DoCount is: 3 48 | DoCount is: 4 49 | DoCount is: 5 50 | DoCount is: 6 51 | DoCount is: 7 52 | DoCount is: 8 53 | DoCount is: 9 54 | DoCount is: 10 55 | */ 56 | 57 | /* 58 | Burada while döngüsü önce döngüye girip sonra yazarken 59 | do while döngüsünde önce yazıp sonraya döngüye girilmektedir. 60 | Bunu şu şekilde bir örnek ile daha iyi pekiştirebiliriz; 61 | */ 62 | 63 | System.out.println("****************************"); 64 | 65 | int count2 = 11; 66 | while(count < 11) { 67 | System.out.println("Count2 is: " + count2); 68 | count2++; 69 | } 70 | 71 | int doCount2 = 11; 72 | do{ 73 | System.out.println("DoCount2 is: " + doCount2); 74 | doCount2++; 75 | } while(doCount2 < 11); 76 | 77 | /* 78 | Bu adımda sadece count ve doCount değişken değerlerini 79 | 11 olarak değiştirdik. Bu kodu çalıştırdığımızda konsol çıktısı 80 | aşağıdaki gibi olacaktır. 81 | */ 82 | 83 | //OUTPUT : DoCount2 is: 11 84 | 85 | //do while döngüsünü bir kodun kesin bir kez çalışması gerektiği yerlerde kullanılabilir. 86 | 87 | 88 | 89 | 90 | 91 | 92 | 93 | 94 | 95 | 96 | 97 | 98 | 99 | 100 | } 101 | } 102 | -------------------------------------------------------------------------------- /src/_26_polymorphism/_4_subtype.java: -------------------------------------------------------------------------------- 1 | package _26_polymorphism; 2 | 3 | public class _4_subtype { 4 | 5 | /* 6 | Java Polymorphism ile ilgili araştırma yaptığınızda bir çok yerde 7 | rastlayacağınız genel Polymorphism tanımı aslında subtype 8 | yapısının tanımıdır. Java’da subclass’lar (altsınıflar) 9 | superclass’ların onlara miras bıraktıkları değişkenleri ve metotları 10 | değiştirebilirler. Aynı zamanda değiştirmek istemedikleri metotları 11 | aynı şekilde kullanmaya devam edebilirler. 12 | 13 | Aşağıdaki örnek Employee sınıfı Inheritance konusunda verilen 14 | Employee sınıfıyla birbir aynıdır. 15 | */ 16 | 17 | public class Employee extends Person { 18 | 19 | private String jobtitle; 20 | 21 | public String getJobtitle() { 22 | return jobtitle; 23 | } 24 | 25 | public void setJobtitle(String jobtitle) { 26 | this.jobtitle = jobtitle; 27 | } 28 | } 29 | 30 | /* 31 | Employee sınıfını miras alacak yeni sınıfta kullanılacak jobTitle 32 | değişkenlerinin hepsinin başında Senior olsun. Konu göz önünde 33 | bulundurularak geliştirme yapıldığında aşağıdaki gibi bir sınıf 34 | ortaya çıkacaktır. 35 | */ 36 | 37 | 38 | 39 | 40 | public class Employeee extends Person {//aynı isim hata vermesin diye Employeee 41 | //yazıldı yoksa Employee olası gerekiyor 42 | 43 | private String jobtitle; 44 | 45 | public String getJobtitle() { 46 | return jobtitle; 47 | } 48 | 49 | public void setJobtitle(String jobtitle) { 50 | this.jobtitle = jobtitle; 51 | } 52 | } 53 | 54 | /* 55 | Employee sınıfını miras alacak yeni sınıfta kullanılacak jobTitle 56 | değişkenlerinin hepsinin başında Senior olsun. Konu göz önünde 57 | bulundurularak geliştirme yapıldığında aşağıdaki gibi bir sınıf 58 | ortaya çıkacaktır. 59 | */ 60 | 61 | public class PolymorphismEmployee extends Employee { 62 | @Override 63 | public String getJobtitle() { 64 | return "Senior " + super.getJobtitle(); 65 | } 66 | } 67 | 68 | /* 69 | Bu değişiklikten sonra PolymorphismEmployee sınıfından alınacak 70 | her jobTitle değişkeninin başında Senior javacaktır. Bu şekilde 71 | çalışma anında PolymorphismEmployee sınıfı Employee sınıfının 72 | getJobTitle() metodunu Override ederek değiştirmiştir. 73 | 74 | 75 | 76 | */ 77 | 78 | /* 79 | SONUC: 80 | Java Nesne Yönelimli Programlama mantığı içerisinde 81 | Polymorphism geni kapsamlı bir yapıya sahiptir. Geliştirme 82 | esnasında bir çok kolaylık sağlar. Java’da nesne yönelimli 83 | programlama yapısına dikkat edilerek geliştirilen projelerde 84 | büyük bir yer tutar. Kodun daha okunabilir, kolay değiştirilebilir 85 | olmasına büyük katkı sağlar. 86 | */ 87 | 88 | 89 | 90 | } 91 | -------------------------------------------------------------------------------- /src/_09_whileDongusu/whileDongusu.java: -------------------------------------------------------------------------------- 1 | package _09_whileDongusu; 2 | 3 | public class whileDongusu { 4 | public static void main(String[] args) { 5 | 6 | /* 7 | Kod yazarken bazı satırları birden fazla defa çalıştırmamız gerekebilir. 8 | Çok basit bir örnekle “Merhaba Robot Ron Grubu :)” yazısını konsola 10 defa 9 | alt alta yazdırmamız gerekti. 10 | Bunu aşağıdaki gibi yapabiliriz. 11 | */ 12 | 13 | System.out.println("Merhaba Robot Ron Grubu :)"); 14 | System.out.println("Merhaba Robot Ron Grubu :)"); 15 | System.out.println("Merhaba Robot Ron Grubu :)"); 16 | System.out.println("Merhaba Robot Ron Grubu :)"); 17 | System.out.println("Merhaba Robot Ron Grubu :)"); 18 | System.out.println("Merhaba Robot Ron Grubu :)"); 19 | System.out.println("Merhaba Robot Ron Grubu :)"); 20 | System.out.println("Merhaba Robot Ron Grubu :)"); 21 | System.out.println("Merhaba Robot Ron Grubu :)"); 22 | System.out.println("Merhaba Robot Ron Grubu :)"); 23 | 24 | /* 25 | 10 tane yazdırmak için yukarıdaki kod kullanılabilinir, 26 | ancak düşünün ki 500 adet istendi veya her hangi bir koşula 27 | bağlanması istendi. İşte bu durumlarda Java bize çok kullanışlı 28 | bir yapı olan döngü yapısını sunmaktadır. 3 adet döngü çeşidi vardır. 29 | While döngüsü, do-while döngüsü ve for döngüsü. 30 | Biz bu dersimizde While döngüsünü anlatacağız. 31 | İlerleyen derslerde ise diğer döngüleri anlatmaya devam edeceğiz. 32 | While döngüsüne başlamadan önce şunu belirtmek isterim. 33 | Bu 3 döngü arasında en çok kullanılan döngü çeşidinin 34 | for döngüsü olduğunu belirttikten sonra artık gelelim 35 | While döngüsü kullanımına. 36 | 37 | Yukarıda “Merhaba Robot Ron Grubu :)” yazısını konsola 38 | 10 defa alt alta yazdırmak için aynı kodu 10 defa alt alta yazdık. 39 | Bunu while döngüsü ile aşağıdaki şekilde yapabiliriz. 40 | */ 41 | 42 | int i =0; 43 | 44 | while (i<10){ //i 10 dan küçük olduğu müddetçe true dönecektir ve while kod bloğuna girecektir 45 | System.out.println("Merhaba Robot Ron Grubu :)"); 46 | i++; //her seferinde i'yi 1 arttırır 47 | } 48 | 49 | /* 50 | Yukarıda görüldüğü gibi 10 defa alt alta yazmaktansa while döngüsü 51 | kullanarak bu işlemi kolaylaştırdık. While içine yazılan koşul 52 | true oldukça program while kod bloğuna girecek ve işlemleri yapacaktır. 53 | Eğer while içine while(true) şeklinde yaparsak burada sonsuz 54 | döngüye girecektir ve sürekli while bloğu çalışacaktır. 55 | (break ve continue ifadeleri ile döngüden çıkmak mümkün ilerleyen 56 | derslerimizde anlatacağız). 57 | */ 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | } 67 | } 68 | -------------------------------------------------------------------------------- /src/_18_dizilerdeSiralama_ArraySort/SelectionSort.java: -------------------------------------------------------------------------------- 1 | package _18_dizilerdeSiralama_ArraySort; 2 | 3 | import java.util.Arrays; 4 | 5 | public class SelectionSort { 6 | public static void main(String[] args) { 7 | 8 | //Selection Sort 9 | 10 | /* 11 | Öncelikle Seçmeli Sıralama’nın mantığını anlatmaya çalışacağım, 12 | sonrasında ise bir örnekle devam edeceğim. Seçmeli sıralamada, 13 | sırası ile tüm elemanlar ele alınıp, dizinin sonuna kadar 14 | o elemandan küçük eleman olup olmadığı kontrol edilir ve 15 | en küçük eleman bulunup eldeki sayı ile değiştirilir. 16 | 17 | Daha açık anlatmak gerekirse , listenin 1. elemanın değeri alınır 18 | ve dizinin sonuna kadar tüm elemanlar kontrol edilir en 19 | küçük eleman bulunur ve 1. sıradaki eleman ile yer değiştirilir. 20 | Artık en küçük eleman 1. sırada yer almaktadır. 1. sıradaki 21 | elemanı tekrardan kontrol etmek gerekmediği için 2.sıradaki 22 | elemana geçilir ve aynı işlem tekrarlanarak 23 | son elemana kadar gidilir. 24 | 25 | Kendi oluşturmuş olduğum liste’yi nasıl selection sort ile 26 | listelediğimi de paylaşayım. 27 | 28 | Kod üzerinde açıklama yapmaya çalıştım. 29 | */ 30 | 31 | int[] liste = {1, 4, 99, 2, 5, -3, 6, 2,-49,52};//Dizi'mizi oluşturuyoruz 32 | 33 | for (int i = 0; i < liste.length-1; i++) { //Dizimizin değerlerini sırası ile alıyoruz 34 | 35 | int sayi = liste[i]; //sıradaki değeri sayi değişkenine atıyoruz 36 | int temp = i; //sayi 'nin indeksini temp değerine atıyoruz 37 | 38 | for (int j = i+1; j < liste.length ; j++) { //dizimizde i' den sonraki elemanlara bakıyoruz 39 | if(liste[j] max){ //max sayıdan büyük ise 68 | max = sayi2; //max sayı değiştiriliyor 69 | } 70 | } 71 | System.out.println("En buyuk sayi : "+max); //En buyuk sayi : 995 72 | 73 | 74 | 75 | 76 | 77 | 78 | 79 | 80 | 81 | 82 | 83 | 84 | } 85 | } 86 | -------------------------------------------------------------------------------- /src/_20_MultidimensionalArrays_cokBoyutluDiziler/MultidimensionalArrays.java: -------------------------------------------------------------------------------- 1 | package _20_MultidimensionalArrays_cokBoyutluDiziler; 2 | 3 | public class MultidimensionalArrays { 4 | 5 | /* 6 | Tek boyutlu diziler tek bir sütunda verileri tutmaktadır. 7 | Çok boyutlu diziler ise birden fazla sütunda verileri tutmaktadır. 8 | Bu şekilde tanımlanan array tiplerinde daha çok matriksler 9 | veya tablo yapıları tutulmaktadır. Genel olarak çok boyutlu 10 | diziler aşağıdaki şekilde tanımlanmaktadır. 11 | */ 12 | 13 | /* 14 | DegiskenTipi[][] degiskenAdi; 15 | 16 | DegiskenTipi degiskenAdi[][]; //geçerli fakat tercih edilmeyen kullanım. 17 | */ 18 | 19 | /* 20 | Yukarıdaki koddan da göreceğiniz gibi iki şekildede tanılama 21 | yapmak mümkün, ikinci satırdaki tanımlama kodu okurken karmaşıklığa 22 | sebebiyet vermesinden dolayı kullanımı tavsiye edilmemektedir. 23 | Genel tanımlamalar yapının nasıl kurulacağıyla ilgili 24 | bilgi vermektedir. Şimdi ise aşağıda Java değişken tipleri 25 | ile nasıl çok boyutlu diziler tanımlanacağına bakalım; 26 | */ 27 | 28 | 29 | int[][] matriks; 30 | String[][] tablo; 31 | double[][] degerler; 32 | 33 | /* 34 | Yukarıdaki şekilde java değişlen tipinde çok boyutlu diziler 35 | tanımlanabilir. Tanımladığımız çok boyutlu diziler içersine 36 | farklı şekillerde değer atayabiliriz. 37 | Şöyle ki; 38 | */ 39 | 40 | private void multidimensionalArrayTest() { 41 | String[][] robotRon = { 42 | {"Ismail","Lale" }, 43 | {"Deniz","Zeliha"}, 44 | {"Sumeyye","Fatma Nur"}, 45 | {"Yasemen","Feyza"}, 46 | {"Emsal","Enes"}, 47 | }; 48 | 49 | stringArrayPrinter(robotRon); 50 | 51 | String[][] robotRonGrubu = new String[6][2]; 52 | robotRonGrubu[0][0] ="Ismail"; 53 | robotRonGrubu[0][1] ="Lale"; 54 | robotRonGrubu[1][0] ="Deniz"; 55 | robotRonGrubu[1][1] ="Zeliha"; 56 | robotRonGrubu[2][0] ="Sumeyye"; 57 | robotRonGrubu[2][1] ="Fatma Nur"; 58 | robotRonGrubu[3][0] ="Yasemen"; 59 | robotRonGrubu[3][1] ="Feyza"; 60 | robotRonGrubu[4][0] ="Emsal"; 61 | robotRonGrubu[4][1] ="Enes"; 62 | 63 | stringArrayPrinter(robotRonGrubu); 64 | 65 | } 66 | 67 | private void stringArrayPrinter(String[][] strArray) { 68 | 69 | int rowSize = strArray.length; 70 | for (int i = 0; i < rowSize; i++) { 71 | int columnSize = strArray[i].length; 72 | for (int j = 0; j < columnSize; j++) { 73 | System.out.println(strArray[i][j]+" "); 74 | } 75 | System.out.println(); 76 | } 77 | System.out.println("---------------------------------"); 78 | 79 | } 80 | 81 | /* 82 | Yukarıdaki örnekte “robotRon” ve “robotRonGrubu” 83 | değişkenleri farklı yöntemlerle tanımlanmış olsa da aynı verileri 84 | içermektedir. Metotları örnek bir sınıf içerisinde çalıştırdığımızda 85 | çıktılarının aynı olduğunu görebiliriz. Bu örnekte String veri tipinde 86 | çok boyutlu dizi oluşturduk, bir sonraki örnekte int veri tipinde 87 | çok boyutlu dizi oluşturarak devam edeceğiz. 88 | */ 89 | 90 | 91 | } 92 | -------------------------------------------------------------------------------- /src/_05_switchCase/SwitchCase.java: -------------------------------------------------------------------------------- 1 | package _05_switchCase; 2 | 3 | public class SwitchCase { 4 | public static void main(String[] args) { 5 | 6 | /* 7 | Başlangıç olarak yazacağımız uygulamada hangi ayın hangi 8 | sayıya denk geldiğini switch-case yapısıyla belirtip, 9 | seçilen ayın ismini yazdıracağız. 10 | */ 11 | 12 | //Secilen ay degeri 13 | int ayDegeri = 7; 14 | 15 | //Yazdirilacak ay degeri 16 | String ayDegeriStr =null; 17 | 18 | //switch-case ile hangi aynı hangi sayıya denk geldiginin belirtildigi bolum 19 | switch (ayDegeri){ 20 | case 1: 21 | ayDegeriStr = "Ocak"; 22 | break; 23 | case 2: 24 | ayDegeriStr = "Şubat"; 25 | break; 26 | case 3: 27 | ayDegeriStr = "Mart"; 28 | break; 29 | case 4: 30 | ayDegeriStr = "Nisan"; 31 | break; 32 | case 5: 33 | ayDegeriStr = "Mayıs"; 34 | break; 35 | case 6: 36 | ayDegeriStr = "Haziran"; 37 | break; 38 | case 7: 39 | ayDegeriStr = "Temmuz"; 40 | break; 41 | case 8: 42 | ayDegeriStr = "Ağustos"; 43 | break; 44 | case 9: 45 | ayDegeriStr = "Eylül"; 46 | break; 47 | case 10: 48 | ayDegeriStr = "Ekim"; 49 | break; 50 | case 11: 51 | ayDegeriStr = "Kasım"; 52 | break; 53 | case 12: 54 | ayDegeriStr = "Aralık"; 55 | break; 56 | default: 57 | break; 58 | 59 | } 60 | //Konsol ekranina secilen ayin yazdirildigi bolum 61 | System.out.println("Secilen ay degeri : " + ayDegeriStr); //Secilen ay degeri : Temmuz 62 | 63 | /* 64 | Yukarıda ki örnek kodda case içerisinde ayDegeriStr değişkenine 65 | hangi ay ise o ayın değeri atanmıştır ve ardından break; 66 | komutuyla case içerisinden çıkılmıştır. break konusuna şimdilik 67 | çok fazla takılmıyoruz, bu konuyla ilgili ayrıca bir dersimiz olacaktır. 68 | Kısaca bahsetmek gerekirse, case değeri içerisine girildikten sonra 69 | diğer case değerlerini kontrol etmemesi için break ile case‘den çıkılıyor. 70 | 71 | Yazmış olduğumuz kodun en üstünde ayDegeri olarak bir int değişken 72 | tanımladık ve bu değişkene 7 değerini atadık, geliştireceğiniz kodlarda 73 | bu kısım genellikle dışarıdan gelecek veya bir kullanıcı tarafından 74 | girilecektir. Bu şekilde hardcode tanımlamalar yani kodun içerisine 75 | gömülmüş değer tanımalaları genellikle örneklerde yapılır. 76 | Atadığımız bu değeri 1 ile 12 arasında istediğiniz bir değer aralığında 77 | verebilirsiniz. Bu değerler haricinde bir değer atadığınızda, 78 | 79 | 80 | default: 81 | break; 82 | 83 | bölümüne girecek ve ayDegeriStr degeri null olarak kalacaktır. 84 | Yukarıdaki örnekte biz ayDegeri değişkenine 7 değerini atadığımız 85 | için konsol ekranı aşağıdaki gibi olacaktır. 86 | 87 | //Secilen ay degeri : Temmuz 88 | */ 89 | 90 | 91 | 92 | 93 | 94 | 95 | } 96 | } 97 | -------------------------------------------------------------------------------- /src/_08_mathSinifi/MathSinifi.java: -------------------------------------------------------------------------------- 1 | package _08_mathSinifi; 2 | 3 | 4 | 5 | public class MathSinifi { 6 | public static void main(String[] args) { 7 | 8 | /* 9 | 10 | Math Sınıfının methodları static methoddur. 11 | Ancak kısaca bahsetmek gerekirse bir sınıfın static 12 | olmayan bir method yada değişkenine erişmek için o sınıftan 13 | bir Obje oluşturmak gerekiyor. Bu nasıl oluyor diyorsak aşağıda 14 | bir sınıfın hem static methoduna hemde static olmayan methoduna 15 | nasıl erişilir örnek vereceğim. 16 | 17 | */ 18 | 19 | 20 | // Static olmayan methoda ulaşmak için önce o sınıftan new kelimesi bir obje yaratılır. 21 | 22 | //Deneme deneme = new Deneme(); // Obje oluşturuldu 23 | 24 | /* 25 | deneme.ornekMethod(); //static olmayan methoda ulaşıldı 26 | 27 | //Static methoda ulaşmak 28 | 29 | Deneme.ornekMethod2(); 30 | */ 31 | 32 | 33 | /* 34 | Evet yukarıdaki anlattıklarımı ilerleyen derslerde çok 35 | daha detaylı anlatacağız. Şuanlık ön bilgilendirme olması 36 | için anlatmaya çalıştım. Math Sınıfının da methodları 37 | static olduğu için obje oluşturmadan methodlarını kullanabiliriz. 38 | Ben bizim ilerleyen derslerde kullancağımız ve çok kullanılan 39 | Meth Sınıfı methodlarını aşağıda listeliyeceğim ve ne işe 40 | yaradıklarını anlatmaya çalışacağım. 41 | */ 42 | 43 | /* 44 | ceil Tek parametre alır(double) ve bir büyük tam sayıya yuvarlama yapar. 45 | Math.ceil(2.6) => 3.0 46 | 47 | cos Tek parametre alır(double) ve cos değerini döner. 48 | Math.cos(30) 49 | 50 | sin Tek parametre alır(double) ve sin değerini döner. 51 | Math.sin(30) 52 | 53 | floor Tek parametre alır(double) ve bir küçük tam sayıya yuvarlar. 54 | Math.floor(2.6) => 2.0 55 | 56 | max İki parametre alır ve parametrelerden büyük olan sayıyı geri döner. 57 | Math.max(2.5,9) =>9 58 | 59 | min İki parametre alır ve parametrelerden küçük olan sayıyı geri döner. 60 | Math.min(2.5,9) => 2.5 61 | 62 | pow İki parametre alır ve ikinci parametreyi birincinin üstü olarak kullanır. 63 | Math.pow(3,5) => 3^5 anlamına gelir => 243.0 64 | 65 | random Parametre almaz ve 0 ile 1 arasında double bir değer döner 66 | Math.random() 67 | 68 | round Tek parametre alır(float) ve yakın olan tam sayıya döner. 69 | Math.round(2.4) => 2 70 | Math.round(2.6) => 3 71 | */ 72 | 73 | 74 | System.out.println("Math.ceil(2.6) = "+Math.ceil(2.6)); 75 | System.out.println("Math.cos(Math.PI) = "+Math.cos(Math.PI)); //Math.PI pi sayısı değerini verir 76 | System.out.println("Math.cos(Math.PI / 2) = "+Math.sin(Math.PI / 2)); 77 | System.out.println("Math.floor(2.6) = "+Math.floor(2.6)); 78 | System.out.println("Math.max(2.5,9) = "+Math.max(2.5,9)); 79 | System.out.println("Math.min(2.5,9) = "+Math.min(2.5,9)); 80 | System.out.println("Math.pow(3,5) = "+Math.pow(3,5)); 81 | System.out.println("Math.random() = "+Math.random()); 82 | System.out.println("Math.ceil(2.4) = "+Math.ceil(2.4)); 83 | System.out.println("Math.round(2.6) = "+Math.ceil(2.6)); 84 | 85 | /* 86 | OUTPUT: 87 | Math.ceil(2.6) = 3.0 88 | Math.cos(Math.PI) = -1.0 89 | Math.cos(Math.PI / 2) = 1.0 90 | Math.floor(2.6) = 2.0 91 | Math.max(2.5,9) = 9.0 92 | Math.min(2.5,9) = 2.5 93 | Math.pow(3,5) = 243.0 94 | Math.random() = 0.3035333575900232 95 | Math.ceil(2.4) = 3.0 96 | Math.round(2.6) = 3.0 97 | */ 98 | 99 | 100 | 101 | 102 | 103 | 104 | } 105 | } 106 | -------------------------------------------------------------------------------- /src/_27_exceptionHandling/ExceptionHandling.java: -------------------------------------------------------------------------------- 1 | package _27_exceptionHandling; 2 | 3 | public class ExceptionHandling { 4 | public static void main(String[] args) { 5 | 6 | //Java Exception Handling (Hata Yakalama) 7 | 8 | /* 9 | Exception sınıfları Java’da diğer sınıfların üretildiği Object 10 | sınıfından türemektedir. Throwable sınıfı Object sınıfının bir alt 11 | sınıfıdır. Throwable sınıfından ise Exception sınıfı türer 12 | Exception sınıfından da bildiğimiz checked ve unchecked olarak 13 | bilinen diğer Exception sınıfları türetilir. 14 | Aşağıdaki grafik yazılanları daha net bir şekilde görmenize yardımcı olacaktır. 15 | 16 | */ 17 | 18 | /* 19 | Throwable 20 | || 21 | A) Error(**) B) Exception(*) 22 | || 23 | || 24 | B1) IOException(*) B2) ClassNot B3) CloneNot B4) Runtime 25 | || Found Exception(*) Supported Exception(*) Exception(**) 26 | || || 27 | * EOFException || 28 | * FileNotFound ** Aritmetic 29 | Exception Exception 30 | * MalformedURL ** ClassCast 31 | Exception Exception 32 | * UnknownHost ** Illegal Argument 33 | Exception Exception 34 | ** Illegal State 35 | Exception 36 | ** IndexOut OfBounds 37 | Exception 38 | ** NoSuch Element 39 | Exception 40 | ** NullPointer 41 | Exception 42 | 43 | 44 | */ 45 | 46 | /* 47 | Yukarıdaki görselde (**) ile gösterilen Error ve Runtime Exception ve Runtime Exceptiondan türeyen alt Exception sınıfları Unchecked Exception olarak işaretlenmiştir. 48 | (*) ile gösterilenler ise Exception sınıfıları ise Checked Exception olarak işaretlenmiştir. 49 | */ 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | } 64 | } 65 | -------------------------------------------------------------------------------- /src/_13_methodYapisi/Method.java: -------------------------------------------------------------------------------- 1 | package _13_methodYapisi; 2 | 3 | public class Method { 4 | 5 | /* 6 | Metot Yapısı sadece Java geliştirme diline özel bir yapı 7 | olmadığı için yapacağımız tanım Nesne Yönelimli Programlamayı 8 | destekleyen bir çok yazılım dili için geçerli bir tanım olacaktır. 9 | Yazılım dünyasında bir çok ifadenin, tanımlamanın bir araya 10 | gelerek bir fonksiyon içerisinde işlemleri gerçekleştirmesiyle 11 | metot yapısı ortaya çıkar. Metot Yapısı bir kez kurulduktan 12 | sonra bir çok kez ve farklı yerlerde kullanılabilir. 13 | Java yazılım dilinde metotların kullanım alanları oldukça geniştir, 14 | en çok kullanılan metot olarak yapılandırıcılar (constructors) 15 | gösterilebilir. Yapılandırıcı metotlar konusunu ilerleyen derslerde 16 | detaylarıyla anlatacağız. Şimdilik sadece bir sınıf çalıştığında 17 | ilk önce eğer varsa yapılandırıcı sınıfını çalıştırır diyerek 18 | bir başlangıç bilgisi vermiş olalım. Artık metot yapısını daha 19 | iyi anlayabilmenizi sağlamak için örnekler vermeye başlayalım. 20 | */ 21 | 22 | /* 23 | Örnek 1 24 | Bir proje geliştirdiğinizi ve bu projenin bir muhasebe 25 | projesi olduğunu varsayalım. Bu projede bir çok kez toplama, 26 | çıkarma, çarpma ve bölme işlemleri yapılacaktır. Bu ve buna 27 | benzer durumlarda her toplama işlemi yapmamız gerektiğinde 28 | tek tek o işlemi yazmaktansa bu işlemleri yapan metotlar 29 | hazırladığımız takdirde işimiz oldukça kolaylaşacaktır. 30 | Şimdi bunu nasıl yapacağımızı görelim; 31 | */ 32 | 33 | public static void toplama(int sayi1, int sayi2) { 34 | int sonuc = sayi1 + sayi2; 35 | System.out.println(sayi1 + " + " + sayi2 + " = " + sonuc); 36 | } 37 | 38 | public static void cikarma(int sayi1, int sayi2) { 39 | int sonuc = sayi1 - sayi2; 40 | System.out.println(sayi1 + " - " + sayi2 + " = " + sonuc); 41 | } 42 | 43 | //eger cikarma isleminde negatif deger cikmasini istemiyorsak 44 | public static void cikarma2(int sayi1, int sayi2) { 45 | if(sayi1 > sayi2) { 46 | int sonuc = sayi1 - sayi2; 47 | System.out.println(sayi1 + " - " + sayi2 + " = " + sonuc); 48 | } else { 49 | System.out.println(sayi1 + " küçüktür " + sayi2); 50 | int sonuc = sayi2 - sayi1; 51 | System.out.println(sayi2 + " - " + sayi1 + " = " + sonuc); 52 | } 53 | } 54 | 55 | public static void carpma(int sayi1, int sayi2) { 56 | int sonuc = sayi1 * sayi2; 57 | System.out.println(sayi1 + " x " + sayi2 + " = " + sonuc); 58 | } 59 | 60 | public static void bolme(int sayi1, int sayi2) { 61 | int sonuc = sayi1 / sayi2; 62 | System.out.println(sayi1 + " / " + sayi2 + " = " + sonuc); 63 | } 64 | 65 | public static void main(String[] args) { 66 | System.out.println("Toplama"); 67 | toplama(5, 6); 68 | System.out.println("Çıkarma"); 69 | cikarma(10, 2); 70 | cikarma2(8, 12); 71 | System.out.println("Çarpma"); 72 | carpma(5, 6); 73 | System.out.println("Bölme"); 74 | bolme(10, 2); 75 | } 76 | 77 | /* 78 | Bu methodları farklı bir sınıfı içerisinden veya farklı 79 | bir metot içerisinden rahatlıkla çağırarak heryerde kullanabiliriz. 80 | Bu şekilde toplama işlemini yapan metodu bir kere yazdıktan 81 | sonra bir daha yazmamıza gerek kalmadan sadece ilgili metodu 82 | çağırmak yeterli olacaktır. Dikkatinizi çeken bir konuda, 83 | yukarıda yazmış olduğumuz örnek metotların hepsi void anahtar 84 | kelimesiyle değer dönmektedir. Aslında bu tip sınıflar 85 | dışarıya bir değer dönmezler tüm tanımlanan değerler ile 86 | kendi içlerinde işlem yaparlar. Bunun aksi durum ise dışarıya 87 | daha önce anlattığımız veri tiplerini dönen metotlardır. 88 | Aslında bir metot istediğiniz her türlü nesneyi dönebilir, 89 | fakat bu konuları önümüzdeki derslerde anlatacağız. 90 | Şimdi veri tiplerini dönen metotlara örnek kodlar yazalım; 91 | */ 92 | 93 | 94 | 95 | 96 | 97 | 98 | } 99 | -------------------------------------------------------------------------------- /src/_15_tekBoyutluDiziler_Array/Array.java: -------------------------------------------------------------------------------- 1 | package _15_tekBoyutluDiziler_Array; 2 | 3 | public class Array { 4 | 5 | public static void main(String[] args) { 6 | /* 7 | Biz bu dersimizde tek boyutlu diziler’den bahsedeceğiz. 8 | Nedir bu diziler derseniz programın çalışma anında (runtime) 9 | birden fazla aynı tip veriyi tutmak/saklamak isteyebiliriz. 10 | Örneğin 10 tane sayının ortalamasını alacağız. Dizi kullanmadan 11 | bunu 10 tane farklı int değişken tanımlayıp tek tek toplayıp sonra 12 | 10’a bölerek bulabiliriz. Fakat bu çok zor bir kullanım ve 13 | daha büyük rakamlarda neredeyse imkansız bir hal alabilir. 14 | İşte bu sorunu Dizi kullanarak çözebiliriz. 15 | 16 | Dizi’yi elementTipi diziAdi[] = new elementTipi[Dizi Boyutu]; 17 | şeklinde oluşturabiliriz. 18 | */ 19 | 20 | String[] stringListe = new String[10]; 21 | int[] intListe = new int[8]; 22 | double[] doubleListe = new double[18]; 23 | boolean[] boolList = new boolean[9]; 24 | char charListe[] = new char[10]; //Bu kullanım şeklide doğrudur. 25 | // Ama javada genel olarak yukarıdaki gibi kullanım olmaktadır. 26 | // Tercih sizindir. 27 | 28 | /* 29 | Yukarıda farklı boyutlarda ve farklı tiplerde diziler oluşturduk. 30 | Burda bilmemiz gereken önemli bir nokta dizinin boyutunu diziyi 31 | oluşturduktan sonra değiştiremiyoruz. Ne dizinin boyunu arttırabilir 32 | ne de azaltabiliriz. 33 | 34 | Gelelim diziye değerlerimizi atamaya. 35 | */ 36 | 37 | int[] arrListe = new int[8]; //8 elemanlı Diziyi oluşturduk 38 | arrListe[0] =12;//ilk değerini atadık 39 | arrListe[1] =11; 40 | arrListe[2] =10; 41 | arrListe[3] =9; 42 | arrListe[4] =8; 43 | arrListe[5] =7; 44 | arrListe[6] =6; 45 | arrListe[7] =5;//son değerini atadık 46 | 47 | /* 48 | Yukarıda oluşturduğumuz mobilhanemListe dizimize değer atadık. 49 | Dikkat ettiyseniz ilk elemana değeri mobilhanemListe[1] ile 50 | değilde mobilhanemListe[0] şeklinde atadık. Bunun sebebi ise 51 | Java’da bir dizideki elemanların sıra numaraları, yani indeksleri 52 | 0 dan başlar ve boyutundan 1 eksik olarak biter. Yani 10 elemanlık 53 | bir dizinin son elemanına değeri diziAdi[9] = x 54 | şeklinde atayabiliriz. Aşağıda mobilhanemListe dizimizi görüyorsunuz. 55 | Gördüğünüz gibi ilk eleman yani 0. indeks 12 değerini tutuyor. 56 | */ 57 | 58 | int[] arr = new int[8]; 59 | arr[0]=2; 60 | arr[1]=4; 61 | arr[2]=6; 62 | 63 | //Diziyi aşağıdaki gibi farklı bir yollada oluşturup değerler atayabiliriz. 64 | 65 | //int array = {12,8,34,19,26,31,-5,78} // Diziyi bu şekildede oluşturabiliriz 66 | 67 | /* 68 | Gelelim oluşturduğumuz ve değer atadığımız dizinin değerini 69 | geri almaya. diziAdi[indeks] şeklinde önceden atadığımız 70 | değeri/değerleri alabiliriz. 71 | */ 72 | 73 | System.out.println(arrListe[0]); 74 | System.out.println(arrListe[3]); 75 | System.out.println(arrListe[5]); 76 | 77 | /* 78 | Diyelim ki diziyi oluşturduk ama değer ataması yapmadık. 79 | Değer ataması yapmadan belli bir indekse ulaşmaya çalıştığımızda 80 | ne olur dersiniz? 81 | 82 | Diziyi oluşturduğumuz an başlangıç değerleri zaten bulunmaktadır. 83 | Aşağıdaki listede bir dizinin oluşturulduğu an başlangıç değerlerini 84 | paylaşıyorum. 85 | 86 | String -> null 87 | int/short/byte/long -> 0 88 | double/float -> 0.0 89 | boolean -> false 90 | char -> ‘\u0000’ 91 | Herhangi Bir Objeyi tutan referans -> null 92 | 93 | Örneğin: 94 | 95 | int[] mobilhanemListe = new int[8]; // 8 elemanlı dizi oluşturuldu 96 | System.out.println(mobilhanemListe[4]); //herhangi bir değer ataması yapılmadan 5. elemana ulaşmaya çalışıyoruz 97 | 98 | Konsol çıktısı: 99 | 0 100 | 101 | 102 | Gördüğünüz gibi biz bir atama yapmadan da 4.indeksin(beşinci eleman) 103 | değeri 0 dönmektedir. Bunun sebebi yukarıdada belirttiğim gibi 104 | başlangıç değerinin 0 olmasıdır. Biz diziyi oluşturur oluşturmaz 105 | Java tüm değerlerini 0 olarak set ediyor, eğer dizimizin tipi int ise. 106 | 107 | 108 | Bu dersimde birde dizi boyutunu öğrenme işleminden bahsedeceğim. 109 | Biz bir diziyi oluştuduğumuz zaman o diziye ait length adında 110 | bir int değişken( method değil) otomatik olarak oluşur ve dizinin 111 | boyutunu tutar. 112 | 113 | Yukarıdaki arrListe dizimizin boyutu 8’dir. Bunu aşağıdaki şekilde öğrenebiliriz. 114 | */ 115 | 116 | int diziBoyutu = arrListe.length; 117 | System.out.println("DiziBoyutu : " + diziBoyutu); 118 | 119 | 120 | } 121 | } 122 | -------------------------------------------------------------------------------- /src/_14_methodYapisi_MainMethod/MainMethod.java: -------------------------------------------------------------------------------- 1 | package _14_methodYapisi_MainMethod; 2 | 3 | public class MainMethod { 4 | /* 5 | public static void main(String[] args) { 6 | } 7 | Bir java programının başlatılabilmesi için main metot olması şarttır. 8 | Bir önceki dersimizde bir metot’u nasıl çağırıcağımızı göstermiştik. 9 | Bir metotu çağırarak o metotu başlatmış oluyoruz ve içinde gerekli 10 | işlemleri yapıyoruz. Main metotta aynı mantık. Java programının başlaması 11 | ve işlemleri yapması için JVM (Java Virtual Machine) tarafından çağırılır 12 | main metot. Basitçe şöyle anlatabiliriz, siz bir java uygulamasını 13 | bilgisayarınızda başlatmak için çift tıkladınız, işte bu anda JVM 14 | programınızı başlatmak için yazmış olduğunuz kodlarınız arasından 15 | main metotu çağırır ve programınızı main metottan başlatır. 16 | İşte bundan dolayı bir programda sadece bir main metot olabilir. 17 | Birden fazla olması durumunda JVM hangisini çağıracağını bilemeyeceği 18 | için compile error verir kodlarınız ve derlenemez. 19 | 20 | Main metot her zaman public static modifier’ı ile başlar ve bir 21 | parametre geri dönmez. Dolayısıyla void metottur. Metotun adı main‘dir 22 | Parametre olarakta String tipinde array alır. 23 | 24 | public static void main(String [] args) 25 | 26 | Not : Arrayleri ve modifier’ları (public,private,protected,static ..) 27 | ilerleyen derslerimizde öğreneceğiz. 28 | */ 29 | 30 | //Metot Yapısı 31 | 32 | /* 33 | Metotlar dönüş tiplerine göre ikiye ayrılıyordu. Parametre dönenler 34 | ve parametre dönmeyen(void) metotlar . Metot tanımlaması yaparken 35 | bunuda(paramtre dönecekse tipini, dönmeyecekse void) tanımlıyoruz. 36 | Aşağıda parametre dönmeyen(void) metota örnek veriyorum. 37 | 38 | public static void metotAdi(parametreler) { 39 | //işlemler 40 | } 41 | 42 | Yukarıdaki metot tanımlaması void metota örnektir. 43 | Void olan bir metot geriye bir değer dönmemektedir. 44 | 45 | public static String metotAdi(parametreler) { 46 | //işlemler 47 | return stringvalue; 48 | } 49 | 50 | Yukarıdaki metotta ise return komutu ile geriye String değer 51 | dönülmektedir. Zaten metot tanımlaması yaparkende geriye String 52 | değer döneceği bilgisini veriyoruz. Bu metot geriye herhangi 53 | bir değer dönmezse veya String dışında bir veri geriye döndürürse 54 | kodumuz hata verecektir. 55 | 56 | Return komutunu kullanırken dikkat edeceğimiz bir husus ise eğer 57 | return komutunu if yapısı içinde kullanıyorsak , kesinlikle else ‘de 58 | ekleyip return komutunu else’de eklememeiz gerekmektedir. 59 | Aşağıda yanlış bir kullanımı göstereceğim. 60 | 61 | public static int deger(int x){ 62 | 63 | if(x>0 && x<10) 64 | return x; 65 | else if(x>=10 && x<50) 66 | return x*10; 67 | else if(x>=50) 68 | return x*50; 69 | 70 | } 71 | 72 | Yukarıdaki kod yanlış bir kullanımdır ve hata verecektir. 73 | Çünkü return komutuna erişemeyebilir ve geriye bir değer dönemez. 74 | Böyle bir durumda zaten kullandığımız ide bizi uyaracaktır ve kodun 75 | en sonuna return eklememizi isteyecektir. Yukarıdaki kodun doğru 76 | kullanımı şu şekildedir ve hata vermeyecektir. 77 | 78 | public static int deger(int x){ 79 | 80 | if(x>0 && x<10) 81 | return x; 82 | else if(x>=10 && x<50) 83 | return x*10; 84 | else 85 | return x*50; 86 | } 87 | 88 | Çünkü her durumda return komutu çalışacaktır. 89 | 90 | Ek olarak şundan bahsetmek istiyorum. Return komutu sadece parametre 91 | dönen metotlarda değil void metotlarda da kullanılabilir. 92 | Nasıl olacak o iş ve ne işimize yarayacak dediğinizi duyar gibiyim 93 | 🙂 Kısaca şöyle anlatayım. Bir metotunuz var ve belli işlemler yapıyor. 94 | Ama siz belli koşullarda artık metottan çıkılmasını istiyorsunuz. 95 | Bu durumda aynı döngülerden break komutu ile çıktığımız gibi metotlardan 96 | da return komutu ile çıkabiliriz 97 | 98 | Örneğin: 99 | public static void bolmeIslemi(int bolen,int bolunen){ 100 | ///eğer bolen sayı 0'a eşit olursa kod hata verecektir. Dolayısıyla kontrol etmemiz gerekir 101 | if(bolen == 0) 102 | return; //metot burada durur ve aşağıdaki işlemler yapılmaz 103 | 104 | int sonuc = bolunen/bolen; 105 | System.out.println("Sonuç ="+sonuc); 106 | } 107 | 108 | Overload metotların ne olduğunu bir önceki dersimizde bahsetmiştik. 109 | Overloading olayı javanın bize sunduğu güzelliklerden birisi. 110 | Aynı metot adı ile farklı parametreler ile aynı işlemi yapacak 111 | metotları çağırabiliriz. Örneğin toplama işlemi yapan bir metotumuz 112 | var . Adı da topla metotu olsun. Bu metotu hem int, hem double 113 | parametre alacak şekilde set edelim. 114 | 115 | public static int topla(int x, int y){ 116 | return x+y; 117 | } 118 | public static double topla(double x, double y){ 119 | return x+y; 120 | } 121 | 122 | Biz topla(3,4) (int değer döneni çağırır) veya topla(3.0 , 4.0) 123 | (double değer döneni çağırır) şeklinde metotları çağırdığımızda 124 | hangi metotun çağırılcağına compiler karar vermekte ve uygun olan 125 | metotu çağırmaktadır. Mesala topla(3 , 4.0) şeklinde çağırdığımızda 126 | metotu double değer dönen metot çağırılacak ve 3 değeri otomatik olarak 127 | 3.0 değerine döndürülecektir. 128 | 129 | Sayalım ki elimizde aşağıdaki gibi iki metot bulunmakta. 130 | 131 | public static double topla(int x ,double y){ 132 | return x+y; 133 | } 134 | public static double topla(double x ,int y){ 135 | return x+y; 136 | } 137 | 138 | Yukarıdaki metotlardan ilkini topla(3 , 4.0) seklinde ikincisini 139 | ise topla(3.0 , 4) şeklinde çağırabiliriz. Peki topla(3 , 4) 140 | şeklinde çağırsak topla metotunu hangisini çağıracak compiler ? 141 | burada compiler hangisini seçeceğine karar veremiyeceği için 142 | error verecektir. Bu nedenle overloading yaparken metotları 143 | compiler’ın karar veremeyeceği durumları iyi düşünerek parametre 144 | seçimleri dikkatli yapılmalıdır. 145 | 146 | Son olarak şu unutulmamalıdır ki bir metota gönderdiğimiz argümentler 147 | (javada metota gönderilen parametreler argüment olarak adlandırılır) 148 | değerleri metotta hangi işlem yapılırsa yapılsın değişmeyecektir. 149 | Ne demek istediğimi aşağıdaki kodda anlayacaksınız. 150 | 151 | 152 | */ 153 | 154 | public static void main(String args[]) { 155 | int x = 5; 156 | int y = 7; 157 | 158 | System.out.println("Metot'a girmeden önce :"+"x ="+x+" y ="+y); 159 | 160 | deneme(5,7); 161 | 162 | System.out.println("Metot'tan çıkınca :"+"x ="+x+" y ="+y); 163 | 164 | 165 | } 166 | public static void deneme(int x,int y){ 167 | 168 | System.out.println("Metot'un içi işlemlerden önce :"+"x ="+x+" y ="+y); 169 | x += 5; 170 | y +=15; 171 | System.out.println("Metot'un içi işlemlerden sonra :"+"x ="+x+" y ="+y); 172 | 173 | 174 | } 175 | 176 | /* 177 | OUTPUT: 178 | Metot'a girmeden önce :x =5 y =7 179 | Metot'un içi işlemlerden önce :x =5 y =7 180 | Metot'un içi işlemlerden sonra :x =10 y =22 181 | Metot'tan çıkınca :x =5 y =7 182 | */ 183 | 184 | /* 185 | Gördüğünüz gibi gönderdiğimiz argümentler metotta farklı işlemlerede 186 | girse değerleri değişmedi çünkü metot’un içindeki x, y yeni değişkenler 187 | oluyor ve metot çağrılırken gönderilen parametrelerle ilgisi bulunmuyor. 188 | */ 189 | 190 | 191 | 192 | 193 | 194 | 195 | 196 | 197 | } 198 | --------------------------------------------------------------------------------