避免類型轉換

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對象並對重要數據整數進行一些操作。

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-我創建了一個接口Data，其中包含一些隨機方法someMethod（）：

package main.interfaces;

public interface Data {

  int myData = 0;

   public void someMethod();
}

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);
    }

}

類數據二：

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();

}

}

之后，使用Factory Design Pattern ...創建了這個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，將DataFactory封裝在這里：

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的構造函數中傳遞對象類型，然后從那里進行檢查，我不想這樣做只是為了簡單起見。祝您好運）