Мнение программистов

@eti666 · Регистрация: 16.01.2014

Студворк — интернет-сервис помощи студентам

Здравствуйте)
Я начинающий программист и у меня не большой опыт программирования.Но хотелось услышать мнения по поводу моего выполненного задания про объектно-ориентированный подход и в общем про реализацию)Буду очень рад услышать ваши мнения)

Условия задания

Построить иерархию классов для калькуляторов с разной функциональностью.
1.Простой калькулятор – выполняет 4 арифметические операции: сложение, вычитание, умножение, деление.
2.Простой калькулятор с памятью – имеет также одну ячейку памяти и выполняет с данной ячейкой 4 операции: очистить ячейку памяти, записать в ячейку памяти текущее значение, увеличить или уменьшить значение в ячейке памяти на текущее значение.
3.Инженерный калькулятор – выполняет 4 арифметические операции и вычисляет значения 3 функций: синус, экспонента, квадратный корень.
4.Инженерный калькулятор с памятью – комбинация пунктов 2 и 3.
Создать консольное приложение с единственным аргументом командной строки – имя входного файла.
Структура входного файла: строка 1 - тип калькулятора, остальные строки - числа и операции для вычисления выражения, при этом каждое данное находится в одной строке. Например, содержимое файла для выражения sin(2*10+5)-1, которое необходимо вычислить инженерным калькулятором, может иметь вид:
3
2
*
10
+
5
sin
-
1
Все исходные данные корректные. Если в исходных данных есть ошибка, то результат работы программы может быть любым, в том числе программа может завершиться аварийно.
В приложении создать экземпляр калькулятора заданного типа и с его помощью вычислить значение выражения, определяемого содержимым файла.

Java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
package task;
import java.io.File;
import java.io.FileNotFoundException;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
public class Program {
    static int i;
 
    public static void main(String[] args) throws FileNotFoundException {
        
        List<String> StringList = new ArrayList<String>();
        Scanner scaner = new Scanner(new File("e:\\New Folder\\Atroshchanka\\src\\task\\file.txt"));
        
        while (scaner.hasNextLine())
        StringList.add(scaner.nextLine());
        
        switch (StringList.get(0)) {
        case "1":
            Calc b = new Calc();
            for(i = 1; i < StringList.size(); i++)
                if("*".equals(StringList.get(i))){
                    b.multiplication(StringList, i);
                    --i;
                }
            else if("/".equals(StringList.get(i))){
                    b.division(StringList, i);
                    --i;
            }
            for(i = 1; i < StringList.size(); i++)
                if("+".equals(StringList.get(i))){
                    b.addition(StringList, i);
                    --i;
                }
                else if("-".equals(StringList.get(i))){
                    b.subtraction(StringList, i);
                    --i;
                }           
            break;
            
            
        case "2":
            CalcMem v = new CalcMem();
            for(i = 1; i < StringList.size(); i++)
                if("*".equals(StringList.get(i))){
                    v.multiplication(StringList, i);
                    --i;
                }
            else if("/".equals(StringList.get(i))){
                    v.division(StringList, i);
                    --i;
            }
            for(i = 1; i < StringList.size(); i++)
                if("+".equals(StringList.get(i))){
                    v.addition(StringList, i);
                    --i;
                }
                else if("-".equals(StringList.get(i))){
                    v.subtraction(StringList, i);
                    --i;
                }
            break;
            
        case "3":
            EnginCalc n = new EnginCalc();
            
            for(i = 1; i < StringList.size(); i++)
                if("exp".equals(StringList.get(i)))
                    n.ex(StringList, i);
            
            for(i = 1; i < StringList.size(); i++)
                if("sqrt".equals(StringList.get(i)))
                    n.sqrt(StringList, i);
 
            for(i = 1; i < StringList.size(); i++)
                if("sin".equals(StringList.get(i)))
                    n.sin(StringList, i);           
            
            for(i = 1; i < StringList.size(); i++)
                if("*".equals(StringList.get(i))){
                    n.multiplication(StringList, i);
                    --i;
                }
            else if("/".equals(StringList.get(i))){
                    n.division(StringList, i);
                    --i;
            }
            for(i = 1; i < StringList.size(); i++)
                if("+".equals(StringList.get(i))){
                    n.addition(StringList, i);
                    --i;
                }
                else if("-".equals(StringList.get(i))){
                    n.subtraction(StringList, i);
                    --i;
                }
                
            break;
            
            
        case "4":
            EnginCalcMem m = new EnginCalcMem();
            for(i = 1; i < StringList.size(); i++)
                if("*".equals(StringList.get(i))){
                    m.multiplication(StringList, i);
                    --i;
                }
            else if("/".equals(StringList.get(i))){
                    m.division(StringList, i);
                    --i;
            }
            for(i = 1; i < StringList.size(); i++)
                if("+".equals(StringList.get(i))){
                    m.addition(StringList, i);
                    --i;
                }
                else if("-".equals(StringList.get(i))){
                    m.subtraction(StringList, i);
                    --i;
                }
            break;
        }
        
        System.out.println(StringList);
 
        
    }
 
}

