Yöntemlerin statik olarak içe aktarılması için iyi bir kullanım durumu nedir?

Sadece yöntemin statik içe aktarımı iyi bir fikir değildi bir inceleme yorum var. Statik içe aktarma, çoğunlukla statik yöntemlere sahip olan bir DA sınıfından bir yöntemdeydi. Yani iş mantığının ortasında görünüşte şu anki sınıfa ait gibi görünen bir etkinlik vardı:

import static some.package.DA.*;
class BusinessObject {
  void someMethod() {
    ....
    save(this);
  }
} 

Gözden geçiren kod değiştirmek ve istedim ama ben onunla aynı tür yapmak istekli değildi. Statik olarak içe aktarılmamasının bir nedeni, yöntemin nerede tanımlandığı, şu anki sınıfta olmadığı ve herhangi bir üst sınıfta olmadığı için kafa karıştırıcı olmasıydı, bu yüzden tanımını tanımlamak için çok fazla zaman vardı (web tabanlı inceleme sisteminin tıklanabilir olmaması IDE gibi bağlantılar :-) Bunun gerçekten önemli olduğunu düşünmüyorum, statik ithalat hala oldukça yeni ve yakında hepimiz onları bulmak için alışacağız.

Ancak, kabul ettiğim diğer neden, niteliksiz bir yöntem çağrısının mevcut nesneye ait gibi görünmesi ve bağlamları atlamamasıdır. Ama gerçekten ait olsaydı, bu süper sınıfı genişletmek mantıklı olurdu.

Yani, ne zaman gelmez statik ithalat yöntemlerine mantıklı? Ne zaman yaptın? Niteliksiz çağrıların görünüşünü beğendin mi / beğendin mi?

DÜZENLEME: Kimse onları mevcut sınıfın yöntemleri olarak karıştırmayacaksa, popüler görüş statik-içe aktarma yöntemleri gibi görünüyor. Örneğin, java.lang.Math ve java.awt.Color'dan yöntemler. Ama abs ve getAlpha belirsiz değilse readEmployee'ın neden olduğunu anlamıyorum. Birçok programlama seçeneğinde olduğu gibi, bunun da kişisel bir tercih olduğunu düşünüyorum.

Yanıtınız için teşekkürler arkadaşlar, soruyu kapatıyorum.

Bu, özelliği yayınladıklarında Sun'ın rehberinden (orijinal vurgu):

