Gra Ping Pong i problem z NullPointerException...

Rejestracja:prawie 5 lat
Ostatnio:ponad rok
Postów:78

Cześć, jak w tytule na 3 - 4 uruchomienia na 5 wyrzuca mi null pointer exception.
Bez tytułu.jpg
Próbowałem jakoś debugerem zlokalizować problem, ale nie bardzo ogarniam jego obsługę... :/ Wyjątek wyrzuca mi albo na ball.move(); albo na player.move(); (linie 188 i 189 ostatnia klasa) Ktoś z was może widzi problem?

Piłka:

Kopiuj

import java.awt.*;
import java.util.Random;

public class Ball implements BallInterface {

    private static final Random random = new Random();
    private static int initialSpeed = 2;

    public int ballHorizontalVelocity;
    public int ballVerticalVelocity;

    private Rectangle rectangle;

    public Ball(int xPosition, int yPosition, int xSize, int ySize) {
        this.rectangle = new Rectangle(xPosition, yPosition, xSize, ySize);
        initBall();
    }

    @Override
    public void initBall() {
        int randomXDirection = random.nextInt(2);
        int randomYDirection = random.nextInt(2);
        if (randomXDirection == 0) {
            randomXDirection--;
        }

        setXDirection(randomXDirection * initialSpeed);

        if (randomYDirection == 0) {
            randomYDirection--;
        }

        setYDirection(randomYDirection * initialSpeed);
    }

    @Override
    public void setXDirection(int randomXDirection) {
        ballHorizontalVelocity = randomXDirection;
    }

    @Override
    public void setYDirection(int randomYDirection) {
        ballVerticalVelocity = randomYDirection;
    }

    @Override
    public void move() {
        rectangle.x += ballHorizontalVelocity;
        rectangle.y += ballVerticalVelocity;
    }

    @Override
    public void draw(Graphics g) {
        g.setColor(new Color(241, 144, 39));
        g.fillOval(rectangle.x, rectangle.y, rectangle.width, rectangle.height);
    }

    public boolean intersects(Rectangle rectangle) {
        return this.rectangle.intersects(rectangle);
    }

    public int getVerticalPos() {
        return rectangle.y;
    }

    public int getHorizontalPos() {
        return rectangle.x;
    }

    public int getYVelocity() {
        return ballVerticalVelocity;
    }

    public int getXVelocity() {
        return ballHorizontalVelocity;
    }
}

Gracz (paletka):

Kopiuj


import java.awt.*;
import java.awt.event.KeyEvent;

public class Paddle implements PaddleInterface {

    private Rectangle rectangle;
    public int paddleVerticalVelocity;
    private static final int ballSpeed = 10;

    public Paddle(int xPosition, int yPosition, int PADDLE_WIDTH, int PADDLE_HEIGHT) {
        rectangle = new Rectangle(xPosition, yPosition, PADDLE_WIDTH, PADDLE_HEIGHT);
    }

    @Override
    public void setYDirection(int yDirection) {
        paddleVerticalVelocity = yDirection;
    }

    @Override
    public void movePaddle(KeyEvent key) {

        if (key.getKeyCode() == KeyEvent.VK_W) {
            setYDirection(-ballSpeed);
        }

        if (key.getKeyCode() == KeyEvent.VK_S) {
            setYDirection(ballSpeed);
        }

        if (key.getKeyCode() == KeyEvent.VK_UP) {
            setYDirection(-ballSpeed);
        }

        if (key.getKeyCode() == KeyEvent.VK_DOWN) {
            setYDirection(ballSpeed);
        }
    }

    @Override
    public void stopPaddle(KeyEvent key) {

        if (key.getKeyCode() == KeyEvent.VK_W) {
            setYDirection(0);
        }

        if (key.getKeyCode() == KeyEvent.VK_S) {
            setYDirection(0);
        }

        if (key.getKeyCode() == KeyEvent.VK_UP) {
            setYDirection(0);
        }

        if (key.getKeyCode() == KeyEvent.VK_DOWN) {
            setYDirection(0);
        }
    }

