Java Semantik Hataları | Neden Java Programcısı Semantik Hataları Kabul Etmeli?

Mar 08 2023

JAVA FLAMES'e Katılın Birçok kişi, Java kodundaki anlamsal hatalar ile sözdizimsel (sözdizimi) hatalar arasındaki farkı anlamakta zorlanır, ancak bunlar farklıdır. Kodunuzun sözdizimi doğru ancak kod kullanımı doğru olmadığında bir anlam hatası görebilirsiniz.

JAVA FLAMES'e Katılın

Birçok kişi, Java kodundaki anlamsal hatalar ile sözdizimsel (sözdizimi) hatalar arasındaki farkı anlamakta zorlanır, ancak bunlar farklıdır. Kodunuzun sözdizimi doğru ancak kod kullanımı doğru olmadığında bir anlam hatası görebilirsiniz.

· Semantik hata nedir?
· Semantik hatalar nasıl tespit edilir?
· Yaygın Semantik Hatalar

Anlam hatası nedir?

Semantik hata, kodunuzdaki yorumlayıcının kodu anlamasını engelleyen bir sorundur. Yazdığınız mantıkta yanlış bir şey olmayabilir, ancak programın yazdığınız şekilde çökmesine neden olur. Örneğin, aşağıdaki kod Semantik çalışma zamanı Hatasında yanlış bir sonuç üretecektir:

var a = 1 // No error
var b = 2 // No error
var c = 3 // No error
a + c = b

Semantik hatalar derleme zamanında tespit edilir ve bunları statik analiz hataları olarak düşünebilirsiniz. Örneğin , bildirmediğiniz bir değişkeni çalıştırmayı denerseniz, bir semantik hata atar: Bir programcı, amaçlanan amacı iletemeyen bir kod yazdığında bir anlam hatası oluşur. Bu, kod sözdizimsel olarak doğru olduğu halde tasarlanmış görevini gerçekleştirmediğinde ortaya çıkan sözdizimi hatasından farklıdır.

Başka bir deyişle, anlamsal hata, anlamsız bir sonuç üreten yanlış bir programı ifade eder. Örneğin , bir hava durumu uygulaması, dışarıda yağmur yağarken bile "Sıcak ve güneşli" diyorsa, bu anlamsal bir hata olur. Program, üretmesi gereken şeyi üretmedi.

Anlamsal hatalar nasıl tespit edilir?

anlamsal hatalardan bazıları (statik anlamsal hatalar), hatanın türünü ve hatanın oluştuğu Java kaynak dosyasındaki konumu belirten bir mesaj üreten derleyici tarafından algılanır (gerçek hatanın konumdan önce gerçekleşmiş olabileceğine dikkat edin). derleyici tarafından bildirilir).

Bu noktada, statik anlamsal hataları açıkladık . Her durumda, programlama dilinin bir gereksinimi karşılanmadığında (geçersiz türler) derleyici statik bir anlam hatası işaretler.

Başka bir sorun türü daha vardır: programınız derlenir ve yürütülür, ancak yapmasını istediğiniz şeyi yapmazsa ne olur? Bilgisayar tam olarak programladığınız şeyi yapıyor, ancak programladığınız şey yanlıştı. Bu başka bir anlamsal hata türüdür: programcı sorunu çözmek için programlama dilini yanlış kullandığında.

Statik bir anlamsal hatadan farklı olarak, dinamik bir anlamsal hatanın anlamla ilgisi vardır. Bir program bu tür bir hata içeriyorsa, başarılı bir şekilde çalışacak, ancak doğru sonucu vermeyecektir.

Semantik bir hata ile hata ayıklama o kadar kolay değildir. Bir örnek görelim.

/**
 * This program prints the total benefit for the company
 * 
*/
public class TotalBenefit {
 public static void main(String[] args) {
  int branch1 = 250; 
        int branch2 = 500;
        System.out.println("The total benefit is  $" + (branch1 * branch2));
 }
}

Yaygın Semantik Hatalar

Uyumsuz tür hatası

Bu sözdizimi hatası yeni başlayanlarda çok yaygındır. Java gibi derlenmiş programlama dillerinde, yalnızca uyumlu değişkenlere değer atayabilirsiniz.

Uyumlu, aynı türe sahip oldukları veya derleyici tarafından otomatik olarak dönüştürülebilen türlere sahip oldukları anlamına gelir.

Aşağıdaki örnekte, Java'da bir tamsayı değişkenine çift atayamayacağınızı görebilirsiniz. Bazı programlama dilleri dönüştürmeyi otomatik olarak yapabilir, ancak aşağıdaki hatayı görürseniz düzeltmesi basittir. Sadece 'a' değişkeninin türünü değiştirin veya çift yerine bir tamsayı değeri atayın (5.5).

Bu tür bir anlamsal hata yanıltıcı olabilir çünkü derleyici bazı hataları işaretler, bazılarını işaretlemez. Örneğin, bir int değişkenine bir kayan nokta atamaya çalışırsanız, derleyici bir hata mesajı görüntüler.

Öte yandan, bir kayan değişkene bir int atarsanız, derleyici onu bir kayan nokta haline getirmek için int'e otomatik bir tür dönüştürmesi gerçekleştirir. Bu ikinci senaryodaki sorun, özellikle gerçekten bir kayan nokta kullanmak isteseydiniz, kodunuzda sessizce hatalar ortaya çıkarabilmesidir.

"<X> değişkeni başlatılmamış olabilir"

Bu, bir yöntem içinde bildirilen yerel bir değişken başlatılmadığında ortaya çıkar. Başlangıç değeri olmayan bir değişken bir if ifadesinin parçası olduğunda ortaya çıkabilir.

