วิธีการคงที่ในชั้นเรียนทั่วไป?

ใน Java ฉันต้องการมีสิ่งต่อไปนี้:

class Clazz<T> {
  static void doIt(T object) {
    // ...
  }
}

แต่ฉันได้

ไม่สามารถทำการอ้างอิงแบบคงที่กับประเภทที่ไม่ใช่แบบคงที่ T

ฉันไม่เข้าใจข้อมูลทั่วไปนอกเหนือจากการใช้งานพื้นฐานดังนั้นจึงไม่สามารถเข้าใจได้ มันไม่ได้ช่วยให้ฉันไม่สามารถหาข้อมูลจำนวนมากบนอินเทอร์เน็ตเกี่ยวกับเรื่องนี้

บางคนสามารถอธิบายได้ว่าการใช้ดังกล่าวเป็นไปได้ด้วยวิธีเดียวกันหรือไม่? ทำไมความพยายามเริ่มแรกของฉันถึงไม่สำเร็จ?

คุณไม่สามารถใช้พารามิเตอร์ประเภททั่วไปของคลาสในวิธีการแบบคงที่หรือเขตข้อมูลแบบคงที่ พารามิเตอร์ชนิดของคลาสอยู่ในขอบเขตสำหรับวิธีการอินสแตนซ์และเขตข้อมูลอินสแตนซ์เท่านั้น สำหรับเขตข้อมูลแบบคงที่และวิธีการแบบคงที่พวกเขาจะใช้ร่วมกันระหว่างอินสแตนซ์ทั้งหมดของคลาสแม้แต่อินสแตนซ์ของพารามิเตอร์ชนิดต่าง ๆ ดังนั้นแน่นอนพวกเขาไม่สามารถขึ้นอยู่กับพารามิเตอร์ชนิดเฉพาะ

ดูเหมือนว่าปัญหาของคุณจะต้องใช้พารามิเตอร์ประเภทของคลาส หากคุณอธิบายสิ่งที่คุณพยายามทำในรายละเอียดเพิ่มเติมเราอาจช่วยคุณหาวิธีที่ดีกว่าในการทำ

Java ไม่ทราบว่าTมีอะไรจนกว่าคุณจะยกตัวอย่างประเภท

บางทีคุณสามารถดำเนินการวิธีการคงที่โดยการโทรClazz<T>.doit(something)แต่ดูเหมือนว่าคุณไม่สามารถ

วิธีอื่น ๆ ในการจัดการสิ่งต่าง ๆ คือการใส่พารามิเตอร์ type ลงในเมธอดเอง:

static <U> void doIt(U object)

ซึ่งคุณไม่ได้รับการ จำกัด ที่ถูกต้องใน U แต่มันดีกว่าไม่มีอะไรเลย ....

ฉันพบปัญหาเดียวกันนี้ ฉันพบคำตอบของฉันด้วยการดาวน์โหลดซอร์สโค้ดสำหรับCollections.sortในกรอบงานจาวา คำตอบที่ฉันใช้คือใส่<T>สามัญในวิธีการไม่ได้อยู่ในคำจำกัดความของชั้นเรียน

ดังนั้นสิ่งนี้ได้ผล:

public class QuickSortArray  {
    public static <T extends Comparable> void quickSort(T[] array, int bottom, int top){
//do it
}

}

แน่นอนหลังจากอ่านคำตอบข้างต้นฉันรู้ว่านี่จะเป็นทางเลือกที่ยอมรับได้โดยไม่ต้องใช้คลาสทั่วไป:

public static void quickSort(Comparable[] array, int bottom, int top){
//do it
}

เป็นไปได้ที่จะทำสิ่งที่คุณต้องการโดยใช้ไวยากรณ์สำหรับวิธีการทั่วไปเมื่อประกาศdoIt()วิธีการของคุณ(สังเกตเห็นการเพิ่ม<T>ระหว่างstaticและvoidในวิธีลายเซ็นของdoIt()):

class Clazz<T> {
  static <T> void doIt(T object) {
    // shake that booty
  }
}

ฉันได้รับ Eclipse editor เพื่อยอมรับโค้ดข้างต้นโดยไม่มีCannot make a static reference to the non-static type Tข้อผิดพลาดจากนั้นขยายไปยังโปรแกรมทำงานต่อไปนี้ (สมบูรณ์ด้วยการอ้างอิงทางวัฒนธรรมที่เหมาะสมกับอายุ):

public class Clazz<T> {
  static <T> void doIt(T object) {
    System.out.println("shake that booty '" + object.getClass().toString()
                       + "' !!!");
  }

  private static class KC {
  }

  private static class SunshineBand {
  }