    @Override
    public void move() {
        rectangle.y = rectangle.y + paddleVerticalVelocity;
    }

    @Override
    public void draw(Graphics g) {
        g.setColor(Color.BLACK);
        g.fillRect(rectangle.x, rectangle.y ,rectangle.width, rectangle.height);
    }

    public Rectangle getRectangle() {
        return rectangle;
    }

    public int getVerticalPos() {
        return rectangle.y;
    }

    public void setVerticalPos(int pos) {
        this.rectangle.y = pos;
    }
}

Rozgrywka:

Kopiuj


import javax.imageio.ImageIO;
import java.awt.*;
import java.awt.event.KeyEvent;
import java.awt.image.BufferedImage;
import java.io.File;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;

public class Skirmish extends GUIState implements SkirmishInterface {

    private static final int PADDLE_WIDTH = 25;
    private static final int PADDLE_HEIGHT = 100;
    private static final int BALL_DIAMETER = 20;
    private static final int MAX_POINTS = 11;
    private static final int FIELD_HEIGHT = 124;
    private static final int FIELD_WIDTH = 1;
    private static final int speedUpBallWhenDificultyIsHeigherThen55 = 55;
    private static final List<Integer> ballVerticalYPosition = new ArrayList<>();
    private static final File backgroundFile = new File("src/main/resources/static/pongTable.jpg");
    private static final Random random = new Random();
    private static final Field field = new Field((GameEngine.WIDTH / 4) * 3 - 20, GameEngine.HEIGHT / 2 - FIELD_HEIGHT / 2, FIELD_WIDTH, FIELD_HEIGHT);

    private int ballTouchPaddle;
    private int randomEnemyMistakeSecondStrategy;
    private int randomEnemyMistake;
    private int randomDificultStrategy;
    private BufferedImage backgroundImage;
    private Paddle player;
    private Enemy enemy;
    private Ball ball;
    private Scores scores;

    public Skirmish(GUIStateManager GUIStateManager) {
        this.GUIStateManager = GUIStateManager;
        this.scores = new Scores();
    }

    @Override
    public void newPaddles() {
        randomEnemyMistake = random.nextInt(100) + 1;
        randomDificultStrategy = random.nextInt(3) + 1;
        randomEnemyMistakeSecondStrategy = random.nextInt(3) + 5;
        player = new Paddle(0, (GameEngine.HEIGHT / 2) - (PADDLE_HEIGHT / 2), PADDLE_WIDTH, PADDLE_HEIGHT);
        enemy = new Enemy(GameEngine.WIDTH - PADDLE_WIDTH, (GameEngine.HEIGHT / 2) - PADDLE_HEIGHT / 2, PADDLE_WIDTH, PADDLE_HEIGHT);
    }

    @Override
    public void newBall() {
        ball = new Ball((GameEngine.WIDTH / 2) - (BALL_DIAMETER / 2), (GameEngine.HEIGHT / 2 - BALL_DIAMETER / 2), BALL_DIAMETER, BALL_DIAMETER);
        ballTouchPaddle = 0;
        clearBallVerticalPositionForDificultStrategyWithFail();
    }

    @Override
    public boolean setRoundDificulty(int enemyMistake, int setedDificulty) {
        if (enemyMistake < setedDificulty) {
            return true;
        } else {
            return false;
        }
    }

    @Override
    public void enemyStrategy() {

        if (setRoundDificulty(randomEnemyMistake, DificultyMenu.dificultyPercent)) {
            if (randomDificultStrategy == EnemyStrategy.HARD_STRATEGY_WITHOUT_FAIL.getStrategyCase()) {
                enemyDificultStrategyWithoutFail();
            } else if (randomDificultStrategy == EnemyStrategy.HARD_STRATEGY_WITH_FAIL.getStrategyCase()) {
                enemyDificultStrategyWithFail();
            } else if (randomDificultStrategy == EnemyStrategy.MEDIUM_STRATEGY.getStrategyCase()) {
                enemyMediumStrategy();
            }
        } else {
            enemyEasyStrategy();
        }
    }

