Java'daki nesneler

1. Nesneler

Java'da her şey bir nesnedir.

Daha doğrusu, Java'da nesne olmayan çok az şey vardır. Örneğin, ilkel tipler. Ancak bu, kuralın oldukça nadir bir istisnasıdır.

Peki nesne nedir?

Nesne, verileri işleyen yöntemlerle birlikte verileri gruplandıran bir varlıktır . "Veri" dediğimizde elbette değişkenleri kastediyoruz.

Bir nesnenin değişkenlerine "veri" veya "durum" denir.

Bir nesnenin yöntemlerinin onun "davranışı" olduğu söylenir. Bir nesnenin durumunu (değişkenleri) yalnızca o nesnenin yöntemlerini kullanarak değiştirmek adettendir. Bir nesnenin değişkenlerini doğrudan değiştirmek (yöntemlerini kullanmamak) kötü bir biçim olarak kabul edilir.

Her nesnenin yanı sıra her değişkenin bir türü vardır . Bu tür, nesne oluşturulduğunda bir kez belirlenir ve gelecekte değiştirilemez. Bir nesnenin türü onun sınıfıdır.

Her nesnenin kendi örnek değişkenleri (alanları) kopyası vardır. Bir sınıfta statik olmayan bir int a değişkeni bildirilirse ve programınız o sınıftan 10 nesne oluşturursa, her nesnenin kendi int a değişkeni olacaktır.

Bir nesne ile etkileşim

Bir nesneyle çalışmanın en uygun yolu, ona bir başvuruyu bir değişkende depolamak ve ardından bu değişkende yöntemleri çağırmaktır. Bu size tanıdık gelecektir:

variable.method()

Nerede variablebir nesneye referans depolayan bir değişkendir ve methodo sınıfın bir yöntemidir.

Bir nesnenin bir alanına (değişkenine) atıfta bulunmak istiyorsanız, nokta operatörünü de kullanmanız gerekir :

variable.field

Nerede variablebir nesneye referans depolayan bir değişkendir ve fieldbir örnek değişkendir (alan).

2. newoperatör

Belirli bir sınıftan bir nesne oluşturmak için operatörü kullanmanız gerekir new. Genel olarak, bir nesne yaratmak şöyle görünür:

Class variable = new Class(arguments);

ClassDeğişkenin sınıfının adı variableve oluşturulacak nesnenin sınıfının adı nerede . Ve, variable oluşturulan nesneye bir referans depolayan bir değişkendir. Ve, argumentsyapıcıya iletilen bağımsız değişkenlerin virgülle ayrılmış listesi için yer tutucudur.

İletilebilecek bağımsız değişkenlerin belirli listesi, sınıfı yazan programcılar tarafından belirlenir.

Daha önce nesneler yarattınız ve hatta bu özel yapıyı kullandınız. Unutmamışsındır umarım?

Scanner console = new Scanner(System.in);
int x = console.nextInt();

Scanner console— bu, consoletürü olan bir değişken oluşturur Scanner. — bu yeni bir nesne oluşturur. Ve atama operatörü, değişkeni yeni oluşturulan nesneye bir referansa eşitler.new Scanner(System.in)Scannerconsole

İkinci satırda, nesneye bir referans depolayan değişkeni kullanarak nesne nextInt()üzerindeki yöntemi çağırıyoruz .ScannerconsoleScanner

Nesne oluşturma örnekleri:

String s = new String("Hello");

Scanner console = new Scanner("");

int[] data = new int[10];

Oluşturulan nesneler, sınıfın nesneleri veya sınıfın örnekleri olarak adlandırılırken , sınıf, nesnenin sınıfı olarak adlandırılır . Örneğin, sdeğişken, sınıfın bir örneğine bir referans depolar String.

3. Sınıflara giriş

Diğer programcılar tarafından yazılan sınıfları kullanmanın ne kadar uygun olduğunu zaten gördüğünüzü düşünüyorum. Peki ya kendi derslerinizi yazmaya ne dersiniz?

Kendi sınıfınıza ne zaman ve nerede ihtiyacınız olduğunu ve nasıl oluşturacağınızı nasıl anlarsınız?

Programcılar, programa yeni bir varlık getirmek istediklerinde genellikle kendi sınıflarını oluştururlar. Kulağa kafa karıştırıcı mı geliyor? Sonra açıklamaya çalışacağım ama çok uzaklardan başlayacağım.

veri grubu