  public static void main(String args[]) {
    KC kc = new KC();
    SunshineBand sunshineBand = new SunshineBand();
    Clazz.doIt(kc);
    Clazz.doIt(sunshineBand);
  }
}

ซึ่งพิมพ์บรรทัดเหล่านี้ไปยังคอนโซลเมื่อฉันเรียกใช้:

เขย่าโจร 'คลาส com.eclipseoptions.datamanager.Clazz $ KC' !!!
เขย่าโจร 'คลาส com.eclipseoptions.datamanager.Clazz $ SunshineBand' !!!

ฉันคิดว่าไวยากรณ์นี้ยังไม่ได้กล่าวถึง (ในกรณีที่คุณต้องการวิธีที่ไม่มีข้อโต้แย้ง):

class Clazz {
  static <T> T doIt() {
    // shake that booty
  }
}

และการโทร:

String str = Clazz.<String>doIt();

หวังว่าจะช่วยคนได้

มันถูกกล่าวถึงอย่างถูกต้องในข้อผิดพลาด: คุณไม่สามารถทำการอ้างอิงแบบคงที่ไปยังประเภทที่ไม่ใช่แบบคงที่ T เหตุผลคือพารามิเตอร์ชนิดTสามารถถูกแทนที่ด้วยอาร์กิวเมนต์ชนิดใด ๆ เช่นClazz<String>หรือClazz<integer>อื่น ๆ แต่ฟิลด์ / วิธีแบบคงที่ วัตถุคงที่ของชั้นเรียน

ข้อความที่ตัดตอนมาต่อไปนี้นำมาจากเอกสาร :

ฟิลด์สแตติกของคลาสเป็นตัวแปรระดับคลาสที่แบ่งใช้โดยอ็อบเจ็กต์ที่ไม่ใช่สแตติกทั้งหมดของคลาส ดังนั้นไม่อนุญาตให้ใช้ฟิลด์แบบคงที่ของพารามิเตอร์ประเภท พิจารณาคลาสต่อไปนี้:

public class MobileDevice<T> {
    private static T os;

    // ...
}

หากอนุญาตให้ใช้ฟิลด์แบบคงที่ของพารามิเตอร์ประเภทดังนั้นรหัสต่อไปนี้จะสับสน:

MobileDevice<Smartphone> phone = new MobileDevice<>();
MobileDevice<Pager> pager = new MobileDevice<>();
MobileDevice<TabletPC> pc = new MobileDevice<>();

เนื่องจากฟิลด์สแตติก OS ถูกแชร์โดยโทรศัพท์เพจเจอร์และพีซีระบบปฏิบัติการจริงคืออะไร ไม่สามารถเป็น Smartphone, Pager และ TabletPC ในเวลาเดียวกัน คุณไม่สามารถสร้างฟิลด์สแตติกของพารามิเตอร์ชนิดได้

ตามที่ถูกต้องโดย chris ในคำตอบของเขาคุณจำเป็นต้องใช้พารามิเตอร์ประเภทด้วยวิธีการและไม่ได้มีชั้นเรียนในกรณีนี้ คุณสามารถเขียนได้เช่น:

static <E> void doIt(E object) 

สิ่งต่อไปนี้จะทำให้คุณใกล้ชิดมากขึ้น

class Clazz
{
   public static <U extends Clazz> void doIt(U thing)
   {
   }
}

แก้ไข: อัปเดตตัวอย่างพร้อมรายละเอียดเพิ่มเติม

public abstract class Thingo 
{

    public static <U extends Thingo> void doIt(U p_thingo)
    {
        p_thingo.thing();
    }

    protected abstract void thing();

}

class SubThingoOne extends Thingo
{
    @Override
    protected void thing() 
    {
        System.out.println("SubThingoOne");
    }
}

class SubThingoTwo extends Thingo
{

    @Override
    protected void thing() 
    {
        System.out.println("SuThingoTwo");
    }

}

public class ThingoTest 
{

    @Test
    public void test() 
    {
        Thingo t1 = new SubThingoOne();
        Thingo t2 = new SubThingoTwo();

        Thingo.doIt(t1);
        Thingo.doIt(t2);

        // compile error -->  Thingo.doIt(new Object());
    }
}

เมื่อคุณระบุประเภททั่วไปสำหรับคลาสของคุณ JVM รู้ว่ามีเพียงอินสแตนซ์ของคลาสของคุณเท่านั้นไม่ใช่นิยาม แต่ละคำจำกัดความมีประเภท parametrized เท่านั้น

