Should I use static or getters/setters?

Question

I am making a small musicplayer application in android , in which my main activity is using lots of static variables like this :-

 public class Fragmentactivity extends FragmentActivity {

         static ArrayList<String> s3=new ArrayList<String>();
        static ArrayList<String> s5=new ArrayList<String>();
        static ArrayList<String> songpaths=new ArrayList<String>();
         static ArrayList<String> alldirectorypaths=new ArrayList<String>();
         static ArrayList<String> internalpaths=new ArrayList<String>();
         static ArrayList<String> tempsongnames=new ArrayList<String>();
         static ArrayList<Bitmap> thumbnails=new ArrayList<Bitmap>();
         static int internal=0;
         static ArrayList<String> folderpaths=new ArrayList<String>();
    //my addtional code after it
    }

And I am accesing it in other classes like :-

  public class A{
    Fragmentactivity.songpaths.get(index);
    //and in  many other classes also i used it

I have made many static variables everywhere in my most of classes But now I learnt that this is not good practice for developing .

Should I continue with static or shoud I use getters/setters ?

Or if there are any other way to reuse variables...please suggests me.

Any help would be appreciated :)

Thanks in advance :)

Answer 1

Am not an Android expert. static have a special meaning that they can be shared across all the instances.

Hence if you are going to share them across multiple instances of them, just goahead with current way.

Should i continue with static or should i use getters/setters ?

Assuming you want shared variables, I'll mix them both

Fragmentactivity.getSongNames().get(index);

Update :

If you are not making multiple istances of it, just get rid of static and provide getter and setters to it. That is all you need.

public class Fragmentactivity extends FragmentActivity {

     private ArrayList<String> s3=new ArrayList<String>();

   ...
   ...
    public ArrayList<String> getS3() {
    return this.s3;
   }

   public setS3(ArrayList<String> input){
   this.s3= input;
  }

...

Answer 2

I see that you are trying to use static variables because songpaths, alldirectorypaths, internalpaths ..probably are values that should exist only in one instance to be accessed across your app. What you need is to use the singleton pattern.

the singleton pattern is a design pattern that restricts the instantiation of a class to one object. This is useful when exactly one object is needed to coordinate actions across the system. (wikipedia)

according to the book "Effective Java" of Joshua Bloch the most efficient way to implement a singleton is with Enums.

  public enum MusicPlayerContext{

    INSTANCE;

    public List<String> internalpaths = new ArrayList<String>();
    public List<String> alldirectorypaths= new ArrayList<String>();

  }

  public class MyActivity extends Activity{

      public void doSomething(){
         List<String> intPaths = MusicPlayerContext.INSTANCE.internalpaths; 
      }
  }

One more thing.. prefer to use interface for variable declaration (List) instead of implemtation (ArrayList< String >)

Answer 3

The main question to be answered in the design of the data model (in the context of the use static access to the variable) is - whether or not this variable to be associated with a class (if so then we use static modifier) or with the concrete instance of this class (and then this variable should be non-static).

Here are a lot of posts(link1, link2, link3) on advantages and disadvantages of using of the static variables in Java. This info is also relevant for the Android as well. And few more things to be mentioned here for Android:

• it is strictly recommended to avoid creating of static reference to the Context and any of its subclasses because this is a direct source to the memory leak;
• though static variables are not associated with concrete object and they will not be garbage-collected with it, but still their values will be cleared when application process is killed (by OS or user). So it is not appropriate for long term storing of valuable data.

With regard to possible alternatives of static access to the data, here are the most commonly used approaches:

1. Singleton pattern. One of the simplest ways (came from usual Java):

   public class GlobalStorage {
       private static volatile GlobalStorage instance; // and drumroll - here we use static access again to make this data accessible everywhere in the app
       private GlobalStorage() { }
   
       public static GlobalStorage getInstance() {
           if (instance == null ) {
               synchronized (GlobalStorage.class) {
                   if (instance == null) {
                       instance = new GlobalStorage();
                   }
               }
           }
   
           return instance;
       }
   }
   

2. Usage of Application class. Create a class subclassing the Application:

   public class CustomApp extends Application{
   private Storage mStorage;
   
        @Override
        public void onCreate() {
            super.onCreate();
   
            mStorage = new Storage();
        }
   
