fixed some formatting typos

[vimdoclet.git] / sample / java.util.ResourceBundle.txt

*java.util.ResourceBundle* *ResourceBundle* Resource bundles contain locale-spec

public abstract class ResourceBundle
  extends    |java.lang.Object|

|java.util.ResourceBundle_Description|
|java.util.ResourceBundle_Fields|
|java.util.ResourceBundle_Constructors|
|java.util.ResourceBundle_Methods|

================================================================================

*java.util.ResourceBundle_Fields*
|java.util.ResourceBundle_java.util.ResourceBundle.parent|

*java.util.ResourceBundle_Constructors*
|java.util.ResourceBundle()|Sole constructor.

*java.util.ResourceBundle_Methods*
|java.util.ResourceBundle.clearCache()|Removes all resource bundles from the ca
|java.util.ResourceBundle.clearCache(ClassLoader)|Removes all resource bundles 
|java.util.ResourceBundle.containsKey(String)|Determines whether the given key 
|java.util.ResourceBundle.getBundle(String)|Gets a resource bundle using the sp
|java.util.ResourceBundle.getBundle(String,Locale)|Gets a resource bundle using
|java.util.ResourceBundle.getBundle(String,Locale,ClassLoader)|Gets a resource 
|java.util.ResourceBundle.getBundle(String,Locale,ClassLoader,ResourceBundle.Control)|
|java.util.ResourceBundle.getBundle(String,Locale,ResourceBundle.Control)|Retur
|java.util.ResourceBundle.getBundle(String,ResourceBundle.Control)|Returns a re
|java.util.ResourceBundle.getKeys()|Returns an enumeration of the keys.
|java.util.ResourceBundle.getLocale()|Returns the locale of this resource bundl
|java.util.ResourceBundle.getObject(String)|Gets an object for the given key fr
|java.util.ResourceBundle.getString(String)|Gets a string for the given key fro
|java.util.ResourceBundle.getStringArray(String)|Gets a string array for the gi
|java.util.ResourceBundle.handleGetObject(String)|Gets an object for the given 
|java.util.ResourceBundle.handleKeySet()|Returns a Set of the keys contained on
|java.util.ResourceBundle.keySet()|Returns a Set of all keys contained in this 
|java.util.ResourceBundle.setParent(ResourceBundle)|Sets the parent bundle of t

*java.util.ResourceBundle_Description*

Resource bundles contain locale-specific objects. When your program needs a 
locale-specific resource, a String for example, your program can load it from 
the resource bundle that is appropriate for the current user's locale. In this 
way, you can write program code that is largely independent of the user's 
locale isolating most, if not all, of the locale-specific information in 
resource bundles. 

This allows you to write programs that can: 

be easily localized, or translated, into different languages handle multiple 
locales at once be easily modified later to support even more locales 

Resource bundles belong to families whose members share a common base name, but 
whose names also have additional components that identify their locales. For 
example, the base name of a family of resource bundles might be "MyResources". 
The family should have a default resource bundle which simply has the same name 
as its family - "MyResources" - and will be used as the bundle of last resort 
if a specific locale is not supported. The family can then provide as many 
locale-specific members as needed, for example a German one named 
"MyResources_de". 

Each resource bundle in a family contains the same items, but the items have 
been translated for the locale represented by that resource bundle. For 
example, both "MyResources" and "MyResources_de" may have a String that's used 
on a button for canceling operations. In "MyResources" the String may contain 
"Cancel" and in "MyResources_de" it may contain "Abbrechen". 

If there are different resources for different countries, you can make 
specializations: for example, "MyResources_de_CH" contains objects for the 
German language (de) in Switzerland (CH). If you want to only modify some of 
the resources in the specialization, you can do so. 

When your program needs a locale-specific object, it loads the ResourceBundle 
class using the getBundle(|java.util.ResourceBundle|) method: 



ResourceBundle myResources = ResourceBundle.getBundle("MyResources", 
currentLocale); 



Resource bundles contain key/value pairs. The keys uniquely identify a 
locale-specific object in the bundle. Here's an example of a ListResourceBundle 
that contains two key/value pairs: 



public class MyResources extends ListResourceBundle { protected Object[][] 
getContents() { return new Object[][] { // LOCALIZE THE SECOND STRING OF EACH 
ARRAY (e.g., "OK") {"OkKey", "OK"}, {"CancelKey", "Cancel"}, // END OF MATERIAL 
TO LOCALIZE }; } } 