Java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
package task;
 
import java.util.List;
 
public class Calc {
    private double a,b,c;
    
    //Умножение
    public List<String> multiplication(List <String> list , int i) {
         a = Double.parseDouble(list.get(i-1));
         b = Double.parseDouble(list.get(i+1));
         c = a * b;
            list.remove(i+1);
            list.remove(i);;
            list.set(i-1, Double.toString(c));
        return list;        
    }
    
 
    //Деление
    public List<String> division(List<String> list, int i) {
         a = Double.parseDouble(list.get(i-1));
         b = Double.parseDouble(list.get(i+1));
         c = a / b;
            list.remove(i+1);
            list.remove(i);;
            list.set(i-1, Double.toString(c));
        return list;
        
    }   
    
    
    //Сложение
    public List<String> addition(List<String> list, int i) {
         a = Double.parseDouble(list.get(i-1));
         b = Double.parseDouble(list.get(i+1));
         c = a + b;
            list.remove(i+1);
            list.remove(i);;
            list.set(i-1, Double.toString(c));
        return list;
        
    }   
        
 
    //Вычитание
    public List<String> subtraction(List<String> list, int i) {
         a = Double.parseDouble(list.get(i-1));
         b = Double.parseDouble(list.get(i+1));
         c = a - b;
            list.remove(i+1);
            list.remove(i);;
            list.set(i-1, Double.toString(c));
        return list;
        
    }   
    
    
    public double getA() {
        return a;
    }
 
    public double getB() {
        return b;
    }
 
    public double getC() {
        return c;
    }
 
    public void setB(double b) {
        this.b = b;
    }
 
    public void setC(double c) {
        this.c = c;
    }
    
    public void setA(double a) {
        this.a = a;
    }
    
}

Java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
package task;
 
import java.util.List;
 
public class CalcMem extends Calc {
    double mem = 0;
    int increase = 0;
    int reduce = 0;
 
    @Override
    public List<String> multiplication(List<String> list, int i) {
        return super.multiplication(list, i);
    }
 
    @Override
    public List<String> division(List<String> list, int i) {
        return super.division(list, i);
    }
 
    @Override
    public List<String> addition(List<String> list, int i) {
        return super.addition(list, i);
    }
 
    @Override
    public List<String> subtraction(List<String> list, int i) {
        return super.subtraction(list, i);
    }
    //Добавить в память текущее значение
    public double addMemory(List<String> list, int i){
        if(mem == 0)
        mem = Double.parseDouble(list.get(i-1));
        return mem; 
    }
    
    //Очистить память
    public double cleanMemory(){
        mem = 0;
        increase = 0;
        reduce = 0;
        return mem;
    }
 
    //Увеличить на текущее значение
    public double increaseMem(List<String> list, int i) {
        if(increase == 0)
        mem = mem + Double.parseDouble(list.get(i-1));
        increase++;
        return mem;
    }
    
    //Уменьшить на текущее значение
    public double reduceMem(List<String> list, int i) {
        if(reduce == 0)
        mem = mem - Double.parseDouble(list.get(i-1));
        reduce++;
        return mem;
    }
 
}

Java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
package task;
 
import java.util.List;
 
public class EnginCalc extends Calc {
    double w;
 
