3.3. Manter a coesão resulta em muitas classes pequenas

 

Listing 10-5

PrintPrimes.j ava

 

   package literatePrimes;
   public class PrintPrimes {
     public static void main (String [] args) {
     final int M = 1000;
     final int RR = 50;
     final int CC = 4;
     final int WW = 10;
     final int ORDMAX =30;
     int P[] = new int [M + 1];
     int PAGENÜMBER;
     int PAGEOFFSET;
     int ROWOFFSET;
     int C;
     int J;
     int K;
     boolean JPRIME;
     int ORD;
     int SQUARE;
     int N;
     int MULT[] = new int[ORDMAX + 1];
     J = 1;
     K = 1;
     P[l] = 2;
     ORD = 2;
     SQUARE = 9;
     while (K < M) {
     do (
       J = J + 2;
       if (J == SQUARE) {
         ORD = ORD + 1;
         SQUARE = P[ORD] * P[ORD];
         MULT[ORD - 1] = J;
       N = 2;
       JPRIME = true;
       while (N < ORD && JPRIME) {
         while (MULT[N] < J)
           MULT [N] = MULT [N] + P [N] + P [N] ;
         if [MULT[N] == J) 
           JPRIME = false;
         N = N + 1;
} while (!JPRIME);
K = K + 1;
P[K] = J;
PAGENUMBER = 1;
PAGEOFFSET = 1;
while (PAGEOFFSET <= M) {
System.out.printlnf"The First " + M +
11 Prime Numbers — Page 11 + PAGENUMBER) ;
System.out.printlnf") ;
for (ROWOFFSET = PAGEOFFSET; ROWOFFSET < PAGEOFFSET + RR; ROWOFFSET++){ for (0=0; C < CC;C++)
if (ROWOFFSET + C * RR <= M)
System.out.format("%10d", P[ROWOFFSET t C * RR]);
System.out.printlnf") ;
System.out.println("\f");
PAGENUMBER = PAGENUMBER + 1;
PAGEOFFSET = PAGEOFFSET + RR * CO;

 

 

Listing 10-6

PrimePrinter.java (refactored)

package literatePrimes;
public class PrimePrinter {
public static void main (String [] args) {
final int NUMBER_OF_PRIMES = 1000;
int[] primes = PrimeGenerator.generate(NUMBER_OF_PRIMES);
final int ROWS_PER_PAGE = 50;
final int COLÜMNS_PER_PAGE = 4;
RowColumnPagePrinter tablePrinter =
new RowColumnPagePrinter(ROWS_PER_PAGE,
COLÜMNS_PER_PAGE,
"The First " + NÜMBER_OF_PRIMES + " Prime Numbers");
tablePrinter.print(primes);

 

 

 

 

Listing 10-7

RowColumnPagePrinter.j ava

 

 

package literatePrimes;
import java.io.PrintStream;
public class RowColumnPagePrinter {
private int rowsPerPage;
private int columnsPerPage;
private int numbersPerPage;
private String PageReader;
private PrintStream printStream;
public RowColumnPagePrinter(int rowsPerPage,
int columnsPerPage,
String PageReader) {
this.rowsPerPage = rowsPerPage;
this.columnsPerPage = columnsPerPage;
this.PageReader = PageReader;
numbersPerPage = rowsPerPage * columnsPerPage;
printStream = System.out;
public void printfint data[]) {
int pageNumber = 1;
for (int firstlndexOnPage = 0;
firstlndexOnPage < data.length;
firstlndexOnPage += numbersPerPage) {
int lastlndexOnPage =
Math.minffirstlndexOnPage + numbersPerPage - 1, data.length - 1);
printPageHeader(pageHeader, pageNumber);
printPage(firstlndexOnPage, lastlndexOnPage, data);
printStream.println("\f");
pageNumber++;
private void printPage(int firstlndexOnPage,
int lastlndexOnPage,
int [] data) {
int firstlndexOfLastRowOnPage =
firstlndexOnPage + rowsPerPage - 1;
for (int firstlndexInRow = firstlndexOnPage;
firstlndexInRow <= firstlndexOfLastRowOnPage;
firstIndexInRow++) {
printRow(first!ndexInRow, lastlndexOnPage, data); printStream.printlnf") ;
} }
private void printRowfint firstlndexInRow,
int lastlndexOnPage,
int [] data) {
for (int column = 0; column < columnsPerPage; column++) {
int index = firstlndexInRow + column * rowsPerPage;
if (index <= lastlndexOnPage) printStream.format("%10d", data[index]);
private void printPageHeader(String pageHeader, int pageNumber) {
printStream.println(pageHeader + " — Page " + pageNumber);
printStream.printlnf");
public void setOutput(PrintStream printStream) { this.printStream = printStream;

 

 

Listing 10-8

PrimeGenerator.j ava

import java.util.ArrayList;
public class PrimeGenerator {
private static int[] primes;
private static ArrayList<Integer> multiplesOfPrimeFactors;
protected static int[] generate(int n) { primes = new int[n];
multiplesOfPrimeFactors = new ArrayList<Integer>();
set2AsFirstPrime();
checkOddNumbersForSubsequentPrimes();
return primes;
private static void set2AsFirstPrime() {
primes [0] = 2;
multiplesOfPrimeFactors.add(2);
private static void checkOddNumbersForSubsequentPrimes() {
int primelndex = 1;
for (int candidate = 3;
primelndex < primes.length;
candidate += 2) {
if (isPrime(candidate))
primes[primelndex++] = candidate;
private static boolean isPrime(int candidate) {
if (isLeastRelevantMultipleOfNextLargerPrimeFactor(candidate)) { multiplesOfPrimeFactors.add(candidate);
return false;
return isNotMultipleOfAnyPreviousPrimeFactor(candidate);
private static boolean
isLeastRelevantMultipleOfNextLargerPrimeFactor(int candidate) {
int nextLargerPrimeFactor = primes[multiplesOfPrimeFactors.size()];
int leastRelevantMultiple = nextLargerPrimeFactor * nextLargerPrimeFactor;
return candidate == leastRelevantMultiple;
private static boolean
isNotMultipleOfAnyPreviousPrimeFactor(int candidate) {
for (int n = 1; n < multiplesOfPrimeFactors.sizeO ; n++) {
if (isMultipleOfNthPrimeFactor(candidate, n)) return false;
return true;
private static boolean
isMultipleOfNthPrimeFactor(int candidate, int n) {
return
candidate == smallestOddNthMultipleNotLessThanCandidate(candidate, n);
private static int
smallestOddNthMultipleNotLessThanCandidate(int candidate, int n) {
int multiple = multiplesOfPrimeFactors.get(n);
while (multiple < candidate)
multiple += 2 * primes[n];
multiplesOfPrimeFactors.set(n, multiple);
return multiple;