Peki statik içe aktarmayı ne zaman kullanmalısınız? Çok tutumlu! Bunu yalnızca sabitlerin yerel kopyalarını bildirme veya mirasın (Sabit Arayüz Antipattern'i) kötüye kullanma isteğinde bulunduğunuzda kullanın. ... Statik içe aktarma özelliğini aşırı kullanırsanız, programınızı okunamaz ve sürdürülemez hale getirerek ad alanını içe aktardığınız tüm statik üyelerle kirletebilir. Kodunuzun okuyucuları (siz de dahil, yazdıktan birkaç ay sonra), statik bir üyenin hangi sınıftan geldiğini bilmeyecektir. Tüm statik üyelerin bir sınıftan içe aktarılması, okunabilirlik açısından özellikle zararlı olabilir; yalnızca bir veya iki üyeye ihtiyacınız varsa, ayrı ayrı içe aktarın.

( https://docs.oracle.com/javase/8/docs/technotes/guides/language/static-import.html )

Özellikle belirtmek istediğim iki bölüm var:

• Statik içe aktarma işlemlerini yalnızca "kötüye kullanım mirasına" maruz kaldığınızda kullanın . Bu durumda, BusinessObject'e sahip olmak ister misiniz extend some.package.DA? Öyleyse, statik içe aktarma bunu ele almanın daha temiz bir yolu olabilir. Asla genişletmeyi hayal etmezseniz some.package.DA, bu muhtemelen statik ithalatın zayıf bir kullanımıdır. Yazarken sadece birkaç karakteri kaydetmek için kullanmayın.
• Tek tek üyeleri içe aktarın. Say import static some.package.DA.saveyerine DA.*. Bu, içe aktarılan bu yöntemin nereden geldiğini bulmayı çok daha kolay hale getirecektir.

Şahsen, bu dil özelliğini çok nadiren kullandım ve neredeyse her zaman sadece sabitlerle veya numaralarla, asla yöntemlerle kullanmadım. Benim için takas, neredeyse hiç buna değmez.

Statik ithalatı için başka makul kullanım gibi JUnit yöntemlerden daha önceki sürümlerinde JUnit 4. ile assertEqualsve faildeney sınıfı genişletilmiş beri devralınan junit.framework.TestCase.

// old way
import junit.framework.TestCase;

public class MyTestClass extends TestCase {
    public void myMethodTest() {
        assertEquals("foo", "bar");
    }
}

JUnit 4'te, test sınıflarının artık genişletilmesine gerek yoktur TestCaseve bunun yerine ek açıklamaları kullanabilir. Daha sonra onay yöntemlerini statik olarak aşağıdakilerden alabilirsiniz org.junit.Assert:

// new way
import static org.junit.Assert.assertEquals;

public class MyTestClass {
    @Test public void myMethodTest() {
        assertEquals("foo", "bar");
        // instead of
        Assert.assertEquals("foo", "bar");
    }
}

JUnit bu şekilde kullanarak belgeleri .

Etkili Java, Second Edition , Madde 19'un sonunda, bir yardımcı program sınıfının sabitlerini kullanarak kendinizi ağır bulursanız, statik içe aktarımları kullanabileceğinizi not eder . Bu ilkenin hem sabitlerin hem de yöntemlerin statik ithalatı için geçerli olacağını düşünüyorum.

import static com.example.UtilityClassWithFrequentlyUsedMethods.myMethod;

public class MyClass {
    public void doSomething() {
        int foo= UtilityClassWithFrequentlyUsedMethods.myMethod();
        // can be written less verbosely as
        int bar = myMethod();
    }
}

Bunun avantajları ve dezavantajları vardır. Yöntemin nerede tanımlandığı hakkında bazı acil bilgileri kaybetme pahasına kodu biraz daha okunabilir hale getirir. Ancak, iyi bir IDE tanımlamaya gitmenize izin verecektir, bu yüzden bu bir sorun değildir.

Bunu yine de dikkatli bir şekilde kullanmalısınız ve yalnızca içe aktarılan dosyadan bir çok şey kullandığınızı fark ederseniz.

Düzenleme: Bu soruya atıfta bulunduğu gibi yöntemlere daha spesifik olacak şekilde güncellendi. İlke, nelerin içe aktarıldığına bakılmaksızın uygulanır (sabitler veya yöntemler).

Okunabilirlik açısından sorunlu olabileceğini ve az miktarda kullanılması gerektiğini kabul ediyorum. Ancak ortak bir statik yöntem kullanırken okunabilirliği artırabilirler. Örneğin, bir JUnit test sınıfında, gibi yöntemler assertEqualsnereden geldikleri açıktır. Benzer yöntemler java.lang.Math.

Statik içe aktarma Arraysve gibi utils sınıflarını kullanırken gereksiz sınıf adlarını kaldırmak için gerçekten yararlı olduğunu düşünüyorum Assertions.

Neden olduğundan emin değilim ama Ross referans aldığı belgede bundan bahseden son cümleyi atladı .

Uygun şekilde kullanıldığında, statik içe aktarma, sınıf adlarının tekrarlama plakasını kaldırarak programınızı daha okunabilir hale getirebilir.

Temel olarak bu blogdan kopyalandı: https://medium.com/alphadev-thoughts/static-imports-are-great-but-underused-e805ba9b279f

Yani mesela:

Testlerdeki iddialar

Hepimizin aynı fikirde olduğunu düşündüğüm en açık durum bu

Assertions.assertThat(1).isEqualTo(2);

// Use static import instead
assertThat(1).isEqualTo(2);

Sınıfları ve sıralamaları kullanır

Sınıf adı, kodun okunmasını kolaylaştıran utils sınıflarını kullanırken birçok durumda kaldırılabilir

List<Integer> numbers = Arrays.asList(1, 2, 3);

// asList method name is enough information
List<Integer> numbers = asList(1, 2, 3);

java.time paketinin kullanılması gereken birkaç durumu vardır

// Get next Friday from now, quite annoying to read
LocalDate.now().with(TemporalAdjusters.next(DayOfWeek.FRIDAY));

// More concise and easier to read
LocalDate.now().with(next(FRIDAY));

Ne zaman kullanılmayacağına örnek

// Ok this is an Optional
Optional.of("hello world");

// I have no idea what this is 
of("hello world");

Renk için çok kullanıyorum.

static import java.awt.Color.*;

Renklerin başka bir şeyle karıştırılması pek olası değildir.

Java ile OpenGL kullanırken "bir yardımcı sınıftan sabitlerin yoğun kullanımı" kategorisine giren bir kullanım örneği olan statik içe aktarma kullanılmasını öneriyorum

Bunu bir düşün

import static android.opengl.GLES20.*;

orijinal C kodunu taşımanıza ve okunabilir bir şey yazmanıza olanak tanır:

glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, texture);
glUniform1i(samplerUniform, 0);
glBindBuffer(GL_ARRAY_BUFFER, vtxBuffer);
glVertexAttribPointer(vtxAttrib, 3, GL_FLOAT, false, 0, 0);

bu yaygın çirkinlik yerine:

GLES20.glActiveTexture(GLES20.GL_TEXTURE0);
GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, texture);
GLES20.glUniform1i(samplerUniform, 0);
GLES20.glBindBuffer(GLES20.GL_ARRAY_BUFFER, vtxBuffer);
GLES20.glVertexAttribPointer(vtxAttrib, 3, GLES20.GL_FLOAT, false, 0, 0);