int x;
if (condition) {
  x = 5;
}
System.out.println(x); // x may not have been initialized

Java'da birçok farklı tür arasında dönüşüm yapmak mümkündür. Ancak, bir boole değerini int'ye ne kadar dönüştürmek isterseniz isteyin, Java bunu yapmanıza izin vermez. Dökümü gerçekleştirme kavramı sözdizimsel olarak doğrudur, ancak siz onu yanlış uyguluyorsunuz, bu da derleyicinin her zaman yakaladığı anlamsal bir hata yapıyor.

"Dönüştürülemez türler" hatası, Java kodu geçersiz bir dönüştürme gerçekleştirmeye çalıştığında ortaya çıkar.

TypeInvocationConversionTest.java:12: inconvertible types
found   : java.util.ArrayList<java.lang.Class<? extends TypeInvocationConversionTest.Interface1>>
required: java.util.ArrayList<java.lang.Class<?>>
lessRestrictiveClassList = (ArrayList<Class<?>>) classList;
                                                 ^

“statik olmayan değişken . . . statik bir bağlamdan referans alınamaz”

Bu hata, derleyici statik bir yöntemden statik olmayan değişkenlere erişmeye çalıştığında oluşur.

public class StaticTest {
private int count=0;
   public static void main(String args[]) throws IOException {
       count++; //compiler error: non-static variable count cannot be referenced from a static context
   }
}

Değişkeni imzada statik olarak bildirin.
Statik yöntemde statik olmayan bir nesne örneği oluşturabileceği için kodu kontrol edin.

Bu sorun, Java kodu statik olmayan bir sınıfta statik olmayan bir yöntemi çağırmaya çalıştığında oluşur. İşte bir örnek:

class Sample {
  private int age;
  public void setAge(int a) {
    age=a;
  }
  public int getAge() {
    return age;
  }
  public static void main(String args[]) {
    System.out.println(“Age is:”+ getAge());
   }
  }

Exception in thread “main” java.lang.Error: Unresolved compilation problem:
Cannot make a static reference to the non–static method getAge() from the type Sample

Bir dizi bildirildiğinde ancak başlatılmadığında "(dizi) <X> başlatılmadı" mesajını alırsınız. Dizilerin uzunluğu sabittir, bu nedenle her dizinin istenen uzunlukta başlatılması gerekir .

Aşağıdaki kod kabul edilebilir:

AClass[] array = {object1, object2}
  As is:
       AClass[] array = new AClass[2];
       …
       array[0] = object1;
       array[1] = object2;
  But not:
       AClass[] array;
       …
       array = {object1, object2};

Bu sorun, işleçler tanımlarında değil türler için kullanıldığında ortaya çıkar.

Operatörler yalnızca belirli türler için tanımlanır, ancak belirli sayısal türler arasında örtük tür dönüştürmeye izin verilir:

int a = 5; 
boolean b = true;
int c = a + b; // Error, can't add a boolean value double 
d = a + 1.4;  // OK, int is implicitly converted to double

Bu genellikle, Java kodu bir hesaplamada bir tür dizesi kullanmaya çalıştığında olur. Düzeltmek için dizenin bir tamsayıya veya kayan değere dönüştürülmesi gerekir.

Olası hassasiyet kaybı

Bazen dökümü yanlış uygulayabilirsiniz. Örneğin, bir kayan noktayı bir int'ye çevirmek iyi çalışır, ancak sayının ondalık kısmı kaybolduğunda.

Bir değişkene tutabileceğinden daha fazla bilgi atandığında “olası kesinlik kaybı” meydana gelir. Bu olursa, parçalar dışarı atılacaktır. Bu uygunsa, kodun değişkeni açıkça yeni bir tür olarak bildirmesi gerekir.

Bu hata, açık bir tür ataması olmadan daha düşük kesinlikteki bir değişkene daha yüksek duyarlıklı bir değer atamaya çalışırken ortaya çıkar. Şaşırtıcı bir şekilde, belki de, kayan nokta sabit değerleri türdedir doubleve bir değişkene bir tane atamaya çalışırsanız bu mesajı alırsınız type float:

float sum = 0.0;  // Error, literal is not of type float

float sum = 0.0f;   // OK float sum = (float) 0.0;  // OK

Bu kesinlik kaybı, uygulamanızın çıktısını beklenmedik şekillerde etkileyebilir ve çıktının beklediğinizden farklı bir değer yansıtmasına neden olabilir. Derleyici bu tür bir hatayı asla bulmaz çünkü değişkene özel olarak bir atama uygulamışsınızdır ve derleyici ne yaptığınızı bildiğinizi bekler.

Kapsam belirlemeyi yanlış uygulamak

Bir yöntemin içinde bildirdiğiniz herhangi bir değişken, yöntem ile aynı kapsama - uygulamanın diğer bölümlerinin görünürlüğüne, başka bir deyişle - sahiptir. Sonuç olarak, bir yöntemin içinde özel bir statik int değişkeni bildiremezsiniz. Bunun yerine, değişkeni genel olarak şu şekilde tanımlamanız gerekir:

public class PrivateVar
{
   // This declaration works.
   private static int PrivateInt = 3;
   public static void main(String[] args)
   {
      // This declaration doesn’t work.
      private static int PrivateInt = 3;
   }
}

Java'daki diğer bazı genel anlamsal hata durumları şunlardır:

Tip uyuşmazlıkları — C#'ta yanlış tipi kullanmanın birçok yolu vardır. Yukarıdaki örnek tek yönlüdür. Diğer bazı olası yollar şunlardır: