java constructor class
Bu öğreticide Java Constructor, türleri ve yapıcı aşırı yükleme ve yapıcı zincirleme gibi kavramları kod örnekleriyle tartışılacaktır:
Daha önceki eğitimlerimizden, bir sınıfın örneğinin bir nesne olarak adlandırıldığını biliyoruz. Bir sınıfın nesnesi, 'new' anahtar sözcüğü kullanılarak oluşturulur. Yeni bir anahtar kelimeyle bir nesne oluşturduğumuzda veya nesne somutlaştırıldığında 'yapıcı' adı verilen özel bir yöntem çağrılır.
Bir kurucu, sınıf nesnesini başlatmak için bir kod bloğu olarak tanımlanır. Yöntemle aynıdır ancak bir yöntem değildir. Ancak Java'da 'özel yöntem' olarak adlandırılabilir.
=> Java Eğitim Öğreticilerinin A-Z'sini Burada Görmek İçin Burayı Kontrol Edin.
Ne öğreneceksin:
Java Yapıcı
Java yapıcısı, yeni oluşturulan nesneyi başlatmak için kullanılır. Bir nesnenin programda kullanılmadan önce bazı verilere sahip olması gerekir. Bu nedenle, nesneye bazı ilk verileri atayabilmek için yapıcı kullanırız.
Basit bir örnek olarak, kendisi için bir nesne oluşturmamız gereken bir ABC sınıfını düşünün. ABC sınıfı için yeni bir anahtar kelime kullanarak bir 'myObj' nesnesi oluşturalım.
ABC myObj = new ABC ();Yukarıdaki ifade bir myObj nesnesi oluşturur. Bu nesne yaratılırken, ABC sınıfı için argümansız bir yapıcı çağrılır (ABC (), yapıcı için hiçbir argüman olmadığını gösterir). Yukarıdaki kurucu için hiçbir bağımsız değişken sağlanmadığından, myObj'nin üye alanları varsayılan başlangıç değerlerine göre başlatılacaktır.
Örneğin,
- İnt gibi sayısal veri türleri 0'a ayarlanmıştır.
- Char veri türü değişken değeri, boş (‘ 0’) karaktere ayarlanır.
- Referanslar null olarak ayarlandı.
Bu eğitimde, Java'da kullanılan çeşitli kurucularla birlikte kurucuları ayrıntılı olarak tartışacağız.
Java'da Oluşturucu Nasıl Oluşturulur
Java'da bir kurucu oluşturmak için, aşağıda verilen belirli kuralları izlememiz gerekir.
- Sınıf yapıcısı, sınıfınki ile aynı ada sahiptir.
- Nihai, soyut, senkronize edilmiş veya statik bir kurucu olamaz. Bunun nedeni, Finalin sabit olarak hareket etmesidir, soyut somutlaştırılamaz. Senkronize edilirken, çoklu iş parçacığı durumunda kullanılır ve static anahtar sözcüğü sınıf düzeyinde kullanılır.
- Kurucularla erişim değiştiricileri kullanabiliriz.
- Bir kurucunun dönüş türü olamaz.
Örneğin,aşağıdaki gibi bir sınıf Öğrenci tanımlayalım:
class Student{ String name; int roll_no; } New anahtar sözcüğünü kullanarak yukarıdaki sınıfın nesnelerini oluşturabiliriz. Nesne oluşturulurken, bu sınıfın iki üyeli değişkenlerini bir kurucu sağlayarak başlatabiliriz. Bir kurucu sağlamasak ve sadece aşağıdaki ifadeyi çalıştırsak bile,
Öğrenci öğrenci = yeni Öğrenci ();
Yine de Java, iki üyeli değişkenleri sistem varsayılanlarına göre başlatacak varsayılan bir kurucu çalıştıracaktır. Şimdi, Student.name'nin başlangıç değerinin “Keith” ve roll_no'nun 27 olmasını istiyorsak, bunu yapmak için aşağıdaki yapıcı yöntemini oluşturabiliriz.
Student () { name = 'Keith'; roll_no = 27; } Aşağıdaki ifade ile öğrenci sınıfının bir nesnesini oluşturduğumuzda
Student student = new Student ();Daha sonra üye değişken adı ve roll_no'nun ilk değerleri sırasıyla Keith ve 27 olacaktır.
Şimdi bir kurucu yaratıldığına göre, ne zaman çağrılacak?
Yukarıdaki örnekte olduğu gibi new anahtar sözcüğüyle bir nesne oluşturulduğunda her seferinde bir kurucu çağrılır. Daha önce belirtildiği gibi, herhangi bir kurucu sağlanmadıysa, Java, nesne new anahtar sözcüğü kullanılarak oluşturulduğunda çağrılan varsayılan bir kurucu sağlar.
Yapıcı Örneği
Aşağıdaki program, herhangi bir argüman içermeyen basit bir kurucuya sahip olduğumuz bir yapıcı örneğini göstermektedir. Bu kurucu, üye değişkenlerine basitçe başlangıç değerleri atar.
//class definition class classDemo{ int num1; int num2; //constructor classDemo(){ num1 = 100; num2 = 250; System.out.println('Inside ClassDemo::Constructor'); } public void display(){ System.out.println('num1 = '+ num1); System.out.println('num2 = '+ num2); } } class Main{ public static void main(String args()){ classDemo cd1 = new classDemo(); //create object of ClassDemo cd1.display(); } }Çıktı:
Java'da Varsayılan Oluşturucu
Varsayılan kurucu, Boş Yapıcı olarak da adlandırılır. . Bu kurucu, Java derleyicisi tarafından, programcı tarafından uygulanan hiçbir kurucunun olmadığı sınıf koduna eklenir. Varsayılan kurucu, derleme sırasında eklenir ve bu nedenle yalnızca '.class' dosyasında görünecek, kaynak kodunda görünmeyecektir.
Aşağıdaki Java sınıfını düşünün.
kaynak dosyası (.java) sınıf dosyası (.class)
Yukarıdaki şekilde, ilk şekil herhangi bir kurucu belirlemediğimiz kaynak kodunu göstermektedir. Yani bu kodu derlediğimizde ve .class dosyası oluşturulduğunda, Java derleyicisinin bitişik şekilde (mavi renkte) gösterildiği gibi varsayılan bir kurucu eklediğini görebiliriz.
Not:
Bazen Java'da arginsiz yapıcıyı tanımlamak için varsayılan bir kurucu kullanılır. Ancak bu iki terim gerçekte farklıdır. No-arg yapıcı, programcı tarafından belirtilen Java'da bir yapıcı türüdür. Varsayılan kurucu, Java derleyicisi tarafından eklenen yapıcıdır.
excel'de test özeti raporu şablonu
Bu nedenle, bu iki terim programcıların çoğu tarafından birbirinin yerine kullanılsa da, bu iki terimin karıştırılmaması tavsiye edilir.
Java varsayılan bir kurucu eklediğinde, programın herhangi bir değişkeni varsa, bu değişkenlere varsayılan değerler atanır.
Aşağıdaki tablo her veri türünün varsayılan değerlerini göstermektedir.
| Tür | Varsayılan değer |
|---|---|
| kömür | u0000 |
| Nesne | Referans boş |
| Boole | yanlış |
| bayt | 0 |
| kısa | 0 |
| int | 0 |
| uzun | 0L |
| yüzer | 0.0f |
| çift | 0.0 g |
Aşağıdaki program, Java'da varsayılan bir kurucu örneği vermektedir.
class Main { int num; boolean flag; public static void main(String() args) { // A default constructor is called Main obj = new Main(); System.out.println('num:default value = ' + obj.num); System.out.println('flag:default value = ' + obj.flag); } }Çıktı:
Java'da Oluşturucu Türleri
Java'da aşağıda gösterildiği gibi iki tür kurucu vardır.
# 1) Argansız Oluşturucu
Bağımsız değişken içermeyen bir oluşturucu, bağımsız değişken olmayan veya bağımsız değişken olmayan oluşturucu olarak adlandırılır. Herhangi bir argümanı olmayan bir kurucumuz yoksa, Java derleyicisi sınıf için varsayılan bir kurucu yaratmaz.
Genel olarak, sınıfımızda bir kurucu tanımlarsak, varsayılan kurucu Java derleyicisi tarafından eklenmez.
Aşağıda argüman içermeyen Oluşturucu'nun bir örneği verilmiştir.
import java.io.*; class DemoClass { int num; String name; // no-args Constructor called when object is created DemoClass() { System.out.println('DemoClass::Constructor called'); System.out.println('Initial member variable values:'); System.out.println('num = ' + num + ' name = ' + name); } } class Main{ public static void main (String() args) { // this will invoke no-args Constructor DemoClass dc1 = new DemoClass(); } } Çıktı:
Bu programda args içermeyen bir kurucu sağladık. Burada üye değişkenlerini içeren bazı mesajları yazdırıyoruz. Çıktıda, yapıcıdan gelen mesajların args olmayan kurucunun çalıştırıldığını gösteren görüntülendiğini görebiliriz.
# 2) Parametreli Yapıcı
Parametreli bir yapıcı, bir veya daha fazla parametreye sahiptir. Sınıfın üye değişkenine bazı ilk değerleri iletmemiz gerektiğinde parametreli bir kurucu kullanabiliriz.
import java.io.*; class DemoClass { // data members of the class. String name; int id; // parameterized constructor called when object is created DemoClass(String name, int id) { this.name = name; this.id = id; } } class Main { public static void main (String() args) { // this will invoke the parameterized constructor. DemoClass dc1 = new DemoClass('Java', 1); System.out.println('Tutorial Name :' + dc1.name + ', Id :' + dc1.id); } } Çıktı:
Burada, ad ve id olmak üzere iki argüman alan parametreleştirilmiş bir kurucu sağladık.
Yapıcı gövdesinin içinde, bağımsız değişkenler sırasıyla üye değişkenlerin adına ve kimliğine değerler olarak atanır.
Daha sonra ana yöntemde new anahtar sözcüğünü kullanarak yeni bir nesne oluşturduğumuzda, yeni bir anahtar sözcüğün ardından sınıf adına iki değer iletiyoruz. Bu, parametreleştirilmiş kurucuyu çağırdığımızı gösterir. Üye değişkenleri gösterdiğimizde nesneyi oluştururken geçirdiğimiz değerlere sahip olduklarını görebiliriz.
Java'da Aşırı Yüklenmiş Oluşturucular
Şimdi soru, bir sınıfın birden fazla kurucuya sahip olup olmayacağı veya bir sınıfın yalnızca bir kurucuya sahip olabileceği şeklinde ortaya çıkıyor.
Bir sınıfta birden fazla kurucumuz olabilir. Bir sınıf, düzgün bir şekilde aşırı yüklendikleri sürece içinde birçok kurucuya sahip olabilir.
Peki, İnşaatçıların Aşırı Yüklenmesi ile tam olarak ne kastedilmektedir?
Yapıcı Aşırı Yüklemesi, bir sınıfın çok sayıda yapıcıya sahip olmasına izin veren bir mekanizmadır, böylece tüm bu oluşturucular, parametre türlerine veya parametre sırasına bağlı olarak farklı parametre listelerine sahip olur.
Aşağıdaki program, Yapıcı Aşırı Yüklemesini göstermektedir.
//class with multiple constructors class DemoClass{ int val1; int val2; //no args Constructor DemoClass(){ val1 = 10; val2 = 20; System.out.println('DemoClass:: No argument Constructor'); } //Overloaded Constructor DemoClass(int num1){ val1 = num1; val2 = num1; System.out.println('DemoClass:: Overloaded Constructor with one argument'); } //Overloaded DemoClass(int num1,int num2){ val1 = num1; val2 = num2; System.out.println('DemoClass:: Overloaded Constructor with two arguments'); } public void display(){ System.out.println('val1 === '+val1 + ' ; val2 === '+val2 ); } } class Main{ public static void main(String args()){ DemoClass d1 = new DemoClass(); //object with no-args Constructor d1.display(); DemoClass d2 = new DemoClass(10); //object with 1 arg Constructor d2.display(); DemoClass d3 = new DemoClass(20,40); //object with 2 arg Constructor d3.display(); } }Çıktı:
Yukarıdaki programda, üç kurucu içeren bir sınıfımız var. İlk kurucu bağımsız değişken olmayan bir kurucudur ve sonra sırasıyla birer bağımsız değişken ve iki bağımsız değişken içeren birer tane elde ederiz. Kurucu benzersiz bir parametre listesine sahip olduğundan, kurucuların aşırı yüklendiğini söyleyebiliriz.
Java'da 'bu ()' Oluşturucu
Birden çok kurucu içeren bir sınıfta, bu sınıftaki başka bir yapıcıdan bir kurucu çağırmak istersek ne olur?
Bu amaçla, başka bir kurucu olarak adlandırmak istediğimiz kurucu içinde 'bu' anahtar kelimesini kullanıyoruz.
Bu nedenle, bir sınıfın birden fazla kurucusu, bağımsız değişken içermeyen bir kurucusu ve parametreleştirilmiş bir kurucusu olduğunda, args olmayan kurucudan parametreli bir kurucu çağırmak için 'this' anahtar sözcüğünü kullanırız. Bu aynı zamanda 'Yapıcının açık çağrısı'.
Bu anahtar kelimeye neden ihtiyacımız var?
Buna ihtiyacımız var çünkü yapıcıların açık çağrısı sadece yapıcı adını kullanarak doğrudan mümkün değil.
Dikkat edilecek noktalar:
- 'Bu' anahtar kelimesi, çağıran kurucudaki ilk ifade olmalıdır.
- Bir kurucu 'this' anahtar kelimesine sahipse, 'süper' olamaz. Bu, kurucunun süper veya buna sahip olabileceği anlamına gelir.
class TestClass { TestClass() { //calling Parameterized Constructor this('SoftwareTestingHelp'); System.out.println('TestClass::No-args Constructor'); } TestClass(String str) { System.out.println('TestClass:: Parameterized Constructor(String):' + str); } } class Main{ public static void main(String() args) { TestClass obj = new TestClass(); } }Çıktı:
Yukarıdaki programda, iki kuruculu bir 'TestClass' var. Biz buna ('SoftwareTestingHelp') args yapıcısından diyoruz. Bu, parametreli yapıcının açık çağrısıdır.
Oluşturucuyu Java'da Kopyala
C ++ 'daki kopya oluşturucunun farkındayız. Copy yapıcısı, argüman olarak bir nesne referansına sahip olan ve referans nesnenin verileri kullanılarak yeni bir nesne oluşturulan bir yapıcıdır.
C ++, programda sağlanmamışsa varsayılan bir kopya oluşturucu sağlar.
Java ayrıca kopya yapıcısı için destek sağlar, ancak varsayılan bir kopya oluşturucu sağlamaz.
Aşağıdaki Java programı, gerçek ve sanal bileşenlere sahip klasik karmaşık sayılar örneğini kullanarak kopya yapıcısını gösterir.
class Complex { private double real, imaginary; // parametrized constructor public Complex(double real, double imaginary) { System.out.println('Complex:: parametrized constructor'); this.real = real; this.imaginary = imaginary; } // copy constructor Complex(Complex c) { System.out.println('Complex::Copy constructor called'); real = c.real; imaginary = c.imaginary; } // Overriding the toString of Object class @Override public String toString() { return '(' + real + ' + ' + imaginary + 'i)'; } } public class Main { public static void main(String() args) { Complex c1 = new Complex(1, 5); //calls parametrized constructor System.out.println('C1 = ' + c1); // copy constructor called Complex c2 = new Complex(c1); System.out.println('C2 = ' + c2); // this is a simple assignment operator Complex c3 = c2; } } Çıktı:
Yukarıdaki program, parametreleştirilmiş bir kurucu ve bir kopya oluşturucuya sahip 'Karmaşık' bir sınıfa sahiptir. İlk olarak ana yöntemde, parametreleştirilmiş bir kurucu kullanarak bir c1 nesnesi oluşturuyoruz. Ardından aşağıdaki ifadeyi kullanarak,
Complex c2 = new Complex (c1); Yeni bir c2 nesnesi yaratılırken c1 başvurusu yapıcıya aktarılırken yukarıdaki ifade copy yapıcısını çağırır.
Java'da Yapıcı Zincirleme
Yapıcı zincirleme, bir kurucunun aynı sınıfın başka bir yapıcısını çağırma işlemidir.
Bir temel sınıftan miras aldığımızda bile, alt sınıf nesnesi oluşturulduğunda ilk olarak temel sınıfın yapıcısı çağrılır. Bu aynı zamanda bir yapıcı zincirleme örneğidir.
Java'da, Oluşturucu zincirleme iki yaklaşım kullanılarak gerçekleştirilebilir:
- Aynı sınıf içinde : Aynı sınıfın başka bir kurucusundan bir kurucuyu çağırdığımızda, bu () anahtar sözcüğünü kullanarak kullanabiliriz.
- Temel sınıftan: Temel sınıfın bir kurucusu, super anahtar sözcüğü kullanılarak türetilmiş sınıfın oluşturucusu tarafından çağrılabilir.
Yapıcı Zincirlemeye Neden İhtiyacımız Var?
Oluşturucumuzda birden fazla görevi gerçekleştirmek istediğimizde, her bir görevi tek bir kurucuda gerçekleştirmek yerine, görevleri birden çok kurucuya böleriz ve ardından yapıcı zincirleme ile sonuçlanan birbirlerinden oluşturucular çağırırız.
Yapıcı zincirleme yaparken uymamız gereken kurallardan bazıları aşağıda verilmiştir.
- Yapıcı zincirleme herhangi bir sırayla yapılır ve aynı sonuçları verir.
- 'This' anahtar kelimesi, yapıcıdaki ilk ifade olmalıdır.
- Bu anahtar kelime olmadan en az bir kurucumuz olmalıdır.
Programımızda bir miras olduğunda, yapıcı zincirleme de gerçekleştirebiliriz. Bu durumda, alt sınıf, temel sınıfın yapıcısını çağıracaktır. Bu alt sınıf nesnelerinin oluşturulması, üst sınıf üyelerinin başlatılmasıyla başlar.
Şimdi yapıcı zincirlemesini Java'da yukarıdaki yaklaşımları kullanarak uygulayacağız.
# 1) Aynı Sınıf İçinde Yapıcı Zincirleme
class DemoClass { // No args constructor DemoClass() { System.out.println('DemoClass::No args constructor'); } // parameterized constructor DemoClass(int val1) { // calls default constructor this(); System.out.println('DemoClass::Constructor with 1 argument: ' + val1); } // parameterized constructor DemoClass(int val1, int val2) { // invokes parameterized constructor with 1 argument this(5); System.out.print('DemoClass::constructor with 2 arguments:'); System.out.println('Product of 2 arguments = ' + val1 * val2); } } class Main{ public static void main(String args()) { // call parameterized constructor with 2 arguments new DemoClass(10, 15); } } Çıktı:
Daha önce de belirtildiği gibi, 'bu' anahtar kelimesini kullanarak aynı sınıf içinde yapıcı zincirleme gerçekleştiriyoruz. Yukarıdaki programda, üç kurucumuz var ve 'bu' anahtar kelimesini kullanarak diğerinden bir kurucu olarak adlandırıyoruz.
Temel Sınıftan
Bir sınıf başka bir sınıfı miras aldığında, yapıcı zinciri olan türetilmiş bir sınıfın bir nesnesini oluşturduğumuzda ilk olarak ana sınıfın yapıcısı çağrılır.
Türetilmiş sınıfta açık bir şekilde temel sınıf kurucusunu çağırmak istiyorsak, bu amaçla 'süper' anahtar kelimesini kullanmalıyız. 'Süper' anahtar kelimesini kullanarak, en üst sınıfa ulaşana kadar kalıtım hiyerarşisindeki üst sınıf oluşturucuları çağırabiliriz.
Aşağıdaki program, yapıcı zincirleme için 'süper' bir anahtar kelimenin kullanımını göstermektedir.
class BaseClass { String name; // no args constructor BaseClass() { this(''); System.out.println('BaseClass::No-argument constructor'); } // Parameterized constructor BaseClass(String name) { this.name = name; System.out.println('BaseClass::Parameterized constructor'); } } class DerivedClass extends BaseClass { // No-argument constructor DerivedClass() { System.out.println('DerivedClass::No-argument constructor'); } // parameterized constructor DerivedClass(String name) { super(name); // invokes Parameterized constructor of BaseClass System.out.println('DerivedClass::Parameterized constructor'); } } class Main { public static void main(String args()) { // invokes DerivedClass parameterized constructor DerivedClass obj = new DerivedClass('Java'); } }Çıktı:
Yukarıdaki programda, türetilmiş sınıfın parametreleştirilmiş yapıcısını 'Java' değeriyle çağırıyoruz. Bu yapıcı da 'super (name)' kullanan temel sınıf yapıcısına bir çağrı yapar; temel sınıfın parametreleştirilmiş yapıcısını çalıştırır.
Sıkça Sorulan Sorular
S # 1) Java'da bir Oluşturucu nasıl oluşturulur?
Cevap: Sınıfın adıyla aynı adı taşıyan özel bir yöntem olarak bir kurucu oluşturuyoruz. Bir kurucu da bir dönüş türüne sahip olamaz. Erişim değiştiricilere sahip olabilir ancak nihai, statik, soyut veya senkronize olamaz.
ABC bir sınıfsa, yapıcısını şu şekilde tanımlayabiliriz:
ABC(){} //no args constructor OR ABC(param1, param 2, …, param n) {} //parameterized constructorS # 2) Java'da bir Oluşturucunun Faydası Nedir?
Cevap: Yapıcıyı kullanarak, sınıfın üyelerini, an nesnesinin oluşturulduğu ilk şey olarak başlatabiliriz. Yapıcı, normal yöntemleri örtük olarak çağırma ihtiyacını ortadan kaldırır.
Oluşturucular nesne oluşturma aşamasında çağrıldıklarından, yapıcıda başlatma, başlatma görevleri vb. İle ilgili çeşitli görevleri gerçekleştirebiliriz.
S # 3) Yapıcılar neden kullanılıyor?
Cevap: Oluşturucular esas olarak sınıfın üyelerini başlatmak için kullanılır ve sınıfın nesnesi yaratılırken çağrılır.
S # 4) Oluşturucu özel olabilir mi?
Cevap: Evet, özel bir kurucumuz olabilir. Yapıcı özel olduğunda, sınıfın somutlaştırılması engellenebilir.
S # 5) İnşaatçı nihai olabilir mi?
Cevap: Hayır, son bir kurucumuz olamaz.
.jnlp dosyaları nasıl açılır
Sonuç
Bu eğitimde, Java'daki yapıcılar hakkındaki tartışmamıza başladık. İnşaatçının temellerini, yaratılışını ve uyulması gereken kuralları öğrendik. Java'da kopya oluşturucuları da tartıştık.
Varsayılan yapıcı ve yapıcı türleri ve yapıcı aşırı yükleme ve yapıcı zincirleme gibi kavramlar örneklerle özetlendi. Bu konuların bir parçası olarak, yapıcılarda 'bu' anahtar kelimenin kullanımını da gördük.
=> Kolay Java Eğitim Serisini Okuyun.
Önerilen Kaynaklar
- Java Class Vs Object - Java'da Sınıf ve Nesne Nasıl Kullanılır
- Java Temelleri: Java Sözdizimi, Java Sınıfı ve Temel Java Kavramları
- Java Tamsayı ve Örneklerle Java BigInteger Sınıfı
- Örneklerle Java Tarayıcı Sınıfı Eğitimi
- Java Dizi Sınıfı Eğitimi - Örneklerle java.util.Arrays Sınıfı
- Java Vektör Nedir | Örneklerle Java Vektör Sınıfı Eğitimi
- Java Arayüzü ve Örneklerle Soyut Sınıf Eğitimi
- Selenium WebDriver'da Java ile Robot Sınıfı