        public Storage getStorage(){
            return this.mStorage;
        }
   }
   

   and register it in Manifest as an attribute of <application> tag:

   <application
      android:name=".CustomApp"
      .... />
   

Though this approach is framework-defined it also is not a "silver bullet". Straight from documentation:

There is normally no need to subclass Application. In most situation, static singletons can provide the same functionality in a more modular way. If your singleton needs a global context (for example to register broadcast receivers), the function to retrieve it can be given a Context which internally uses Context.getApplicationContext() when first constructing the singleton.

Answer 4

If you want to communicate 2 Fragments/Activities, then use a Bundle

Answer 5

It will more or less depend on your functionality that you wish to achieve. Like do you want these variables to be shared across instances. Use of getter setters is no way related to declaring variable static . For any type of variables you can use getters and setters.

Other than accessors/mutators they have other advantages also.

Normally getters are declared to prevent your variables ( esp mutable ) from being exposed to outer world.

Setters are helpful if you don't want your client to update your variable directly.

For example consider the case of date variables

For date type variables, you may want to return a copy of your date variable to your client, not your own reference. Because client can misuse this reference or corrupt it. And while calling setter you may like to check the validity first of the date or its format whatever.

Answer 6

static is thread unsafe, if you do not want to use get()/set() functions, you can use public to modify basic data types instead.

Define Point like this:

public class Point{
    public double x;
    public double y;
}

And then use Point like this :

Point p = new Point();
p.x = ;
p.y = ;

But, to Object data types, you would better use get()/set() functions, they are safe.

Answer 7

This question has already been answered here.

Personally I would use a Singleton Pattern, it is very easy to implement and makes your code easier to test and easier to change in the future.

The point is that with static variables you have to write Fragmentactivity... everywhere in your client and you are coupling your client to this specific class.

Using a Singleton you could, f.i., introduce an interface and then in the future easily replace the Singleton with another one.

A Singleton implementation would also allow lazy initialization.

Answer 8

In native languages like C++ it's common practice to use getters (i = getCount()) instead of accessing the field directly (i = mCount). This is an excellent habit for C++ and is often practiced in other object oriented languages like C# and Java, because the compiler can usually inline the access, and if you need to restrict or debug field access you can add the code at any time.

However, this is a bad idea on Android. Virtual method calls are expensive, much more so than instance field lookups. It's reasonable to follow common object-oriented programming practices and have getters and setters in the public interface, but within a class you should always access fields directly.

So as android developer guide you should avoid so much use of getter/setter().

Reference : http://developer.android.com/training/articles/perf-tips.html

Answer 9

For context, let's briefly talk about what static does. static is a keyword that changes the scope of a variable to global, persists its value across all instances, and makes its allocation of memory permanent for the lifetime of the application.

This has a few consequences:

• The variable becomes unsafe for threaded environments
• The variable, if public, can be accessed anywhere
• The variable will never be cleaned by garbage collection

To more nicely perform what you're accomplishing with static, we can use an interface.

Make a new interface:

public interface FragmentActivityInterface {
  String getSongPath(int index);
  //etc...
}

Have your Fragment implement the interface:

public class Fragmentactivity extends FragmentActivity implements FragmentActivityInterface {

    static ArrayList<String> s3=new ArrayList<String>();
    static ArrayList<String> s5=new ArrayList<String>();
    static ArrayList<String> songpaths=new ArrayList<String>();
    static ArrayList<String> alldirectorypaths=new ArrayList<String>();
    static ArrayList<String> internalpaths=new ArrayList<String>();
    static ArrayList<String> tempsongnames=new ArrayList<String>();
    static ArrayList<Bitmap> thumbnails=new ArrayList<Bitmap>();
    static int internal=0;
    static ArrayList<String> folderpaths=new ArrayList<String>();
    //my addtional code after it

    @Override
    public String getSongPath(int index) {
        return songpaths.get(index);
    }

    //etc...
}

Make your other class require a FragmentActivityInterface:

public class A {
  private FragmentActivityInterface fragInterface;

  public A (FragmentActivityInterface fragInterface) {
    this.fragInterface = fragInterface;
  }
}

Finally, when you create the instance of your A class, you simply pass in your activity.

A foo = new A(this);

Now, anywhere in A where you want to get access to the FragmentActivity's members, just use fragInterface.getSongPath(0).