Narzędzia 2D jako klasa pomocnicza (refaktoryzacja)
Zrefaktoryzują Państwo powtarzającą się logikę 2D, przenosząc ją do wielokrotnego użytku helpera. Udostępnią statyczne narzędzia do obliczania szerokości, wyrównanego wyświetlania, średnich, maksimów i transpozycji. Wykorzystają helpera w małych demonstracjach.
Narzędzia 2D jako klasa pomocnicza (refaktoryzacja) to bezpłatna lekcja Java Academy na CoddyKit. To lekcja 5 z 6. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Java Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Java Academy zawiera 6 lekcji w sumie.
Po co refaktoryzować
Po co przeprowadzać refaktoryzację do klasy pomocniczej? Aby uniknąć kopiowania i wklejania, zachować jedno źródło prawdy oraz uprościć kolejne lekcje. Należy utworzyć klasę pomocniczą GradeUtil ze statycznymi metodami obliczającymi szerokości, wyświetlającymi dane w wyrównanym układzie, obliczającymi średnie i maksima oraz wykonującymi transpozycję.
Szkielet klasy pomocniczej i wyświetlanie
Należy utworzyć statyczną klasę pomocniczą GradeUtil z metodami widths i printAligned. Następnie w main należy wywołać GradeUtil.printAligned(m), aby wyświetlić dowolną nieregularną macierz z wyrównanymi kolumnami.
public class Main {
// Static helper with reusable utilities for 2D int matrices
static class GradeUtil {
// Compute per-column widths (jagged-aware)
static int[] widths(int[][] m) {
int maxCols = 0;
for (int r = 0; r < m.length; r = r + 1) if (m[r].length > maxCols) maxCols = m[r].length;
int[] w = new int[maxCols];
for (int r = 0; r < m.length; r = r + 1) {
for (int c = 0; c < m[r].length; c = c + 1) {
int len = Integer.toString(m[r][c]).length();
if (len > w[c]) w[c] = len;
}
}
for (int c = 0; c < w.length; c = c + 1) if (w[c] < 1) w[c] = 1;
return w;
}
// Print matrix with aligned columns
static void printAligned(int[][] m) {
int[] w = widths(m);
for (int r = 0; r < m.length; r = r + 1) {
String line = "";
for (int c = 0; c < m[r].length; c = c + 1) {
String s = Integer.toString(m[r][c]);
while (s.length() < w[c]) s = " " + s;
line = line + s + (c + 1 < m[r].length ? " " : "");
}
System.out.println(line);
}
}
}
public static void main(String[] args) {
// Demo: build a small jagged matrix and print it via the helper
int[][] m = {
{1, 23, 456},
{7, 8},
{90, 12, 3, 4}
};
System.out.println("Aligned print via GradeUtil:");
GradeUtil.printAligned(m);
}
}
Pomocnicze metody średnich
Należy dodać do klasy pomocniczej metody rowAverage i colAverage, a następnie wywołać je w main. Średnie kolumn należy obliczać z uwzględnieniem długości poszczególnych wierszy, aby bezpiecznie obsługiwać tablice nieregularne.
public class Main {
static class GradeUtil {
static double rowAverage(int[][] g, int r) {
int sum = 0;
for (int c = 0; c < g[r].length; c = c + 1) sum = sum + g[r][c];
return (double) sum / g[r].length;
}
static double colAverage(int[][] g, int c) {
int sum = 0;
int count = 0;
for (int r = 0; r < g.length; r = r + 1) {
if (c < g[r].length) { sum = sum + g[r][c]; count = count + 1; }
}
return (double) sum / count;
}
}
public static void main(String[] args) {
int[][] g = {
{78, 85, 90, 88, 92},
{95, 91, 89, 93, 87},
{60, 72, 70, 68, 75},
{88, 84, 79, 85, 90}
};
// Use helper to compute row averages
for (int r = 0; r < g.length; r = r + 1) {
double avg = GradeUtil.rowAverage(g, r);
System.out.println("student " + r + " avg = " + String.format("%.2f", avg));
}
// Use helper to compute column averages
for (int c = 0; c < g[0].length; c = c + 1) {
double avg = GradeUtil.colAverage(g, c);
System.out.println("assignment " + c + " avg = " + String.format("%.2f", avg));
}
}
}
Pomocnicze metody transpozycji
Należy zaimplementować transpozycję tablic prostokątnych i nieregularnych. Wersja dla tablicy nieregularnej tworzy wiersz dla każdego indeksu kolumny i uzupełnia brakujące elementy zerem.
public class Main {
static class GradeUtil {
// Transpose rectangular matrix (R x C) -> (C x R)
static int[][] transposeRect(int[][] m) {
int rows = m.length;
int cols = m[0].length;
int[][] t = new int[cols][rows];
for (int r = 0; r < rows; r = r + 1) {
for (int c = 0; c < cols; c = c + 1) t[c][r] = m[r][c];
}
return t;
}
// Jagged-safe transpose (pads with 0)
static int[][] transposeJagged(int[][] m) {
int maxCols = 0;
for (int r = 0; r < m.length; r = r + 1) if (m[r].length > maxCols) maxCols = m[r].length;
int[][] t = new int[maxCols][];
for (int c = 0; c < maxCols; c = c + 1) {
t[c] = new int[m.length];
for (int r = 0; r < m.length; r = r + 1) t[c][r] = (c < m[r].length) ? m[r][c] : 0;
}
return t;
}
}
public static void main(String[] args) {
int[][] rect = {
{1, 2, 3},
{4, 5, 6}
};
int[][] t = GradeUtil.transposeRect(rect);
System.out.println("t[0][1] should be 2: " + t[0][1]);
int[][] jag = {
{9, 12, 7},
{5},
{8, 10}
};
int[][] tj = GradeUtil.transposeJagged(jag);
System.out.println("tj[1][0] should be 12: " + tj[1][0]);
}
}
Pomocnicza metoda maksimów kolumn
Należy udostępnić metodę colMaxima obliczającą maksimum dla każdej kolumny i bezpiecznie obsługującą nieregularne wiersze. Należy użyć flagi seen, aby uniknąć błędnych wartości minimalnych, gdy kolumna jest pusta.
public class Main {
static class GradeUtil {
// Column maxima for a jagged matrix
static int[] colMaxima(int[][] m) {
int maxCols = 0;
for (int r = 0; r < m.length; r = r + 1) if (m[r].length > maxCols) maxCols = m[r].length;
int[] max = new int[maxCols];
for (int c = 0; c < maxCols; c = c + 1) {
int best = Integer.MIN_VALUE;
boolean seen = false;
for (int r = 0; r < m.length; r = r + 1) {
if (c < m[r].length) {
if (!seen || m[r][c] > best) { best = m[r][c]; seen = true; }
}
}
max[c] = seen ? best : 0;
}
return max;
}
}
public static void main(String[] args) {
int[][] jag = {
{9, 12, 7},
{5},
{8, 10}
};
int[] cm = GradeUtil.colMaxima(jag);
System.out.print("col maxima: ");
for (int i = 0; i < cm.length; i = i + 1) System.out.print(cm[i] + (i + 1 < cm.length ? " " : ""));
System.out.println();
}
}
Wszystkie narzędzia razem
Należy połączyć narzędzia w jednej klasie pomocniczej i uruchamiać je z jednego main: wyświetlanie, średnie, transpozycję i maksima kolumn. Jest to wielokrotnego użytku zestaw narzędzi na potrzeby kolejnych lekcji.
public class Main {
static class GradeUtil {
static int[] widths(int[][] m) {
int maxCols = 0;
for (int r = 0; r < m.length; r = r + 1) if (m[r].length > maxCols) maxCols = m[r].length;
int[] w = new int[maxCols];
for (int r = 0; r < m.length; r = r + 1) {
for (int c = 0; c < m[r].length; c = c + 1) {
int len = Integer.toString(m[r][c]).length();
if (len > w[c]) w[c] = len;
}
}
for (int c = 0; c < w.length; c = c + 1) if (w[c] < 1) w[c] = 1;
return w;
}
static void printAligned(int[][] m) {
int[] w = widths(m);
for (int r = 0; r < m.length; r = r + 1) {
String line = "";
for (int c = 0; c < m[r].length; c = c + 1) {
String s = Integer.toString(m[r][c]);
while (s.length() < w[c]) s = " " + s;
line = line + s + (c + 1 < m[r].length ? " " : "");
}
System.out.println(line);
}
}
static double rowAverage(int[][] g, int r) {
int sum = 0; for (int c = 0; c < g[r].length; c = c + 1) sum = sum + g[r][c];
return (double) sum / g[r].length;
}
static double colAverage(int[][] g, int c) {
int sum = 0; int count = 0;
for (int r = 0; r < g.length; r = r + 1) { if (c < g[r].length) { sum = sum + g[r][c]; count = count + 1; } }
return (double) sum / count;
}
static int[][] transposeRect(int[][] m) {
int rows = m.length; int cols = m[0].length; int[][] t = new int[cols][rows];
for (int r = 0; r < rows; r = r + 1) for (int c = 0; c < cols; c = c + 1) t[c][r] = m[r][c];
return t;
}
static int[][] transposeJagged(int[][] m) {
int maxCols = 0; for (int r = 0; r < m.length; r = r + 1) if (m[r].length > maxCols) maxCols = m[r].length;
int[][] t = new int[maxCols][];
for (int c = 0; c < maxCols; c = c + 1) { t[c] = new int[m.length]; for (int r = 0; r < m.length; r = r + 1) t[c][r] = (c < m[r].length) ? m[r][c] : 0; }
return t;
}
static int[] colMaxima(int[][] m) {
int maxCols = 0; for (int r = 0; r < m.length; r = r + 1) if (m[r].length > maxCols) maxCols = m[r].length;
int[] max = new int[maxCols];
for (int c = 0; c < maxCols; c = c + 1) {
int best = Integer.MIN_VALUE; boolean seen = false;
for (int r = 0; r < m.length; r = r + 1) if (c < m[r].length) { if (!seen || m[r][c] > best) { best = m[r][c]; seen = true; } }
max[c] = seen ? best : 0;
}
return max;
}
}
public static void main(String[] args) {
int[][] g = {
{78, 85, 90, 88, 92},
{95, 91, 89, 93, 87},
{60, 72, 70, 68, 75},
{88, 84, 79, 85, 90}
};
System.out.println("Original gradebook:");
GradeUtil.printAligned(g);
System.out.println("Row averages:");
for (int r = 0; r < g.length; r = r + 1) System.out.println(r + ": " + String.format("%.2f", GradeUtil.rowAverage(g, r)));
System.out.println("Column averages:");
for (int c = 0; c < g[0].length; c = c + 1) System.out.println(c + ": " + String.format("%.2f", GradeUtil.colAverage(g, c)));
System.out.println("Transpose (rect):");
GradeUtil.printAligned(GradeUtil.transposeRect(g));
System.out.println("Column maxima:");
int[] cm = GradeUtil.colMaxima(g);
for (int i = 0; i < cm.length; i = i + 1) System.out.print(cm[i] + (i + 1 < cm.length ? " " : ""));
System.out.println();
}
}
Sprawdzenie wywołania statycznego
Szybkie sprawdzenie: Jak wywołać statyczną metodę pomocniczą, która wyświetla macierz?
Podsumowanie i następny krok
Podsumowanie: Przeprowadzono refaktoryzację typowych operacji na tablicach 2D do klasy pomocniczej GradeUtil i użyto jej w kilku przykładach. Dzięki temu kod pozostaje krótki, czytelny i spójny w kolejnych lekcjach.
Często zadawane pytania
Czy lekcja „Narzędzia 2D jako klasa pomocnicza (refaktoryzacja)” jest bezpłatna?
Tak — pełny tekst „Narzędzia 2D jako klasa pomocnicza (refaktoryzacja)” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Java Academy, przejdź na CoddyKit PRO. Kurs Java Academy zawiera 6 lekcji w sumie.
Co nauczysz się w „Narzędzia 2D jako klasa pomocnicza (refaktoryzacja)”?
Zrefaktoryzują Państwo powtarzającą się logikę 2D, przenosząc ją do wielokrotnego użytku helpera. Udostępnią statyczne narzędzia do obliczania szerokości, wyrównanego wyświetlania, średnich, maksimów… Ćwiczysz Java Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.
Czy potrzebuję doświadczenia, aby zacząć Java Academy?
Nie wymagamy żadnego doświadczenia. Java Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 5 z 6.
Ile czasu zajmuje lekcja „Narzędzia 2D jako klasa pomocnicza (refaktoryzacja)”?
Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.
Czy mogę pisać i uruchamiać kod w tej lekcji Java Academy?
Tak. Każda lekcja Java Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.
Wszystkie lekcje w tym kursie
- Podstawy tablic 2D i zagnieżdżona iteracja
- Tablice postrzępione i formatowanie tabel
- Maksima wierszy i kolumn, transpozycja i formatowanie
- Projekt 2D: dziennik ocen
- Narzędzia 2D jako klasa pomocnicza (refaktoryzacja)
- Czyszczenie i walidacja danych 2D