Generics ใช้งานได้เช่นเทมเพลตใน C ++ ดังนั้นคุณควรสร้างอินสแตนซ์ของคลาสก่อนจากนั้นใช้ฟังก์ชันที่มีประเภทที่ระบุ

นอกจากนี้ในการใส่คำง่ายๆมันเกิดขึ้นเพราะคุณสมบัติ "ลบ" ของข้อมูลทั่วไปซึ่งหมายความว่าถึงแม้ว่าเราจะกำหนดArrayList<Integer>และArrayList<String>ในเวลาคอมไพล์มันยังคงเป็นคอนกรีตสองประเภทที่แตกต่างกัน แต่ที่รันไทม์ JVM จะลบประเภททั่วไปและ สร้างคลาส ArrayList เพียงคลาสเดียวแทนที่จะเป็นสองคลาส ดังนั้นเมื่อเรากำหนดวิธีการประเภทแบบคงที่หรืออะไรก็ได้สำหรับทั่วไปมันจะถูกใช้ร่วมกันโดยอินสแตนซ์ทั้งหมดของทั่วไปนั้นในตัวอย่างของฉันมันถูกแชร์โดยทั้งสองArrayList<Integer>และArrayList<String>นั่นคือสาเหตุที่คุณได้รับข้อผิดพลาดพารามิเตอร์ประเภททั่วไปของ Class ไม่ใช่ อนุญาตในบริบทแบบคงที่!

@BD ที่ Rivenhill: เนื่องจากคำถามเก่า ๆ นี้ได้รับความสนใจอย่างมากเมื่อปีที่แล้วให้พวกเราไปสักหน่อยเพื่อคุยกัน เนื้อหาของdoItวิธีการของคุณไม่ได้ทำอะไรเป็นTพิเศษเลย นี่มันคือ:

public class Clazz<T> {
  static <T> void doIt(T object) {
    System.out.println("shake that booty '" + object.getClass().toString()
                       + "' !!!");
  }
// ...
}

ดังนั้นคุณสามารถปล่อยตัวแปรประเภททั้งหมดและเพียงแค่รหัส

public class Clazz {
  static void doIt(Object object) {
    System.out.println("shake that booty '" + object.getClass().toString()
                       + "' !!!");
  }
// ...
}

ตกลง. แต่กลับมาใกล้ชิดกับปัญหาเดิมกันดีกว่า ตัวแปรชนิดแรกในการประกาศคลาสนั้นซ้ำซ้อน ต้องการเพียงวิธีที่สองในวิธีการ ที่นี่เราไปอีกครั้ง แต่ยังไม่ได้คำตอบสุดท้าย:

public class Clazz  {
  static <T extends Saying> void doIt(T object) {
    System.out.println("shake that booty "+ object.say());
  }

  public static void main(String args[]) {
    Clazz.doIt(new KC());
    Clazz.doIt(new SunshineBand());
  }
}
// Output:
// KC
// Sunshine

interface Saying {
      public String say();
}

class KC implements Saying {
      public String say() {
          return "KC";
      }
}

class SunshineBand implements Saying {
      public String say() {
          return "Sunshine";
      }
}

อย่างไรก็ตามมันไม่ได้เกี่ยวอะไรเลยมากนักเนื่องจากเวอร์ชั่นต่อไปนี้ทำงานในลักษณะเดียวกัน สิ่งที่ต้องการคือประเภทอินเตอร์เฟสของพารามิเตอร์ method ไม่มีตัวแปรประเภทที่มองเห็นได้ทุกที่ นั่นเป็นปัญหาดั้งเดิมจริงๆเหรอ?

public class Clazz  {
  static void doIt(Saying object) {
    System.out.println("shake that booty "+ object.say());
  }

  public static void main(String args[]) {
    Clazz.doIt(new KC());
    Clazz.doIt(new SunshineBand());
  }
}

interface Saying {
      public String say();
}

class KC implements Saying {
      public String say() {
          return "KC";
      }
}

class SunshineBand implements Saying {
      public String say() {
          return "Sunshine";
      }
}

เนื่องจากตัวแปรแบบสแตติกถูกแบ่งใช้โดยอินสแตนซ์ทั้งหมดของคลาส ตัวอย่างเช่นหากคุณมีรหัสต่อไปนี้

class Class<T> {
  static void doIt(T object) {
    // using T here 
  }
}

T สามารถใช้ได้หลังจากสร้างอินสแตนซ์แล้วเท่านั้น แต่วิธีการแบบคงที่สามารถใช้งานได้ก่อนที่อินสแตนซ์จะพร้อมใช้งาน ดังนั้นพารามิเตอร์ประเภททั่วไปไม่สามารถอ้างอิงภายในวิธีการคงที่และตัวแปร