Değişken kapsam hakkında daha fazla bilgi

"Profesör bir türlü içinden çıkamıyor. Ders vermeye alışmış eski öğretmenler hep böyledir. Kitaplarda bulamayacağınız hiçbir şey söylemez. Yüzmeyi dinleyerek öğrenemezsiniz. " yüzme derslerine. Dersler ancak konuya aşina olduğunuzda ve neredeyse profesörünüz kadar bilgi sahibi olduğunuzda faydalıdır."

"Yine de dersleri faydalıdır."

"Evet. Yani, umarız öyledir. Konuyla ilgili ne kadar çok bakış açısı duyarsan, gerçeğe o kadar yaklaşırsın. Tek bir bakış açısı duyduğunda, yapabileceğin tek şey ona inanmak ya da inanmamak. işine geri dön."

"Sana daha önce gösterdiğim bir resme bakalım."

┏
┃public class Variables
┃┏
┃┃{
┃┃   private static String TEXT = "The end.";
┃┃  ┗━━━━━━━━━━━━━━━━━━━┛
┃┃   public static void main (String[] args)
┃┃ ┏                         ┗━━━━━━━┛
┃┃ ┃ {
┃┃ ┃    System.out.println("Hi");
┃┃ ┃    String s = "Hi!";
┃┃ ┃  ┏┗━━━━┛
┃┃ ┃  ┃ System.out.println(s);
┃┃ ┃  ┃ if (args != NULL)
┃┃ ┃  ┃ {
┃┃ ┃  ┃    String s2 = s;
┃┃ ┃  ┃   ┗━━━━┛
┃┃ ┃  ┃  ┏
┃┃ ┃  ┃  ┃ System.out.println(s2);
┃┃ ┃  ┃  ┗
┃┃ ┃  ┃ }
┃┃ ┃  ┃ Variables variables = new Variables();
┃┃ ┃  ┃ System.out.println(variables.instanceVariable);
┃┃ ┃  ┃ System.out.println(TEXT);
┃┃ ┃  ┗
┃┃ ┃ }
┃┃ ┗
┃┃   public String instanceVariable;
┃┃  ┗━━━━━━━━━━━━━━━┛
┃┃   public Variables()
┃┃   {
┃┃      instanceVariable = "Instance variable test.";
┃┃   }
┃┃}
┃┗
┗

1. Bir yöntemde bildirilen bir değişken, bildiriminin başlangıcından yöntemin sonuna kadar mevcuttur (görünür).

2. Bir kod bloğunda bildirilen bir değişken, kod bloğunun sonuna kadar mevcuttur.

3. Bir yöntemin parametreleri, yöntem geri dönene kadar mevcuttur.

4. Bir nesnedeki değişkenler, onları içeren nesnenin tüm ömrü boyunca mevcuttur. Görünürlükleri ayrıca özel erişim değiştiricileri tarafından yönetilir.

5. Programın çalıştığı süre boyunca statik (sınıf) değişkenler mevcuttur. Görünürlükleri ayrıca erişim değiştiricileri tarafından tanımlanır."

"Doğru. Bu resmi hatırlıyorum."

"Harika. Size bazı önemli noktaları hatırlatmama izin verin."

"Metodlarda bildirilen tüm değişkenler, ilan edildikleri noktadan yöntemin sonuna kadar mevcuttur (görünürdür) (Örnek 1)."

"Bir kod bloğunda bir değişken bildirilirse, kod bloğunun sonuna kadar var olur (Örnek 2)."

"Bir değişken bir yöntem parametresiyse, yöntemin tüm gövdesinde bulunur (görünürdür) (Örnek 3)."

"Bir değişken bir örnek değişken ise (Örnek 4), belirli bir nesneye bağlıdır ve nesne var olduğu sürece vardır. Hiçbir nesne yoksa, o zaman değişkenin örnekleri yoktur. Değişkene erişebilirsiniz (örn. değişken, sınıfın tüm metotlarından önce veya sonra bildirilmiş olmasına bakılmaksızın görünür.Her nesne için yeni bir değişken oluşturulur.Diğer nesnelerden bağımsızdır.Statik yöntemlerden bir örnek değişkene erişemezsiniz. . "

"Bir değişken static olarak bildirilirse, yani static anahtar sözcüğüyle işaretlenirse , sınıfı var olduğu sürece var olur. JVM genellikle ilk kullanımında bir sınıfı belleğe yükler. Statik değişkenler de bu zamanda başlatılır."