    @Override
    public void init() {
        newPaddles();
        newBall();
        try {
            backgroundImage = ImageIO.read(backgroundFile);
        } catch (Exception e){
            e.printStackTrace();
        }
    }

    @Override
    public void checkBallPaddleCollision() {
        checkPlayerCollision();
        checkEnemyCollision();
    }

    @Override
    public void checkBallCollisionWithFrame() {
        if (ball.getVerticalPos() <= 0) {
            ball.setYDirection(-ball.ballVerticalVelocity);
        }

        if (ball.getVerticalPos() >= GameEngine.HEIGHT - BALL_DIAMETER) {
            ball.setYDirection(-ball.ballVerticalVelocity);
        }
    }

    @Override
    public void checkPaddleCollisionWithFrame() {
        if (player.getVerticalPos() <= 0) {
            player.setVerticalPos(0);
        }

        if (player.getVerticalPos() >= GameEngine.HEIGHT - PADDLE_HEIGHT) {
            player.setVerticalPos(GameEngine.HEIGHT - PADDLE_HEIGHT);
        }
    }

    @Override
    public void givePlayerPoint() {
        if (ball.getHorizontalPos() > GameEngine.WIDTH) {
            newBall();
            newPaddles();
            scores.scorePlayer1++;
            if (scores.scorePlayer1 == MAX_POINTS) {
                checkSetWinner();
                scores.scorePlayer1 = 0;
                scores.scorePlayer2 = 0;
            }
        }
    }

    @Override
    public void giveEnemyPoint() {
        if (ball.getHorizontalPos() + BALL_DIAMETER < 0) {
            newBall();
            newPaddles();
            scores.scorePlayer2++;
            if (scores.scorePlayer2 == MAX_POINTS) {
                checkSetWinner();
                scores.scorePlayer1 = 0;
                scores.scorePlayer2 = 0;
            }
        }
    }

    @Override
    public void addPlayer1Score() {
        Scores.player1Scores.add(scores.scorePlayer1);
    }

    @Override
    public void addPlayer2Score() {
        Scores.player2Scores.add(scores.scorePlayer2);
    }

    @Override
    public void checkSetWinner() {
        if (scores.scorePlayer1 == MAX_POINTS) {
            addPlayer1Score();
            addPlayer2Score();
            Scores.setWinPlayer1++;
        }

        if (scores.scorePlayer2 == MAX_POINTS) {
            addPlayer1Score();
            addPlayer2Score();
            Scores.setWinPlayer2++;
        }
    }

    @Override
    public void checkwhoWinSkirmish() {
        if (Scores.setWinPlayer1 == Sets.TWO_WINS.getSetWins() && Scores.setWinPlayer2 == Sets.ZERO_WINS.getSetWins()) {
            GUIStateManager.setStates(GUIStateManager.STATISTICS);
        } else if (Scores.setWinPlayer2 == Sets.TWO_WINS.getSetWins() && Scores.setWinPlayer1 == Sets.ZERO_WINS.getSetWins()) {
            GUIStateManager.setStates(GUIStateManager.STATISTICS);
        } else if (Scores.setWinPlayer1 == Sets.TWO_WINS.getSetWins() && Scores.setWinPlayer2 == Sets.ONE_WIN.getSetWins()) {
            GUIStateManager.setStates(GUIStateManager.STATISTICS);
        } else if (Scores.setWinPlayer2 == Sets.TWO_WINS.getSetWins() && Scores.setWinPlayer1 == Sets.ONE_WIN.getSetWins()) {
            GUIStateManager.setStates(GUIStateManager.STATISTICS);
        }
    }