Keys are always Strings. In this example, the keys are "OkKey" and "CancelKey". 
In the above example, the values are also Strings--"OK" and "Cancel"--but they 
don't have to be. The values can be any type of object. 

You retrieve an object from resource bundle using the appropriate getter 
method. Because "OkKey" and "CancelKey" are both strings, you would use 
getString to retrieve them: 



button1 = new Button(myResources.getString("OkKey")); button2 = new 
Button(myResources.getString("CancelKey")); 

The getter methods all require the key as an argument and return the object if 
found. If the object is not found, the getter method throws a 
MissingResourceException. 

Besides getString, ResourceBundle also provides a method for getting string 
arrays, getStringArray, as well as a generic getObject method for any other 
type of object. When using getObject, you'll have to cast the result to the 
appropriate type. For example: 



int[] myIntegers = (int[]) myResources.getObject("intList"); 



The Java Platform provides two subclasses of ResourceBundle, ListResourceBundle 
and PropertyResourceBundle, that provide a fairly simple way to create 
resources. As you saw briefly in a previous example, ListResourceBundle manages 
its resource as a list of key/value pairs. PropertyResourceBundle uses a 
properties file to manage its resources. 

If ListResourceBundle or PropertyResourceBundle do not suit your needs, you can 
write your own ResourceBundle subclass. Your subclasses must override two 
methods: handleGetObject and getKeys(). 

ResourceBundle.Control 

The (|java.util.ResourceBundle.Control|) class provides information necessary 
to perform the bundle loading process by the getBundle factory methods that 
take a ResourceBundle.Control instance. You can implement your own subclass in 
order to enable non-standard resource bundle formats, change the search 
strategy, or define caching parameters. Refer to the descriptions of the class 
and the getBundle(|java.util.ResourceBundle|) factory method for details. 

Cache Management 

Resource bundle instances created by the getBundle factory methods are cached 
by default, and the factory methods return the same resource bundle instance 
multiple times if it has been cached. getBundle clients may clear the cache, 
manage the lifetime of cached resource bundle instances using time-to-live 
values, or specify not to cache resource bundle instances. Refer to the 
descriptions of the <code>getBundle</code> factory 
method(|java.util.ResourceBundle|) , clearCache(|java.util.ResourceBundle|) , 
ResourceBundle.Control.getTimeToLive(|java.util.ResourceBundle.Control|) , and 
ResourceBundle.Control.needsReload(|java.util.ResourceBundle.Control|) for 
details. 

Example 

The following is a very simple example of a ResourceBundle subclass, 
MyResources, that manages two resources (for a larger number of resources you 
would probably use a Map). Notice that you don't need to supply a value if a 
"parent-level" ResourceBundle handles the same key with the same value (as for 
the okKey below). 



// default (English language, United States) public class MyResources extends 
ResourceBundle { public Object handleGetObject(String key) { if 
(key.equals("okKey")) return "Ok"; if (key.equals("cancelKey")) return 
"Cancel"; return null; } 

public Enumeration<String> getKeys() { return 
Collections.enumeration(keySet()); } 

// Overrides handleKeySet() so that the getKeys() implementation // can rely on 
the keySet() value. protected Set<String> handleKeySet() { return new 
HashSet<String>(Arrays.asList("okKey", "cancelKey")); } } 

// German language public class MyResources_de extends MyResources { public 
Object handleGetObject(String key) { // don't need okKey, since parent level 
handles it. if (key.equals("cancelKey")) return "Abbrechen"; return null; } 

protected Set<String> handleKeySet() { return new 
HashSet<String>(Arrays.asList("cancelKey")); } } 

You do not have to restrict yourself to using a single family of 
ResourceBundles. For example, you could have a set of bundles for exception 
messages, ExceptionResources (ExceptionResources_fr, ExceptionResources_de, 
...), and one for widgets, WidgetResource (WidgetResources_fr, 
WidgetResources_de, ...); breaking up the resources however you like. 



*java.util.ResourceBundle_java.util.ResourceBundle.parent*

The parent bundle of this bundle. The parent bundle is searched by 
getObject(|java.util.ResourceBundle|) when this bundle does not contain a 
particular resource. 



*java.util.ResourceBundle()*

public ResourceBundle()

Sole constructor. (For invocation by subclass constructors, typically 
implicit.) 


*java.util.ResourceBundle.clearCache()*