    @Override
    public List<String> multiplication(List<String> list, int i) {
        return super.multiplication(list, i);
    }
 
    @Override
    public List<String> division(List<String> list, int i) {
        return super.division(list, i);
    }
 
    @Override
    public List<String> addition(List<String> list, int i) {
        return super.addition(list, i);
    }
 
    @Override
    public List<String> subtraction(List<String> list, int i) {
        return super.subtraction(list, i);
    }
    
    //Синус
    public List<String> sin(List<String> list, int i) {
        for(int j = 1; j < i-1; j++){
            if("*".equals(list.get(j))){
                 setA(Double.parseDouble(list.get(j-1)));
                 setB(Double.parseDouble(list.get(j+1)));
                 setC(getA() * getB());
                    list.remove(j+1);
                    list.remove(j);
                    list.set(j-1, Double.toString(getC()));
                    i--;
                    i--;                    
                    System.out.println(list);
                    }
                 else if("/".equals(list.get(j))){
                     setA(Double.parseDouble(list.get(j-1)));
                     setB(Double.parseDouble(list.get(j+1)));
                     setC(getA() / getB()); 
        list.remove(j+1);
        list.remove(j);
        list.set(j-1, Double.toString(getC()));
        i--;
        i--;
        System.out.println(list);
        }}
        for(int j = 1; j < i-1; j++){
            if("+".equals(list.get(j))){
                //System.out.println("****************");
                 setA(Double.parseDouble(list.get(j-1)));
                // System.out.println("****************");
                 setB(Double.parseDouble(list.get(j+1)));
                 setC(getA() + getB());
                    list.remove(j+1);
                    list.remove(j);
                    list.set(j-1, Double.toString(getC()));
                    i--;
                    i--;
                    System.out.println(i);
                    System.out.println(list);}
                 else if("-".equals(list.get(j))){
                     System.out.println(i);
                     System.out.println("Math.exp(1)" + Math.exp(1));
                     setA(Double.parseDouble(list.get(j-1)));
                     setB(Double.parseDouble(list.get(j+1)));
                     setC(getA() - getB());
        list.remove(j+1);
        list.remove(j);
        list.set(j-1, Double.toString(getC()));
        i--;
        i--;
        }}
        for(int j = 1; j < list.size(); j++){
            if("sin".equals(list.get(j))){
                 setC(Double.parseDouble(list.get(j-1)));
                 System.out.println("Math.exp(1)" + Math.exp(1));
                 setA(Math.sin(getC()));
                 System.out.println("sin " + Math.sin(getC()));
                    list.remove(j);
                    System.out.println(getA());
                    list.set(j-1, Double.toString(getA()));
                    System.out.println(list);
            }
        }
 
        return list;
        
        
    }
 
    //Экспонента
    public List<String> ex(List<String> list, int i) {
        if("exp".equals(list.get(i))){
             setC(Double.parseDouble(list.get(i-1)));
             //System.out.println("Math.exp(1)" + Math.exp(1));
             setA(Math.exp(getC()));
            // System.out.println("sin " + Math.sin(getC()));
                list.remove(i);
                System.out.println(getA());
                list.set(i-1, Double.toString(getA()));
                System.out.println(list);}      
        return list;
        
    }
        
