Kachalov
- ООП это способ мышления, заметно превосходящий по гибкости и удобству "процедурное" и "пошаговое" мышление (программирование). Если Вы мыслите исходя из данных сомнений в необходимости ООП просто не может быть, если Вы мыслите действиями, то наверное ООП Вам кажется излишне сложным. Это два разных взгляда на жизнь.
Как я ни люблю ООП, но комбинация ООП + статическая типизация (при всех плюсах) приводит к появлению "лишних" строчек кода, которые иногда существенно увеличивают время на внесение изменений.
Тут нужно сразу внести пояснения, иначе меня скушают.
1. На высоком уровне, когда обсуждаются отношения между объектами выделенными из предметной области ООП, действительно, можно назвать средством обладающим достаточной гибкостью. Избыточность синтаксических конструкций связаных с описанием объектов здесь не играет никакой роли.
2. Но "Дьявол в деталях" (с). На одних объектах из предметной области далеко не уедешь.
Появляются "синтетические" классы: классы-утилиты, промежуточные интерфейсы для обеспечения дополнительной гибкости, фактори, паттерны визитор, темлейт метод и т.п.
Казалось бы где грабли, ведь синтетические классы тоже решают задачи к которым можно применить ООА? А они есть. Преимущество использования декомпозиции данных (оно же ООА) существует только пока "данные" достаточно стабильны (существенно стабильнее, чем связанное с ними поведение). Так вот, данные предметной области стабильны и поэтому классы предметной области тоже стабильны, а синтетические классы не стабильны, т.к. исользуются для описания _поведения_, которое _нестабильно_.
К чему это приводит?
Либо к полному игнорированию ООП на уровне методов классов (включается процедурное программирование со всеми его плюсами и минусами), либо, при последовательном подходе, к разрастанию количества мини-классов, на которых становится заметен оверхед связанный с необходимостью их описания.
Н-р, код из второго сообщения.
Что вижу - то пою:
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
public class PrintOS
{
public static void main( final String[] args)
{
String osName = System.getProperty("os.name") ;
if (osName.equals("SunOS") || osName.equals("Linux"))
{
System.out.println("This is a UNIX box and therefore good.") ;
}
else if (osName.equals("Windows NT") || osName.equals("Windows 95"))
{
System.out.println("This is a Windows box and therefore bad.") ;
}
else
{
System.out.println("This is not a box.") ;
}
}
}
Процедурная декомпозиция:
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.
public class PrintOS {
public static void main( final String[] args) {
String osName = System.getProperty("os.name");
if (isUnix(osName)) {
processUnix();
} else if (isWindows(osName)) {
processWindows();
} else {
processUnknown();
}
}
private static void processUnknown() {
System.out.println("This is not a box.");
}
private static boolean isWindows(String osName) {
return osName.equals("Windows NT") || osName.equals("Windows 95");
}
private static void processWindows() {
System.out.println("This is a Windows box and therefore bad.");
}
private static boolean isUnix(String osName) {
return osName.equals("SunOS") || osName.equals("Linux");
}
private static void processUnix() {
System.out.println("This is a UNIX box and therefore good.");
}
}
Ясно стало видно дублирование кода для выявления типа OS, которое трудно устранить не имея возможности получить ссылку на метод.
Используем для этого полиморфизм:
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.
public class PrintOS {
public static void main( final String[] args) {
findOSByName(System.getProperty("os.name")).process();
}
private static OS findOSByName(String osName) {
for (OS os : new OS[]{ new Unix(), new Windows(), new Unknown()}) {
if (os.isMatch(osName)) {
return os;
}
}
throw new InternalError();
}
interface OS {
boolean isMatch(String osName);
void process();
}
static class Unknown implements OS {
public boolean isMatch(String osName) {
return true;
}
public void process() {
System.out.println("This is not a box.");
}
}
static class Windows implements OS {
public boolean isMatch(String osName) {
return osName.equals("Windows NT") || osName.equals("Windows 95");
}
public void process() {
System.out.println("This is a Windows box and therefore bad.");
}
}
static class Unix implements OS {
public boolean isMatch(String osName) {
return osName.equals("SunOS") || osName.equals("Linux");
}
public void process() {
System.out.println("This is a UNIX box and therefore good.");
}
}
}
Смотрим и видим, что класс PrintOS содержит утилитные методы, которым нужно найти другое место, чтобы они могли быть повторно использованы где-то ещё.
Синтезируем объект "известные операционные системы":
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.
public class PrintOS {
public static void main( final String[] args) {
//Сказка?
OSes.findByName(System.getProperty("os.name")).process();
}
}
interface OS {
boolean isMatch(String osName);
void process();
}
class OSes {
static OS[] registred = new OS[]{ new Unix(), new Windows(), new Unknown()};
public static OS findByName(String osName) {
for (OS os : registred) {
if (os.isMatch(osName)) {
return os;
}
}
throw new InternalError();
}
static class Unknown implements OS {
public boolean isMatch(String osName) {
return true;
}
public void process() {
System.out.println("This is not a box.");
}
}
static class Windows implements OS {
public boolean isMatch(String osName) {
return osName.equals("Windows NT") || osName.equals("Windows 95");
}
public void process() {
System.out.println("This is a Windows box and therefore bad.");
}
}
static class Unix implements OS {
public boolean isMatch(String osName) {
return osName.equals("SunOS") || osName.equals("Linux");
}
public void process() {
System.out.println("This is a UNIX box and therefore good.");
}
}
}
Смотрим и снова видим, что что-то не так. А именно метод process. Он делает то, что нужно классу PrintOS, а как же быть другим пользователям OSes? Можно дописывать методы в интерфейс OS и реализовывать их, но это нарушает OSP.
Поэтому появляется визитор:
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.
public class PrintOS {
public static void main( final String[] args) {
OSes.findByName(System.getProperty("os.name")).process( new PrintMessageVisitor());
}
private static class PrintMessageVisitor implements OSes.Visitor {
public void visit(OSes.Unix unix) {
System.out.println("This is a UNIX box and therefore good.");
}
public void visit(OSes.Windows windows) {
System.out.println("This is a Windows box and therefore bad.");
}
public void visit(OSes.Unknown unknown) {
System.out.println("This is not a box.");
}
}
}
interface OS {
boolean isMatch(String osName);
void process(OSes.Visitor visitor);
}
class OSes {
static OS[] registred = new OS[]{ new Unix(), new Windows(), new Unknown()};
public static OS findByName(String osName) {
for (OS os : registred) {
if (os.isMatch(osName)) {
return os;
}
}
throw new InternalError();
}
interface Visitor {
void visit(Unknown unknown);
void visit(Windows windows);
void visit(Unix unix);
}
static class Unknown implements OS {
public boolean isMatch(String osName) {
return true;
}
public void process(Visitor visitor) {
visitor.visit( this );
}
}
static class Windows implements OS {
public boolean isMatch(String osName) {
return osName.equals("Windows NT") || osName.equals("Windows 95");
}
public void process(Visitor visitor) {
visitor.visit( this );
}
}
static class Unix implements OS {
public boolean isMatch(String osName) {
return osName.equals("SunOS") || osName.equals("Linux");
}
public void process(Visitor visitor) {
visitor.visit( this );
}
}
}
Лечге стало? Стало. Но остаётся дублирование и трудно добавлять новые типы оs.
Фиксим:
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.
public class PrintOS {
public static void main( final String[] args) {
OSes.findByName(System.getProperty("os.name")).process( new PrintMessageVisitor());
}
private static class PrintMessageVisitor {
@OS.Type(OSes.Unix. class )
public void unixGood() {
System.out.println("This is a UNIX box and therefore good.");
}
@OS.Type(OSes.Windows. class )
public void windowsBad() {
System.out.println("This is a Windows box and therefore bad.");
}
@OS.Type(OSes.Unknown. class )
public void foo() {
System.out.println("This is not a box.");
}
}
}
abstract class OS {
private static Object[] emptyArray = new Object[]{};
public abstract boolean isMatch(String osName);
public final void process(Object visitor) {
for (Method method : visitor.getClass().getMethods()) {
OS.Type annotation = method.getAnnotation(OS.Type. class );
if (annotation != null && annotation.value().equals( this .getClass())) {
try {
method.invoke(visitor, emptyArray);
} catch (Exception e) {
throw new InternalError(); //TODO;
}
}
}
}
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@ interface Type {
Class value();
}
}
class OSes {
static List<OS> registred = new ArrayList<OS>();
private OSes() {
}
static {
for ( Class clazz : OSes. class .getClasses()) {
if (OS. class .isAssignableFrom(clazz)) {
try {
register((OS) clazz.newInstance());
} catch (Exception e) {
throw new InternalError(); //TODO;
}
}
}
}
public static void register(OS os) {
registred.add(os);
}
public static OS findByName(String osName) {
for (OS os : registred) {
if (os.isMatch(osName)) {
return os;
}
}
return Unknown.INSTANCE;
}
public static class Unknown extends OS {
public final static OS INSTANCE = new Unknown();
public boolean isMatch(String osName) {
return false;
}
}
public static class Windows extends OS {
public boolean isMatch(String osName) {
return osName.equals("Windows NT") || osName.equals("Windows 2003");
}
}
public static class Unix extends OS {
public boolean isMatch(String osName) {
return osName.equals("SunOS") || osName.equals("Linux");
}
}
}
Избавляемся от мусора ввиде статиков:
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.
public class PrintOS {
public static void main( final String[] args) {
new OSContainer().resolve(System.getProperty("os.name")).process( new MessagePrinter());
}
private static class OSContainer extends AbstractOSContainer {
public static class Windows extends OS {
public boolean isMatch(String osName) {
return osName.equals("Windows NT") || osName.equals("Windows 2003");
}
}
public static class Unix extends OS {
public boolean isMatch(String osName) {
return osName.equals("SunOS") || osName.equals("Linux");
}
}
}
private static class MessagePrinter {
@OS.Type(OSContainer.Unix. class )
public void unixGood() {
System.out.println("This is a UNIX box and therefore good.");
}
@OS.Type(OSContainer.Windows. class )
public void windowsBad() {
System.out.println("This is a Windows box and therefore bad.");
}
@OS.Type(OS.Unknown. class )
public void foo() {
System.out.println("This is not a box.");
}
}
}
// Support ---------------------------------------------------------------------
abstract class OS {
public final static OS UNKNOWN = new Unknown();
private static Object[] emptyArray = new Object[]{};
public abstract boolean isMatch(String osName);
public final void process(Object visitor) {
for (Method method : visitor.getClass().getMethods()) {
OS.Type annotation = method.getAnnotation(OS.Type. class );
if (annotation != null && annotation.value().equals( this .getClass())) {
try {
method.invoke(visitor, emptyArray);
} catch (Exception e) {
throw new InternalError(); //TODO;
}
}
}
}
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@ interface Type {
Class value();
}
public static class Unknown extends OS {
public boolean isMatch(String osName) {
return false;
}
}
}
class OSes {
private List<OS> registred = new ArrayList<OS>();
public void register(OS os) {
registred.add(os);
}
public OS findByName(String osName) {
for (OS os : registred) {
if (os.isMatch(osName)) {
return os;
}
}
return OS.UNKNOWN;
}
}
class AbstractOSContainer {
private OSes oses = new OSes();
public AbstractOSContainer() {
initOSesFromInnerClasses();
}
private void initOSesFromInnerClasses() {
for ( Class clazz : this .getClass().getClasses()) {
if (OS. class .isAssignableFrom(clazz)) {
try {
oses.register((OS) clazz.newInstance());
} catch (Exception e) {
throw new InternalError(); //TODO;
}
}
}
}
public OS resolve(String osName) {
return oses.findByName(osName);
}
}
Итого из простого метода получены синтетические сущности:
OS - операционная система
@Os.Type - аннотация упрощающая создание visitor'ов
OSes - произвольный набор операционных систем и методы работы с ними
AbstractOSContainer - базовый класс для конкретного набора OS (с автоматической подгрузкой типов операционных систем)
OSConainer - конкретный набор OS (их может быть несколько для разных задач)
Однако изменение в тз на исходный метод может сразу сделать все эти классы бесполезными (если им не успели найти применения ещё где-нибудь) или существенно большей переработки, чем потребовалось для простого варианта.
Какой вывод?
ООП не является достаточно гибким способом мышления.
Нет времени сейчас, кто хочет может дописать как тоже самое будет выглядеть на лиспе, чтобы убедиться, что есть способ "лучше" :)
