Değişken tanımlamaları

Javada iki tür değişken tipi vardır. “Primitives” ve “Reference variables”

Primitives: Primitive tipler de 8 tipten oluşur. “char, boolean, byte, short, int, long, double, float”

Reference variables: Reference variable (Referans değişkenleri) bir objeye erişim için kullanılır. Reference variable spesifik bir tipte tanımlanır ve bu spesifik tip değiştirilemez. Reference variable bir objenin referans tipine(tanımlanma tipi) erişim amacıyla kullanılır.

Declaring Primitives and Primitive Ranges

Primitive değişkenler sınıf değişkeni olarak tanımlanabilir (static), instance variable olarak tanımlanabilir, methodların parametreleri olarak tanımlanabilir ve yerel değişkenler olarak kullanılabilir. Tek bir satırda birden fazla sayıda primitive değişken tanımlayabilirsiniz.

Örnek primitive tanınmalması aşağıdaki gibidir.

byte b;
  1. boolean myBooleanPrimitive;
  2. int x, y, z;

Bir diğer bilmemiz gereken husus büyüklük sıralamaları. En küçük alandan en büyük alana doğru sıralamak gerekirse eğer —>>> byte, short, int, long

Aynı şekilde float türlerinde ise double türü floatlar arasında en büyük olandır.

Bir diğer bilmeniz gereken husus, tüm sayı türlerinde işaretlenme söz konusudur. Bir sayının negatif ya da pozitif olmasının belirlenme durumu. Burada bit türünden bir değerlendirme vardır. Byte olarak ele aldığımızda, ilk hane (sol baştan) eğer 1 ise negatif, 0 ise pozitiftir.

Örneğin byte türünde 00010011 değerini incelersek, ilk “0” işaretlendiği değeri betimler ki burada pozitiftir. Geriye kalan “0010011” ise değer kısmıdır.

Aynı durumu short içinde inceleyebiliriz. 1101 0011 1011 1110 değeri incelendiğinde, ilk bit “1” olduğu için bu sayı negatiftir. Değeri ise “101 0011 1011 1110”

1 Byte = 8 Bits = 1 byte ->> (-2 üzeri 7 ) =< byte =< (2 üzeri 7 )-1
1 Short = 16 Bits = 2 byte ->> (-2 üzer1 15) =< short =< (-2 üzer1 15)-1
1 int = 32 Bits = 4 byte ->> (-2 üzeri 31) =< int =< (-2 üzeri 31) -1
1 long = 64 Bits = 8 byte ->> (-2 üzeri 63) =< long =< (-2 üzeri 63)-1
1 float = 32 Bits = 4 byte
1 double= 64 Bits = 8 byte

Reference Variables

Reference Variables; static değişkenler olarak tanımlanabilir, instance variable olarak tanımlanabilir, method parametresi olabilir, ya da yerel değişken olarak kullanılabilir.

Legal kullanımı ve örneği aşağıdaki gibidir.

Object o;
  1. Dog myNewDogReferenceVariable;
  2. String s1, s2, s3;

Instance Variables

Sınıfın içerisinde fakat sınıf methodlarının dışında tanımlanan değişkenlerdir. Hangi sınıfın değişkenleri ise, o sınıf yaratılmadan yani örneği oluşturulmadan, instance variables’ların da örneği oluşturulmaz. Örneğin

class Employee {
  1.  // define fields (instance variables) for employee instances
  2.  private String name;
  3.  private String title;
  4.  private String manager;
  5. }

Empleyee sınıfında bulunan name, title, manager değişkenleri instance variable ‘dır.

**Bu “Instance Variables” lar, tanımlanırken 4 erişim seviyesine (default, private, public, protected) de sahip olabilirler.
**transient, final, abstract, synchronized, strictfp, native, static olarak işaretlenebilirler.

Local Variables —> final
Variables(non-local)—-> final,public, private, transient, protected, static, volatile
Methods —-> final,public,protected,private,static,abstract,synchronized,strictfp,native

Local Variables

Yerel değişkenler(Local Variables) method içerisinde ya da iç küme parantez ( { ) ile kapa küme parantez ( } ) arasında tanımlanır. Bu yerel değişkenlerin ömrü, bulundukları method içerisi ile ya da aç-kapa küme parantezler arası ile sınırlıdır. Yerel değişkenler yığında(stack) tutulur, heap ‘te değil.

