java - Is loosely coupling more reliable (based on lookup API from netbeans)? -

i've seen netbeans platform development tutorial videos (now known trails) (http://www.netbeans.org/kb/trails/platform.html)

and i've been wondering how stable using lookup netbeans

this understood how lookup works

as image :

as psudo code (class stucture):

{  ((class implements myinterface)) , ((class b implements myinterface))   [myinterface (api)]  [coreapplication] ([lookup provide access , b via myinterface ])  } 

my question above implementation creates reliable outcome compared heavily coupled (also think of scenario static variables,methods , inner classes accessed other classes) ?

[i need know if use loosely coupling , use lookup api implement it. program become more or less reliable compared tightly coupled one. (by reliable mean factors stability of application, crash often, etc)]

if how works ?

i'd (also) depends on if it's reliable.

think it. have class b registered in lookup, class needs service class b able provide. class wants service, doesn't matter if implementation class b, class c, class d or whatever. so, using lookup ask if service available , use if is. , here comes reliability. let's service you're looking cannot found within lookup, it's make sure system won't break if service cannot found.

a scenario in netbeans this:

requiredservice s = lookup.getdefault().lookup(requiredservice.class); if (s != null) {     s.dosomething(); // in case responsibility of reliability lies on side of implemented service. } else {     // it's keep reliable , perhaps let user know went not expected. } 

now imagen "tightly" rely on implementation of requiredservice , of sudden, reason, it's not there anymore. since modules loaded @ runtime within netbeans, you'll classloader exceptions , won't have chance make decision in such cases.