避免類型鑄造

Question

我有一個空接口，名爲Data，它由類DataOne和DataTwo實現。

然後我有一個叫做DataHolder的類，它包含一個Data對象。

它看起來是這樣的：

public class DataHolder() { 
    public Data data; 
} 

public class DataOne() { 
    public int importantData; 

    public int getImportantData() { 
     return importantData; 
    } 

    public int setImportantData(int importantData) { 
     this.importantData = importantData; 
    } 
} 

public class DataTwo() { 
    public int notSoImportantData; 
} 

讓我們孤單說函數，它接受一個DataHolder對象，並做了一些操作上的importantData整數。

public void calculateImportantData(DataHolder dh) { 
    int importantData = 1234567890; 
    dh.data.setImportantData(importantData); 
} 

我怎麼能肯定的是，DataHolder包含DataOne對象，沒有類型轉換？

Answer 1

如何：

public class DataHolder<T extends Data> { 
    public T data; 
} 

，並在你的代碼，你將有：

public void calculateImportantData(DataHolder<DataOne> dh) { 
    int importantData = 1234567890; 
    dh.data.setImportantData(importantData); 
} 

，我以爲你的意思DataOne和DataTwo實現數據。

Answer 2

首先，我調整您的代碼一點點，

1-我創建了一個接口，數據，含有一些隨機方法的someMethod（）：

package main.interfaces; 

public interface Data { 

    int myData = 0; 

    public void someMethod(); 
} 

2-然後，我創建2類稱爲DataOne和DataTwo： 類DataOne :(注意我是如何在這裏添加重要的業務方法setImportantData（），這提供了總計封裝你的工作）。

package main; 
import main.interfaces.Data; 
public class DataOne implements Data{ 
    public int importantData; 

    public int getImportantData() { 
     return importantData; 
    } 

    public void setImportantData(int importantData) { 
     this.importantData = importantData; 
    } 

    @Override 
    public void someMethod() { 
     System.out.println("here in DataOne!... "); 

    } 
    public void calculateImportantData(int importantData) { 

    //  int importantData = 1234567890; 

     setImportantData(importantData); 
    } 

} 

類DataTwo：

package main; 

import main.interfaces.Data; 

public class DataTwo implements Data{ 
public int notSoImportantData; 

@Override 
public void someMethod() { 
    System.out.println("here in DataTwo!..."); 

} 
public void calculateUsualData(DataTwo d2) { 
    d2.someMethod(); 

} 

}後

，使用工廠設計模式 ...我創建了這個DataFactory類：

package main.factory; 

import main.DataOne; 
import main.DataTwo; 
import main.interfaces.Data; 

public class DataFactory { 
    public static Data getData(String dataType){ 
      if(dataType == null){ 
      return null; 
      }  
      if(dataType.equalsIgnoreCase("DATAONE")){ 
      return new DataOne(); 
      } else if(dataType.equalsIgnoreCase("DATATWO")){ 
      return new DataTwo(); 
      } 
      return null; 
     } 

} 

現在，回到您的問題解決方案，我使用DataHolder封裝DataFact ORY這裏：

package main.holder; 

import main.factory.DataFactory; 
import main.interfaces.Data; 

public class DataHolder { 
    Data data; 
    public DataHolder(String dataType){ 
     data = DataFactory.getData(dataType); 
    } 

    public Data getData(){ 
     return data; 
    } 
} 

現在，嘗試運行應用程序，我補充說，將出現在控制檯上的一些意見，我希望他們會有所幫助:)

package main.run; 

import main.DataOne; 
import main.DataTwo; 
import main.holder.DataHolder; 
import main.interfaces.Data; 

public class main { 
    public static void main(String[] args) { 

     // lets assume user of the method passed a DataOne Object, you can 
     // manage it by changing the value of flag string 
     String flag = "DataOne"; 
     DataHolder dataHolder = new DataHolder(flag); 

     if (dataHolder.getData() instanceof DataOne) { 
      System.out 
        .println("you have a DataOne object , but a Data reference"); 
      System.out 
        .println("/nso , you need to create a 'reference' to DataOne to work on that object ..."); 
     } else if (dataHolder.getData() instanceof DataTwo) { 
      System.out 
        .println("you have a DataTwo object , but a Data reference"); 
     } else { 
      System.out 
        .println("you dont have a DataOne nor DataTwo references , it is a " 
          + dataHolder.getData().getClass() + " object!"); 
     } 

     System.out 
       .println("in order for the compiler to pass the following test , you must cast he RHS (right hand side) to match the LHS (left hand side)"); 
     // in order for the compiler to pass the following test , you must cast 
     // the RHS (right hand side) to match the LHS (left hand side) 
     DataOne d1 = (DataOne) dataHolder.getData(); 
     // in case you wanted to test DataTwo scenario 
     //DataTwo d2 = (DataTwo) dataHolder.getData(); 

     System.out.println("if you didnt do that , you can make it a Data Object , but you will not be able to access the method 'getImportantData()' created in DataOne"); 
     Data data = dataHolder.getData(); 
    } 

} 

（注意，這裏的程序結構是：在啓動應用程序之前選擇數據的類型，存儲在main方法內的「flag」變量中。之後，將調用DataHolder方法，之後，您可以檢查返回的對象並檢查它是否是您之前指定的內容。如果你希望它有點複雜，你可以在DataHolder的構造函數中傳遞對象類型，並從那裏進行檢查，我不想僅僅爲了簡單起見。好運）