如何用命令行运行含有多个类的java程序，是全部写在一起，然后用含main的那个命名，还是别的什么方法？

设计。

在学之前来了解下，编写JAVA时要建立哪几个文件夹?

——不用建什么文件夹，只要安装好JDK。

说明每个文件夹的作用

——现在在网吧，没有JDK，没法为你解释那些文件夹。

学编写JAVA是不是英语一定要会?

——英语，初中文化就够了，虽然程序源码那么多英语，但是并不是涉及多少高级英语。

英语还有那些代码是不是要记住?

——你应该记住JAVA中的一些关键字、修饰符之类的，只要懂汉语拼音和标识符的命名规则，编写程序没有问题。

帮我推荐个编写JAVA的工具，最好是免费的。

编写JAVA程序可以用或者textpad配合JDK，也可以用JBuilder。

你们可以编个简单的程序给我看，步骤要说清楚，图就不用了。随便什么都行,步骤要清楚啊!不然我不给分哦!我爱编程网

——

public class pro //以下为pro类 含第三行的语句则说明本类为主类

{

public static viod main[String args] //这一句目前我还没学到 主类含有此句

{

char c='A'; //定义char型变量c 赋值为A

System.out.println("我要学JAVA，我可以用JAVA输出："+c); //本行将控制输出“我要学JAVA，我可以用JAVA输出：A”

}

}

将代码保存为pro.java(假设保存到C:\J\，设置好JDK的PATH和CLASSPACH环境变量后，可以运行CMD，用CD命令进入C:\J，然后使用javac命令编译*.java，如C:\J\>javac pro.java，该目录下产生一个pro.class文件。用相同办法使用java命令可以运行pro程序，如C:\J\>java pro，注意编译*.java时需要输入扩展名，运行class时没有扩展名。)