public static final void clearCache()

Removes all resource bundles from the cache that have been loaded using the 
caller's class loader. 



*java.util.ResourceBundle.clearCache(ClassLoader)*

public static final void clearCache(java.lang.ClassLoader loader)

Removes all resource bundles from the cache that have been loaded using the 
given class loader. 


    loader - the class loader 

*java.util.ResourceBundle.containsKey(String)*

public boolean containsKey(java.lang.String key)

Determines whether the given key is contained in this ResourceBundle or its 
parent bundles. 


    key - the resource key 

    Returns: true if the given key is contained in this ResourceBundle or its parent 
             bundles; false otherwise. 

*java.util.ResourceBundle.getBundle(String)*

public static final |java.util.ResourceBundle| getBundle(java.lang.String baseName)

Gets a resource bundle using the specified base name, the default locale, and 
the caller's class loader. Calling this method is equivalent to calling 

getBundle(baseName, Locale.getDefault(), this.getClass().getClassLoader()), 

except that getClassLoader() is run with the security privileges of 
ResourceBundle. See getBundle(|java.util.ResourceBundle|) for a complete 
description of the search and instantiation strategy. 


    baseName - the base name of the resource bundle, a fully qualified class name 

    Returns: a resource bundle for the given base name and the default locale 

*java.util.ResourceBundle.getBundle(String,Locale)*

public static final |java.util.ResourceBundle| getBundle(
  java.lang.String baseName,
  java.util.Locale locale)

Gets a resource bundle using the specified base name and locale, and the 
caller's class loader. Calling this method is equivalent to calling 

getBundle(baseName, locale, this.getClass().getClassLoader()), 

except that getClassLoader() is run with the security privileges of 
ResourceBundle. See getBundle(|java.util.ResourceBundle|) for a complete 
description of the search and instantiation strategy. 


    baseName - the base name of the resource bundle, a fully qualified class name 
    locale - the locale for which a resource bundle is desired 

    Returns: a resource bundle for the given base name and locale 

*java.util.ResourceBundle.getBundle(String,Locale,ClassLoader)*

public static |java.util.ResourceBundle| getBundle(
  java.lang.String baseName,
  java.util.Locale locale,
  java.lang.ClassLoader loader)

Gets a resource bundle using the specified base name, locale, and class loader. 

Conceptually, getBundle uses the following strategy for locating and 
instantiating resource bundles: 

getBundle uses the base name, the specified locale, and the default locale 
(obtained from Locale.getDefault(|java.util.Locale|) ) to generate a sequence 
of candidate bundle names. If the specified locale's language, country, and 
variant are all empty strings, then the base name is the only candidate bundle 
name. Otherwise, the following sequence is generated from the attribute values 
of the specified locale (language1, country1, and variant1) and of the default 
locale (language2, country2, and variant2): 

baseName + "_" + language1 + "_" + country1 + "_" + variant1 baseName + "_" + 
language1 + "_" + country1 baseName + "_" + language1 baseName + "_" + 
language2 + "_" + country2 + "_" + variant2 baseName + "_" + language2 + "_" + 
country2 baseName + "_" + language2 baseName 

Candidate bundle names where the final component is an empty string are 
omitted. For example, if country1 is an empty string, the second candidate 
bundle name is omitted. 

getBundle then iterates over the candidate bundle names to find the first one 
for which it can instantiate an actual resource bundle. For each candidate 
bundle name, it attempts to create a resource bundle: 

First, it attempts to load a class using the candidate bundle name. If such a 
class can be found and loaded using the specified class loader, is assignment 
compatible with ResourceBundle, is accessible from ResourceBundle, and can be 
instantiated, getBundle creates a new instance of this class and uses it as the 
result resource bundle. 

Otherwise, getBundle attempts to locate a property resource file. It generates 
a path name from the candidate bundle name by replacing all "." characters with 
"/" and appending the string ".properties". It attempts to find a "resource" 
with this name using ClassLoader.getResource(|java.lang.ClassLoader|) . (Note 
that a "resource" in the sense of getResource has nothing to do with the 
contents of a resource bundle, it is just a container of data, such as a file.) 
If it finds a "resource", it attempts to create a new 
(|java.util.PropertyResourceBundle|) instance from its contents. If successful, 
this instance becomes the result resource bundle. 

If no result resource bundle has been found, a MissingResourceException is 
thrown. 

