Đó là cách tốt hơn để gọi một phương thức chỉ có sẵn cho một lớp thực hiện một giao diện chứ không phải một phương thức khác?

Về cơ bản tôi cần phải thực hiện các hành động khác nhau với một điều kiện nhất định. Mã hiện tại được viết theo cách này

Giao diện cơ sở

// DoSomething.java
interface DoSomething {

   void letDoIt(String info);
}

Thực hiện lớp công nhân đầu tiên

class DoItThisWay implements DoSomething {
  ...
}

Thực hiện lớp công nhân thứ hai

class DoItThatWay implements DoSomething {
   ...
}

Lớp chính

   class Main {
     public doingIt(String info) {
        DoSomething worker;
        if (info == 'this') {
          worker = new DoItThisWay();
        } else {
          worker = new DoItThatWay();
        }
        worker.letDoIt(info)
     }

Mã này hoạt động tốt và dễ hiểu.

Bây giờ, do một yêu cầu mới, tôi cần phải truyền một mẩu thông tin mới chỉ có ý nghĩa DoItThisWay.

Câu hỏi của tôi là: phong cách mã hóa sau có tốt để xử lý yêu cầu này không.

Sử dụng biến và phương thức lớp mới

// Use new class variable and method

class DoItThisWay implements DoSomething {
  private int quality;
  DoSomething() {
    quality = 0;
  }

  public void setQuality(int quality) {
    this.quality = quality;
  };

 public void letDoIt(String info) {
   if (quality > 50) { // make use of the new information
     ...
   } else {
     ...
   }
 } ;

}

Nếu tôi làm theo cách này, tôi cần thực hiện thay đổi tương ứng cho người gọi:

   class Main {
     public doingIt(String info) {
        DoSomething worker;
        if (info == 'this') {
          int quality = obtainQualityInfo();
          DoItThisWay tmp = new DoItThisWay();
          tmp.setQuality(quality)
          worker = tmp;

        } else {
          worker = new DoItThatWay();
        }
        worker.letDoIt(info)
     }

Đó có phải là một phong cách mã hóa tốt? Hoặc tôi có thể bỏ nó

   class Main {
     public doingIt(String info) {
        DoSomething worker;
        if (info == 'this') {
          int quality = obtainQualityInfo();
          worker = new DoItThisWay();
          ((DoItThisWay) worker).setQuality(quality)
        } else {
          worker = new DoItThatWay();
        }
        worker.letDoIt(info)
     }

Tôi cho rằng qualitycần phải được đặt cùng với mỗi letDoIt()cuộc gọi trên a DoItThisWay().

Vấn đề tôi thấy phát sinh ở đây là: Bạn đang giới thiệu khớp nối tạm thời (nghĩa là điều gì xảy ra nếu bạn quên gọi setQuality()trước khi gọi letDoIt()a DoItThisWay?). Và các triển khai cho DoItThisWayvà DoItThatWayđang chuyển hướng (một cái cần phải setQuality()được gọi, cái kia thì không).

Mặc dù điều này có thể không gây ra vấn đề ngay bây giờ, cuối cùng nó có thể quay lại ám ảnh bạn. Có thể đáng để xem xét lại letDoIt()và xem xét nếu thông tin chất lượng có thể cần phải là một phần của việc infobạn vượt qua nó; nhưng điều này phụ thuộc vào các chi tiết.

Đó có phải là một phong cách mã hóa tốt?

Theo quan điểm của tôi, cả hai phiên bản của bạn đều không. Đầu tiên phải gọi setQualitytrước letDoItcó thể được gọi là khớp nối tạm thời . Bạn bị mắc kẹt khi xem DoItThisWaynhư là một công cụ phái sinh DoSomething, nhưng nó không (ít nhất là không hoạt động), nó giống như một

interface DoSomethingWithQuality {
   void letDoIt(String info, int quality);
}

Điều này sẽ làm cho Mainmột cái gì đó như

class Main {
    // omitting the creation
    private DoSomething doSomething;
    private DoSomethingWithQuality doSomethingWithQuality;

    public doingIt(String info) {
        DoSomething worker;
        if (info == 'this') {
            int quality = obtainQualityInfo();
            doSomethingWithQuality.letDoIt(info, quality);
        } else {
            doSomething.letDoIt(info);
        }
    }
}

Mặt khác, bạn có thể truyền trực tiếp các tham số cho các lớp (giả sử điều này là có thể) và ủy thác quyết định sử dụng cái nào cho nhà máy (điều này sẽ làm cho các thể hiện có thể hoán đổi cho nhau và cả hai đều có thể xuất phát từ đó DoSomething). Điều này sẽ làm Mainnhư thế này

class Main {
    private DoSomethingFactory doSomethingFactory;

     public doingIt(String info) {
         int quality = obtainQualityInfo();
         DoSomething doSomethingWorker = doSomethingFactory.Create(info, quality);
         doSomethingWorker.letDoIt();
     }
}

Tôi biết rằng bạn đã viết rằng

bởi vì lý do hiệu năng, việc xây dựng DoIt ThisWay và DoItThatWay được thực hiện một lần trong hàm tạo của Main

Nhưng bạn có thể lưu trữ các bộ phận tốn kém để tạo trong nhà máy và chuyển chúng cho nhà xây dựng.

Giả sử qualitykhông thể truyền vào hàm tạo và setQualityyêu cầu gọi đến .

Hiện tại, một đoạn mã như

    int quality = obtainQualityInfo();
    worker = new DoItThisWay();
    ((DoItThisWay) worker).setQuality(quality);

là quá nhỏ để đầu tư quá nhiều suy nghĩ vào nó. IMHO trông hơi xấu xí, nhưng không thực sự khó hiểu.

Các vấn đề phát sinh khi một đoạn mã như vậy phát triển và do tái cấu trúc, bạn kết thúc với một cái gì đó như

    int quality = obtainQualityInfo();
    worker = CreateAWorkerForThisInfo();
    ((DoItThisWay) worker).setQuality(quality);

Bây giờ, bạn không thấy ngay lập tức nếu mã đó vẫn đúng và trình biên dịch sẽ không cho bạn biết. Vì vậy, giới thiệu một biến tạm thời của loại chính xác và tránh diễn viên, sẽ an toàn hơn một chút về loại, mà không cần bất kỳ nỗ lực thực sự nào.

Tuy nhiên, tôi thực sự sẽ cho tmpmột cái tên tốt hơn:

      int quality = obtainQualityInfo();
      DoItThisWay workerThisWay = new DoItThisWay();
      workerThisWay.setQuality(quality)
      worker = workerThisWay;

Việc đặt tên như vậy giúp làm cho mã sai nhìn sai.

Một giao diện phổ biến trong đó việc khởi tạo thay đổi dựa trên dữ liệu thời gian chạy thường cho chính mẫu nhà máy.

DoThingsFactory factory = new DoThingsFactory(thingThatProvidesQuality);
DoSomething doSomething = factory.getDoer(info);

doSomething.letDoIt();

Sau đó, DoThingsFactory có thể lo lắng về việc nhận và thiết lập thông tin chất lượng bên trong getDoer(info)phương thức trước khi trả lại đối tượng DoThingsWithQuality cụ thể cho giao diện DoS Something.