You can only add folders or jar files to a class loader. So if you have a single class file, you need to put it into the appropriate folder structure first.

Here is a rather ugly hack that adds to the SystemClassLoader at runtime:

import java.io.IOException;
import java.io.File;
import java.net.URLClassLoader;
import java.net.URL;
import java.lang.reflect.Method;

public class ClassPathHacker {

  private static final Class[] parameters = new Class[]{URL.class};

  public static void addFile(String s) throws IOException {
    File f = new File(s);
    addFile(f);
  }//end method

  public static void addFile(File f) throws IOException {
    addURL(f.toURL());
  }//end method


  public static void addURL(URL u) throws IOException {

    URLClassLoader sysloader = (URLClassLoader) ClassLoader.getSystemClassLoader();
    Class sysclass = URLClassLoader.class;

    try {
      Method method = sysclass.getDeclaredMethod("addURL", parameters);
      method.setAccessible(true);
      method.invoke(sysloader, new Object[]{u});
    } catch (Throwable t) {
      t.printStackTrace();
      throw new IOException("Error, could not add URL to system classloader");
    }//end try catch

   }//end method

}//end class

The reflection is necessary to access the protected method addURL. This could fail if there is a SecurityManager.

1. Adding resource folder to classpath:

   When you Clean-&-Build a NetBeans Ant Based Project it creates a manifest.mf file in the root directory of the project. This file gets included in the JAR file also. Modify this file and add entry like follows:

   Manifest-Version: 1.0
   X-COMMENT: Main-Class will be added automatically by build
   Class-Path: arts/  
   

   slash is important after arts in the class path.

2. Including the arts resource folder in the distribution

   Either copy this folder in the dist folder after the build or add a ANT target to copy the required resources in the dist folder.

   Add the target like as follows in the build.xml file:

   <target name="-post-jar">
        <mkdir dir="${dist.dir}/resources"/>
        <copy todir="${dist.dir}/resources">
            <fileset dir="${basedir}/resources" />
        </copy>
    </target>
   

3. Code to access such resources:

   The code needed to access such resource files shall be as follows: (This will not work in design time but surely from the JAR file)

   // pay attention to relative path
   URL resource = ClassLoader.getSystemResource("gui/refresh.png"); 
   ImageIcon tmp = new ImageIcon(resource);
   

   NOTE: The files manifest.mf and build.xml located in the root directory of the project are accessible from the Files Panel in NetBeans IDE

You can use the following method:

URLClassLoader.addURL(URL url)

But you'll need to do this with reflection since the method is protected:

public static void addPath(String s) throws Exception {
    File f = new File(s);
    URL u = f.toURL();
    URLClassLoader urlClassLoader = (URLClassLoader) ClassLoader.getSystemClassLoader();
    Class urlClass = URLClassLoader.class;
    Method method = urlClass.getDeclaredMethod("addURL", new Class[]{URL.class});
    method.setAccessible(true);
    method.invoke(urlClassLoader, new Object[]{u});
}

See the Java Trail on Reflection. Especially the section Drawbacks of Reflection

In Eclipse, there is a build classpath and a runtime classpath. There is also the build output location, which by default is bin. You don't want to add resources directly to bin because Eclipse can delete its contents when doing a clean build. What you need to do is add a resources folder in your project to contain any non-Java files that you want included in your build output.

To include the contents of this resources folder in the build output (bin), right-click the project and select Properties. In the Project Properties, select the Java Build Path section, then the Source tab.

Use the Add Folder... button to select the resources folder from your project, then OK to save the changes. At that point, Eclipse will automatically copy everything from resources into bin when it builds.

In your source code, use the following construct:

package com.foo.package;

public class Example {
    public void loadResourceExample) {
         Example.class.getResource("/cde/FGH/SomeRandomFile.xml");
         Example.class.getResource("relative/example.xml");
    }
}

The first line will load resource "/cde/FGH/SomeRandomFile.xml" from any folder or jar mentioned in the classpath, so in your example command line, D:\WorkSpace\Testspace\MyProject\target\classes\cde\FGH\SomeRandomFile.xml would for example be scanned.

The second line takes the package name of your class into account, so, it would for example check at D:\WorkSpace\Testspace\myProject\dependency\somedep.jar for entry /com/foo/package/relative/example.xml.

Note that the * syntax in the -cp parameter will take every JAR inside the stated folder and include it in the classpath. That's all it does.

If you are not using the getResource, you're dependent on the 'current working directory' which can be anything, really, and the -cp parameter wouldn't have any effect.