Kenneth: /* Read Console */

2018-07-03T05:17:29Z

Read Console

New page

== Java ==

''"Java is a programming language originally developed by Sun Microsystems and released in 1995 as a core component of Sun Microsystems' Java platform. The language derives much of its syntax from C and C++ but has a simpler object model and fewer low-level facilities. Java applications are typically compiled to bytecode that can run on any Java virtual machine (JVM) regardless of computer architecture.''

''The original and reference implementation Java compilers, virtual machines, and class libraries were developed by Sun from 1995. As of May 2007, in compliance with the specifications of the Java Community Process, Sun made available most of their Java technologies as free software under the GNU General Public License. Others have also developed alternative implementations of these Sun technologies, such as the GNU Compiler for Java and GNU Classpath."'' [http://en.wikipedia.org/wiki/Java_programming_language]

== Subpage Table of Contents ==

{{Special:PrefixIndex/{{PAGENAME}}/}}

== Browser Plugin Version Check ==

Verify Java Browser Plugin Version - http://www.java.com/en/download/installed.jsp

== Duke - Mascot ==

<img src="http://upload.wikimedia.org/wikipedia/commons/4/41/Duke_Wave.png" height="200"/>

== Hello World ==

Hello.java:
<pre>
public class Hello {
public static void main(String args[]) {
System.out.println("Hello World!\n");
}
}
</pre>

Compile and execute:
<pre>
javac Hello.java
java Hello
</pre>

Note: If your file has a "public" class, file name should match the public class name, or you will get this error:
HelloWorld.java:3: error: class Hello is public, should be declared in a file named Hello.java

=== Hello World Package Version ===

Package version:

World/Hello.java
<pre>
package World;

public class Hello {
public static void main(String args[]) {
System.out.println("Hello World!\n");
}
}
</pre>

Compile and execute:
<pre>
javac World/Hello.java
java World.Hello
</pre>

== Execution Commands ==

Compile:
java -cp [classpath] [package]\[class].java
java -cp . test.java

Execute:
java -cp [classpath] [package].[class]
java -cp . test