Fakat eğer yerel değişken stack’te iken değişken object reference yoluyla oluşturulursa, obje de kendisini heap’te oluşturur.

Local değişkenlerde erişim kontrollerini kullanamazsınız. Örneğin public, private, protected gibi ama final kullanılabilir.

Yine unutulmaması gereken durumlardan bir tanesi, local değişkenler kullanılmadan önce ilk değer atamaları mutlaka yapılmalıdır.

class TestServer {
  1.  public void logIn() {
  2.  int count = 10;
  3.  }
  4.  public void doSomething(int i) {
  5.  count = i; // Compile olmaz! method dışındaki tanımlamaya buradan erişim sağlayamazsınız
  6.  }
  7. }

Yukarıdaki kod çalışmaz çünkü doSomething(int i) methodu, logIn() metodu içerisinde oluşturulan değişkene erişmeye çalışıyor fakat bu mümkün değil çünkü count değişkenin tanım aralığı logIn() methodu içerisi ile sınırlı.

package com.umitsamimi.localvariable;
  1.  
  2. public class TestServer {
  3.  
  4.  int count = 9;
  5.  
  6.  public void logIn() {
  7.   int count = 10;
  8.   System.out.println("local variable count is " + count);
  9.  }
  10.  
  11.  public void count() {
  12.   System.out.println("instance variable count is " + count);
  13.  }
  14.  
  15.  public static void main(String[] args) {
  16.   new TestServer().logIn();
  17.   new TestServer().count();
  18.  }
  19. }

Peki bu kodun çıktısı ne olur?

İlk olarak logIn() methodu çağrıldığı için ve logIn() methodunda yerel değişken count yeniden oluşturulduğu için, yerel değişkenin değeri, global olarak tanımlanan count değişkeni yerine kullanılır. Daha sonra ise count() methodu çağrılıyor fakat count() methodu count değişkenini yeniden oluşturmadığı için, global değişkenin değerini ekrana yazacaktır.

local variable count is 10
  1. instance variable count is 9

Peki ya global değişkendeki değere, ilk değer ataması yapılmasaydı nasıl olurdu?

package com.umitsamimi.localvariable;
  1.  
  2. public class TestServer {
  3.  
  4.  int count;  //Değer atanmadı
  5.  
  6.  public void logIn() {
  7.   int count = 10;
  8.   System.out.println("local variable count is " + count);
  9.  }
  10.  
  11.  public void count() {
  12.   System.out.println("instance variable count is " + count);
  13.  }
  14.  
  15.  public static void main(String[] args) {
  16.   new TestServer().logIn();
  17.   new TestServer().count();
  18.  }
  19. }

count global değişkeni primitive tipe sahip olduğu için, varsayılan değeri int olması sebebiyle 0 olacaktır.

local variable count is 10
  1. instance variable count is 0

Bir de kötü kullanıma örnek verelim..

class Foo {
  1.  int size = 27;
  2.  public void setSize(int size) {
  3.  size = size; // ??? hangi size değişkeni, hangisine atanıyor???
  4.  }
  5. }

Yukarıdaki gibi kullanacağınız yerel değişken kullanımı, kodun okunabilirliğini bozar ve zaten sağlıklı değildir. Bunun yerine aşağıdaki kullanımı tercih etmek daha doğrudur

class Foo {
  1.  int size = 27;
  2.  public void setSize(int size) {
  3.  this.size = size; // this.size means the current object's
  4.  // instance variable, size. The size
  5.  // on the right is the parameter
  6.  }
  7. }

Array Declarations

Aynı tipteki değişkenlerin kümelenmesi durumuna dizi denir. Java’da bu diziler, primitive de olabilir object’te fakat dizi’nin (arrays) kendisi object olduğundan “Heap” te tutulur.

Bilinmesi gereken 3 önemli husus vardır.
1)Nasıl “array reference” değişkeni oluşturulur? (declare)
2)Nasıl “array object” oluşturulur? (construct)
3)Nasıl array değişkenlerine değer atanır? (initialize)

Primitive Array Tanımlama
int[] key; // parantezler değişkenden önce (tavsiye edilen kullanım yöntemi)
int key []; // parantezler değişkenden sonra (legal, kullanılabilir fakat tavsiye edilmez)

Object reference ile Array Tanımlama