呵呵!~~~~~~~~`因为是刚入门,所以一定要说清楚步骤,拜托了各位大哥大姐!~~~~~~~~~

——呵呵，我也是刚入门，自学《java基础教程》到40页，学的还算踏实，以后我们可以互相交流讨论一下。

!我只知道这么多了

你说的三个程序是不是有main 可以独立运行的那种啊?

如果是的话你可以这样：

你可以讲main 函数名字改成 比如 start();

然后，选定一个做主程序，主程序中获取用户输入的参数 (1或2或3)

然后做个判断就可以了如下：

switch(int choose)

{

case 1: new A().start();break;

case 2: new B().start();break;

case 3: new C().start();break;

default: break;

}

进程是程序在处理机中的一次运行。一个进程既包括其所要执行的指令，也包括了执行指令所需的系统资源，不同进程所占用的系统资源相对独立。所以进程是重量级的任务，它们之间的通信和转换都需要操作系统付出较大的开销。

线程是进程中的一个实体，是被系统独立调度和分派的基本单位。线程自己基本上不拥有系统资源，但它可以与同属一个进程的其他线程共享进程所拥有的全部资源。所以线程是轻量级的任务，它们之间的通信和转换只需要较小的系统开销。

Java支持多线程编程，因此用Java编写的应用程序可以同时执行多个任务。Java的多线程机制使用起来非常方便，用户只需关注程序细节的实现，而不用担心后台的多任务系统。

Java语言里，线程表现为线程类。Thread线程类封装了所有需要的线程操作控制。在设计程序时，必须很清晰地区分开线程对象和运行线程，可以将线程对象看作是运行线程的控制面板。在线程对象里有很多方法来控制一个线程是否运行，睡眠，挂起或停止。线程类是控制线程行为的唯一的手段。一旦一个Java程序启动后，就已经有一个线程在运行。可通过调用Thread.currentThread方法来查看当前运行的是哪一个线程。

class ThreadTest{

public static void main(String args[]){

Thread t = Thread.currentThread();

t.setName("单线程"); //对线程取名为"单线程"

t.setPriority(8);

//设置线程优先级为8，最高为10，最低为1，默认为5

System.out.println("The running thread: " + t);

// 显示线程信息

try{

for(int i=0;i<3;i++){

System.out.println("Sleep time " + i);

Thread.sleep(100); // 睡眠100毫秒

}

}catch(InterruptedException e){// 捕获异常

System.out.println("thread has wrong");

}

}

}

多线程的实现方法

继承Thread类

可通过继承Thread类并重写其中的run()方法来定义线程体以实现线程的具体行为，然后创建该子类的对象以创建线程。

在继承Thread类的子类ThreadSubclassName中重写run()方法来定义线程体的一般格式为:

public class ThreadSubclassName extends Thread{

public ThreadSubclassName(){

..... // 编写子类的构造方法，可缺省

}

public void run(){

..... // 编写自己的线程代码

}

}

用定义的线程子类ThreadSubclassName创建线程对象的一般格式为:

ThreadSubclassName ThreadObject =

new ThreadSubclassName();

然后，就可启动该线程对象表示的线程：

ThreadObject.start(); //启动线程

应用继承类Thread的方法实现多线程的程序。本程序创建了三个单独的线程，它们分别打印自己的“Hello World!”。

class ThreadDemo extends Thread{

private String whoami;

private int delay;

public ThreadDemo(String s,int d){

whoami=s;

delay=d;

}

public void run(){

try{

sleep(delay);

}catch(InterruptedException e){ }

System.out.println("Hello World!" + whoami

+ " " + delay);

}

}

public class MultiThread{

public static void main(String args[]){

ThreadDemo t1,t2,t3;

t1 = new ThreadDemo("Thread1",

(int)(Math.random()*2000));

t2 = new ThreadDemo("Thread2",

(int)(Math.random()*2000));

t3 = new ThreadDemo("Thread3",

(int)(Math.random()*2000));

t1.start();

t2.start();

t3.start();

}

}

实现Runnable接口

编写多线程程序的另一种的方法是实现Runnable接口。在一个类中实现Runnable接口(以后称实现Runnable接口的类为Runnable类),并在该类中定义run()方法，然后用带有Runnable参数的Thread类构造方法创建线程。

创建线程对象可用下面的两个步骤来完成:

(1)生成Runnable类ClassName的对象

ClassName RunnableObject = new ClassName();

(2)用带有Runnable参数的Thread类构造方法创建线程对象。新创建的线程的指针将指向Runnable类的实例。用该Runnable类的实例为线程提供 run()方法---线程体。

Thread ThreadObject = new Thread(RunnableObject);

然后，就可启动线程对象ThreadObject表示的线程：

ThreadObject.start();

在Thread类中带有Runnable接口的构造方法有:

public Thread(Runnable target);

public Thread(Runnable target, String name);

public Thread(String name);

public Thread(ThreadGroup group，Runnable target);

public Thread(ThreadGroup group，Runnable target，

String name);

其中，参数Runnable target表示该线程执行时运行target的run()方法，String name以指定名字构造线程，ThreadGroup group表示创建线程组。

用Runnable接口实现的多线程。

class TwoThread implements Runnable{

TwoThread(){

Thread t1 = Thread.currentThread();

t1.setName("第一主线程");

System.out.println("正在运行的线程: " + t1);

Thread t2 = new Thread(this,"第二线程");

System.out.println("创建第二线程");

t2.start();

try{

System.out.println("第一线程休眠");

Thread.sleep(3000);

}catch(InterruptedException e){

System.out.println("第一线程有错");

}

System.out.println("第一线程退出");

}

public void run(){

try{

for(int i = 0;i < 5;i++){

System.out.println(“第二线程的休眠时间：”

+ i);

Thread.sleep(1000);

}

}catch(InterruptedException e){

System.out.println("线程有错");

}

System.out.println("第二线程退出");

}

public static void main(String args[]){

new TwoThread();

}

}

程序运行结果如下：

正在运行的线程: Thread[第一主线程,5,main

创建第二线程

第一线程休眠

第二线程的休眠时间：0

第二线程的休眠时间：1

第二线程的休眠时间：2

第一线程退出

第二线程的休眠时间：3

第二线程的休眠时间：4

第二线程退出

至于一个处理器同时处理多个程序，其实不是同时运行多个程序的，简单的说，如果是单核的CPU，在运行多个程序的时候其实是每个程序轮流占用CPU的，只是每个程序占用的时间很短，所以我们人为的感觉是“同时”运行多个程序。