    @Override
    public void update() {
        player.move();
        ball.move();
        enemyStrategy();
        checkBallCollisionWithFrame();
        checkPaddleCollisionWithFrame();
        checkBallPaddleCollision();
        givePlayerPoint();
        giveEnemyPoint();
        checkSetWinner();
        checkwhoWinSkirmish();
    }

    @Override
    public void draw(Graphics g) {
        g.drawImage(backgroundImage, 0, 0, null);
        field.draw(g);
        player.draw(g);
        enemy.draw(g);
        ball.draw(g);
        scores.draw(g);
    }

    @Override
    public void onKeyPressed(KeyEvent key) {
        player.movePaddle(key);
    }

    public int whenEnemyIntersectsUpperEdgeOfFrame() {
        return PADDLE_HEIGHT / 2 - BALL_DIAMETER / 2 - 1;
    }

    public int whenEnemyIntersectsLowerEdgeOfFrame() {
        return GameEngine.HEIGHT - PADDLE_HEIGHT / 2 - BALL_DIAMETER / 2  + 2;
    }

    @Override
    public void onKeyReleased(KeyEvent key) {
        player.stopPaddle(key);
    }

    private void checkEnemyCollision() {
        if (ball.intersects(enemy.getRectangle())) {
            ball.ballHorizontalVelocity = Math.abs(ball.getXVelocity());
            if (DificultyMenu.dificultyPercent >= speedUpBallWhenDificultyIsHeigherThen55) {
                ball.ballHorizontalVelocity++;
                if (ball.getYVelocity() > 0) {
                    ball.ballVerticalVelocity++;
                } else {
                    ball.ballVerticalVelocity--;
                }
            }
            ball.setXDirection(-ball.getXVelocity());
            ball.setYDirection(ball.getYVelocity());
        }
    }

    private void checkPlayerCollision() {
        if (ball.intersects(player.getRectangle())) {
            ball.ballHorizontalVelocity = Math.abs(ball.getXVelocity());
            if (DificultyMenu.dificultyPercent >= speedUpBallWhenDificultyIsHeigherThen55) {
                ball.ballHorizontalVelocity++;
                if (ball.getYVelocity() > 0) {
                    ball.ballVerticalVelocity++;
                } else {
                    ball.ballVerticalVelocity--;
                }
            }
            ball.setXDirection(ball.getXVelocity());
            ball.setYDirection(ball.getYVelocity());
        }
    }

    private void enemyEasyStrategy() {
        //Algorytm, który robi błąd (łatwy poziom)
        enemy.setVerticalPos(enemy.moveStrategyEasy());
        if (enemy.getVerticalPos() <= 0) {
            enemy.setYDirection(-enemy.getVelocity());
        }
        if (enemy.getVerticalPos() >= GameEngine.HEIGHT - PADDLE_HEIGHT) {
            enemy.setYDirection(-enemy.getVelocity());
        }
    }

    private void enemyMediumStrategy() {
        //Algorytm o średnim poziomie trudności
        enemy.setVerticalPos(enemy.moveStrategyMedium());
        if (enemy.getVerticalPos() <= 0) {
            enemy.setYDirection(-enemy.getVelocity());
        }
        if (enemy.getVerticalPos() >= GameEngine.HEIGHT - PADDLE_HEIGHT) {
            enemy.setYDirection(-enemy.getVelocity());
        }
    }