Thread[] threads; // Tavsiye edilen kullanım yöntemi
Thread threads []; // Legal ama tavsiye edilmeyen kullanım yöntemi

Çok boyutlu diziler de tanımlanabilir. Örneğin

  1. String[][][] occupantName;
  2. String[] managerName [];

Son olarak, dizi tanımlarken parantezler içerisinde dizinin ebatları amacıyla tanımlama yapılamaz. Örneğin;

  1. int[5] scores;

Yukarıdaki kod asla JAVA’da derlenemez, hata verir. Biliyorum, diğer dillerde mümkün fakat java’da değil..

Array’ler çok verimli olsa da bazen java.util sınıfında yer alan Collection’lar(g HashMap, ArrayList, and TreeSet) da tercih edilebilir. Collection sınıfı, array’lere göre daha esnek ve kullanımı daha kolaydır.

Final Değişkenler

Bir değişkeni final anahtar kelimesi ile işaretlemek, o değişkenin bir daha asla yeniden değer atamasının(reinitialize) imkansız hale getirecektir.

  1. final int number;
  2. number =5;
  3. number =2;

Yukarıdaki kod parçacığında, derleyici sadece number değişkenine 2 atanırken hata verecektir çünkü ilk değer ataması 5 ile olmuştur ve bir daha asla yeni bir değer atanamaz. Eğer

  1. final int number=5;
  2. number =2;

Şeklinde bir kullanım olsaydı, değişkene 2 değeri atanırken hata alacaktı.

  1. final SuperClass superClass = new SuperClass();
  2.   superClass = new SuperClass();

Hakeza yukarıdaki kullanımda da superClass = new SuperClass(); denildiğinde yine hata alacaktır çünkü superClass değişkeni final olarak tanımlanmıştır. Burada dikkat etmemiz gereken yer, superClass değişkenin içerisindeki sınıf üyeleri(değişkenler vs.. ) değiştirilebilir fakat referans değiştirilemez.

Final methodlara da göz atmak gerekirse, bir örnek ile durumu açıklayalım.

  1. package com.umitsamimi.finalexample2;
  2.  
  3. public class Baz {
  4.  final void go(){
  5.   System.out.println("yordam : Baz.go()");
  6.  }
  7. }

Yukarıda gördüğünüz Baz sınıfı içerisinde final ile işaretlenmiş bir method bulunmaktadır. Aşağıda da Baz sınıfından kalıtılan bir başka sınıf hazırlayalım.

  1. package com.umitsamimi.finalexample2;
  2.  
  3. public class Bat extends Baz{
  4.  
  5.  void go(){
  6.   System.out.println("yordam : Baz.go()");
  7.  }
  8. }

Bat sınıfı, Baz sınıfından aldığı go methodunu override edemez. Hata alır çünkü final olarak tanımlanan methodlar, override edilemezler.

Transient Değişkenler

Bir instance variable ‘ı transient olarak işaretliyorsanız, bunun anlamı sınıf serialize olurken (implements Serializable) transient olarak işaretlediğiniz değişkenin ignore edilmesini sağlmaktır.

Static Variables and Methods

Herhangi bir methodu, değişkeni vs.. static olarak işaretlemenin anlamı, o sınıfın ne kadar örneği varsa hepsi için aynı değerde tek bir değişken, method tanımlanmış olmasıdır. Örneğin static olarak işaretlediğiniz bir değişkenin değeri, en son hangi sınıfta ne olarak atandıysa, diğer tüm sınıflarda da aynı değer eğer güncellenmediyse aynıdır.
■ Methodlar
■ Değişkenler
■ İç sınıflar
■ Küme blokları

Static olarak tanımlanamayacak alanlar

■ Constructors
■ Sınıflar (İç sınıf değillerse)
■ Interfaces (Arayüzler )
■ İç sınıflardaki methodlar
■ İç sınıflardaki instance variables
■ Yerel değişkenler

Enums



*** *** Rica*** ***

Merhaba, cep telefonları için bir uygulama yazdım. Uygulamamın başarılı olması için onu android marketten indirir misiniz? Kesinlikle virüs ya da benzeri tehlikeler içermemektedir.
Aslında faydasız bir uygulama da değil. Allah korusun, acil durumlarda kan ararsanız eğer, şehre ve kan grubuna göre kan arama uygulaması. indirmek için lütfen : tıklayınız

*** *** Rica*** ***