    //Квадратный корень
    public List<String> sqrt(List<String> list, int i) {
        for(int j = 1; j < i-1; j++){
            if("*".equals(list.get(j))){
                 setA(Double.parseDouble(list.get(j-1)));
                 setB(Double.parseDouble(list.get(j+1)));
                 setC(getA() * getB());
                    list.remove(j+1);
                    list.remove(j);
                    list.set(j-1, Double.toString(getC()));
                    i--;
                    i--;                    
                    System.out.println(list);
                    }
                 else if("/".equals(list.get(j))){
                     setA(Double.parseDouble(list.get(j-1)));
                     setB(Double.parseDouble(list.get(j+1)));
                     setC(getA() / getB()); 
        list.remove(j+1);
        list.remove(j);
        list.set(j-1, Double.toString(getC()));
        i--;
        i--;
        System.out.println(list);
        }}
        for(int j = 1; j < i-1; j++){
            if("+".equals(list.get(j))){
                //System.out.println("****************");
                 setA(Double.parseDouble(list.get(j-1)));
                // System.out.println("****************");
                 setB(Double.parseDouble(list.get(j+1)));
                 setC(getA() + getB());
                    list.remove(j+1);
                    list.remove(j);
                    list.set(j-1, Double.toString(getC()));
                    i--;
                    i--;
                    System.out.println(i);
                    System.out.println(list);}
                 else if("-".equals(list.get(j))){
                     System.out.println(i);
                     setA(Double.parseDouble(list.get(j-1)));
                     setB(Double.parseDouble(list.get(j+1)));
                     setC(getA() - getB());
        list.remove(j+1);
        list.remove(j);
        list.set(j-1, Double.toString(getC()));
        i--;
        i--;
        }}
        for(int j = 1; j < list.size(); j++){
            if("sqrt".equals(list.get(j))){
                 setC(Double.parseDouble(list.get(j-1)));
                 setA(Math.sqrt(getC()));
                 //System.out.println("sin " + Math.sin(getC()));
                    list.remove(j);
                    //System.out.println(getA());
                    list.set(j-1, Double.toString(getA()));
                    System.out.println(list);
            }
        }
        return list;
        
    }
}

Java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
package task;
 
import java.util.List;
 
public class EnginCalcMem extends EnginCalc {
    double mem = 0;
    int increase = 0;
    int reduce = 0;
    
    @Override
    public List<String> multiplication(List<String> list, int i) {
        // TODO Auto-generated method stub
        return super.multiplication(list, i);
    }
 
    @Override
    public List<String> division(List<String> list, int i) {
        // TODO Auto-generated method stub
        return super.division(list, i);
    }
 
    @Override
    public List<String> addition(List<String> list, int i) {
        // TODO Auto-generated method stub
        return super.addition(list, i);
    }
 
    @Override
    public List<String> subtraction(List<String> list, int i) {
        // TODO Auto-generated method stub
        return super.subtraction(list, i);
    }
    
    public double addMemory(List<String> list, int i){
        if(mem == 0)
        mem = Double.parseDouble(list.get(i-1));
        return mem; 
    }
    
    public double cleanMemory(){
        mem = 0;
        increase = 0;
        reduce = 0;
        return mem;
    }
 
    public double increaseMem(List<String> list, int i) {
        if(increase == 0)
        mem = mem + Double.parseDouble(list.get(i-1));
        increase++;
        return mem;
    }
    
    public double reduceMem(List<String> list, int i) {
        if(reduce == 0)
        mem = mem - Double.parseDouble(list.get(i-1));
        reduce++;
        return mem;
    }
 
    
    
}

@Lumber · 13.02.2016, 06:13

Много повторяющегося кода. Так быть не должно.
switch 1,2,3,4; одно и то же с минимальными различиями.
В каждом case тоже повторения для каждой операции. циклы одинаковые.

В классе Calc:
методы: multiplication, division, addition, subtraction - методы отличаются одним символом, остальное всё повторение. Это ненормально.

В классах наследниках куча переопределённых методов которые ничего не делают:

Java
1
2
3
4
@Override
public List<String> multiplication(List<String> list, int i) {
    return super.multiplication(list, i);
}

это всё нужно удалить просто.
Если метод не меняет своего поведения - не надо его переопределять.
Метод предка и так будет вызываться.

Программу можно сократить в разы.

Имена:
Calc b = new Calc();
плохое имя, надо что-то имеющее смысл.

Я бы сделал одинаковый интерфейс у всех калькуляторов.
Они должны принимать только строки. Не нужно парсить строки в main(),
пусть калькулятор сам этим занимается.

В main() можно прочитать первую строку и создать калькулятор нужного типа.
Тип ссылочной переменной Calc на любой калькулятор. А далее работать со всеми калькуляторами через
единый интерфейс - скармливать им строки.

@reisal78 · 13.02.2016, 10:45

Сообщение от eti666

Создать консольное приложение с единственным аргументом командной строки – имя входного файла.

Обратите внимание на эту строчку задания. Этот пункт задания у вас проигнорирован

Далее... Вот представьте я решил воспользоваться вашим классом калькулятора в своей программе. Мне понадобилось умножить 2 числа. Я беру ваш класс Calc и смотрю на метод.