References:
*[http://www.javacoffeebreak.com/java101/java101.html Java Coffee Break: Java 101 : Hello World]

== Jar ==

Build jar:
jar cf jar-file input-files
jar cvf [NAME].jar [file.class] [folder] ...
jar cvf Hi.jar Hello.class

Execute a jar:
java -classpath Program.jar MyMainClass

Auto start main class using a manifest [http://stackoverflow.com/questions/2591516/why-its-failed-to-load-main-class-manifest-attribute-from-jar-file] [http://download.oracle.com/javase/tutorial/deployment/jar/appman.html]

Build with manifeset:
jar cfm app.jar manifest.txt *.class

manifest.txt:
Main-Class: MyMainClass

Execute:
java -jar app.jar

== Compile ==

Layout:
\doc
\bin
\lib
\src

Compile:
set PATH=%PATH%;"c:\Program Files\Java\jdk1.7.0_17\bin"
C:\dev\risk\riskGamePlayer> javac -cp lib\gson-2.2.2.jar -sourcepath src -d bin src\Main.java

Execute:
set PATH=%PATH%;"c:\Program Files\Java\jdk1.7.0_17\bin"
C:\dev\risk\riskGamePlayer> java -cp lib\gson-2.2.2.jar;bin Main

== Installation ==

Java SE JDK
sh jdk-6u25-linux-x64-rpm.bin

Installed to:
/usr/java/jdk1.6.0_25

Path:
export PATH=/usr/java/jdk1.6.0_25/bin:$PATH

== Alternative ==

rpm -Uvh /path/to/binary/jdk-7u55-linux-x64.rpm

alternatives --install /usr/bin/java java /usr/java/latest/jre/bin/java 200000

/usr/sbin/alternatives --display java

/usr/sbin/alternatives --config java

References:
* How to Install Java 7 (JDK 7u55) on CentOS/RHEL 6/5 & Fedora - http://tecadmin.net/steps-to-install-java-on-centos-5-6-or-rhel-5-6/#
* Install Oracle Java JDK/JRE 7u55 on Fedora 20/19, CentOS/RHEL 6.5/5.10 - http://www.if-not-true-then-false.com/2010/install-sun-oracle-java-jdk-jre-7-on-fedora-centos-red-hat-rhel/
* Appendix A. Installing a Java Development Kit on Red Hat Enterprise Linux - https://access.redhat.com/site/documentation/en-US/JBoss_Enterprise_SOA_Platform/4.3/html/Getting_Started_Guide/appe-install_jdk_rhel.html

== Editors ==

*[http://www.eclipse.org/ Eclipse]

*[http://www.jetbrains.com/idea/ IntelliJ IDEA]

*[http://www.jedit.org/ jEdit]

*[http://www.netbeans.info/ NetBeans IDE]
*[http://www.netbeans.info/downloads/index.php NetBeans IDE Download]
** NetBeans Hello World : [http://java.sun.com/docs/books/tutorial/getStarted/cupojava/netbeans.html "Hello World!" for the
NetBeans IDE (The Java™ Tutorials > Getting Started > The "Hello World!" Application)]

== Code ==

=== Comments ===

The Java programming language supports three kinds of comments: [http://java.sun.com/docs/books/tutorial/getStarted/application/index.html]

/* text */
:The compiler ignores everything from /* to */.

/** documentation */
:This indicates a documentation comment (doc comment, for short). The compiler ignores this kind of comment, just like it ignores comments that use /* and */. The javadoc tool uses doc comments when preparing automatically generated documentation. For more information on javadoc, see the JavadocTM tool documentation .

// text
:The compiler ignores everything from // to the end of the line.

=== Import ===

import java.util.*; // Data structures (Collections), time, Scanner, etc classes.
import java.io.*; // Input-output classes.

=== Print ===

System.out.print("Hello World"); // does not include new line
System.out.println("Hello World"); // includes new line
System.out.format("Hello %s\n", name); // format output with format parameters

=== String ===

System.out.println("Hello World");
System.out.println("Hello " + "World");
String message = "Hello World";
System.out.println("Message: " + message);

=== For Each ===

for (String arg: args) { System.out.format("Arg: %s", arg); }

=== Exit ===

System.exit(0); // return code of 0
System.exit(1); // return code of 1

=== Command Line Arguments ===

<pre>
// Programmed by Kenneth Burgener <kenneth@kennethburgener.org> (2012)
public class ArgList {
public static void main(String args[]) {
String className = ArgList.class.getName();
System.out.format("Program: %s\n", className);
System.out.format("Arg Count: %d\n", args.length);
if(args.length < 1) {
System.out.println("No Arguments");
}
for (String arg: args) {
System.out.format("Arg: %s\n", arg);
}
}
}
</pre>

References:
* $0 (Program Name) in Java? Discover main class? - Stack Overflow - http://stackoverflow.com/questions/41894/0-program-name-in-java-discover-main-class
* Command-Line Arguments (The Java™ Tutorials > Essential Classes > The Platform Environment) - http://docs.oracle.com/javase/tutorial/essential/environment/cmdLineArgs.html

=== Try Catch ===

<pre>
try {
...
} catch (ExceptionType name) {
...
} catch (ExceptionType|ExceptionType name) {
...
} finally {
...
}
</pre>

<pre>
try {
firstArg = Integer.parseInt(args[0]);
} catch (NumberFormatException ex) {
System.err.println("Argument" + " must be an integer");
System.exit(1);
//logger.log(ex);
//throw ex;
}
</pre>

=== System.out.print ===

System.out.println("enter an integer: ");
System.out.print("enter an integer: \n");

<pre>
public void sayHello(String message) {
System.out.println(message);
}
</pre>

=== System.in.read ===

BufferedReader buffer=new BufferedReader(new InputStreamReader(System.in));
String line=buffer.readLine();

Scanner scan=new Scanner(System.in);

ReadingLine class: http://terokarvinen.com/readline_in_java.html
<pre>
import java.io.*;
class ReadingLine{
public static String readLine()
{
String s = "";
try {
InputStreamReader converter = new InputStreamReader(System.in);
BufferedReader in = new BufferedReader(converter);
s = in.readLine();
} catch (Exception e) {
System.out.println("Error! Exception: "+e);
}
return s;
}
public static void main(String[] args)
{
System.out.print("Hello, what's your name? ");
String name=readLine();
System.out.println("Hello "+name+"!");
}
}
</pre>

== Advanced Code ==

=== Reflection ===

<pre>
Object methodCaller(Object theObject, String methodName) {
try {
return theObject.getClass().getMethod(methodName).invoke(theObject);
} catch (Exception e) {
System.err.println("Exception caught: " + e);
System.exit(1);
}
return null;
}

// use it
String theDescription = methodCaller(object1, "toString");
Class theClass = methodCaller(object2, "getClass");
</pre>

My example:
<pre>
public class Test {
public static void main(String args[]) {
Test test = new Test();
test.methodCaller(test, "callme", "test", 1);
}

public void callme(String message, int number) {
System.out.println("Message: " + message);
System.out.println("Number: " + number);
}

Object methodCaller(Object theObject, String methodName, String message, int number) {
try {
return theObject.getClass().getMethod(methodName,
String.class, Integer.TYPE).invoke(theObject, message, number);
} catch (Exception e) {
System.err.println("Exception caught: " + e);
System.exit(1);
}
return null;
}
}
</pre>

References:
* Function Pointers in Java - Stack Overflow - http://stackoverflow.com/questions/1073358/function-pointers-in-java
* reflection - How do I invoke a Java method when given the method name as a string? - Stack Overflow - http://stackoverflow.com/questions/160970/how-do-i-invoke-a-java-method-when-given-the-method-name-as-a-string
* reflection - Does int.class equal Integer.class or Integer.TYPE in Java? - Stack Overflow - http://stackoverflow.com/questions/7082997/does-int-class-equal-integer-class-or-integer-type-in-java

=== Callback Method ===

Callback functions in Java - Stack Overflow - http://stackoverflow.com/questions/443708/callback-functions-in-java

=== Pass a function as an argument ===

A common pattern would be to 'wrap' it within an interface, like Callable, for example, then you pass in a Callable:
<pre>
public T myMethod(Callable<T> func) {
return func.call();
}
</pre>
This pattern is known as the [http://en.wikipedia.org/wiki/Command_pattern Command Pattern].

---

You could use Java reflection to do this. The method would be represented as an instance of java.lang.reflect.Method.

<pre>
import java.lang.reflect.Method;

public class Demo {

public static void main(String[] args) throws Exception{
Class[] parameterTypes = new Class[1];
parameterTypes[0] = String.class;
Method method1 = Demo.class.getMethod("method1", parameterTypes);

Demo demo = new Demo();
demo.method2(demo, method1, "Hello World");
}

public void method1(String message) {
System.out.println(message);
}

public void method2(Object object, Method method, String message) throws Exception {
Object[] parameters = new Object[1];
parameters[0] = message;
method.invoke(object, parameters);
}

}
</pre>

---

References:
* How to pass a function as a parameter in Java? - Stack Overflow - http://stackoverflow.com/questions/4685563/how-to-pass-a-function-as-a-parameter-in-java

== CLI JUnit ==

Command Line Interface (CLI) JUnit

<pre>
//Program: myTestSuite2.java

import junit.framework.*;

public class myTestSuite extends TestCase {

public static Test suite() {
TestSuite suite = new TestSuite();

// TEST SUITES
suite.addTest(myTestSuite2.suite());

// TEST CASES
suite.addSuite(myTestCase.class);

return suite;
}

public static void main(String[] args) {
try {
Test test = suite();
junit.text.ui.TestRunner.run(test);
} catch (Exception ex) {
ex.printStackTrace();
}
}

}
</pre>

<pre>
// myTestCase
import junit.framework.TestCase;
public class myTestCase extends TestCase {
public void testMyTest() {
// assert ...
}
}
</pre>

to run:
<pre>
# javac -cp ./:./junit.jar myTestSuite.java
# java -cp ./:./junit.jar myTestSuite
</pre>

== Examples ==

=== Read Password ===

<pre>
private String readLine(String format, Object... args) throws IOException {
if (System.console() != null) {
return System.console().readLine(format, args);
}
System.out.print(String.format(format, args));
BufferedReader reader = new BufferedReader(new InputStreamReader(
System.in));
return reader.readLine();
}

private char[] readPassword(String format, Object... args)
throws IOException {
if (System.console() != null)
return System.console().readPassword(format, args);
return this.readLine(format, args).toCharArray();
}
</pre>

source: java - System.console() returns null - Stack Overflow - http://stackoverflow.com/questions/4203646/system-console-returns-null

=== Read Console ===

<pre>
import java.util.Scanner;

Scanner in;
in = new Scanner(System.in);
String s = in.nextLine();
in.close();
</pre>

This works in Eclipse too, where System.console() won't.

== List Classes in JAR ==

You can use Java jar tool. List the content of jar file in a txt file and you can see all the classes in the jar. [https://stackoverflow.com/questions/15720822/how-to-get-names-of-classes-inside-a-jar-file]

jar tvf jarfile.jar

== keywords ==

Java - Revision history

Kenneth: /* Read Console */