Once a result resource bundle has been found, its parent chain is instantiated. 
getBundle iterates over the candidate bundle names that can be obtained by 
successively removing variant, country, and language (each time with the 
preceding "_") from the bundle name of the result resource bundle. As above, 
candidate bundle names where the final component is an empty string are 
omitted. With each of the candidate bundle names it attempts to instantiate a 
resource bundle, as described above. Whenever it succeeds, it calls the 
previously instantiated resource bundle's setParent(|java.util.ResourceBundle|) 
method with the new resource bundle, unless the previously instantiated 
resource bundle already has a non-null parent. 

getBundle caches instantiated resource bundles and may return the same resource 
bundle instance multiple times. 

The baseName argument should be a fully qualified class name. However, for 
compatibility with earlier versions, Sun's Java SE Runtime Environments do not 
verify this, and so it is possible to access PropertyResourceBundles by 
specifying a path name (using "/") instead of a fully qualified class name 
(using "."). 

Example:The following class and property files are provided: 

MyResources.class MyResources.properties MyResources_fr.properties 
MyResources_fr_CH.class MyResources_fr_CH.properties MyResources_en.properties 
MyResources_es_ES.class 

The contents of all files are valid (that is, public non-abstract subclasses of 
ResourceBundle for the ".class" files, syntactically correct ".properties" 
files). The default locale is Locale("en", "GB"). 

Calling getBundle with the shown locale argument values instantiates resource 
bundles from the following sources: 

Locale("fr", "CH"): result MyResources_fr_CH.class, parent 
MyResources_fr.properties, parent MyResources.class Locale("fr", "FR"): result 
MyResources_fr.properties, parent MyResources.class Locale("de", "DE"): result 
MyResources_en.properties, parent MyResources.class Locale("en", "US"): result 
MyResources_en.properties, parent MyResources.class Locale("es", "ES"): result 
MyResources_es_ES.class, parent MyResources.class 

The file MyResources_fr_CH.properties is never used because it is hidden by 
MyResources_fr_CH.class. Likewise, MyResources.properties is also hidden by 
MyResources.class. 


    baseName - the base name of the resource bundle, a fully qualified class name 
    locale - the locale for which a resource bundle is desired 
    loader - the class loader from which to load the resource bundle 

    Returns: a resource bundle for the given base name and locale 

*java.util.ResourceBundle.getBundle(String,Locale,ClassLoader,ResourceBundle.Control)*

public static |java.util.ResourceBundle| getBundle(
  java.lang.String baseName,
  java.util.Locale targetLocale,
  java.lang.ClassLoader loader,
  java.util.ResourceBundle.Control control)

Returns a resource bundle using the specified base name, target locale, class 
loader and control. Unlike the <code>getBundle</code> factory methods with no 
<code>control</code> argument(|java.util.ResourceBundle|) , the given control 
specifies how to locate and instantiate resource bundles. Conceptually, the 
bundle loading process with the given control is performed in the following 
steps. 



This factory method looks up the resource bundle in the cache for the specified 
baseName, targetLocale and loader. If the requested resource bundle instance is 
found in the cache and the time-to-live periods of the instance and all of its 
parent instances have not expired, the instance is returned to the caller. 
Otherwise, this factory method proceeds with the loading process below. 

The control.getFormats(|java.util.ResourceBundle.Control|) method is called to 
get resource bundle formats to produce bundle or resource names. The strings 
"java.class" and "java.properties" designate class-based and 
property(|java.util.PropertyResourceBundle|) -based resource bundles, 
respectively. Other strings starting with "java." are reserved for future 
extensions and must not be used for application-defined formats. Other strings 
designate application-defined formats. 

The control.getCandidateLocales(|java.util.ResourceBundle.Control|) method is 
called with the target locale to get a list of candidate Locales for which 
resource bundles are searched. 

The control.newBundle(|java.util.ResourceBundle.Control|) method is called to 
instantiate a ResourceBundle for the base bundle name, a candidate locale, and 
a format. (Refer to the note on the cache lookup below.) This step is iterated 
over all combinations of the candidate locales and formats until the newBundle 
method returns a ResourceBundle instance or the iteration has used up all the 
combinations. For example, if the candidate locales are Locale("de", "DE"), 
Locale("de") and Locale("") and the formats are "java.class" and 
"java.properties", then the following is the sequence of locale-format 
combinations to be used to call control.newBundle. 



Locale 

format 