    private void enemyDificultStrategyWithFail() {
        if (DificultyMenu.dificultyPercent >= speedUpBallWhenDificultyIsHeigherThen55) {
            if (ball.getVerticalPos() <= whenEnemyIntersectsUpperEdgeOfFrame() || ball.getVerticalPos() >= whenEnemyIntersectsLowerEdgeOfFrame()) {
                enemy.setYDirection(0);
            } else {
                enemy.setVerticalPos(enemyVerticalPositionForDificultStrategyWithFail());

                if (ball.intersects(player.getRectangle())) {
                    ballTouchPaddle++;
                }

                if (ballTouchPaddle >= randomEnemyMistakeSecondStrategy && ball.intersects(field.getRectangle())) {
                    ballVerticalYPosition.add(ball.getVerticalPos());
                }
            }


            if (ball.getHorizontalPos() >= stopEnemyLine() && !ballVerticalYPosition.isEmpty()) {
                enemy.setVerticalPos(enemyStopPosition(0));
            }

            if (ball.getHorizontalPos() < stopEnemyLine()) {
            clearBallVerticalPositionForDificultStrategyWithFail();

            }

            if (ball.getHorizontalPos() >= stopEnemyLine()) {
                field.setHorizontalPos(temporaryFieldPosition());
            } else {
                field.setHorizontalPos(basiclyFieldPostion());
            }

        } else {
            enemyMediumStrategy();
        }
    }

    private void enemyDificultStrategyWithoutFail() {
        //Algorytm, który nie robi błędu
        if (ball.getVerticalPos() <= whenEnemyIntersectsUpperEdgeOfFrame() || ball.getVerticalPos() >= whenEnemyIntersectsLowerEdgeOfFrame()) {
            enemy.setYDirection(0);
        } else {
            enemy.setVerticalPos(enemyVerticalPositionForDificultStrategyWithFail());
        }
    }

    private int enemyVerticalPositionForDificultStrategyWithFail() {
        return ball.getVerticalPos() - (PADDLE_HEIGHT / 2) + (BALL_DIAMETER / 2);
    }

    private void clearBallVerticalPositionForDificultStrategyWithFail() {
        ballVerticalYPosition.clear();
    }

    private int temporaryFieldPosition() {
        return GameEngine.WIDTH / 2 + 10;
    }

    private int basiclyFieldPostion() {
        return (GameEngine.WIDTH / 4) * 3 - 20;
    }

    private int stopEnemyLine() {
        return (GameEngine.WIDTH / 4 * 3) - 40;
    }

    private int enemyStopPosition(int index) {
        return ballVerticalYPosition.get(index) - PADDLE_HEIGHT / 2 + BALL_DIAMETER / 2;
    }
}

Bez tytułu.jpg (223 KB) - ściągnięć: 12

Java

99xmarcin

2021-08-24 16:55

~~99xmarcin~~2021-08-24 16:55

Rejestracja:około 5 lat
Ostatnio:6 miesięcy
Postów:2420

https://kodilla.com/pl to jakaś kolejna no-name'owa ~~platforma do testowania programistów~~ bootcamp. Czyżbyś próbował robić jakieś zadanie rekrutacyjne/zaliczeniowe?

edytowany 1x, ostatnio: ~~99xmarcin~~ 2021-08-24 16:56

Ukulelemelelele

2021-08-24 17:39

Ukulelemelelele2021-08-24 17:39

Rejestracja:prawie 5 lat
Ostatnio:ponad rok
Postów:78

@0xmarcin: Staram się dokończyć pierwszy projekt na bootcamp i tylko to zostało mi do zrobienia.

RequiredNickname 2021-08-25 13:34

Nie licz na znalezienie pracy po tym bootcampie jeśli zamiast uczyć Cię przydatnych rzeczy każą robić pseudo gry z wykorzystaniem awt...

szatkus

2021-08-24 17:46

~~szatkus~~2021-08-24 17:46

Rejestracja:ponad 21 lat
Ostatnio:ponad 3 lata
Postów:227

Raczej wiele Ci nie uradzimy. ball jest nullem, a chyba nie powinien. Wygląda na to, że jedyne miejsce, gdzie to pole się wypełnia to newBall. To się wywołuje?

Ukulelemelelele

2021-08-25 07:36

Ukulelemelelele2021-08-25 07:36

Rejestracja:prawie 5 lat
Ostatnio:ponad rok
Postów:78

@szatkus: Problem rozwiązany. :)