Java
1
public List<String> multiplication(List <String> list , int i)

what? что бы произвести умножение мне нужно множители в коллекцию перед этим запихать? А i тогда что? а на выходе тоже коллекция? коллекция чего? 2*2 = 100500 вариантов результатов?

@eti666 · 13.02.2016, 11:19 **[ТС]**

так может сделать в классе Calc в методах вот так?? тогда в mail перебор уберется)

Java
1
2
3
4
5
6
7
8
9
10
for(i = 1; i < StringList.size(); i++)
         if("*".equals(StringList.get(i))){
                 a = Double.parseDouble(list.get(i-1));
             b = Double.parseDouble(list.get(i+1));
                     c = a * b;
         if("/".equals(StringList.get(i))))  
                  c = a / b;
              list.remove(i+1);
              list.remove(i);;
              list.set(i-1, Double.toString(c));

@reisal78 · 13.02.2016, 13:39

eti666, разбейте задачу на более простые действия (чем проще тем лучше). Начните делать самые простые действия. Постепенно расширяйте возможности своей программы. Старайтесь что бы при расширении возможностей не было необходимости исправлять то, что уже написано.

@Lumber · 13.02.2016, 18:43

Вот скажем ещё кусок:

Java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
            for(i = 1; i < StringList.size(); i++)
                if("exp".equals(StringList.get(i)))
                    n.ex(StringList, i);
            
            for(i = 1; i < StringList.size(); i++)
                if("sqrt".equals(StringList.get(i)))
                    n.sqrt(StringList, i);
 
            for(i = 1; i < StringList.size(); i++)
                if("sin".equals(StringList.get(i)))
                    n.sin(StringList, i);           
            
            for(i = 1; i < StringList.size(); i++)
                if("*".equals(StringList.get(i))){
                    n.multiplication(StringList, i);
                    --i;
                }
            else if("/".equals(StringList.get(i))){
                    n.division(StringList, i);
                    --i;

зачем каждый раз прогоняется цикл?
Цикл поиска "exp", потом "sqrt" и т.д.
Можно ведь в одном цикле проверять соответствие строки каждой из поддерживаемых операций.
Можно switch со строками использовать.

Далее. А нужен ли вообще цикл? Ведь структура файла такова что после строкой с числом всегда следует строка с операцией. Т.е достаточно проверять только строку при i = 1;

Модификация списка строк - удаление обработанных операций и запись туда результата выглядит сомнительно (особенно преобразование числа в строку только для того чтобы потом преобразовть обратно в число). Возможно стоит просто хранить индекс текущей строки и текущий результат вычислений.

UPD: Поэкспериментировал с enum'ами на примере этой задачи:
здесь реализованы п.п. 1-3.
4-ю из этого так просто не реализовать (или придётся код дублировать).

Есть недоработки: после операции с памятью должна быть возможность
число ввести по идее. Но здесь только следующую команду.

Зато добавил команду "извлечь из памяти" хотя в задании такой нет.
Но без неё смысл работы с памятью теряется.

Java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class Calculator {
 
    public static void main(String[] args) {
 
        BasicCalc calc = new BasicMemoryCalc();
 
        calc.enterLine("500");
        calc.enterLine("-");
        calc.enterLine("50");
        calc.enterLine("/");
        calc.enterLine("10");
        calc.enterLine("M+");
        calc.enterLine("M+");
        calc.enterLine("M+");
        calc.enterLine("MR");
 
        System.out.println(calc.getResult());
 
    }
}

Java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
class BasicCalc {
 
    State state = State.WAIT_FOR_FIRST_OPERAND;
 
    public void enterLine(String line) {
        state = state.processLine(line);
    }
 
    public double getResult() {
        return state.getResult();
    }
 
    public void reset() {
        state.setResult(0.0);
        state = State.WAIT_FOR_FIRST_OPERAND;
    }
 
    enum State {
        WAIT_FOR_FIRST_OPERAND {
            @Override
            State processLine(String line) {
                firstOp = Double.parseDouble(line);
                return State.WAIT_FOR_OPERATION;
            }
        },
        WAIT_FOR_OPERATION {
            @Override
            State processLine(String line) {
                operation = (BasicOperation) enumFromString(line, BasicOperation.values());
                return State.WAIT_FOR_SECOND_OPERAND;
            }
        },
        WAIT_FOR_SECOND_OPERAND {
            @Override
            State processLine(String line) {
                double secondOp = Double.parseDouble(line);
                firstOp = operation.calculate(firstOp, secondOp);
                return State.WAIT_FOR_OPERATION;
            }
        };
 
        private static double firstOp;
        private static BasicOperation operation;
 
        public double getResult() {
            return firstOp;
        }
        public void setResult(double res) { firstOp = res; }
 
        abstract State processLine(String line);
    }
 
    static Enum enumFromString(String op, Enum[] values) {
        for (Enum b : values) {
            if (op.equals(b.toString())) {
                return b;
            }
        }
        return null;
    }
 
    private enum BasicOperation {
        PLUS("+") { @Override double calculate(double x, double y) { return x + y; } },
        MINUS("-") { @Override double calculate(double x, double y) { return x - y; } },
        MULTIPLICATION("*") { @Override double calculate(double x, double y) { return x * y; } },
        DIVISION("/") { @Override double calculate(double x, double y) { return x / y; } };
 
        private String operationText;
 
        BasicOperation(String op) {
            operationText = op;
        }
 
        abstract double calculate(double x, double y);
 
        @Override
        public String toString() { return operationText; }
    }
}

Java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
class EngineeringCalc extends BasicCalc {
 
    EngineeringOperation engineeringOperation;
 
    @Override
    public void enterLine(String line) {
        if (state == State.WAIT_FOR_OPERATION
                && (engineeringOperation = (EngineeringOperation) enumFromString(line, EngineeringOperation.values())) != null) {
            double res = engineeringOperation.calculate(state.getResult());
            state.setResult(res);
            state = State.WAIT_FOR_OPERATION;
            return;
        }
        super.enterLine(line);
    }
 
    private enum EngineeringOperation {
        SINUS("sin") { @Override double calculate(double x) { return Math.sin(x); } },
        EXPONENT("exp") { @Override double calculate(double x) { return Math.exp(x); } },
        SQRT("sqrt") { @Override double calculate(double x) { return Math.sqrt(x); } };
 
        private String operationText;
 
        EngineeringOperation(String op) {
            operationText = op;
        }
 
        abstract double calculate(double x);
 
        @Override
        public String toString() { return operationText; }
    }
}

Java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
public class BasicMemoryCalc extends BasicCalc {
 
    MemoryOperation memoryOperation;
 
    @Override
    public void enterLine(String line) {
        if (state == State.WAIT_FOR_OPERATION
                && ((memoryOperation = (MemoryOperation) enumFromString(line, MemoryOperation.values())) != null)) {
            memoryOperation.calculate(state);
            state = State.WAIT_FOR_OPERATION;
            return;
        }
        super.enterLine(line);
    }
 
    @Override
    public void reset() {
        MemoryOperation.memory = 0.0;
        super.reset();
    }
 
    private enum MemoryOperation {
        MEM_CLEAR("MC") { @Override void calculate(State state) { memory = 0; } },
        MEM_PLUS("M+") { @Override void calculate(State state) { memory += state.getResult(); } },
        MEM_MINUS("M-") { @Override void calculate(State state) { memory -= state.getResult(); } },
        MEM_SAVE("MS") { @Override void calculate(State state) { memory = state.getResult(); } },
        MEM_RECOVER("MR") { @Override void calculate(State state) { state.setResult(memory); } };
 
        private String operationText;
 
        static double memory;
 
        MemoryOperation(String op) {
            operationText = op;
        }
 
        abstract void calculate(State x);
 
        @Override
        public String toString() { return operationText; }
    }
}

@korvin_ · 13.02.2016, 21:38

Сообщение от eti666

Но хотелось услышать мнения по поводу моего выполненного задания про объектно-ориентированный подход и в общем про реализацию)Буду очень рад услышать ваши мнения)

