MERHABA! Bugün Java'daki sınıflardan bahsedeceğiz. Sınıfların Java programlamanın temel taşını oluşturduğunu söyleyebilirsiniz. Bir programcı olduğunuzda, neredeyse tüm işiniz çeşitli işlevlere sahip kendi sınıflarınızı yazmak olacaktır. Bunun ne anlama geldiğini ve nasıl çalıştığını görelim. :) Bildiğiniz gibi Java, nesne yönelimli bir programlama dilidir. Tüm programlar, şu veya bu şekilde birbiriyle ilişkili nesnelerden oluşur. Bir sınıf, esasen, bir nesne için bir şablondur. Nesnenin nasıl görüneceğini ve hangi işlevlere sahip olacağını belirler. Her nesne bir sınıfın nesnesidir. Bu çok basit örneği ele alalım:
public class Cat {
String name;
int age;
}
Diyelim ki herhangi bir nedenle kedileri içeren bir program yazıyoruz (örneğin, çevrimiçi bir hesaba erişim sağlayan bir veteriner kliniğimiz var). Bir Cat sınıfı oluşturduk ve içinde iki değişken bildirdik: String name ve int age . Bu üye değişkenlere alanlar denir. Temelde bu, gelecekte oluşturacağımız tüm kediler için bir şablon. Her Cat nesnesinin iki değişkeni olacaktır: bir ad ve bir yaş.
public class Cat {
String name;
int age;
public static void main(String[] args) {
Cat smudge = new Cat();
smudge.age = 3;
smudge.name = "Smudge";
System.out.println("We created a cat named " + smudge.name + ". His age is " + smudge.age);
}
}
İşte nasıl çalıştığı! Bir kedi yaratıyoruz, ona bir isim ve yaş veriyoruz ve hepsini konsolda gösteriyoruz. Kekin parçası. :) Çoğu zaman, sınıflar gerçek dünyadaki şeyleri ve fenomenleri tanımlar. Bir kedi, bir masa, bir insan, bir şimşek, bir kitap sayfası, bir tekerlek—tüm bunları programlarınızda bireysel sınıfları kullanarak yaratacaksınız. Şimdilik Cat sınıfında bildirdiğimiz değişkenlere odaklanalım . Bunlara alanlar veya örnek değişkenler denir. İsimleri gerçekten her şeyi söylüyor. Cat sınıfının her örneği (veya nesnesi) bu değişkenlere sahip olacaktır. Oluşturduğumuz her kedinin kendi isim değişkeni ve kendi yaşı olacaktır.değişken. Bu mantıklı - temelde gerçek kedilerde böyle. :) Örnek değişkenlere ek olarak, sınıf değişkenleri de (statik değişkenler) vardır. Örneğimizi bitirelim:
public class Cat {
String name;
int age;
static int count = 0;
public static void main(String[] args) {
Cat smudge = new Cat();
smudge.age = 3;
smudge.name = "Smudge";
count++;
Cat fluffy = new Cat();
fluffy.age = 5;
fluffy.name = "Fluffy";
count++;
System.out.println("We created a cat named " + smudge.name + ". His age is " + smudge.age);
System.out.println("We created a cat named " + fluffy.name + ". His age is " + fluffy.age);
System.out.println("Total number of cats = " + count);
}
}
Konsol çıktısı: Smudge adında bir kedi oluşturduk. Yaşı 3 Fluffy adında bir kedi yarattık. Yaşı 5 Toplam kedi sayısı = 2 Artık sınıfımızın count adında yeni bir değişkeni var. Oluşturulan kedileri saymakla görevlidir. Main'de her defasında bir kedi oluşturuyoruz.yönteminde bu değişkeni 1 artırıyoruz. Bu değişken static anahtar kelimesi kullanılarak bildiriliyor. Bu, sınıfın belirli bir nesnesine değil, sınıfa ait olduğu anlamına gelir. Bu elbette mantıklı: her kedinin adı o belirli kediye ait, ancak hepsi için geçerli olan bir kedi sayacına ihtiyacımız var. Bu tam olarak static anahtar kelimesinin başardığı şeydir: Count değişkenini tüm kediler için tek bir değişken yapar. Not: değişkeni görüntülediğimizde, leke.sayım veya kabarık.sayım kullanmıyoruz. Ne Smudge'a ne de Fluffy'ye ait değil; tüm Cat sınıfına aittir . Bu yüzden basitçe sayılır. Ayrıca Cat.count yazabilirsiniz. Bu da doğru olurdu. name değişkenini görüntülerken aşağıdakileri yapmazdık:
public class Cat {
String name;
int age;
static int count = 0;
public static void main(String[] args) {
Cat smudge = new Cat();
smudge.age = 3;
smudge.name = "Smudge";
count++;
System.out.println("We created a cat named " + name + ". His age is " + smudge.age);
System.out.println("Total number of cats = " + count);
}
}
Bu bir hata! Her kedinin kendi adı vardır. Derleyici burada karışıyor. "Konsola bir isim verin? Kimin ismi?" :/"
Yöntemler
Değişkenlere ek olarak, her sınıfın yöntemleri vardır. Onlar hakkında ayrı bir derste daha ayrıntılı olarak konuşacağız, ancak genel prensipler oldukça basit. Yöntemler, sınıfınızın işlevselliğini, yani sınıfınızdaki nesnelerin neler yapabileceğini tanımlar. Bu yöntemlerden birine zaten aşinasınız: main() yöntemi. Ancak, hatırlayabileceğiniz gibi, ana yöntem statiktir, yani tüm sınıfa aittir (mantık, değişkenlerle aynıdır). Ancak standart, statik olmayan yöntemler yalnızca oluşturduğumuz belirli nesneler üzerinde çağrılabilir. Örneğin, bir kedi sınıfı yazmak istiyorsak, programımızda bir kedinin hangi işlevlerin olması gerektiğini bilmemiz gerekir. Bu öncülde, kedimiz için birkaç yöntem yazalım:
public class Cat {
String name;
int age;
public void sayMeow() {
System.out.println("Meow!");
}
public void jump() {
System.out.println("Pounce!");
}
public static void main(String[] args) {
Cat smudge = new Cat();
smudge.age = 3;
smudge.name = "Smudge";
smudge.sayMeow();
smudge.jump();
}
}
Buna bir bak! Artık sınıfımız bir kediyi andırmaya çok daha yakın! Artık sadece adı ("Smudge") ve yaşı (3) olan bir kedimiz yok. Ayrıca miyav diyebilir ve zıplayabilir! Bu "işlevsellik" olmadan ne tür bir kedi olurdu? :) Belirli bir nesneyi (smudge) alıyoruz ve onun sayMeow() ve jump() yöntemlerini çağırıyoruz. Konsola bakalım: Miyav! Pençe! Gerçek bir kedi! :)
Kendi sınıflarınızı oluşturma. Soyutlama
Gelecekte, kendi sınıflarınızı yazmak zorunda kalacaksınız. Bunları yazarken nelere dikkat etmelisiniz? Değişkenlerden bahsediyorsak, o zaman soyutlama denen bir şeyi kullanmanız gerekir. Soyutlama, nesne yönelimli programlamanın dört temel ilkesinden biridir. Bir öğenin en önemli ve önemli özelliklerini çıkarmak ve tersine küçük veya önemsiz olanları bir kenara atmak anlamına gelir. Örneğin şirket çalışanları için bir dosya dolabı oluşturalım. Çalışan nesneleri oluşturmak için bir Çalışan yazdık.sınıf. Şirketimizin dosya dolabı için bir çalışanın önemli tanımlayıcıları nelerdir? İsim, doğum tarihi, SSN ve çalışan kimliği. Ancak şirketin çalışan kaydı için çalışanın boyuna, göz rengine veya saç rengine ihtiyacımız olacak gibi görünmüyor. Şirketlerin bu bilgilere ihtiyacı yoktur. Böylece, Çalışan sınıfında şu değişkenleri bildiririz: String name , int age , int socialSecurityNumber ve int staffId. Ve gereksiz bilgileri (göz rengi gibi) dışarıda bırakıyoruz. Başka bir deyişle, bir soyutlama yaratıyoruz. Ancak, mankenlik ajansları için bir dosya dolabı yapıyorsak, durum dramatik bir şekilde değişir. Bir modelin boyu, göz rengi ve saç rengi önemli özelliklerdir, ancak SSN'si bizim için kesinlikle önemsizdir. Bu nedenle, Model sınıfında şu değişkenleri oluşturmamız gerekiyor: String height , String hair , String eyes . Soyutlama böyle çalışır - çok kolay! :)
İnşaatçılar
Kedi örneğimize geri dönelim.
public class Cat {
String name;
int age;
public static void main(String[] args) {
Cat smudge = new Cat();
System.out.println("Here the program does something for 2 hours...");
smudge.age = 3;
smudge.name = "Smudge";
}
}
Bu kodu gözden geçirin ve programımızda neyin yanlış olduğunu anlamaya çalışın. Programımızda 2 saat boyunca adı ve yaşı belli olmayan bir kedi vardı! Elbette bu özünde yanlıştır. Veteriner kliniğinin veri tabanı, bilgisi olmayan kedileri içermemelidir. Şu anda kedimiz programcının insafına kalmış durumda. Adını ve yaşını belirtmeyi unutmayacağına ve her şeyin yoluna gireceğine güveniyoruz. Unutursa, veritabanında bir sorun olacaktır: isimsiz kediler. Bu sorunu nasıl çözebiliriz? Kedilerin isimsiz ve yaşsız yaratılmalarına bir şekilde engel olmalıyız. İnşaatçıların kurtarmaya geldiği yer burasıdır. Bir örnek verelim:
public class Cat {
String name;
int age;
// Constructor for the Cat class
public Cat(String name, int age) {
this.name = name;
this.age = age;
}
public static void main(String[] args) {
Cat smudge = new Cat("Smudge", 5);
}
}
Temel olarak, bir yapıcı, bir sınıfın nesneleri için bir şablondur. Bu durumda, her cat nesnesi için bir String ve bir int olmak üzere iki bağımsız değişkenin belirtilmesi gerektiğini belirtiyoruz . Şimdi isimsiz bir kedi yaratmaya çalışırsak işe yaramaz.
public class Cat {
String name;
int age;
public Cat(String name, int age) {
this.name = name;
this.age = age;
}
public static void main(String[] args) {
Cat smudge = new Cat(); // Error!
}
}
Artık sınıfın bir yapıcısı olduğuna göre, Java derleyicisi nesnelerin nasıl görünmesi gerektiğini bilir ve argümanlar belirtilmeden nesnelerin oluşturulmasına izin vermez. Şimdi yapıcı içerisinde gördüğünüz this anahtar kelimesini inceleyelim. Bu da basit. this anahtar sözcüğü belirli bir nesneyi belirtmek içindir. Yapıcıdaki kod
public Cat(String name, int age) {
this.name = name;
this.age = age;
}
neredeyse kelimesi kelimesine yorumlanabilir: "Bu kedinin adı (yarattığımız) = yapıcının adı parametresi için iletilen argüman. Bu kedinin yaşı (yarattığımız) = yapıcınınki için iletilen argüman yaş parametresi." Yapıcı çalıştıktan sonra, gerekli tüm değerlerin kedimize atandığını doğrulayabilirsiniz:
public class Cat {
String name;
int age;
public Cat(String name, int age) {
this.name = name;
this.age = age;
}
public static void main(String[] args) {
Cat smudge = new Cat("Smudge", 5);
System.out.println(smudge.name);
System.out.println(smudge.age);
}
}
Konsol çıktısı: Smudge 5 Yapıcı çağrıldığında:
Cat smudge = new Cat("Smudge", 5);
Bu aslında dahili olarak olan şeydi:
this.name = "Smudge";
this.age = 5;
Ve yapıcıya iletilen bağımsız değişkenlerin değerleri leke nesnesine atandı (bu durumda bunun anlamı budur). Aslında, bir sınıfta herhangi bir kurucu bildirmeseniz bile, yine de bir kurucu çağıracaktır! Ama bu nasıl mümkün olabilir? О_О Çünkü, tüm Java sınıflarının varsayılan bir yapıcısı vardır. Herhangi bir argüman almaz, ancak herhangi bir sınıftan herhangi bir nesne oluşturduğunuzda çağrılır.
public class Cat {
public static void main(String[] args) {
Cat smudge = new Cat(); // The default constructor is invoked here
}
}
İlk bakışta, bu açık olmayabilir. Bir nesne yarattık, ne olmuş yani? Yapıcı burada nerede bir şey yapıyor? Bunu görmek için, açık bir şekilde Cat sınıfı için boş bir oluşturucu yazalım . İçinde, konsola bazı ifadeler yazdıracağız. Cümle görüntülenirse, yapıcı çağrıldı.
public class Cat {
public Cat() {
System.out.println("A cat has been created!");
}
public static void main(String[] args) {
Cat smudge = new Cat(); // The default constructor is invoked here
}
}
Konsol çıktısı: Bir kedi yaratıldı! İşte onay. Varsayılan kurucu, sınıflarınızda her zaman görünmez bir şekilde bulunur. Ancak bununla ilgili bir şeyi daha bilmeniz gerekiyor. Bağımsız değişkenlerle bir kurucu oluşturduğunuzda, varsayılan kurucu bir sınıftan elenir. Aslında, bunun kanıtını zaten yukarıda gördük. Bu koddaydı:
public class Cat {
String name;
int age;
public Cat(String name, int age) {
this.name = name;
this.age = age;
}
public static void main(String[] args) {
Cat smudge = new Cat(); // Error!
}
}
İsimsiz ve yaşsız bir Cat yaratamadık, çünkü string ve int parametreleriyle bir Cat kurucusu tanımladık. Bu, varsayılan kurucunun sınıftan hemen kaybolmasına neden oldu. Bu nedenle, sınıfınızda bağımsız değişken içermeyen bir oluşturucu da dahil olmak üzere birkaç oluşturucuya ihtiyacınız varsa, onu ayrı ayrı bildirmeniz gerekeceğini unutmayın. Kliniğimiz, adları ve yaşları bilinmeyen sahipsiz yavru kedilere iyilik yapmak ve yardım etmek istiyor. O zaman kodumuz şöyle görünmelidir:
public class Cat {
String name;
int age;
// For cats with owners
public Cat(String name, int age) {
this.name = name;
this.age = age;
}
// For street cats
public Cat() {
}
public static void main(String[] args) {
Cat smudge = new Cat("Smudge", 5);
Cat streetCat = new Cat();
}
}
Artık açık bir varsayılan oluşturucu belirttiğimize göre, her iki kedi türünü de oluşturabiliriz. Yapıcıda, değerleri doğrudan atayabilirsiniz. Bunları her zaman argümanlardan almak zorunda değilsiniz. Örneğin, şablon olarak "Sokak kedisi No. <sayım>" kullanarak veritabanındaki tüm sokak kedilerini etiketleyebiliriz. :
public class Cat {
String name;
int age;
static int count = 0;
public Cat() {
count++;
this.name = "Street cat No. " + count;
}
public Cat(String name, int age) {
this.name = name;
this.age = age;
}
public static void main(String[] args) {
Cat streetCat1 = new Cat();
Cat streetCat2 = new Cat();
System.out.println(streetCat1.name);
System.out.println(streetCat2.name);
}
}
Sokak kedilerimizi sayan bir sayım değişkenimiz var . Varsayılan oluşturucu her çalıştırıldığında, sayımı 1 artırırız ve bu sayıyı kedinin adına ekleriz. Argümanların sırası yapıcılar için çok önemlidir. Yapıcımıza iletilen ad ve yaş argümanlarını değiştirelim.
public class Cat {
String name;
int age;
public Cat(int age, String name) {
this.name = name;
this.age = age;
}
public static void main(String[] args) {
Cat smudge = new Cat("Smudge", 10); // Error!
}
}
Bir hatamız var! Yapıcı, bir Cat nesnesi oluşturulduğunda, bu sırayla bir sayı ve bir dize iletilmesi gerektiğini açıkça belirtir. Yani kodumuz çalışmıyor. Kendi sınıflarınızı ilan ederken bu kuralı hatırladığınızdan ve bunlara saygı gösterdiğinizden emin olun:
public Cat(String name, int age) {
this.name = name;
this.age = age;
}
public Cat(int age, String name) {
this.age = age;
this.name = name;
}
Bunlar tamamen farklı iki kurucu! Şimdi, materyal hakkındaki anlayışınızı sağlamlaştırmak için birkaç görevi tamamlayın. :)
Eski Eserler Müzesi.
Göreviniz bir Artifact sınıfı tasarlamaktır .
Müzede saklanan üç tür eser vardır.
İlk tip hakkında müze tarafından verilen seri numarası (örneğin: 212121) dışında hiçbir şey bilmiyoruz.
İkinci tür için seri numarasını ve onu oluşturan kültürü biliyoruz (örneğin: 212121, "Aztekler").
Üçüncü tip için seri numarasını, onu yaratan kültürü ve yaratıldığı yüzyılı biliyoruz (örneğin: 212121, "Aztekler", 12).
Müzede tutulan eski eserleri tanımlayan bir Artifact sınıfı oluşturun ve sınıf için gerekli oluşturucu setini yazın. Ardından, main() yönteminde her türden bir yapı oluşturun.
public class Artifact {
// Write your code here
public static void main(String[] args) {
// Write your code here
}
}
Randevu sitesi
Bir flört sitesi için bir kullanıcı veritabanı oluşturalım.
Ancak sorun şu: Argümanların gerekli sırasını unuttunuz ve teknik dokümantasyon mevcut değil. Şu alanlara sahip olacak
bir Kullanıcı sınıfı tasarlayın: name ( String ), age ( short ) ve height ( int ).
İsim, yaş ve boy herhangi bir sırada belirtilebilecek şekilde uygun sayıda oluşturucu oluşturun.
public class User {
String name;
short age;
int height;
// Write your code here
public static void main(String[] args) {
}
}
Öğrendiklerinizi pekiştirmek için Java Kursumuzdan bir video dersi izlemenizi öneririz.
GO TO FULL VERSION