[O.....i]

Kolejny dzień z Javą kolejne problemy. :)

Załóżmy, że mam zestaw klas, które reprezentują figury szachowe - abstrakcyjną Piece i dziedziczące po nie King, Queen, Pawn, Rook, Knight, Bishop.

Każda figura ma swoją wartość, która jest zależna tylko od jej typu - na przykład Bishop 3, a Rook 5, dla króla można przyjąć 0. W klasie Piece chciałbym więc mieć metodę getValue(), która zwraca wartość pola VALUE (private static final int) z klasy, którą akurat jest. Da się to zrealizować tak, żeby te pola pozostały statyczne i stałe, oraz żebym nie musiał przeciążać getValue() w każdej klasie pochodnej?

#programowanie #java

[d__k]

@Onoki: ogólnie statycznych składowych odradza się stosować :)

[f.....o]

@Onoki: zmień język a twoje problemy się rozwiążą

[kazio_gt]

@Onoki: Nie da się tak. Jak niby klasa Piece ma wiedzieć co ma w sobie coś co po niej dziedziczy. Najlepiej byłoby zrobić interfejs Piece z metodą getValue() i pod niego podpinać obiekty klas, które go implementują.

[O.....i]

@d__k: Ale w tym wypadku aż się o to prosi. :)

@fermento: Programuję w czym mi każą. Ogólnie to z C++ radzę sobie ZNACZNIE lepiej.


@kazio_gt: Piece nie może być interfejsem, ponieważ trzymam w niej implementację różnych wspólnych metod. Ale ogólnie właśnie tak zrobiłem - public abstract int getValue(); w Piece i bite sześć razy

public int getValue() {

return VALUE;

}

w każdej klasie pochodnej. Sześć razy większe

[kazio_gt]

@Onoki: Na upartego mógłbyś pobawić się refleksją, ale to zapewne bardziej zagmatwa wszystko niż pomoże ;) .

[Rincewind]

@Onoki: Odpuść sobie statyczne pola. A już zdecydowanie nie pchaj się w refleksję! Przecież to proste:

abstract
```**```
 
```**```
class
```**```
 Piece {
``````
  
```**```
private
```**```
 
```**```
final
```**```
 
```**```
int
```**```
 value;
``````
        
``````
  
```**```
protected
```**```
 Piece(
```**```
int
```**```
 value) {
``````
    
```**```
this
```**```
.value = value;
``````
  }
``````
        
``````
  
```**```
public
```**```
 
```**```
int
```**```
 getValue() {
``````
    

[O.....i]

@Rincewind: No dobra, chyba rzeczywiście tak zrobię. :)

[hbpitero]

@Onoki: Ja to bym zroił jedną klasę pawn, która przechowuje nazwę, wartość i listę możliwych do wykonywania ruchów np. proste, ukośne itd. do tego klasa/interfejs typu "sposob poruszania" i zestaw implementacji obliczających gdzie może dane figura skoczyć. Sposób podawania wartości jaki podał Rincewind nie wydaje mi się do końca prawidłowy, ponieważ podklasy tworzymy po to by rozszerzyć zachowanie, a nie żeby przechowywać w nich dane (czy gdybyś robił klasę człowiek to

[hbpitero]

@Onoki: Jako dowód tego, by w pawnie nie implementować poruszania, najłatwiej można przyjąć świadomość, że mamy np. pionka który chodzi po prostych (wierza), po ukosach (goniec), i łącznie (królówka) w związku z tym jakbyś nie kombinował, przez brak wielodziedziczenia powielisz kod, bo nie dasz rady dziedziczyć z gońca i wierzy by zrobić królówkę, a jeżeli próbowałbyś gdzieś wyżej w hierarchi zakodować możliwe ruchy (np. metoda do ukosu, metoda na prostych) i

[GwnBrz]

Każda figura ma swoją wartość, która jest zależna tylko od jej typu

@Onoki: A po co Ci jakaś wartość w szachach? Nawet jak sobie ustalisz jakąś wartość dla każdej figury, to przecież ona niczego nie wyraża. W szachach liczy się typ figury, a nie jakaś liczbowa wartość z dupy.

Podaj realny przykład, a nie problem z implementacją.

(Jak bardzo chcesz mieć to value to możesz sobie zrobić jakąś statyczną mapę klasa/wartość)

[GwnBrz]

@hbpitero: Wydaje mi się, że trochę przesadzasz z takim "perfect design". Moim zdaniem zaimplementowanie jednej metody w każdej klasie, która w jakiś sposób obrazuje sposób poruszania się figury (czy to sprawdzanie poprawności, czy enumerowanie możliwych ruchów) to nie jest duży wysiłek, a takie powielenie kodu na zasadzie, że "królówka może ruszać się tak jak wieża i tak jak goniec" to nie jest żadne powielanie, wielokrotne dziedziczenie w takiej sytuacji dopiero byłoby

[O.....i]

@Onoki: A po co Ci jakaś wartość w szachach? Nawet jak sobie ustalisz jakąś wartość dla każdej figury, to przecież ona niczego nie wyraża. W szachach liczy się typ figury, a nie jakaś liczbowa wartość z dupy.

@GwnBrz: Ponieważ potrzebuję jakichś kryteriów oceny pozycji do min-maxu.

[hbpitero]

@GwnBrz: Nie mogę się z Tobą zgodzić. Nie wiem czy jeszcze do końca nie poczułeś tego zorientowanego obiektowo designu, ale właśnie dokładnie:

- kodu nie należy powtarzać

- powinien być łatwy w utrzymaniu

- powinien być przystosowany do ponownego użycia

Tak jak mówiłem, tutaj wprowadzenie poruszania do pionków nie jest dobrym rozwiązaniem - zaprezentuj mi design tego w javie, bez dosłownego "kopiuj wklej" kwałków kodu - no chyba, że w osobnych