Locale("de", "DE") 

java.class 



Locale("de", "DE") java.properties 



Locale("de") java.class 

Locale("de") java.properties 

Locale("") 

java.class 

Locale("") java.properties 





If the previous step has found no resource bundle, proceed to Step 6. If a 
bundle has been found that is a base bundle (a bundle for Locale("")), and the 
candidate locale list only contained Locale(""), return the bundle to the 
caller. If a bundle has been found that is a base bundle, but the candidate 
locale list contained locales other than Locale(""), put the bundle on hold and 
proceed to Step 6. If a bundle has been found that is not a base bundle, 
proceed to Step 7. 

The control.getFallbackLocale(|java.util.ResourceBundle.Control|) method is 
called to get a fallback locale (alternative to the current target locale) to 
try further finding a resource bundle. If the method returns a non-null locale, 
it becomes the next target locale and the loading process starts over from Step 
3. Otherwise, if a base bundle was found and put on hold in a previous Step 5, 
it is returned to the caller now. Otherwise, a MissingResourceException is 
thrown. 

At this point, we have found a resource bundle that's not the base bundle. If 
this bundle set its parent during its instantiation, it is returned to the 
caller. Otherwise, its parent chain is instantiated based on the list of 
candidate locales from which it was found. Finally, the bundle is returned to 
the caller. 



During the resource bundle loading process above, this factory method looks up 
the cache before calling the 
control.newBundle(|java.util.ResourceBundle.Control|) method. If the 
time-to-live period of the resource bundle found in the cache has expired, the 
factory method calls the 
control.needsReload(|java.util.ResourceBundle.Control|) method to determine 
whether the resource bundle needs to be reloaded. If reloading is required, the 
factory method calls control.newBundle to reload the resource bundle. If 
control.newBundle returns null, the factory method puts a dummy resource bundle 
in the cache as a mark of nonexistent resource bundles in order to avoid lookup 
overhead for subsequent requests. Such dummy resource bundles are under the 
same expiration control as specified by control. 

All resource bundles loaded are cached by default. Refer to 
control.getTimeToLive(|java.util.ResourceBundle.Control|) for details. 

The following is an example of the bundle loading process with the default 
ResourceBundle.Control implementation. 

Conditions: 

Base bundle name: foo.bar.Messages Requested Locale: (|java.util.Locale|) 
Default Locale: (|java.util.Locale|) Available resource bundles: 
foo/bar/Messages_fr.properties and foo/bar/Messages.properties 



First, getBundle tries loading a resource bundle in the following sequence. 

class foo.bar.Messages_it_IT file foo/bar/Messages_it_IT.properties class 
foo.bar.Messages_it file foo/bar/Messages_it.properties class foo.bar.Messages 
file foo/bar/Messages.properties 

At this point, getBundle finds foo/bar/Messages.properties, which is put on 
hold because it's the base bundle. getBundle calls 
control.getFallbackLocale("foo.bar.Messages", 
Locale.ITALY)(|java.util.ResourceBundle.Control|) which returns Locale.FRENCH. 
Next, getBundle tries loading a bundle in the following sequence. 

class foo.bar.Messages_fr file foo/bar/Messages_fr.properties class 
foo.bar.Messages file foo/bar/Messages.properties 

getBundle finds foo/bar/Messages_fr.properties and creates a ResourceBundle 
instance. Then, getBundle sets up its parent chain from the list of the 
candiate locales. Only foo/bar/Messages.properties is found in the list and 
getBundle creates a ResourceBundle instance that becomes the parent of the 
instance for foo/bar/Messages_fr.properties. 


    baseName - the base name of the resource bundle, a fully qualified class name 
    targetLocale - the locale for which a resource bundle is desired 
    loader - the class loader from which to load the resource bundle 
    control - the control which gives information for the resource bundle loading process 

    Returns: a resource bundle for the given base name and locale 

*java.util.ResourceBundle.getBundle(String,Locale,ResourceBundle.Control)*

public static final |java.util.ResourceBundle| getBundle(
  java.lang.String baseName,
  java.util.Locale targetLocale,
  java.util.ResourceBundle.Control control)

Returns a resource bundle using the specified base name, target locale and 
control, and the caller's class loader. Calling this method is equivalent to 
calling 

getBundle(baseName, targetLocale, this.getClass().getClassLoader(), control), 

