Блог

У меня сейчас три класса, один — основной класс,

Класс А:

 class A{
  int resu<    
  
  int getHeightBase() {
    return resu<
  }

  void setHeightBase(int h, int b) {
   result=h*b;
  }
}
 

Класс В:

Этот класс будет выполнять вычисления, отличные от

 class B{
  int resu<

  int getHeightBase() {
    return resu<
  }

  void setHeightBase(int h, int b) {
   result=12*h*b;
  }
}
 

Основной класс:

 public class Main {    

  public static void main(String[] args) {

   A a= new A();    
   B b= new B();    
  calculateArea(a,b);    
  }

void calculateArea(A obj1, B obj2){    
  obj1.setHeightBase(5,6);    
  obj2.setHeightBase(5,6);
}

}
 

Теперь, когда я изменяю аргументы класс метод setHeightBase или класса B метод setHeightBase по какой-то причине я должен изменить в MainClass как и куда я отправляю целочисленных значений , и я думаю, что это противоречит шаблоны дизайна, может кто-нибудь пожалуйста, руководство мне, как избавиться от этого, я хочу изменить аргументы позже, но я не хочу, чтобы эффект любого другого класса или изменить любой другой класс, я попытался использовать интерфейс, но не вам, как избавиться от этой проблемы
большое спасибо заранее , любая помощь будет оценили

Допустим, у вас есть этот класс:

 public void printNumbers(int one, int two) {
  int result = one   two;
  System.out.println("result = "   result);
}
 

И это вызывается из нескольких других классов. Вы не можете просто изменить подпись (тип возврата, имя метода, список параметров) и ожидать, что все будет работать просто отлично.

Теперь давайте предположим, что вы не хотите, чтобы он автоматически выводил сумму, но вы хотите иметь возможность выбирать, какое действие выполнять при сложении или вычитании.

Для текущего метода ничего не меняйте. Он использовался для добавления. Таким образом, вы добавите перегруженный метод, который принимает дополнительный параметр:

 public void printNumbers(int one, int two) {
  int result = one   two;
  System.out.println("result = "   result);
}

public void printNumbers(int one, int two, String action) {
  // action is either add or sub
  if ( !"add".equals(action) amp;amp; !"sub".equals(action) ) {
    System.out.println("Error");
  } else if ("add".equals(action) {
    int result = one   two;
    System.out.println("result = "   result);
  } else {
    int result = one - two;
    System.out.println("result = "   result);
  }
}
 

Как только вы это сделаете, вы можете изменить исходный метод на:

 public void printNumbers(int one, int two) {
  printNumbers(one, two, "add");
}

public void printNumbers(int one, int two, String action) {
  // action is either add or sub
  if ( !"add".equals(action) amp;amp; !"sub".equals(action) ) {
    System.out.println("Error");
  } else if ("add".equals(action) {
    int result = one   two;
    System.out.println("result = "   result);
  } else {
    int result = one - two;
    System.out.println("result = "   result);
  }
}
 

и функциональность, которая была когда-то предоставлена, останется прежней, в то время как вам не придется изменять какой-либо другой существующий код

Вы можете использовать перегрузку метода,

   void setHeightBase(int h, int b) {
     result=12*h*b;
  }

  void setHeightBase(double h, double b) {
     result=12.0*h*b;
  }
 

это сохранит предыдущий метод, а также создаст метод с точным именем и различными аргументами.

Я бы использовал абстрактный класс в качестве основы и расширил его до других классов. Публичные методы в абстрактном классе будут действовать как контракт с внешним миром. В будущем, если вы хотите предоставить доступ к другим методам, вы добавляете их в интерфейс, и в зависимости от функциональности вы можете предоставить реализацию по умолчанию. В реальных сценариях вы избегаете изменения существующего контракта.

В качестве примера, ваши классы могут быть написаны как таковые

 abstract class Shape{
    int height;
    int base;
    
    Shape(int height, int base){
        super();
        this.height = height;
        this.base = base;
    }
    
    public int area(){
        return height * base;
    }
    
}

class Shape1 extends Shape{

    Shape1(int height, int base){
        super(height, base);
    }
}

class Shape2 extends Shape{
    
    Shape2(int height, int base){
        super(height, base);
    }
    
    @Override
    public int area(){
        return 12 * height * base;
    }
}

public class Test{
    public static void main(String args[]){
        Shape s1 = new Shape1(2,3);
        Shape s2 = new Shape2(2,3);
        System.out.println(s1.area());
        System.out.println(s2.area());
    }
}