Sumowanie podanych liczb - prosty program, a poprawność kodowania

Na wstępie podam kod progamu:

import java.util.Scanner;

public class zad1
{
    private int suma;

    public int getSuma() 
    {
        return suma;
    }

    public void setSuma(int suma) 
    {
        this.suma = suma;
    }

    public void dodawanie(int liczba)
    {
        zad1 z = new zad1();
        z.setSuma(suma+=liczba);
    }

    public static void main(String[] args) 
    {
        zad1 za = new zad1();
        Scanner wejscie = new Scanner(System.in);
        int liczba=0,zlicz=0;

        do
        {
            System.out.println("Podaj liczby, do zastopowania podaj liczbe 0: ");
            liczba = wejscie.nextInt();
            za.dodawanie(liczba);
            zlicz++;
        }
        while(liczba!=0);

        System.out.println("Suma liczb wynosi: " + za.getSuma());
        System.out.println("Podałeś "+ (zlicz-1) + " liczb");
    }
}

Program ma za zadanie prosic o kolejne liczby i je sumowac, az do momentu kiedy uzytkownik poda liczbe 0.

Na poczatku wszystko było w mainie, potem podzieliłem program na metode sumowania oraz settery i gettery dla pola suma.
Pytanie jest takie: czy to ogole powinno byc podzielone na settery gettery? czy raczej na jedną metode statyczna? w koncu te obiekty tylko utrudniaja prace?

No i ciekawi mnie linijka:

public void dodawanie(int liczba)
{
    zad1 z = new zad1();
    z.setSuma(suma+=liczba);
}

Otoz od kiedy poznalem zasade hermetyzacji, jakos mocno sie mnie ona trzyma. A w niektorych tutorialach widuje, ze w metodach pola np. inkrementowane są po prostu: " nazwa_pola++; " zamiast przez setter. To jest poprawne?
Przykład takiego działania:
Minuta: 7:05 - chwile po zainicjowaniu pola ustawia wartosc nextId i ID

prosze o wsparcie ;)
pozdrawiam!

Obiektowość oraz hermetyzacja istnieją po to aby uprościć kod dzieląc go na kilka niezależnych, samodzielnych kawałków.
W twoim przypadku użyto aby skomplikować.
wystarczy:

public void dodawanie(int liczba) { suma+=liczba; }

Co robisz:

public void dodawanie(int liczba)
  {
   zad1 z = new zad1(); // tworzysz nikomu nie potrzebny obiekt
   z.setSuma(suma+=liczba); // zwiększasz aktualną sumę obiektu: suma+=liczba, po czym inicjalizujesz tą wartością ten nowy bezsensowny obiekt
  } // gdzieś tu lub nieco później GC usunie ten bezsensowny, nikomu nie potrzebny obiekt

Zmieniłem kod do takiej postaci:

import java.util.Scanner;

public class zad1
{
    public static int suma;

    public static int dodawanie(int x)
    {
        suma = suma + x;
        return suma;
    }

    public static void main(String[] args) 
    {
        Scanner wejscie = new Scanner(System.in);
        int liczba=0,zlicz=0;
        do
        {
            System.out.println("Podaj liczby, do zastopowania podaj liczbe 0: ");
            liczba = wejscie.nextInt();
            dodawanie(liczba);
            zlicz++;
        }
        while(liczba!=0);

        System.out.println("Suma liczb wynosi: " + suma);
        System.out.println("Podałeś "+ (zlicz-1) + " liczb");
    }
}

Zastanawiało mnie dlaczego jak zrobie cos takiego:

public static int dodawanie(int x)
{
    int suma = suma + x;
    return suma;
}

(nie istniało wtedy pole suma i nie drukowało sie przy pierwszym system.out.println "suma") Wywalało błąd przy tym int suma. Moze dlatego ze nie moge przy deklaracji zwiekszyc Od razu o jakas tam wartosc?

A co do zasady hermetyzacji - co powiesz na temat tego filmu ktory dalem? Jesli jakas metoda w klasie ustawia wartosc jakiemus polu(i nie jest to metoda settera) to nie potrzeba robic settera? hermetyzacja bedzie wtedy zachowana?

prosiłbym o odpowiedz, bo bardzo sie z tym problemem borykam i mi duzo rzeczy miesza i komplikuje :)

To co robisz to kompletny bezsens, rób albo tak:

public class zad1
  {
   public static void main(String[] args) 
     {
      Scanner wejscie = new Scanner(System.in);
      int suma=0,zlicz=0;
      while(true)
        {
         System.out.println("Podaj liczby, do zastopowania podaj liczbe 0: ");
         int liczba=wejscie.nextInt();
         if(!liczba) break;
         suma+=liczba;
         ++zlicz;
        }
      System.out.println("Suma liczb wynosi: " + suma);
      System.out.println("Podałeś "+ zlicz + " liczb");
     }
  }

albo tak:

public class zad1
  {
   public int suma,zlicz;
   public zad1() { reset(); }
   public void reset() { suma=zlicz=0; }
   public void add(int liczba) { suma+=liczba; ++zlicz; }
   public static void main(String[] args) 
     {
      Scanner wejscie = new Scanner(System.in);
      zad1 z=new zad1();
      while(true)
        {
         System.out.println("Podaj liczby, do zastopowania podaj liczbe 0: ");
         int liczba=wejscie.nextInt();
         if(!liczba) break;
         z.add(liczba);
        }
      System.out.println("Suma liczb wynosi: " + z.suma);
      System.out.println("Podałeś "+ z.zlicz + " liczb");
     }
  }

Nie widzę sensu robienia setera/getera dla składowej która może mieć dowolną wartość.

A gdybym chciał stworzyc klase zad1 i ona nie miałaby maina, tylko powiedzmy pola suma/zlicz i metode do zwiekszania sumy(wtedy bylaby to klasa abstrakcyjna?), a to wszystko chciałbym wykorzystac w innej klasie np zad2?
Wtedy uzyc drugiego sposobu, ale tę pętlę while musze wrzucic w jakas metode "suma" , zebym mogl sie odwołać do niej w klasie zad2(przez rozszerzenie klasy zad2 o klase zad1)? (i oczywiscie cała klasa zad 1 musi (lub moze?) byc abstrakcyjna?)