except that getClassLoader() is run with the security privileges of 
ResourceBundle. See getBundle(|java.util.ResourceBundle|) for the complete 
description of the resource bundle loading process with a 
ResourceBundle.Control. 


    baseName - the base name of the resource bundle, a fully qualified class name 
    targetLocale - the locale for which a resource bundle is desired 
    control - the control which gives information for the resource bundle loading process 

    Returns: a resource bundle for the given base name and a Locale in locales 

*java.util.ResourceBundle.getBundle(String,ResourceBundle.Control)*

public static final |java.util.ResourceBundle| getBundle(
  java.lang.String baseName,
  java.util.ResourceBundle.Control control)

Returns a resource bundle using the specified base name, the default locale and 
the specified control. Calling this method is equivalent to calling 

getBundle(baseName, Locale.getDefault(), this.getClass().getClassLoader(), 
control), 

except that getClassLoader() is run with the security privileges of 
ResourceBundle. See getBundle(|java.util.ResourceBundle|) for the complete 
description of the resource bundle loading process with a 
ResourceBundle.Control. 


    baseName - the base name of the resource bundle, a fully qualified class name 
    control - the control which gives information for the resource bundle loading process 

    Returns: a resource bundle for the given base name and the default locale 

*java.util.ResourceBundle.getKeys()*

public abstract |java.util.Enumeration|<String> getKeys()

Returns an enumeration of the keys. 



    Returns: an Enumeration of the keys contained in this ResourceBundle and its parent 
             bundles. 

*java.util.ResourceBundle.getLocale()*

public |java.util.Locale| getLocale()

Returns the locale of this resource bundle. This method can be used after a 
call to getBundle() to determine whether the resource bundle returned really 
corresponds to the requested locale or is a fallback. 



    Returns: the locale of this resource bundle 

*java.util.ResourceBundle.getObject(String)*

public final |java.lang.Object| getObject(java.lang.String key)

Gets an object for the given key from this resource bundle or one of its 
parents. This method first tries to obtain the object from this resource bundle 
using handleGetObject(|java.util.ResourceBundle|) . If not successful, and the 
parent resource bundle is not null, it calls the parent's getObject method. If 
still not successful, it throws a MissingResourceException. 


    key - the key for the desired object 

    Returns: the object for the given key 

*java.util.ResourceBundle.getString(String)*

public final |java.lang.String| getString(java.lang.String key)

Gets a string for the given key from this resource bundle or one of its 
parents. Calling this method is equivalent to calling 

(String) getObject(|java.util.ResourceBundle|) (key). 


    key - the key for the desired string 

    Returns: the string for the given key 

*java.util.ResourceBundle.getStringArray(String)*

public final |java.lang.String|[] getStringArray(java.lang.String key)

Gets a string array for the given key from this resource bundle or one of its 
parents. Calling this method is equivalent to calling 

(String[]) getObject(|java.util.ResourceBundle|) (key). 


    key - the key for the desired string array 

    Returns: the string array for the given key 

*java.util.ResourceBundle.handleGetObject(String)*

protected abstract |java.lang.Object| handleGetObject(java.lang.String key)

Gets an object for the given key from this resource bundle. Returns null if 
this resource bundle does not contain an object for the given key. 


    key - the key for the desired object 

    Returns: the object for the given key, or null 

*java.util.ResourceBundle.handleKeySet()*

protected |java.util.Set|<String> handleKeySet()

Returns a Set of the keys contained only in this ResourceBundle. 

The default implementation returns a Set of the keys returned by the 
getKeys(|java.util.ResourceBundle|) method except for the ones for which the 
handleGetObject(|java.util.ResourceBundle|) method returns null. Once the Set 
has been created, the value is kept in this ResourceBundle in order to avoid 
producing the same Set in the next calls. Override this method in subclass 
implementations for faster handling. 



    Returns: a Set of the keys contained only in this ResourceBundle 

*java.util.ResourceBundle.keySet()*

public |java.util.Set|<String> keySet()

Returns a Set of all keys contained in this ResourceBundle and its parent 
bundles. 



    Returns: a Set of all keys contained in this ResourceBundle and its parent bundles. 

*java.util.ResourceBundle.setParent(ResourceBundle)*

protected void setParent(java.util.ResourceBundle parent)

Sets the parent bundle of this bundle. The parent bundle is searched by 
getObject(|java.util.ResourceBundle|) when this bundle does not contain a 
particular resource. 


    parent - this bundle's parent bundle.