Java - passing an object as a parameter vs. using it's qualified name

java

I am writing a Java program where a method in one class needs to access a method of an object that is a member of another class. I can do this in at least two different ways, passing as a parameter, or directly accessing the object using the name of the class it is a member of. I find a lot of questions about pass-by-reference vs. pass-by-value, but I can't find anything that addresses this scenario. Here is some pseudo-code showing what I mean:

// class of object to pass
class MyPrefs {
  public String getPref(int i){
    String s = ... //some code to get a String indexed by i
    return s;
  }
}

// class where object is instantiated
class Main {
  protected static MyPrefs prefs = new MyPrefs();
}

Here are the two options I am looking at. In a third class, Toolbar, I can do either of these:

// pass as parameter
class Toolbar{
  public void applyPrefs(MyPrefs p){
    String s = p.getPref(1);
    ...
  }

//or use qualified name of object
class Toolbar{
  public void applyPrefs(){
   String s = Main.prefs.getPref(1);
   ...
  }
}

It works either way, what I would like to know is what are the merits or problems associated with each method, and if there is another way of doing this that I hadn't considered.

Solution 1:

I hope this question doesn't get closed for being opinion-based because technically it is. So, I am not going to claim my answer is based on some undisputed best-practice, but I do believe it is generally accepted as the correct approach.

In my opinion, it would be either a variant of the first, and/or a combination of the two. For example:

public static String getProp(String prop) {
    // use java.util.Properties to retrieve the property.
}

This works well when your application has a single property file. In cases you have multiple property files, you need to override this method and pass the path to the correct file.

public static String getProp(String filename, String prop) {
    // use java.util.Properties to retrieve the property.
}

Where filename could be just the file name or the fully qualified name (with the path). I tend to keep all my property files in the same folder, so I "hard-code" the path and use that as the base location for my files, so most of the time when using this approach, I only need the actual file name.

I also have created utility methods to obtain specific properties where the name of the method implies what property I am obtaining. This is useful for people that are not too familiarized with the property keys.

public static String getXYZProp() {
    // use java.util.Properties to load the properties.
    return prop.getProperty("XYZ");
}

Alternatively, you should take advantage of the genetic method you created to do the same

public static String getXYZProp() {
    return getProp("XYZ");
}

Or even something like

public static String getXYZProp() {
    return getProp("someProps.properties", "XYZ");
}

It is OK to have multiple method that ultimately do the same thing. Think that some users will call the generic ones because they are more familiarized with the property keys while others will rely on method with names that help them figure out what properties they need to retrieve.

Java - passing an object as a parameter vs. using it's qualified name

Solution 1:

Related

Recent Posts