Kopiuj

    public Skirmish(GUIStateManager GUIStateManager) {
        this.GUIStateManager = GUIStateManager;
        this.scores = new Scores();
        this.player = new Paddle(0, (GameEngine.HEIGHT / 2) - (PADDLE_HEIGHT / 2), PADDLE_WIDTH, PADDLE_HEIGHT);
        this.ball = new Ball((GameEngine.WIDTH / 2) - (BALL_DIAMETER / 2), (GameEngine.HEIGHT / 2 - BALL_DIAMETER / 2), BALL_DIAMETER, BALL_DIAMETER);
        this.enemy = new Enemy(GameEngine.WIDTH - PADDLE_WIDTH, (GameEngine.HEIGHT / 2) - PADDLE_HEIGHT / 2, PADDLE_WIDTH, PADDLE_HEIGHT);
    }

AnyKtokolwiek

2021-08-25 21:55

AnyKtokolwiek2021-08-25 21:55

Rejestracja:prawie 7 lat
Ostatnio:około miesiąc
Postów:3561

Poza tym, co złapałeś, jest bardzo dziwne traktowanie pól klas zamiast zmiennych, co się łączy z nadmiarem void. Coś poprawiłeś, wyskoczą następne.

Niby się chwali opisowe nazwy zmiennych, ale tu są przesadne. A to mojej ocenie to wynika ze słabej strukturyzacji (np brak wydzielenia konfiguracji, ale nie tylko).

Mam wrażenie, nie panujesz nad dzieleniem całkowitoliczbowym (drobiazg przy reszcie problemów)

Jak nie byłbym absolutnym przeciwnikiem np programowania projektu szkolnego w Swingu, choć nie ma na to etatów, ale za zaletę bym widział (przy dobrym użyciu Swinga) nauczenie sie fajnych wzroców - TU TO NIE ZACHODZI - ten projekt nie uczy za bardzo niczego. Jebutne klasy stąd do podłogi, dalekie od porządnego OOP.

edytowany 1x, ostatnio: AnyKtokolwiek 2021-08-25 22:01

AnyKtokolwiek 2021-08-25 21:58

prywatne getery o sensie stałej ...Jestem zdziwiony. Nie jest jakąś wielką winą, ale jestem zdziwony

AnyKtokolwiek 2021-08-25 21:59

metody których nazwy nie są czasownikami (tak by się zaczynało uczyć OOP), tylko "nie wiadomo czym", rzeczownikami LUB KŁAMIĄ

AnyKtokolwiek 2021-08-25 22:00

ekstrakcja strategi łatwej, średniej i trudnej jest zaprzeczeniem programowania obiektowego

Ukulelemelelele

2021-08-26 06:28

Ukulelemelelele2021-08-26 06:28

Rejestracja:prawie 5 lat
Ostatnio:ponad rok
Postów:78

@AnyKtokolwiek: OK, czyli co dokładnie poprawić (na pewno nazwy metod)? I mam jeszcze jedno pytanie, jak zrobić, żeby przycisk plusa działał (linia 25)?

Kopiuj

@Override
    public void onKeyPressed(KeyEvent key) {
        if (key.getKeyCode() == KeyEvent.VK_ENTER) {
            selectMenuOption();
        }
        if (key.getKeyCode() == KeyEvent.VK_UP || key.getKeyCode() == KeyEvent.VK_W) {
            currentChoiceMenu--;
            if (currentChoiceMenu == -1) {
                currentChoiceMenu = menuOptions.length - 1;
            }
        }
        if (key.getKeyCode() == KeyEvent.VK_DOWN || key.getKeyCode() == KeyEvent.VK_S) {
            currentChoiceMenu++;
            if (currentChoiceMenu == menuOptions.length) {
                currentChoiceMenu = 0;
            }
        }
        
        if (key.getKeyCode() == KeyEvent.VK_LEFT|| key.getKeyCode() == KeyEvent.VK_MINUS) {
            difficultyPercent--;
            if (difficultyPercent <= MIN_PERCENT) {
                difficultyPercent = GUI_MIN_PERCENT;
            }
        }
        if (key.getKeyCode() == KeyEvent.VK_RIGHT || key.getKeyCode() == KeyEvent.VK_PLUS) {
            difficultyPercent++;
            if (difficultyPercent == MAX_PERCENT) {
                difficultyPercent = GUI_MAX_PERCENT;
            }
        }
    }