Biraz basitleştirerek, Java'daki bir nesnenin, bir sınıfta bildirilen değişkenleri (örnek alanları) içeren bir bellek bloğu olduğunu söyleyebiliriz. Veya başka bir deyişle, değişkenler bir grupta birleştirilir.

Diyelim ki programınızın noktaların koordinatlarını saklaması 100ve bunları ekranda görüntülemek için bir yönteme ihtiyacı var. Bu diziler kullanılarak yapılabilir. Örneğin, bunun gibi:

class Solution
{
   public static void printPoints(int[] x, int[] y, int[] color)
   {
     for (int i = 0; i < x.length; i++)
       System.out.println("Color of (" + x[i] + ", " + y[i] + ") = " + color[i]);
   }

   public static void main(String[] args)
   {
     int[] x = new int[100];
     int[] y = new int[100];
     int[] color = new int[100];
     printPoints(x, y, color);
   }
}

Bir nokta hakkındaki tüm bilgileri depolamak için tek bir tipimiz olsaydı çok daha uygun olurdu: x, y, color. Java'da böyle bir tür yoksa, kendiniz oluşturabilirsiniz.

PointBunu yapmak için, bir sınıf için kod yazacağız :

public class Point
{
   public int x;
   public int y;
   public int color;
}

Şimdi yukarıdaki kod şu şekilde yeniden yazılabilir:

class Solution
{
   public static void printPoints(Point[] points)
   {
     for (int i = 0; i < points.length; i++)
       System.out.println("Color of (" + points[i].x + ", " + point[i].y + ") = " + points[i].color);
   }

   public static void main(String[] args)
   {
     Point[] data = new Point[100];
     for (int i = 0; i < data.length; i++)
       data[i] = new Point();
     printPoints(data);
   }
}

PointŞimdi sınıfa nesne hakkında bilgi gösterecek bir metot ekleyelim :

public class Point
{
   public int x;
   public int y;
   public int color;
   public void print()
   {
     System.out.println("Color of (" + x + ", " + y + ") = " + color);
   }
}

Şimdi Solutionsınıf şöyle görünür:

class Solution
{
   public static void printPoints(Point[] points)
   {
     for (int i = 0; i < points.length; i++)
       points[i].print();
   }

   public static void main(String[] args)
   {
     Point[] data = new Point[100];
     for (int i = 0; i < data.length; i++)
       data[i] = new Point();
     printPoints(data);
   }
}

Noktanın koordinatlarını ve renk bilgilerini, Pointnoktanın durumunu gösteren metotla birlikte sınıfın içine ustaca sakladık.

Sınıflar, program karmaşıklığını yönetmenin bir yoludur. Büyük bir program birçok küçük sınıfa bölündüğünde daha az karmaşık hale gelir.

4. Değişken ve değişmez nesneler

Bir zamanlar Java'da sabitleri inceledik ve pek iç açıcı olmayan bir sonuca vardık. Sabitler, değişkenleri değişmekten korumanıza izin verir, ancak başvurdukları nesnelerde değişiklik yapılmasını engelleyemezler.

Java, bu sorunu çözmek için sabit nesneler buldu. Veya daha sık adlandırıldıkları şekliyle değişmez nesneler.

Bu arada, nesneleri değiştirilemeyen böyle bir sınıfı zaten biliyorsunuz: String. Bir Stringnesne oluşturulduktan sonra sonsuza kadar değişmeden kalır. Ve Java'nın yaratıcıları bunu nasıl başardı?

İlk olarak, sınıfın tüm değişkenleri Stringgizlenir, yani bildirilir private.

İkincisi, sınıfı miras alamazsınız String: sınıfın bildirimi, değiştiriciyi içerir final.

StringÜçüncüsü ve en ilginç olanı, teoride var olan nesneyi değiştirmesini bekleyeceğiniz sınıfın tüm yöntemleri aslında onu değiştirmez, bunun yerine yeni bir nesne döndürür.

Örneğin, toUpperCase()yöntem dizedeki tüm harfleri büyük yapar. Ancak yöntemin çağrıldığı nesneyi değiştirmek yerine Stringbüyük harflerden oluşan yeni bir nesne döndürür:

String text = "This is a very important message";
String message = text.toUpperCase();

Bu kodu çalıştırdıktan sonra bellekte olacak olan budur:

Bu nedenle, dizelerinizi herhangi bir yönteme iletmekten çekinmeyin: kimse onları değiştirmeyecek.