Importing has nothing to do with loading classes or setting CLASSPATH.
Try this:
java -cp .;../lib/* Generator
Using the dot '.' as the first entry in the CLASSPATH assumes that the Generator.class file exists in the directory from which you're running java, and /lib is one level up from that directory. Adjust as needed if both of these are not correct.
Importing has nothing to do with loading classes or setting CLASSPATH.
Try this:
java -cp .;../lib/* Generator
Using the dot '.' as the first entry in the CLASSPATH assumes that the Generator.class file exists in the directory from which you're running java, and /lib is one level up from that directory. Adjust as needed if both of these are not correct.
You should run the program including again the same cp:
java -cp "lib directory where i put all the jars" MainClassOfYourApplication
After you compiled it with:
javac -cp "lib directory where i put all the jars" AvroReader.java
More applied to your example:
First step(compile all the needed java files): javac -cp "path/to/jars/*" AvroReader.java //here you should include all the java files not yet compiled but which you need to run your app
Second step: java -cp "path/to/jars/*" package.subpackage1.subpackage2.Generator
command line - Including all the jars in a directory within the Java classpath - Stack Overflow
Java : How to use a -classpath in the command prompt.
java - Run a JAR file from the command line and specify classpath - Stack Overflow
How do to run java class in command Line (cmd)? (use classpath) - Stack Overflow
Videos
As per my understanding you want to change the classpath which you have set by command
set classpath=d:java
can be done
in two ways either you can set classpth directly as environment varible by
--> Right click on my computer select advanced options
--> there you will see option as environment variables open that option
--> now you will see multiple variables being set...search for classpath variable if it exist
their edit this variable value by just putting semicolon and write ur full classpath ended by semicolon and save it.
FOR EG:-
variable name:- CLASSAPTH
variable value- .;C:\Oracle\product\10.1.0\Client_2\jdbc\lib\ojdbc14.jar;
Second option is just set your class in command promt as u have set earlier
by opening command prompt
set classpath=C:\Oracle\product\10.1.0\Client_2\jdbc\lib\ojdbc14.jar;
both the method are easy but i would prefer you should go with first one as by doing that you didn't need to set your classpath again and again after you reboot your system or application.
If u want to do while running your java program ,you can use
java -classpath C:\java\MyClasses utility.myapp.Cool
for more details about class path see oracle documentation about classpath.
jdk/bin/jpsshould list all the java process IDs running that system- subsequently invoke
jdk/bin/jinfo <pid>to see lot of information... what you require is also there...
No need to print the default classpath. In Java, the default classpath is just the current directory:
If -classpath and -cp are not used and CLASSPATH is not set, the user class path consists of the current directory (.).
(documentation of java:)
Note: For completeness' sake: Theree are two other paths where java will look for stuff:
- the bootstrap class path
- the extension directory
The bootstrap class path by default points to parts of the JDK, and you almost never want to mess with it (unless you want to override part of the JDK), so you probably should not worry about it. The extension directories are for extending the JDK; see http://docs.oracle.com/javase/7/docs/technotes/guides/extensions/index.html
Using Java 6 or later, the classpath option supports wildcards. Note the following:
- Use straight quotes (
") - Use
*, not*.jar
Windows
java -cp "Test.jar;lib/*" my.package.MainClass
Unix
java -cp "Test.jar:lib/*" my.package.MainClass
This is similar to Windows, but uses : instead of ;. If you cannot use wildcards, bash allows the following syntax (where lib is the directory containing all the Java archive files):
java -cp "$(printf %s: lib/*.jar)"
(Note that using a classpath is incompatible with the -jar option. See also: Execute jar file with multiple classpath libraries from command prompt)
Understanding Wildcards
From the Classpath document:
Class path entries can contain the basename wildcard character
*, which is considered equivalent to specifying a list of all the files in the directory with the extension.jaror.JAR. For example, the class path entryfoo/*specifies all JAR files in the directory named foo. A classpath entry consisting simply of*expands to a list of all the jar files in the current directory.A class path entry that contains
*will not match class files. To match both classes and JAR files in a single directory foo, use eitherfoo;foo/*orfoo/*;foo. The order chosen determines whether the classes and resources infooare loaded before JAR files infoo, or vice versa.Subdirectories are not searched recursively. For example,
foo/*looks for JAR files only infoo, not infoo/bar,foo/baz, etc.The order in which the JAR files in a directory are enumerated in the expanded class path is not specified and may vary from platform to platform and even from moment to moment on the same machine. A well-constructed application should not depend upon any particular order. If a specific order is required then the JAR files can be enumerated explicitly in the class path.
Expansion of wildcards is done early, prior to the invocation of a program's main method, rather than late, during the class-loading process itself. Each element of the input class path containing a wildcard is replaced by the (possibly empty) sequence of elements generated by enumerating the JAR files in the named directory. For example, if the directory
foocontainsa.jar,b.jar, andc.jar, then the class pathfoo/*is expanded intofoo/a.jar;foo/b.jar;foo/c.jar, and that string would be the value of the system propertyjava.class.path.The
CLASSPATHenvironment variable is not treated any differently from the-classpath(or-cp) command-line option. That is, wildcards are honored in all these cases. However, class path wildcards are not honored in theClass-Path jar-manifestheader.
Note: due to a known bug in java 8, the windows examples must use a backslash preceding entries with a trailing asterisk: https://bugs.openjdk.java.net/browse/JDK-8131329
Under Windows this works:
java -cp "Test.jar;lib/*" my.package.MainClass
and this does not work:
java -cp "Test.jar;lib/*.jar" my.package.MainClass
Notice the *.jar, so the * wildcard should be used alone.
On Linux, the following works:
java -cp "Test.jar:lib/*" my.package.MainClass
The separators are colons instead of semicolons.
So I have two different .java files in two different directories. One contains the main method which calls the other one through its method name. . This is in the directory
E:\JavaWorld\TardyCoder\temp1
Here is my program which contains the main method with the fileName Lemons.java
public class Lemons{
public static void main(String args[]){
Sorra sorraObject = new Sorra();
sorraObject.testName();
}
}My another program is in the directory
E:\JavaWorld\TardyCoder\temp2
Here is my program Sorra.java which doesn't contain the main method.
class Sorra{
public void testName(){
System.out.println("My name is Khan.");
}
}I used -sourcepath to create two .class files like this:
E:\JavaWorld\TardyCoder\temp1>javac -sourcepath E:\JavaWorld\TardyCoder\temp2 Lemons.java
Everything worked perfectly and i got two .class files in their respective directories.
Now I tried to use the -classpath to get the output like this:
E:\JavaWorld\TardyCoder\temp1>java -classpath .; E:\JavaWorld\TardyCoder\temp2 Lemons
But I'm getting an error :(
Error: Could not find or load main class E:\JavaWorld\TardyCoder\temp2
Please explain the right way to use -classpath in command prompt.
Edit: Got the answer. There should be no space after .;
When you specify -jar then the -cp parameter will be ignored.
From the documentation:
When you use this option, the JAR file is the source of all user classes, and other user class path settings are ignored.
You also cannot "include" needed jar files into another jar file (you would need to extract their contents and put the .class files into your jar file)
You have two options:
- include all jar files from the
libdirectory into the manifest (you can use relative paths there) - Specify everything (including your jar) on the commandline using
-cp:
java -cp MyJar.jar:lib/* com.somepackage.subpackage.Main
Run a jar file and specify a class path like this:
java -cp <jar_name.jar:libs/*> com.test.App
jar_name.jar is the full name of the JAR you want to execute
libs/* is a path to your dependency JARs
com.test.App is the fully qualified name of the class from the JAR that has the main(String[]) method
The jar and dependent jar should have execute permissions.