Java, nesne yönelimli bir dildir. Bu, Java programlarını nesne yönelimli bir paradigma kullanarak yazmanız gerektiği anlamına gelir. Ve bu paradigma, programlarınızda nesneleri ve sınıfları kullanmayı gerektirir. Sınıfların ve nesnelerin ne olduğunu ve temel OOP ilkelerinin (soyutlama, kalıtım, polimorfizm ve kapsülleme) pratikte nasıl uygulanacağını anlamak için örnekler kullanmayı deneyelim.
nesne nedir?
İçinde yaşadığımız dünya nesnelerden oluşur. Etrafımıza baktığımızda evler, ağaçlar, arabalar, mobilyalar, tabaklar ve bilgisayarlarla çevrili olduğumuzu görebiliriz. Bütün bunlar birer nesnedir ve her birinin kendine özgü özellikleri, davranışları ve amaçları vardır. Nesnelere alışkınız ve onları her zaman çok özel amaçlar için kullanırız. Örneğin işe gitmemiz gerekiyorsa araba kullanırız. Yemek yemek istiyorsak tabak kullanırız. Ve dinlenmek istiyorsak rahat bir kanepe buluyoruz. İnsanlar, günlük yaşamdaki sorunları çözmek için nesneler açısından düşünmeye alışkındır. Nesnelerin programlamada kullanılmasının bir nedeni de budur. Bu yaklaşıma nesne yönelimli programlama denir. Bir örnek verelim. Yeni bir telefon geliştirdiğinizi ve seri üretime geçmek istediğinizi düşünün. Telefonun geliştiricisi olarak, ne işe yaradığını biliyorsunuz, nasıl çalıştığı ve parçalarının neler olduğu (gövde, mikrofon, hoparlör, teller, düğmeler vb.). Dahası, bu parçaları nasıl bağlayacağınızı yalnızca siz bilirsiniz. Ancak telefonları kişisel olarak yapmayı planlamıyorsunuz - bunu yapmak için bütün bir çalışan ekibiniz var. Telefonun parçalarının nasıl birleştirileceğini defalarca anlatma ihtiyacını ortadan kaldırmak ve tüm telefonların aynı şekilde yapılmasını sağlamak için, onları üretmeye başlamadan önce, telefonun nasıl organize edildiğini anlatan bir çizim yapmanız gerekir. OOP'de böyle bir açıklama, çizim, diyagram veya şablona sınıf diyoruz. Program çalışırken nesne oluşturmanın temelini oluşturur. Bir sınıf, alanlardan, yöntemlerden ve bir oluşturucudan oluşan ortak bir şablon gibi, belirli türdeki nesnelerin tanımıdır. Bir nesne, bir sınıfın örneğidir.
Soyutlama
Şimdi gerçek dünyadaki bir nesneden programdaki bir nesneye nasıl geçebileceğimizi düşünelim. Telefonu örnek olarak kullanacağız. Bu iletişim aracının 100 yılı aşkın bir geçmişi vardır. Modern telefon, 19. yüzyıldaki selefinden çok daha karmaşık bir cihazdır. Telefonu kullanırken, onun organizasyonunu ve içinde meydana gelen süreçleri düşünmüyoruz. Biz sadece telefonun geliştiricileri tarafından sağlanan işlevleri kullanıyoruz: bir telefon numarası girmek ve arama yapmak için düğmeler veya dokunmatik ekran. İlk telefon arayüzlerinden biri, arama yapmak için döndürülmesi gereken bir kranktı. Tabii ki, bu çok uygun değildi. Ancak görevini kusursuz bir şekilde yerine getirdi. En modern ve ilk telefonları karşılaştırırsanız, 19. yüzyılın sonlarına ait cihaz ve modern akıllı telefon için en önemli işlevleri hemen tanımlayabilirsiniz. Bunlar, çağrı yapma ve çağrı alma yeteneğidir. Aslında telefonu telefon yapan da budur, başka bir şey değil. Şimdi sadece bir OOP ilkesi uygulandı: bir nesnenin en önemli özelliklerini ve bilgilerini tanımlayın. Bu ilkeye soyutlama denir. OOP'de soyutlama, gerçek dünyadaki bir görevin öğelerini bir programdaki nesneler olarak temsil etme yöntemi olarak da tanımlanabilir. Soyutlama her zaman bir nesnenin belirli özelliklerinin genelleştirilmesiyle ilişkilendirilir, bu nedenle asıl mesele, eldeki görev bağlamında anlamlı bilgileri önemsiz olanlardan ayırmaktır. Ek olarak, çeşitli soyutlama seviyeleri olabilir. İzin vermek' Soyutlama ilkesini telefonlarımıza uygulamayı deneyelim. Başlamak için, ilk telefonlardan günümüzün telefonlarına kadar en yaygın telefon türlerini belirleyeceğiz. Örneğin, bunları Şekil 1'deki diyagram biçiminde gösterebiliriz. Soyutlamayı kullanarak, artık bu nesne hiyerarşisindeki genel bilgileri belirleyebiliriz: genel soyut nesne (telefon), telefonun ortak özellikleri (ör. üretildiği yıl) ve ortak arayüz (tüm telefonlar çağrı alabilir ve yapabilir). İşte Java'da nasıl göründüğü:
public abstract class AbstractPhone {
private int year;
public AbstractPhone(int year) {
this.year = year;
}
public abstract void call(int outgoingNumber);
public abstract void ring(int incomingNumber);
}
Bir programda, bu soyut sınıfı kullanarak ve aşağıda inceleyeceğimiz diğer temel OOP ilkelerini uygulayarak yeni telefon türleri oluşturabiliriz.
kapsülleme
Soyutlama ile tüm nesneler için ortak olanı tanımlarız. Ancak her telefon türü benzersizdir ve bir şekilde diğerlerinden farklıdır. Bir programda sınırları nasıl çizeriz ve bu bireyselliği nasıl tanımlarız? Hiç kimsenin yanlışlıkla veya kasten telefonumuzu kırmaması veya bir modeli diğerine dönüştürmeye çalışmaması için nasıl yaparız? Gerçek dünyada cevap açıktır: tüm parçaları bir telefon kılıfına koymanız gerekir. Ne de olsa, yapmazsanız - bunun yerine telefonun tüm dahili parçalarını ve bağlantı kablolarını dışarıda bırakmak - bazı meraklı deneyciler kesinlikle telefonumuzu "geliştirmek" isteyecektir. Bu tür kurcalamayı önlemek için, bir nesnenin tasarımında ve çalışmasında kapsülleme ilkesi kullanılır. Bu ilke, bir nesnenin özniteliklerinin ve davranışının tek bir sınıfta, yani nesnede birleştirildiğini belirtir. s dahili uygulaması kullanıcıdan gizlenir ve nesneyle çalışmak için genel bir arayüz sağlanır. Programcının görevi, bir nesnenin özniteliklerinden ve yöntemlerinden hangilerinin genel erişim için uygun olması gerektiğini ve hangilerinin erişilmemesi gereken dahili uygulama ayrıntıları olduğunu belirlemektir.
Kapsülleme ve erişim kontrolü
Bir telefonla ilgili bilgilerin (üretim yılı veya üreticinin logosu) üretildiğinde sırtına kazınmış olduğunu varsayalım. Bilgi (durumu) bu belirli modele özeldir. Üreticinin bu bilgilerin değişmez olduğundan emin olduğunu söyleyebiliriz - herhangi birinin gravürü kaldırmayı düşünmesi pek olası değildir. Java dünyasında, bir sınıf, alanları kullanarak gelecekteki nesnelerin durumunu tanımlar ve davranışları, yöntemler kullanılarak tanımlanır. Bir nesnenin durumuna ve davranışına erişim, alanlara ve yöntemlere uygulanan değiştiriciler kullanılarak kontrol edilir: özel, korumalı, genel ve varsayılan. Örneğin, üretim yılı, üretici adı ve yöntemlerden birinin sınıfın dahili uygulama ayrıntıları olduğuna ve programdaki diğer nesneler tarafından değiştirilemeyeceğine karar verdik. kodda,
public class SomePhone {
private int year;
private String company;
public SomePhone(int year, String company) {
this.year = year;
this.company = company;
}
private void openConnection(){
// findSwitch
// openNewConnection...
}
public void call() {
openConnection();
System.out.println("Calling");
}
public void ring() {
System.out.println("Ring-ring");
}
}
Özel değiştirici, sınıfın alanlarına ve yöntemlerine yalnızca bu sınıf içinde erişilmesine izin verir. Bu, özel yöntemler çağrılamadığından özel alanlara dışarıdan erişmenin imkansız olduğu anlamına gelir. OpenConnection yöntemine erişimin kısıtlanması, yöntemin başka nesneler tarafından kullanılmaması veya onların çalışmalarını kesintiye uğratmaması garanti edildiğinden, bize yöntemin dahili uygulamasını özgürce değiştirme olanağı da sağlar. Nesnemizle çalışmak için, public değiştiriciyi kullanarak call ve ring yöntemlerini kullanılabilir durumda bırakıyoruz. Nesnelerle çalışmak için halka açık yöntemler sağlamak da kapsüllemenin bir parçasıdır, çünkü erişim tamamen reddedilirse işe yaramaz hale gelir.
Miras
Telefonların şemasına bir kez daha göz atalım. Bir modelin kendi kolu boyunca daha üstte yer alan modellerin tüm özelliklerine sahip olduğu ve kendi özelliklerinden bazılarını eklediği bir hiyerarşi olduğunu görebilirsiniz. Örneğin, bir akıllı telefon iletişim için hücresel bir ağ kullanır (cep telefonu özelliklerine sahiptir), kablosuz ve taşınabilirdir (telsiz telefon özelliklerine sahiptir) ve arama alabilir ve yapabilir (telefon özelliklerine sahiptir). Burada sahip olduğumuz, nesne özelliklerinin kalıtımıdır. Programlamada kalıtım, yenilerini tanımlamak için mevcut sınıfları kullanmak anlamına gelir. Bir akıllı telefon sınıfı oluşturmak için kalıtımı kullanma örneğini ele alalım. Tüm kablosuz telefonlar, belirli bir pil ömrüne sahip olan şarj edilebilir pillerle çalışır. Buna göre bu özelliği telsiz telefon sınıfına ekliyoruz:
public abstract class CordlessPhone extends AbstractPhone {
private int hour;
public CordlessPhone (int year, int hour) {
super(year);
this.hour = hour;
}
}
Cep telefonları telsiz telefonun özelliklerini devralır ve bu sınıfta arama ve çalma yöntemlerini uygularız:
public class CellPhone extends CordlessPhone {
public CellPhone(int year, int hour) {
super(year, hour);
}
@Override
public void call(int outgoingNumber) {
System.out.println("Calling " + outgoingNumber);
}
@Override
public void ring(int incomingNumber) {
System.out.println("Incoming call from " + incomingNumber);
}
}
Ve son olarak, klasik cep telefonlarının aksine tam teşekküllü bir işletim sistemine sahip akıllı telefon sınıfımız var. İşletim sisteminde çalışabilen yeni programlar ekleyerek akıllı telefonunuzun işlevselliğini artırabilirsiniz. Kodda, sınıf aşağıdaki gibi tanımlanabilir:
public class Smartphone extends CellPhone {
private String operationSystem;
public Smartphone(int year, int hour, String operationSystem) {
super(year, hour);
this.operationSystem = operationSystem;
}
public void install(String program) {
System.out.println("Installing " + program + " for " + operationSystem);
}
}
Gördüğünüz gibi, Akıllı Telefon sınıfını tanımlamak için epeyce yeni kod oluşturduk , ancak yeni işlevlere sahip yeni bir sınıfımız var. Bu OOP ilkesi, gereken Java kodu miktarını önemli ölçüde azaltmayı mümkün kılar ve böylece programcı için hayatı kolaylaştırır.
polimorfizm
Çeşitli telefon türlerinin görünüm ve tasarımındaki farklılıklara rağmen, bazı ortak davranışları belirleyebiliriz: hepsi arama alabilir ve yapabilir ve hepsinin oldukça açık ve basit bir kontrol seti vardır. Programlama açısından, (zaten aşina olduğumuz) soyutlama ilkesi, telefon nesnelerinin ortak bir arayüze sahip olduğunu söylememizi sağlar. Bu nedenle kişiler, cihazın teknik detaylarına girmeden, aynı kontrollere (mekanik düğmeler veya dokunmatik ekran) sahip farklı telefon modellerini kolayca kullanabilirler. Böylece sürekli cep telefonu kullanırsınız ve arkadaşınızın sabit hattından kolayca arama yapabilirsiniz. Bir programın ortak bir arayüze sahip nesneleri, nesnenin iç yapısı hakkında herhangi bir bilgi olmadan kullanabileceğini söyleyen OOP ilkesine polimorfizm denir. İzin vermek' Başka bir kullanıcıyı aramak için herhangi bir telefonu kullanabilen bir kullanıcıyı tanımlamak için programımıza ihtiyacımız olduğunu düşünün. Bunu şu şekilde yapabiliriz:
public class User {
private String name;
public User(String name) {
this.name = name;
}
public void callAnotherUser(int number, AbstractPhone phone){
// And here's polymorphism: using the AbstractPhone type in the code!
phone.call(number);
}
}
}
Şimdi birkaç çeşit telefondan bahsedeceğiz. İlk telefonlardan biri:
public class ThomasEdisonPhone extends AbstractPhone {
public ThomasEdisonPhone(int year) {
super(year);
}
@Override
public void call(int outgoingNumber) {
System.out.println("Crank the handle");
System.out.println("What number would you like to connect to?");
}
@Override
public void ring(int incomingNumber) {
System.out.println("The phone is ringing");
}
}
Sıradan bir sabit hatlı telefon:
public class Phone extends AbstractPhone {
public Phone(int year) {
super(year);
}
@Override
public void call(int outgoingNumber) {
System.out.println("Calling " + outgoingNumber);
}
@Override
public void ring(int incomingNumber) {
System.out.println("The phone is ringing");
}
}
Ve son olarak, harika bir görüntülü telefon:
public class VideoPhone extends AbstractPhone {
public VideoPhone(int year) {
super(year);
}
@Override
public void call(int outgoingNumber) {
System.out.println("Connecting video call to " + outgoingNumber);
}
@Override
public void ring(int incomingNumber) {
System.out.println("Incoming video call from " + incomingNumber);
}
}
main() yönteminde nesneler oluşturacağız ve callAnotherUser() yöntemini test edeceğiz:
AbstractPhone firstPhone = new ThomasEdisonPhone(1879);
AbstractPhone phone = new Phone(1984);
AbstractPhone videoPhone=new VideoPhone(2018);
User user = new User("Jason");
user.callAnotherUser(224466, firstPhone);
// Crank the handle
// What number would you like to connect to?
user.callAnotherUser(224466, phone);
// Calling 224466
user.callAnotherUser(224466, videoPhone);
// Connecting video call to 224466
Kullanıcı nesnesinde aynı yöntemi çağırmak farklı sonuçlar üretir. Çağrı yönteminin belirli bir uygulaması, program çalışırken iletilen belirli nesne türüne bağlı olarak callAnotherUser() yöntemi içinde dinamik olarak seçilir . Bu, polimorfizmin ana avantajıdır - çalışma zamanında bir uygulama seçme yeteneği. Yukarıda verilen telefon sınıfları örneklerinde, yöntem geçersiz kılmayı kullandık - temel sınıfta tanımlanan bir yöntemin uygulanmasını, yöntem imzasını değiştirmeden değiştirdiğimiz bir hile. Bu, esasen yöntemin yerini alır: alt sınıfta tanımlanan yeni yöntem, program yürütüldüğünde çağrılır. Genellikle, bir yöntemi geçersiz kıldığımızda, @Overrideaçıklama kullanılır. Derleyiciye geçersiz kılma ve geçersiz kılma yöntemlerinin imzalarını kontrol etmesini söyler. Son olarak, Java programlarınızın OOP ilkeleriyle tutarlı olduğundan emin olmak için şu ipuçlarını izleyin:
bir nesnenin ana özelliklerini tanımlayın;
ortak özellikleri ve davranışları tanımlayın ve sınıfları oluştururken kalıtımı kullanın;
nesneleri tanımlamak için soyut türleri kullanın;
bir sınıfın dahili uygulamasıyla ilgili yöntemleri ve alanları her zaman gizlemeye çalışın.
Soyutlamayı kullanarak, artık bu nesne hiyerarşisindeki genel bilgileri belirleyebiliriz: genel soyut nesne (telefon), telefonun ortak özellikleri (ör. üretildiği yıl) ve ortak arayüz (tüm telefonlar çağrı alabilir ve yapabilir). İşte Java'da nasıl göründüğü:
GO TO FULL VERSION