Помогите понять в чём разница (Перевод из 8 системы исчисления в 10 и наоборот)

В первую очередь надо обосновывать что простой, что понятный код на примере. Вы будто пытаетесь написать, что вы понимаете, но на деле вы ничего не написали по существу.

1) 3 раза запустил - ничего не изменилось. Ответ как был, так и остался верным. Оно и так всё работало верно. 2) Я не могу понять почему в решении джава раш совсем по-другому. Кажется они усложняют решение. Зачем нам эта проверка

if (octalNumber <= 0)

и зачем

while (octalNumber != 0)

когда можно использовать просто условие >0 и else return 0; 3) Про имена переменных подумаю. Но пишу их 1 буквой, чтобы ускорить процесс написания. И уменьшить длину кода, т.е. я переменной присваиваю наше длинное выражение, и чтобы каждый раз не писать это длинное выражение, я подставляю переменную. Код визуально сразу меньше, и, кажется, лучше читаем. Если ошибаюсь, напишите ваш пример для понимания. И, да, лучше статические переменные использовать внутри метода - это исправил, спасибо; так же это позволило уменьшить количество переменных в 2 раза.

Нет, разница между статическими и локальными переменными принципиальная. Ты запускаешь свой код, раз за разом выполняя метод main. При каждом старте программы у тебя заново запускается джава-машина, и всё выполняется с самого начала, Я же тебе говорю, что если несколько вызвать именно один из твоих методов toDecimal() / toOctal(), то начиная со второго запуска результаты "поедут". Сейчас я тебе продемонстрирую, но вообще можешь взять за правило использовать статические переменные только в тех случаях, когда можешь логически обосновать, зачем они нужны именно статические, а не просто "потому что почему бы и нет". Итак, смотри. Методы - штука многоразовая, и они должны каждый раз выполнять ожидаемую работу, независимо от того, сколько раз и какой именно метод их вызовет. Добавим несколько различных вызовов метода toDecimal в метод main:

public static void main(String[] args) {
	System.out.println(toDecimal(10)); // 8
	System.out.println(toDecimal(12)); // 10
	System.out.println(toDecimal(20)); // 16
}

Такой вызов должен вывести три разных результата, а твой код выводит три восьмёрки. Что касается проверок, которые выполняются в начале метода, то я с тобой не соглашусь. Вообще стоит начать с того, что разница в подходах не критичная и не в этом причина того, что твой код не засчитывается, но разница всё же есть. Как ещё одно неписанное правило можно запомнить, что чем меньше отступов требует твой код, тем легче он читается, понимается и проверяется, и тем менее сложная логика в твоём методе. По сути разница в том, в каком порядке использовать if и else. В своём коде ты мог вообще не использовать слово else, и его поведение не изменилось бы: если условие if выполнилось, то тело ифа обязательно закончится командой return, поэтому весь код после ифа будет выполнен только в том случае, если иф не сработал. Продолжение мысли будет ниже.

Итак, мы можем убрать слово else, потому что тело ифа завершается выходом из метода `return w`:

if (octalNumber > 0 ) {
	u = octalNumber / (int) (Math.pow(10, j));
	for (; u > 0; j++) {
		w = w + (u % 10) * (int) (Math.pow(8, j));
		u /= 10;
	}
	return w;
}
// слово else не нужно, потому что тело if заканчивается командой return:
return 0;

Но при этом у нас весь логический код заключён в условный блок if. Если мы инвертируем условие на противоположное, то мы можем поменять местами логику ветвления:

if (octalNumber <= 0) return 0;

u = octalNumber / (int) (Math.pow(10, j));
for (; u > 0; j++) {
	w = w + (u % 10) * (int) (Math.pow(8, j));
	u /= 10;
}
return w;

Всё то же самое, просто поменяли местами "позитивный" и "негативный" варианты. Но при этом это позволило нам избавиться от лишнего отступа. Тем самым, мы в самом начале проверили, что значение аргумента удовлетворяет условию, и дальше об этом можем не заботиться. Обрати внимание, что это никак не повлияло на количество переменных. Это один из принципов чистого кода - Guard Clause (условие-защитник)

Что касается твоего вопроса про while (octalNumber != 0), то у тебя есть точно такое же условие, только в цикле for: `for (; u > 0; j++)`. Только использование for у тебя не каноничное. Вообще цикл for и цикл while - это один и тот же цикл. Перед запуском программы компилятор преобразует любой цикл for в while. Вместо "стандартного" `for (int i = 0; i < 10; i++)` в байт-коде будет записан аналог цикла while:

{
	int i = 0;
	while (i < 10) {
		...
		i++;
	}
}

Поэтому с точки зрения оптимальности выполнения здесь разницы нет. Цикл фор добавили в язык скорее для упрощения и потому что он существовал в более старых языках программирования. Но его принято использовать именно при перечислениях значений от x до y с некоторым шагом. В остальных случаях принято использовать именно цикл while, чтобы просто не путаться. Но по большому счёт нет разницы между тем, чтобы записано for (; x > 0;) и while (x > 0). И наконец, даже если бы количество переменных было действительно разным, это не значит, что это было бы лучше. Одной из главных ценностей хорошего кода - лёгкость его восприятия другим программистом. Это стоит ставить во главу угла, не гонясь за сокращением количества строк или объявленных переменных. PS. Я не говорю, что твой код плохой или неправильный, я так не считаю. Это просто несколько советов по оформлению кода, которые действительно приняты в индустрии и которые тебе могут помочь добиться большего и стать более ценным специалистом в будущем. Удачи!

Всё очень полезно и по делу. Спасибо тебе добрый человек.