Почему у тебя EnginCalcMem наследуется от EnginCalc, а не от CalcMem, например? Подумай над этим.

@eti666 · 14.02.2016, 14:23 **[ТС]**

Ну мне так кажется более разумным. Может я и ошибаюсь

Добавлено через 2 часа 5 минут

Сообщение от Lumber

Я бы сделал одинаковый интерфейс у всех калькуляторов.

я думал может сделать интерфейсы операции (+-*/) - это один и память - второй и наследоваться от них)

@Lumber · 14.02.2016, 16:14

Ну в задании сказано построить иерархию классов калькуляторов.

А если от этого отойти...

Можно сделать класс-контейнер калькулятор. И сделать интерфейс "вычислительный блок".
И реализовать с этим интерфейсом "блок основных-операций", "блок инженерных вычислений", "блок операций с памятью".

А потом лепить свои экземпляры класса-калькулятора запихивая в класс-контейнер произвольный набор вычислительных блоков. Но это не наследование, а композиция.

Набор блоков можно даже в run-time менять, "собирая" из вычислительных блоков разные калькуляторы без перекомпиляции.

Новые блоги и статьи Все статьи Все блоги /
сукцессия микоризы: основная теория в виде двух уравнений. anaschu 11.01.2026 https:/ / rutube. ru/ video/ 7a537f578d808e67a3c6fd818a44a5c4/	WordPad для Windows 11 Jel 10.01.2026 WordPad для Windows 11 — это приложение, которое восстанавливает классический текстовый редактор WordPad в операционной системе Windows 11. После того как Microsoft исключила WordPad из. . .	Classic Notepad for Windows 11 Jel 10.01.2026 Old Classic Notepad for Windows 11 Приложение для Windows 11, позволяющее пользователям вернуть классическую версию текстового редактора «Блокнот» из Windows 10. Программа предоставляет более. . .	Почему дизайн решает? Neotwalker 09.01.2026 В современном мире, где конкуренция за внимание потребителя достигла пика, дизайн становится мощным инструментом для успеха бренда. Это не просто красивый внешний вид продукта или сайта — это. . .
Модель микоризы: классовый агентный подход 3 anaschu 06.01.2026 aa0a7f55b50dd51c5ec569d2d10c54f6/ O1rJuneU_ls https:/ / vkvideo. ru/ video-115721503_456239114	Owen Logic: О недопустимости использования связки «аналоговый ПИД» + RegKZR ФедосеевПавел 06.01.2026 Owen Logic: О недопустимости использования связки «аналоговый ПИД» + RegKZR ВВЕДЕНИЕ Введу сокращения: аналоговый ПИД — ПИД регулятор с управляющим выходом в виде числа в диапазоне от 0% до. . .	Модель микоризы: классовый агентный подход 2 anaschu 06.01.2026 репозиторий https:/ / github. com/ shumilovas/ fungi ветка по-частям. коммит Create переделка под биомассу. txt вход sc, но sm считается внутри мицелия. кстати, обьем тоже должен там считаться. . . .	Расчёт токов в цепи постоянного тока igorrr37 05.01.2026 / * Дана цепь постоянного тока с сопротивлениями и источниками (напряжения, ЭДС и тока). Найти токи и напряжения во всех элементах. Программа составляет систему уравнений по 1 и 2 законам Кирхгофа и. . .

@reisal78 944 / 687 / 230 Регистрация: 28.04.2013 Сообщений: 1,925
	13.02.2016, 13:39
	eti666, разбейте задачу на более простые действия (чем проще тем лучше). Начните делать самые простые действия. Постепенно расширяйте возможности своей программы. Старайтесь что бы при расширении возможностей не было необходимости исправлять то, что уже написано. 1

@Lumber 345 / 141 / 51 Регистрация: 02.12.2015 Сообщений: 333
	14.02.2016, 16:14
	Ну в задании сказано построить иерархию классов калькуляторов. А если от этого отойти... Можно сделать класс-контейнер калькулятор. И сделать интерфейс "вычислительный блок". И реализовать с этим интерфейсом "блок основных-операций", "блок инженерных вычислений", "блок операций с памятью". А потом лепить свои экземпляры класса-калькулятора запихивая в класс-контейнер произвольный набор вычислительных блоков. Но это не наследование, а композиция. Набор блоков можно даже в run-time менять, "собирая" из вычислительных блоков разные калькуляторы без перекомпиляции. 0