Question

In class we usually declare global variables and local variables. I have most of the time seen declaring global variables, setters ,getters. Are these essential everytime?Is it ok if I can implement it without using those things?

Answer 1

Generally you should always try to reduce the scope of visibility of variables, methods, classes etc.

So, if you need some variable that is used in one call sequence use local variable and method arguments to pass its value from method to method.
For example I have 2 methods foo() and bar() while foo calls bar:

public void foo() {
    bar();
}
private void bar() {
}

Let’s say both work on the same string appending to it some suffixes. You can use local variable as in the following example:

public String foo(String s) {
    s += "foo1"
    bar(s);
    s += "foo2"
    return s;
}
private String bar(String s) {
    s += "bar1"
    return s;
}

Or class level variable:

private String s;

public String foo() {
    s += "foo1"
    bar();
    s += "foo2"
    return s;
}
private String bar() {
    s += "bar1"
    return s;
}

The first way is better because:

1. it is encapsulated. No-one knows the detail of implementation. No-one can affect it from outside.
2. It is easier readable: you do not have to travel back and forward into your code to understand what objects participate in the implementation.
3. It is thread-safe without any extra efforts like synchronized blocks or atomic variable because it never uses object level variables.

The second implementation is not encapsulated: one can add code that changes the object state and affects on the next call of foo(). You have to go back and forward in you class to understand both algorithm and what variables are affected by algorithm. It is not thread-safe. Two concurrent threads running the same code may compete on changing the same variable.