Ez a kód mennyire "bonyolult"?
Gyakoroltam az internetről JAVA -t, de eljutottam egy olyan pontra, ahol már azt mondom, hogy elég komplikált és kezdem elveszíteni a fonalat, hogy mi micsoda. Az alapok megtanulása után elkezdtem alkalmazni a tanultakat. Egy szoftverfejlesztői képzésre ha jelentkezem, akkor az alapok megtanulása után általában egyből ilyen komplex programokban szokás alkalmazni a tanultakat? Pl. ha kifizetem a több millió forintot egy képzésre akkor félek attól, hogy ott sem fogom érteni.. de feltételezem az sokkal jobb mint az internetről tanulni. Aki a nulláról kezdte, annak milyen volt a tanuló és befogadóképessége? Milyen nehézségekkel kellett szembesülnie? A kódot teljesen 0 szintről kezdtem el megtanulni és alkalmazni, ez 2db gép által irányított karaktert hoz létre konzolos felületen. Az ellenség próbálja elkapni a játékost. Íme a kódom:
import java.util.Random;
public class BasicGame {
static final int GAMELOOPNUMBER = 100;
static final int HEIGHT = 15;
static final int WIDTH = 15;
static final Random RANDOM = new Random();
public static void main(String[] args) throws InterruptedException {
String[][] level = new String[HEIGHT][WIDTH];
initLevel(level);
addRandomWalls(level);
String playerMark = "O";
int[] playerStartingCoordinates = getRandomStartingCoordinatesForPlayer(level);
int playerRow = playerStartingCoordinates[0];
int playerColumn = playerStartingCoordinates[1];
Direction playerDirection = Direction.RIGHT;
String enemyMark = "-";
int[] enemyStartingCoordinates = getRandomStartingCoordinatesForEnemy(level, playerStartingCoordinates);
int enemyRow = enemyStartingCoordinates[0];
int enemyColumn = enemyStartingCoordinates[1];
Direction enemyDirection = Direction.LEFT;
for (int iterationNumber = 1; iterationNumber <= GAMELOOPNUMBER; iterationNumber++) {
if (iterationNumber % 10 == 0) {
playerDirection = changeDirection(playerDirection);
}
int[] playerCoordinates = makeMove(playerDirection, level, playerRow, playerColumn);
playerRow = playerCoordinates[0];
playerColumn = playerCoordinates[1];
if (iterationNumber % 2 == 0) {
enemyDirection = changeEnemyDirection(level, enemyDirection, playerRow, playerColumn, enemyRow,
enemyColumn); // changeEnemyDirection
int[] enemyCoordinates = makeMove(enemyDirection, level, enemyRow, enemyColumn);
enemyRow = enemyCoordinates[0];
enemyColumn = enemyCoordinates[1];
}
draw(level, playerMark, playerRow, playerColumn, enemyMark, enemyRow, enemyColumn);
addSomeDelay(200L, iterationNumber);
if (playerRow == enemyRow && playerColumn == enemyColumn) {
break;
}
}
System.out.println("Játék vége.");
}
static int[] getRandomStartingCoordinatesForEnemy(String[][] level, int[] playerStartingCoordinates) {
int playerStartingRow = playerStartingCoordinates[0];
int playerStartingColumn = playerStartingCoordinates[1];
int randomRow;
int randomColumn;
do {
randomRow = RANDOM.nextInt(HEIGHT);
randomColumn = RANDOM.nextInt(WIDTH);
} while (!level[randomRow][randomColumn].equals(" ")
|| calculateDistance(randomRow, randomColumn, playerStartingRow, playerStartingColumn) < 10); //calculateDistance metódusban kiszámolom, hogy mekkora a távolság az ellenség és player távolsága között
return new int[] { randomRow, randomColumn };
}
static int calculateDistance(int row1, int column1, int row2, int column2) {
int rowDifference = Math.abs(row1 - row2);
int columnDifference = Math.abs(column1 - column2);
return rowDifference + columnDifference;
}
static int[] getRandomStartingCoordinatesForPlayer(String[][] level) {
int randomRow;
int randomColumn;
do {
randomRow = RANDOM.nextInt(HEIGHT);
randomColumn = RANDOM.nextInt(WIDTH);
} while (!level[randomRow][randomColumn].equals(" "));
return new int[] { randomRow, randomColumn };
}
static Direction changeEnemyDirection(String[][] level, Direction originalEnemyDirection, int playerRow, // Külön
int playerColumn, int enemyRow, int enemyColumn) {
if (playerRow < enemyRow && level[enemyRow - 1][enemyColumn].equals(" ")) {
return Direction.UP;
}
if (playerRow > enemyRow && level[enemyRow + 1][enemyColumn].equals(" ")) {
return Direction.DOWN;
}
if (playerColumn < enemyColumn && level[enemyRow][enemyColumn - 1].equals(" ")) {
return Direction.LEFT;
}
if (playerColumn > enemyColumn && level[enemyRow][enemyColumn + 1].equals(" ")) {
return Direction.RIGHT;
}
return originalEnemyDirection;
}
static void addRandomWalls(String[][] level) {
addRandomWalls(level, 2, 3);
}
static void addRandomWalls(String[][] level, int numberOfHorizontalWalls, int numberOfVerticalWalls) {
for (int i = 0; i < numberOfHorizontalWalls; i++) {
addHorizontalWall(level);
}
for (int i = 0; i < numberOfVerticalWalls; i++) {
addVerticalWall(level);
}
}
static void addHorizontalWall(String[][] level) {
int wallWidth = RANDOM.nextInt(WIDTH - 3);
int wallRow = RANDOM.nextInt(HEIGHT - 2) + 1;
int wallColumn = RANDOM.nextInt(WIDTH - 2 - wallWidth); // meghatározzuk melyik OSZLOPBA kezdődjön a fal
for (int i = 0; i < wallWidth; i++) { // ebbe a ciklusba végigmegyünk a véletlenszerű falhosszúság számán, és
level[wallRow][wallColumn + i] = "X";
}
}
static void addVerticalWall(String[][] level) {
int wallHeight = RANDOM.nextInt(HEIGHT - 3);
int wallRow = RANDOM.nextInt(HEIGHT - 2 - wallHeight);
int wallColumn = RANDOM.nextInt(WIDTH - 2) + 1;
for (int i = 0; i < wallHeight; i++) {
level[wallRow + i][wallColumn] = "X";
}
}
private static void addSomeDelay(long timeout, int iterationNumber) throws InterruptedException {
System.out.println("-------" + iterationNumber + "-------");
Thread.sleep(timeout);
}
static void initLevel(String[][] level) {
for (int row = 0; row < level.length; row++) { // az összes i -t átneveztem row -ra
for (int column = 0; column < level[row].length; column++) { // az összes j -t átneveztem column -re
if (row == 0 || row == HEIGHT - 1 || column == 0 || column == WIDTH - 1) { // innentől rakom be a falat
level[row][column] = "X";
} else {
level[row][column] = " ";
}
}
}
}
static int[] makeMove(Direction direction, String[][] level, int row, int column) {
switch (direction) {
case UP:
if (level[row - 1][column].equals(" ")) {
row--;
}
break;
case DOWN:
if (level[row + 1][column].equals(" ")) {
row++;
}
break;
case LEFT:
if (level[row][column - 1].equals(" ")) {
column--;
}
break;
case RIGHT:
if (level[row][column + 1].equals(" ")) {
column++;
}
break;
}
return new int[] { row, column };
}
static Direction changeDirection(Direction direction) {
switch (direction) {
case RIGHT:
return Direction.DOWN;
case DOWN:
return Direction.LEFT;
case LEFT:
return Direction.UP;
case UP:
return Direction.RIGHT;
}
return direction;
}
static void draw(String[][] board, String playerMark, int playerRow, int playerColumn, String enemyMark,
int enemyRow, int enemyColumn) {
for (int row = 0; row < HEIGHT; row++) {
for (int column = 0; column < WIDTH; column++) {
if (row == playerRow && column == playerColumn) {
System.out.print(playerMark);
} else if (row == enemyRow && column == enemyColumn) {
System.out.print(enemyMark);
} else {
System.out.print(board[row][column]);
}
}
System.out.println();
}
}
}
válasza:Ez a kód magam elég ronda és biztos nem menne át egy ilyen megvalósítás egy normális cégben kód reviewn, de ennek is meg van a helye az oktatásban.
Előttem már írták, de feltételezem ezt egy oktató videóból másoltad.
Én vállalati szoftvereken dolgozom Java fejlesztőként és szinte soha sem kell egymásba ágyazott foor lookokat írnunk, meg 2 dimenziós tömböket használni. Főleg nem random cellákba pakolni dolgokat különféle szabályok szerint. Ez tipikus oktató feladatnak tűnik vagy egy kezdő otthoni szórakozásának.
Ha ezt érted, akkor az már jó haladás.
Munkakörnyezetben a komplexitást inkább az adja, hogy adnak egy microservice-t, amivel soha sem találkoztál, de kell rajta egy új funkciót csinálni vagy valamit helyre rakni és úgy hogy valószínűleg nem is érted mit csinál a program kb 15 java fájlom keresztül követnek kell a működését a programank és valamilyen módon rájönni, hogy mi is az amit csinál és neked mit hogyan és hova kéne megalkotni.
Majd miután létrehoztad a remélhetőleg helyes megoldást, akkor meg a valószínűleg kb 3-4 db fejenként 3.000 soros unit és integrációs teszteket tartalmazó osztályokban kb 10 tesztet meg kell javítanod, mert a fejlesztésed miatt elbuknak és meg is kell annyira értened a működést, hogy saját tesztet írj.
Ezen felül gondolnod kel az adatok integritására, így ha adatbázisban valamit változtattál, akkor egy jó migrációs scriptet megírni. Utána persze ezt teszteni valami test adatbázisan.
Stb...
Inkább ez adja a nehézséget Java fejlesztőként, de szerintem kb mindenhol máshol is. Nem az, hogy egy nested for loopot kell megérteni, hogy mit csinál. Azt ha most nem is érted, ha eleget látsz, akkor majd érteni fogod.
Viszont erősen óvaintelélek a bootcampektől.
válasza:Én inkább ajánlanék egy jóra értékelt udemy kurzust, ahol ráadásul 30 napos refund van, szóval ha nagyon nincs pénzed akkor az a 10-20 ezer forintod se veszik el és tanultál rengeteget.
Amúgy nem hülyeségek ezek a képzések (de az tény, hogy a papír nem sokakat érdekel és mindent amit tanítanak elérsz neten), de ennyire az elején szerintem ne gondolkozz rajta még, mert lehet nem is fog érdekelni ez a terület.
Most következő lépésnek barátkozz még az alapokkal és ha már a fentebb írt kódot is könnyen megérted, akkor azonnal térj rá az OOP-re és kezdj el azzal projecteket csinálni. Ha ezek után is tetszik ez az egész, akkor nézz utána, hogy milyen java munkák vannak és olvasgass arról, hogy milyen egy nagy multinál dolgozni (mert java-s munkát ott fogsz találni). Ha még mindig érdekel ez az egész, csak akkor gondolkozz kurzusokon, mert csak így lesz valamilyen képed erről a szakmáról.
Kurzust amúgy csak úgy ajánlok, ha a teljes ideje alatt nem kell dolgoznod ÉS van lehetőség arra, hogy keresnek neked munkát. Mivel ha nem ajánlanak munkát, akkor semmivel nem vagy előrébb a papírral amit kapsz. Másik eset, hogy van lehetőség állásra, de nincs elég időd rá, ekkor biztosan nem fogsz állashoz jutni, ha csak nem vagy nagyon durván kiemelkedő tehetség.
Van még egy érv a kurzus ellen, mégpedig az, hogy az autodidakta tanulás ebben a szakmában elengedhetetlen és ha ez a képesség hiányzik vagy szimplán utálsz magad tanulni, akkor jobb ha ez az elején kiderül, mert később csak jön a kiégés vagy a fejfájás, hogy megkell tanulnod magadat tanítani. Nem véletlenül kapnak a programozók nagy fizukat, mi (és mások is) az IT-ban folyamatosan képezzük magunkat a kerrierünk elején, majd pedig lépést tartunk a változásokkal. A legtöbb ember utál tanulni, pláne ilyen gondolkozós területet ahol gyakran akadsz el és szenvedned kell, ezért is mondják, hogy a programozás kell legyen a hobbid.
Na mindegy, nagyon elkalandoztam:D a lényeg, hogy derítsd ki mennyire érdekel ez az egész téged vagy mennyire vagy képes ezt csinálni csak a pénzért, mert lehetségez ez, de nem mindenki elég szorgalmas és kitartó hozzá.
válasza:Azért a pozitívumokat is említsük meg, legalább normálisan vannak elnevezve a változók :D
Bár ha tényleg egy tutorial videóból másoltad a kódot, akkor ez sem a te érdemed, és ráadásul még nem is értem, hogy miért kell azt hazudni, hogy te írtad a nulláról.
Kapcsolódó kérdések:
Minden jog fenntartva © 2024, www.gyakorikerdesek.hu
GYIK | Szabályzat | Jogi nyilatkozat | Adatvédelem | Cookie beállítások | WebMinute Kft. | Facebook | Kapcsolat: info(kukac)gyakorikerdesek.hu
Ha kifogással szeretne élni valamely tartalommal kapcsolatban, kérjük jelezze e-mailes elérhetőségünkön!