RequiredNickname 2021-08-26 07:07

Primo poczytaj co to jest OOP ale takie prawdziwe OOP, potem weź na tapetę aplikację pokroju jakiejś todo listy z restowym api, pewnie na bazie spring boota bo najszybciej zamiast pisać kod który jest drabinką ifów z wykorzystaniem technologii (awt) które spotkasz jedynie w legacy. Generalnie + za chęci nauki ale mocno skorygowałbym kierunek tej nauki (to powinni Ci zapewnić właśnie na bootcampie).

AnyKtokolwiek

2021-08-26 08:34

AnyKtokolwiek2021-08-26 08:34

Rejestracja:prawie 7 lat
Ostatnio:około miesiąc
Postów:3561

@Ukulelemelelele:

Nazwy mogą być problemem samoistnym, ale częściej wskazują na problem koncepcyjny.
Pokrętny projekt podziału na metody właśnie z tym się łączy: trudno dać dobrą nazwę.
I na odwrót: jak projekt jest jasny i klarowny, w szczególności metoda robi jedną i wyrazistą rzecz, nazwa pojawia się naturalnie.

Strategia: twoja strategia gry by z chęcią była zaimplementowana ... strasznie trudno zgadnąć ... wzorcem strategia.
https://www.google.com/search?client=firefox-b-d&q=wzorzec+strategia

@RequiredNickname
Wybaczył bym przestarzałą technologię w projekcie edukacyjnym, bo jest przestarzała (choć moje serduszko by było mile ujęte Swingiem zamiast AWT) - gdyby delikwent oprócz tego fajnie to projektował w OOP. Dobrze projektować da się w każdym języku, nawet w C ;)
Więc @Ukulelemelelele nie przepisuj tego na inną technologię, ale zadbaj o dobre OOP.

edytowany 1x, ostatnio: AnyKtokolwiek 2021-08-26 08:37

AnyKtokolwiek 2021-08-26 08:35

@Ukulelemelelele: na pewno to można leczyć przez większą ilość mniejszych klarownych klas: konfiguracja, schemat interfejs + klasy do strategii itd

AnyKtokolwiek 2021-08-26 08:41

Mniej pól (niezbędne minimum, oprócz tego po fajnym podziale na klasy niektóre pola właśnie tam się znajdą) - metody jak WłaśnieJakaśKlasa newPaddles() podstawiające pod odpowiedni rodzaj zmiennej, lokalnej lub pola.

AnyKtokolwiek 2021-08-26 08:41

Daj dane właścicieli bootcampu, wyślę im fakturę.

Liczba odpowiedzi na stronę

Zarejestruj się i dołącz do największej społeczności programistów w Polsce.

Otrzymaj wsparcie, dziel się wiedzą i rozwijaj swoje umiejętności z najlepszymi.

Utwórz konto

Gra Ping Pong i problem z NullPointerException...

Ukulelemelelele

99xmarcin

Ukulelemelelele

szatkus

Ukulelemelelele

AnyKtokolwiek

Ukulelemelelele

AnyKtokolwiek

Programista Systemów Automatyki - PCS7

React Frontend Developer

PHP + Codeigniter 4 programista, aplikacja do fakturowania

DevOps Engineer - migracja serwerów (Kubernetes,Docker,RoR)

Praca dla programistów

Forum dyskusyjne

Sprawy administracyjne

O nas

Skontaktuj się z nami