Statik içe aktarma, Java'nın daha önce hiç kullanmadığınız ve az önce bahsettiğiniz sorunlardan dolayı kullanmak istemediğim tek "yeni" özelliktir.

Matematik ağır kod C / C ++ java için taşıma sırasında 'import statik java.lang.Math. *' Kullanın. Matematik yöntemleri 1'den 1'e eşlenir ve sınıf adı kalifikasyonu olmadan taşınan kodu ayırmayı kolaylaştırır.

Utility sınıflarını kullanırken bunu çok uygun buldum.

Örneğin, kullanmak yerine: if(CollectionUtils.isNotEmpty(col))

Bunun yerine şunları yapabilirim:

import static org.apache.commons.collections.CollectionUtils.isNotEmpty;
if(isNotEmpty(col))

Kodumda bu yardımcı programı birden çok kez kullandığımda hangi IMO kod okunabilirliğini artırır.

Birim testleri hakkında konuşmak: Çoğu insan, alaycı çerçevelerin sağladığı when()veya gibi çeşitli statik yöntemler için statik içe aktarma kullanırverify() .

import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

Ve elbette, birini kullanırken ve sadece kullanmanız gerektiğini iddia ettiğinizde assertThat(), gerekli hamcrest eşleştiricilerini statik olarak içe aktarmak için kullanışlı olur:

import static org.hamcrest.Matchers.*;

Özellikle çok sayıda içe aktarılan yöntemin çağrıldığı ve yerel ve içe aktarılan yöntemler arasındaki ayrımın açık olduğu durumlarda, söz konusu tehlikeyi azaltmak için faydalıdırlar.

Bir örnek: java.lang.Math'e birden çok başvuru içeren kod

Başka: Sınıf adını her referansa eklemenin, inşa edilen yapıyı gizleyeceği bir XML oluşturucu sınıfı

Statik ithalat gettext tarzı NLS için temiz olduğunu düşünüyorum.

import static mypackage.TranslatorUtil._;

//...
System.out.println(_("Hello world."));

Bu, dizeyi ayıklanması gereken bir dize olarak işaretler ve dizeyi çevirisiyle değiştirmek için kolay ve temiz bir yol sağlar.

IMO statik içe aktarma oldukça güzel bir özelliktir. Statik içe aktarmaya aşırı bağımlı olmanın, kodu okunamaz hale getirdiği ve hangi sınıfın statik bir yönteme veya özelliğe ait olduğunu anlamasını zorlaştırdığı kesinlikle doğrudur. Ancak, tecrübelerime göre, özellikle Utilbazı statik yöntemler ve öznitelikler sağlayan sınıflar tasarlanırken kullanılabilir bir özellik haline gelir . Statik ithalat sağlarken ortaya çıkan belirsizlik, kod standartları belirlenerek atlatılabilir. Bir şirketteki tecrübelerime göre bu yaklaşım kabul edilebilir ve kodu daha temiz ve kolay anlaşılır hale getirir. Tercihen _karakteri ön statik yöntemlere ve statik özelliklere eklerim (bir şekilde C'den benimsenir). Görünüşe göre bu yaklaşım Java'nın adlandırma standartlarını ihlal ediyor, ancak kodlamaya açıklık sağlıyor. Örneğin, bir AngleUtils sınıfımız varsa:

public class AngleUtils {

    public static final float _ZERO = 0.0f;
    public static final float _PI   = 3.14f;

    public static float _angleDiff(float angle1, float angle2){

    }

    public static float _addAngle(float target, float dest){

    }
}

Bu durumda statik içe aktarma netlik sağlar ve kod yapısı benim için daha zarif görünüyor:

import static AngleUtils.*;

public class TestClass{

    public void testAngles(){

        float initialAngle = _ZERO;
        float angle1, angle2;
        _addAngle(angle1, angle2);
    }
}

Birisi statik bir içe aktarmadan hangi yöntemin veya niteliğin geldiğini söyleyebilir ve ait olduğu sınıfın bilgilerini gizler. Bir modülün ayrılmaz bir parçası olan ve bu durumda hangi sınıfın belirli statik işlevsellik sağladığını bilmek önemlidir.

Bunları şu durumlarda kullanmanız gerekir:

• switchenum değerleri olan bir ifade kullanmak istersiniz
• kodunuzun anlaşılmasını zorlaştırmak istiyorsunuz

Onları elimden geldiğince kullanıyorum. Unutursam hatırlatmak için IntelliJ kurulumum var. Bence tam nitelikli bir paket adından çok daha temiz görünüyor.