"Yukarıdaki örnek, dört değişkeni olan Cat sınıfını bildirir: a, b, s (statik olmayan değişkenler) ve count (statik bir değişken). Bu sınıftan birkaç nesne (örneğin üç) oluşturursak, her biri sınıfın statik olmayan değişkenlerinin kendi örneklerini içerecekler. Statik bir değişken, bir sınıfın tüm nesneleri tarafından paylaşılır. Teknik olarak konuşursak, herhangi bir Cat nesnesi oluşturulmadan önce bile var olduğundan, bu nesnelerin içinde bile değildir."

"Statik bir değişken bildirirsek ne olur s:"

"Tamam. Sanırım anladım."

"Aynı ada sahip değişkenleri bildirebilir misiniz?"

"Bir yöntemin içinde değil. Bir yöntemin içinde bildirilen tüm değişkenlerin benzersiz adları olmalıdır. Bir yöntemin bağımsız değişkenleri de yerel değişkenler olarak kabul edilir."

"Üye değişkenleri ne olacak?"

"Üye değişkenler ayrıca her sınıf için benzersiz olmalıdır."

"Ancak bir istisna var: yerel değişkenlerin ve üye değişkenlerin adları aynı olabilir. "

"Böyle bir değişkeni değiştirirsek, aynı isimli iki değişkenden hangisi değişir?"

"Kodumuzda birkaç görünür (erişilebilir) değişken varsa - örneğin, bir örnek değişken ve bir yerel değişken - yerel değişkene erişilecektir."

class Main
{
    public int count = 0;     // Declare an instance variable

    public void run()
    {
        count = 15;           // Access the instance variable
        int count = 10;       // Declare a local method variable
        count++;             // Access the method variable
    }
}

"Bu kod iki sayma değişkeni bildiriyor. 3. Satır bir örnek değişkeni ve 8. satır yerel bir değişken bildiriyor ."

"Çalıştır yöntemi çalıştırıldığında şunlar olur:"

"7. satırda, örnek değişkene erişiyoruz ve ona 15 değerini atadık"

"8. satırda, yeni bir yerel değişken bildiriyoruz (oluşturuyoruz) : count. Bu, örnek değişkeni maskeliyor. Yerel değişken, yöntemdeki sonraki tüm kodun göreceği (erişim)."

"Anladım."

"Yerel değişken, örnek değişkeni maskeliyor. Diğer bir deyişle, yerel değişken erişilecek olandır. Ancak, örnek değişkene de erişebilirsiniz. Bunu yapmak biraz daha karmaşıktır."

ClassName.variableName

// Here are some examples:
Cat.catsCount

this.variableName

// Here are some examples:
this.catsCount

"Bana statik yöntemler ve statik değişkenler hakkında başka ne söyleyebilirsin?"

"Statik yöntemler ve değişkenler sınıfın nesnelerine bağlı değildir, sınıfın kendisine bağlıdırlar. On Değişken nesnesi oluşturursak (bu seviyenin başındaki örneğe bakın), on adet instanceVariable değişkenimiz olur (her biri için bir tane). nesne) ve yalnızca bir paylaşılan (statik) değişken TEXT ."

"Bir sorum var."

"Statik ve statik olmayan yöntemler arasındaki fark nedir?"

"Statik olmayan bir yöntemin nasıl çalıştığına bir göz atalım:"

Cat cat = new Cat();
String name = cat.getName();
cat.setAge(17);
cat.setChildren(cat1, cat2, cat3);

Cat cat = new Cat();
String name = Cat.getName(cat);
Cat.setAge(cat,17);
Cat.setChildren(cat, cat1, cat2, cat3);

" <object> dot <method name> kullanarak bir yöntemi çağırdığınızda , aslında bir sınıf yöntemini çağırıyorsunuz ve aynı nesneyi ilk bağımsız değişken olarak geçiriyorsunuz. Yöntemin içinde , nesne 'this' olarak adlandırılır . yöntemi bu nesne ve verileri üzerinde gerçekleştirilir."

"Vay canına! Demek her şey böyle çalışıyor!"

"Ve statik bir yöntem böyle çalışır."

Cat cat1 = new Cat();
Cat cat2 = new Cat();
int catCount = Cat.getAllCatsCount();

Cat cat1 = new Cat();
Cat cat2 = new Cat();
int catCount = Cat.getAllCatsCount(null);

"Statik bir yöntem çağırdığınızda, ona hiçbir nesne iletilmez. Başka bir deyişle, 'bu' eşittir null . Bu nedenle statik bir yöntem, statik olmayan değişkenlere ve yöntemlere erişemez (çünkü geçirecek ' bu' yoktur) bu yöntemlere)."

"Hmmm. Sanırım anladım. En azından biraz."

"Ve işte Diego Amca geliyor... ve görevleri."