Помогите понять принцип работы программы.

public class Main {
 public static void main(String[] args) { 
 for (byte i = 0; i != -1; i++) { 
 String binary = Integer.toBinaryString(i);
 if (binary.length()>8) binary=binary.substring(binary.length()-8); 
 binary = String.format("%8s", binary).replace(" ", "0"); 
 System.out.printf("%8s %4d %n",binary, i); 
} 
} 
}

public class Task001 {
 
    public static void main(String[] args) {
        //вариант 1
        //используем константы из класса оболочки byte (есть и для других примитоивов)
        byte min = Byte.MIN_VALUE;
        byte max = Byte.MAX_VALUE;
        System.out.println("min: " + min + "; max: " + max + ";");
 
        //вариант 2
        //мы знаем, что byte = 1 byte или 8 бит
        //следовательно максимальный порог - это 01111111 (8 цифр), а минимальный 10000000
        //вот и переводим двоичный вариант в число
        min = (byte) Integer.parseInt("10000000", 2);
        max = (byte) Integer.parseInt("01111111", 2);
        System.out.println("min: " + min + "; max: " + max + ";");
 
        //вариант 3
        //через степень 2^(биты - 1)
        min = (byte) Math.pow(2, 7);
        max = (byte) (Math.pow(2, 7) - 1);
        System.out.println("min: " + min + "; max: " + max + ";");
 
        //вариант 4
        //тут мы выводим просто все числа, возможные в типе и выводим его двоичный код
        String binary = "";
        for (byte i = 0; i != -1; i++) {
            binary = Integer.toBinaryString(i);
            if (binary.length() > 8) {
                binary = binary.substring(binary.length() - 8);
            }
            System.out.println("digit: " + i + "; binary: " + binary + ";");
        }
    }
 
}

        //вариант 5
        //сдвигами (тоже самое, что и степень)
        min = (byte) ( 1 << 7);
        max = (byte) (( 1 << 7) - 1);
        System.out.println("min: " + min + "; max: " + max + ";");

public static void main(String[] args) {
        //для char немного по другому, т.к. он хранит лишь положительные числа
 
        //вариант 1
        //используем константы из класса оболочки Character (есть и для других примитоивов)
        int min = Character.MIN_VALUE;
        int max = Character.MAX_VALUE;
        System.out.println("min: " + min + "; max: " + max + ";");
 
        //вариант 2
        //мы знаем, что char = 2 byte или 16 бит
        //следовательно максимальный порог - это 1111111111111111 (16 цифр), а минимальный 0
        //вот и переводим двоичный вариант в число
        min = 0;
        max = Integer.parseInt("1111111111111111", 2);
        System.out.println("min: " + min + "; max: " + max + ";");
 
        //вариант 3
        //через степень 2^биты
        min = 0;
        max = (int) Math.pow(2, 16) - 1;
        System.out.println("min: " + min + "; max: " + max + ";");
 
        //вариант 4
        //сдвигами (тоже самое, что и степень)
        min = 0;
        max = (1 << 16) - 1;
        System.out.println("min: " + min + "; max: " + max + ";");
    }

/**
 * Created by Mihail on 21.02.2019.
 */
public class Task001 {
 
    public static void main(String[] args) {
        /*
        Итак, у нас имеются 8 примитивных типов.
        byte = 1 байт (8 бит)
        short = 2 байта (16 бит)
        int = 4 байта (32 бита)
        long = 8 байт (64 бита)
        char = 2 байта (16 бит) - целочисленный
 
        есть ещё для вещественных чисел float - 4 bytes и double - 8 bytes
        и boolean, но их рассматривать не буду
         */
 
        //вариант 1
        //используем константы из классов оболочек
        long byteMin = Byte.MIN_VALUE;
        long byteMax = Byte.MAX_VALUE;
        long shortMin = Short.MIN_VALUE;
        long shortMax = Short.MAX_VALUE;
        long charMin = Character.MIN_VALUE;
        long charMax = Character.MAX_VALUE;
        long intMin = Integer.MIN_VALUE;
        long intMax = Integer.MAX_VALUE;
 
        System.out.println("<byte> min: " + byteMin + "; max: " + byteMax + ";");
        System.out.println("<short> min: " + shortMin + "; max: " + shortMax + ";");
        System.out.println("<char> min: " + charMin + "; max: " + charMax + ";");
        System.out.println("<int> min: " + intMin + "; max: " + intMax + ";");
        System.out.println();
 
        //вариант 2
        //переводим двоичный код в 10-чную систему
        //стоит учесть, что в типах, которые хранят и оложительные и отрицательные числа
        //верхний бит используется для хранения отрицательного числа
        //поэтому отрицательное максимальное число записывается: верхний бит 1, остальное всё 0
        //а положительное максимальное: верхний бит 0, а остальное 1
        //в целочисленных типах все биты равны 1
        byteMin = Long.parseLong("10000000", 2);
        byteMax = Long.parseLong("01111111", 2);
        shortMin = Long.parseLong("1000000000000000", 2);
        shortMax = Long.parseLong("0111111111111111", 2);
        charMin = 0;
        charMax = Long.parseLong("1111111111111111", 2);
        intMin = Long.parseLong("10000000000000000000000000000000", 2);
        intMax = Long.parseLong("01111111111111111111111111111111", 2);
 
        System.out.println("<byte> min: " + byteMin + "; max: " + byteMax + ";");
        System.out.println("<short> min: " + shortMin + "; max: " + shortMax + ";");
        System.out.println("<char> min: " + charMin + "; max: " + charMax + ";");
        System.out.println("<int> min: " + intMin + "; max: " + intMax + ";");
        System.out.println();
 
        //вариант 3
        //в типах, которые имеют диапазон от - до +
        //высчитать диапазон можно по формуле 2^(n-1) - минимальное число и 2^((n-1) - 1) для положительного
        //в целочисленном типе высчитывается по формуле (2^n)-1
        byteMin = (byte) Math.pow(2, 7);
        byteMax = (byte) (Math.pow(2, 7) - 1);
        shortMin = (short) Math.pow(2, 15);
        shortMax = (short) (Math.pow(2, 15) - 1);
        charMin = 0;
        charMax = (int) (Math.pow(2, 16) - 1);
        intMin = (int) Math.pow(2, 31);
        intMax = (int) (Math.pow(2, 31) - 1);
 
        System.out.println("<byte> min: " + byteMin + "; max: " + byteMax + ";");
        System.out.println("<short> min: " + shortMin + "; max: " + shortMax + ";");
        System.out.println("<char> min: " + charMin + "; max: " + charMax + ";");
        System.out.println("<int> min: " + intMin + "; max: " + intMax + ";");
        System.out.println();
 
        //вариант 4
        //сдвигами (тоже самое, что и степень)
        byteMin = 1 << 7;
        byteMax = (1 << 7) - 1;
        shortMin = 1 << 15;
        shortMax = (1 << 15) - 1;
        charMin = 0;
        charMax = (1 << 16) - 1;
        intMin = 1 << 31;
        intMax = (1 << 31) - 1;
        System.out.println("<byte> min: " + byteMin + "; max: " + byteMax + ";");
        System.out.println("<short> min: " + shortMin + "; max: " + shortMax + ";");
        System.out.println("<char> min: " + charMin + "; max: " + charMax + ";");
        System.out.println("<int> min: " + intMin + "; max: " + intMax + ";");
        System.out.println();
    }
 
}