Understanding Exercise Book use Java head

return 1; //Sempre retornará 1, aqui entendi

Will not always return only if index is less than 7.

return 0; //Não achei o porque do return 0 neste ponto

It will execute whenever index is not less than 7. The function needs to have a return in any circumstances, it cannot return something only in some cases and in another it cannot.

Does this same maybeNew(x) somehow affect the assignment of the count variable itself from the beginning of the line?

It itself does not, but the whole line is affecting count, after all this line it is saying to save in count, and this by itself already affects something, a value that in the case is itself count Added from an expression

System.out.println(count + " " + m4a[1].counter); //Porque m4a[1]?

We have no way of knowing what is in the question, but for some reason it needs to take the second element of this array.

The output of this exercise would be 14 1, but I was lost and I can not see how it came to 14, the 1 itself return indicates the value.

He was following the algorithm. I could explain line by line, but the best is to do the table test yourself and identify. However, in a confusing code so it is best not to try. Learn from something more meaningful. Understanding this will be detrimental to your learning.

Rarely should main() be next to a class that needs to be instantiated. This confuses everything. There is no reason for every part of this class to exist and if you start working with meaningless things you will get used to it. Note that in each step there is the accumulation of 2. The first accumulation is quite explicit and then the other happens because maybeNew() always returns 1, this could have been written in one line.

It is not your fault to have difficulty understanding, it is the fault of the code.

The code is poorly written and poorly didactic. It teaches doing weird, confusing, and probably wrong things, so I would question the book. This book series was well regarded, so I don't know if it got worse over time or this one specifically was misspelled.

This is quite confusing code and as @Maneiro said it is questionable as code to be in a book, but I will try to explain what is happening on the basis that this is the only code of the project.

It all starts in your main, where the class attributes are named and instantiated:

int count = 0;
Mix4[] m4a = new Mix4[20];
int x = 0;

Then makes a loop that will iterate 7 times increasing the value of x with each iteration

while (x < 7 ) // itera 7 vezes de x=0 até x=6

x +=1; //aumenta o valor de x a cada iteração

Well let's go the four lines of code inside the loop ( analyze what the code is doing=))

    m4a[x] = new Mix4();                   //linha 1
    m4a[x].counter = m4a[x].counter + 1;   //linha 2
    count += 1;                            //linha 3
    count = count + m4a[x].maybeNew(x);    //linha 4

On Line 1 main creates an instance of Mix4 and places it in the list m4a

In Line 2 the code is taking this instance that is now in the list and adding the value 1 to the attribute of that object, in the case of counter, which was 0 and is now 1

In Line 3 the code adds the value 1 to the variable count, since this code is executed 7 times we can say that this line is responsible for adding the value 7 to the variable count

In Line 4 the code is taking the value of count by adding a value to it * and saving that sum to the variable itself count, we can say that it is adding a value to the value it already had before.

Let's analyze this added value:

The code is calling the maybeNew method of the object that was just saved in the list, what we know his?

- > we know that the value of its attribute counter is equal to 1, and that the passed parameter (x) is always less than 7

Parsing method maybeNew:

The method has as its first line a if which checks if the passed parameter is less than 7 ( which we know it always is) and does a series of things if this condition is true.

 Mix4 m4 = new Mix4();
 m4.counter = m4.counter + 1;
 return 1;

First creates a new instance and assigns it to an object named m4, then modifies the value of the attribute m4 and finally returns the value 1

So we know that it will always return 1 and we now know how much is added to count in Line 4

Knowing that in Line 4 is always added 1 we have that at the end of the 7 iteration will be added the value 7.

System.out.println(count + " " + m4a[1].counter); 

We reached the result of 14

The value 1 of m4a[1].counter is the one that the code had added in Line 2

Hope I helped, any doubts leave a comment