① 求java製作小程序方法
Java Applet程序開發步驟
Java Applet程序開發主要步驟如下：
1)選用EDIT或WindowsNotepad等工具作為編輯器建立Java Applet源程序。
2)把Java Applet的源程序轉換為位元組碼文件。
3)編制使用class的HTML文件。在HTML文件內放入必要的＜Java Applet＞語句。
下面舉一個最簡單的HelloWorld例子來說明Java Applet程序的開發過程：
(1)編輯Java Applet的java源文件
創建文件夾C:ghq，在該文件夾下建立HelloWorld.java
文件的源代碼如下：
importjava.awt.*;
importjava.JavaApplet.*;
//繼承Appelet類，這是AppeletJava程序的特點
{
publicvoidpaint(Graphicsg)
{
g.drawString("HelloWorld!",5,35)；
}
}
保存上述程序在C:ghqHelloWorld.java文件里。
(2)編譯Java Applet
編譯HelloWorld.java源文件可使用如下JDK命令：
C:ghq＞javacHelloWorld.java＜Enter＞
注意：如果編寫的源程序違反了Java編程語言的語法規則，Java編譯器將在屏幕上顯示語法錯誤提示信息。源文件中必須不含任何語法錯誤，Java編譯器才能成功地把源程序轉換為Java Appletviewer和瀏覽器能夠執行的位元組碼程序。
成功地編譯Java Applet之後生成響應的位元組碼文件HelloWorld.class的文件。用資源管理器或DIR命令列出目錄列表，將會發現目錄C:ghq中多了一個名為HelloWorld.class的文件。
(3)創建HTML文件
在運行創建的HelloWorld.class之前，還需創建一個HTML文件，Java Appletviewer或瀏覽器將通過該文件訪問創建的Java Applet。為運行HelloWorld.class,需要創建包含如下HTML語句的名為HelloWorld.html的文件。
＜HTML＞
＜TITLE＞HelloWorld!JavaApplet＜/TITLE＞
＜JavaApplet
CODE="JavaWorld.class"
WIDTH=200
HEIGHT=100＞
＜/JavaApplet＞
＜/HTML＞
本例中，＜Java Applet＞語句指明該Java Applet位元組碼類文件名和以像素為單位的窗口的尺寸。雖然這里HTML文件使用的文件名為HelloWorld.HTML，它對應於HelloWorld.java的名字，但這種對應關系不是必須的，可以用其他的任何名字(比如說Ghq.HTML)命名該HTML文件。但是使文件名保持一種對應關系可給文件的管理帶來方便。
(4)執行HelloWorld.html
如果用Java Appletviewer運行HelloWorld.html,需輸入如下的命令行：
C:ghq＞JavaAppletviewerJavaWorld.html＜ENTER＞
可以看出，該命令啟動了Java Appletviewer並指明了HTML文件，該HTML文件中包含對應於HelloWorld的＜Java Applet＞語句。
如果用瀏覽器運行HelloWorldJava Applet,需在瀏覽器的地址欄中輸入HTML文件URL地址。
至此，一個Java Applet程序的開發運行整個過程結束了(包括java源文件、編譯的class文件、html文件以及用Java Appletviewer或用瀏覽器運行)。
② java習題：編寫一個數據報通信程序,一端發送一個int型數據10000,另一端接收到發送的數據並將
importjava.io.DataInputStream;
importjava.io.DataOutputStream;
importjava.io.IOException;
importjava.io.InputStream;
importjava.io.OutputStream;
importjava.net.ServerSocket;
importjava.net.Socket;
publicclassSocketTest{
publicstaticvoidmain(String[]args){
newServerThread().start();
newClientThread().start();
}
{
privateInputStreaminputStream;
;
publicvoidrun(){
try{
initServer();
doServer();
}catch(IOExceptione){
e.printStackTrace();
}finally{
closeServer();
}
}
privatevoidinitServer()throwsIOException{
ServerSocketsocket=newServerSocket(8899);
Socketaccept=socket.accept();
inputStream=accept.getInputStream();
}
privatevoiddoServer()throwsIOException{
DataInputStreamdis=newDataInputStream(inputStream);
while(dis.available()>0){
System.out.println(dis.readInt());
}
}
privatevoidcloseServer(){
if(inputStream!=null){
try{
inputStream.close();
}catch(IOExceptione){
e.printStackTrace();
}
}
}
}
{
privateInputStreaminputStream;
;
publicvoidrun(){
try{
initClient();
doClient();
}catch(IOExceptione){
e.printStackTrace();
}finally{
closeClient();
}
}
privatevoidinitClient()throwsIOException{
Socketsocket=newSocket("localhost",8899);
outputStream=socket.getOutputStream();
}
privatevoiddoClient()throwsIOException{
DataOutputStreamdos=newDataOutputStream(outputStream);
dos.writeInt(10000);
dos.writeInt(10001);
dos.writeInt(10002);
dos.flush();
}
privatevoidcloseClient(){
if(outputStream!=null){
try{
outputStream.close();
}catch(IOExceptione){
e.printStackTrace();
}
}
}
}
}
③ JAVA小程序 錯誤：錯誤：僅當顯式請求注釋處理時才接受類名稱「ShiYan.html」 簡單招呼小應用程序常式！！
沒有發現任何問題。用你的程序可以正常運行。
運行applet需要appletviewer或是瀏覽器或是注釋運行。
④ Java問題,文件File類問題,書上的一個常式看不懂,求教~
1、程序的功能是輸入一個文件夾路徑，遞歸列出該文件夾下的所有文件。
2、File pathName = new File(args[0]);是新建一個以args[0]為路徑的文件對象。agrs是命令行執行java程序的參數。比如改程序，編譯成class文件後，命令行進入class文件所在的目錄下，輸入java FindDirectories d:/test，「d:/test」就是args String數組第一個值，即args[0]為d:/test
3、是賦值的意思，不過這里的「..」在文件上表示上層目錄
4、這里就是遞歸調用了（自己調用自己）。在判斷一個文件對象是文件夾路徑的話（if (f.isDirectory()），就再次調用main方法，列出此文件夾的文件。
5、參見2。
⑤ 用java實現一個模擬操作系統內核運行的程序。（1）進程式控制制：其中包括進程創建與撤銷
在編寫Java程序時，有時候需要在Java程序中執行另外一個程序。
1、啟動程序Java提供了兩種方法用來啟動其它程序：
（1）使用Runtime的exec（）方法
（2）使用ProcessBuilder的start（）方法
不管在哪種操作系統下，程序具有基本類似的一些屬性。一個程序啟動後就程序操作系統的一個進程，進程在執行的時候有自己的環境變數、有自己的工作目錄。Runtime和ProcessBuilder提供了不同的方式來啟動程序，設置啟動參數、環境變數和工作目錄。
能夠在Java中執行的外部程序，必須是一個實際存在的可執行文件，對於shell下的內嵌命令是不能直接執行的。
採用Runtime的exec執行程序時，首先要使用Runtime的靜態方法得到一個Runtime，然後調用Runtime的exec方
法。可以將要執行的外部程序和啟動參數、環境變數、工作目錄作為參數傳遞給exec方法，該方法執行後返回一個Process代表所執行的程序。
Runtime有六個exec方法，其中兩個的定義為：
public Process exec（String[] cmdarray， String[] envp， File dir）
public Process exec（String command， String[] envp， File dir）
cmdarray和command為要執行的命令，可以將命令和參數作為一個字元串command傳遞給exec（）方法，也可以將命令和參數一個一個的方在數組cmdarray里傳遞給exec（）方法。
envp為環境變數，以name=value的形式放在數組中。dir為工作目錄。
可以不要dir參數，或者不要envp和dir參數，這樣就多出了其它4個exec（）方法。如果沒有dir參數或者為null，那麼新啟動的
進程就繼承當前java進程的工作目錄。如果沒有envp參數或者為null，那麼新啟動的進程就繼承當前java進程的環境變數。
也可以使用ProcessBuilder類啟動一個新的程序，該類是後來添加到JDK中的，而且被推薦使用。通過構造函數設置要執行的命令以及
參數，或者也可以通過command（）方法獲取命令信息後在進行設置。通過directory（File directory）
方法設置工作目錄，通過environment（）獲取環境變數信息來修改環境變數。
在使用ProcessBuilder構造函數創建一個新實例，設置環境變數、工作目錄後，可以通過start（）方法來啟動新程序，與Runtime的exec（）方法一樣，該方法返回一個Process對象代表啟動的程序。
ProcessBuilder與Runtime.exec（）方法的不同在於ProcessBuilder提供了
redirectErrorStream（boolean redirectErrorStream）
方法，該方法用來將進程的錯誤輸出重定向到標准輸出里。即可以將錯誤輸出都將與標准輸出合並。
2、Process
不管通過那種方法啟動進程後，都會返回一個Process類的實例代表啟動的進程，該實例可用來控制進程並獲得相關信息。Process 類提供了執行從進程輸入、執行輸出到進程、等待進程完成、檢查進程的退出狀態以及銷毀（殺掉）進程的方法：
（1） void destroy（）
殺掉子進程。
一般情況下，該方法並不能殺掉已經啟動的進程，不用為好。
（2） int exitValue（）
返回子進程的出口值。
只有啟動的進程執行完成、或者由於異常退出後，exitValue（）方法才會有正常的返回值，否則拋出異常。
（3）InputStream getErrorStream（）
獲取子進程的錯誤流。
如果錯誤輸出被重定向，則不能從該流中讀取錯誤輸出。
（4）InputStream getInputStream（）
獲取子進程的輸入流。
可以從該流中讀取進程的標准輸出。
（5）OutputStream getOutputStream（）
獲取子進程的輸出流。
寫入到該流中的數據作為進程的標准輸入。
（6） int waitFor（）
導致當前線程等待，如有必要，一直要等到由該 Process 對象表示的進程已經終止。
通過該類提供的方法，可以實現與啟動的進程之間通信，達到交互的目的。
3、從標准輸出和錯誤輸出流讀取信息
從啟動其他程序的Java進程看，已啟動的其他程序輸出就是一個普通的輸入流，可以通過getInputStream（）和getErrorStream來獲取。
對於一般輸出文本的進程來說，可以將InputStream封裝成BufferedReader，然後就可以一行一行的對進程的標准輸出進行處理。
4、舉例
（1）Runtime.exec（）import java.io.BufferedReader;
import java.io.File;
import java.io.InputStreamReader;
public class Test1 {
public static void main(String[] args) {
try {
Process p = null;
String line = null;
BufferedReader stdout = null;
//list the files and directorys under C:\
p = Runtime.getRuntime().exec("CMD.exe /C dir", null, new File("C:\\"));
stdout = new BufferedReader(new InputStreamReader(p
.getInputStream()));
while ((line = stdout.readLine()) != null) {
System.out.println(line);
}
stdout.close();
//echo the value of NAME
p = Runtime.getRuntime().exec("CMD.exe /C echo %NAME%", new String[] {"NAME=TEST"});
stdout = new BufferedReader(new InputStreamReader(p
.getInputStream()));
while ((line = stdout.readLine()) != null) {
System.out.println(line);
}
stdout.close();
} catch (Exception e) {
e.printStackTrace();
}
}
（2）ProcessBuilderimport java.io.BufferedReader;
import java.io.File;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;
public class Test2 {
public static void main(String[] args) {
try {
List list = new ArrayList();
ProcessBuilder pb = null;
Process p = null;
String line = null;
BufferedReader stdout = null;
//list the files and directorys under C:\
list.add("CMD.EXE");
list.add("/C");
list.add("dir");
pb = new ProcessBuilder(list);
pb.directory(new File("C:\\"));
p = pb.start();
stdout = new BufferedReader(new InputStreamReader(p
.getInputStream()));
while ((line = stdout.readLine()) != null) {
System.out.println(line);
}
stdout.close();
//echo the value of NAME
pb = new ProcessBuilder();
mand(new String[] {"CMD.exe", "/C", "echo %NAME%"});
pb.environment().put("NAME", "TEST");
p = pb.start();
stdout = new BufferedReader(new InputStreamReader(p
.getInputStream()));
while ((line = stdout.readLine()) != null) {
System.out.println(line);
}
stdout.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
5、獲取進程的返回值
通常，一個程序/進程在執行結束後會向操作系統返回一個整數值，0一般代表執行成功，非0表示執行出現問題。有兩種方式可以用來獲取進程的返回
值。一是利用waitFor()，該方法是阻塞的，執導進程執行完成後再返回。該方法返回一個代表進程返回值的整數值。另一個方法是調用
exitValue()方法，該方法是非阻塞的，調用立即返回。但是如果進程沒有執行完成，則拋出異常。
6、阻塞的問題
由Process代表的進程在某些平台上有時候並不能很好的工作，特別是在對代表進程的標准輸入流、輸出流和錯誤輸出進行操作時，如果使用不慎，有可能導致進程阻塞，甚至死鎖。
如果將以上事例中的從標准輸出重讀取信息的語句修改為從錯誤輸出流中讀取：stdout = new BufferedReader(new InputStreamReader(p
.getErrorStream()));
那麼程序將發生阻塞，不能執行完成，而是hang在那裡。
當進程啟動後，就會打開標准輸出流和錯誤輸出流准備輸出，當進程結束時，就會關閉他們。在以上例子中，錯誤輸出流沒有數據要輸出，標准輸出流中
有數據輸出。由於標准輸出流中的數據沒有被讀取，進程就不會結束，錯誤輸出流也就不會被關閉，因此在調用readLine()方法時，整個程序就會被阻
塞。為了解決這個問題，可以根據輸出的實際先後，先讀取標准輸出流，然後讀取錯誤輸出流。
但是，很多時候不能很明確的知道輸出的先後，特別是要操作標准輸入的時候，情況就會更為復雜。這時候可以採用線程來對標准輸出、錯誤輸出和標准輸入進行分別處理，根據他們之間在業務邏輯上的關系決定讀取那個流或者寫入數據。
針對標准輸出流和錯誤輸出流所造成的問題，可以使用ProcessBuilder的redirectErrorStream()方法將他們合二為一，這時候只要讀取標准輸出的數據就可以了。
當在程序中使用Process的waitFor()方法時，特別是在讀取之前調用waitFor()方法時，也有可能造成阻塞。可以用線程的方法來解決這個問題，也可以在讀取數據後，調用waitFor()方法等待程序結束。
總之，解決阻塞的方法應該有兩種：
（1）使用ProcessBuilder類，利用redirectErrorStream方法將標准輸出流和錯誤輸出流合二為一，在用start()方法啟動進程後，先從標准輸出中讀取數據，然後調用waitFor()方法等待進程結束。
如：import java.io.BufferedReader;
import java.io.File;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;
public class Test3 {
public static void main(String[] args) {
try {
List list = new ArrayList();
ProcessBuilder pb = null;
Process p = null;
String line = null;
BufferedReader stdout = null;
//list the files and directorys under C:\
list.add("CMD.EXE");
list.add("/C");
list.add("dir");
pb = new ProcessBuilder(list);
pb.directory(new File("C:\\"));
//merge the error output with the standard output
pb.redirectErrorStream(true);
p = pb.start();
//read the standard output
stdout = new BufferedReader(new InputStreamReader(p
.getInputStream()));
while ((line = stdout.readLine()) != null) {
System.out.println(line);
}
int ret = p.waitFor();
System.out.println("the return code is " + ret);
stdout.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
（2）使用線程import java.util.*;
import java.io.*;
class StreamWatch extends Thread {
InputStream is;
String type;
List output = new ArrayList();
boolean debug = false;
StreamWatch(InputStream is, String type) {
this(is, type, false);
}
StreamWatch(InputStream is, String type, boolean debug) {
this.is = is;
this.type = type;
this.debug = debug;
}
public void run() {
try {
PrintWriter pw = null;
InputStreamReader isr = new InputStreamReader(is);
BufferedReader br = new BufferedReader(isr);
String line = null;
while ((line = br.readLine()) != null) {
output.add(line);
if (debug)
System.out.println(type + ">" + line);
}
if (pw != null)
pw.flush();
} catch (IOException ioe) {
ioe.printStackTrace();
}
}
public List getOutput() {
return output;
}
}
public class Test5 {
public static void main(String args[]) {
try {
List list = new ArrayList();
ProcessBuilder pb = null;
Process p = null;
// list the files and directorys under C:\
list.add("CMD.EXE");
list.add("/C");
list.add("dir");
pb = new ProcessBuilder(list);
pb.directory(new File("C:\\"));
p = pb.start();
// process error and output message
StreamWatch errorWatch = new StreamWatch(p.getErrorStream(),
"ERROR");
StreamWatch outputWatch = new StreamWatch(p.getInputStream(),
"OUTPUT");
// start to watch
errorWatch.start();
outputWatch.start();
//wait for exit
int exitVal = p.waitFor();
//print the content from ERROR and OUTPUT
System.out.println("ERROR: " + errorWatch.getOutput());
System.out.println("OUTPUT: " + outputWatch.getOutput());
System.out.println("the return code is " + exitVal);
} catch (Throwable t) {
t.printStackTrace();
}
}
}
7、在Java中執行Java程序
執行一個Java程序的關鍵在於：
（1）知道JAVA虛擬機的位置，即java.exe或者java的路徑
（2）知道要執行的java程序的位置
（3）知道該程序所依賴的其他類的位置
舉一個例子，一目瞭然。
（1）待執行的Java類public class MyTest {
public static void main(String[] args) {
System.out.println("OUTPUT one");
System.out.println("OUTPUT two");
System.err.println("ERROR 1");
System.err.println("ERROR 2");
for(int i = 0; i < args.length; i++)
{
System.out.printf("args[%d] = %s.", i, args[i]);
}
}
}
（2）執行該類的程序
import java.util.*;
import java.io.*;
class StreamWatch extends Thread {
InputStream is;
String type;
List output = new ArrayList();
boolean debug = false;
StreamWatch(InputStream is, String type) {
this(is, type, false);
}
StreamWatch(InputStream is, String type, boolean debug) {
this.is = is;
this.type = type;
this.debug = debug;
}
public void run() {
try {
PrintWriter pw = null;
InputStreamReader isr = new InputStreamReader(is);
BufferedReader br = new BufferedReader(isr);
String line = null;
while ((line = br.readLine()) != null) {
output.add(line);
if (debug)
System.out.println(type + ">" + line);
}
if (pw != null)
pw.flush();
} catch (IOException ioe) {
ioe.printStackTrace();
}
}
public List getOutput() {
return output;
}
}
public class Test6 {
public static void main(String args[]) {
try {
List list = new ArrayList();
ProcessBuilder pb = null;
Process p = null;
String java = System.getProperty("java.home") + File.separator + "bin" + File.separator + "java";
String classpath = System.getProperty("java.class.path");
// list the files and directorys under C:\
list.add(java);
list.add("-classpath");
list.add(classpath);
list.add(MyTest.class.getName());
list.add("hello");
list.add("world");
list.add("good better best");
pb = new ProcessBuilder(list);
p = pb.start();
System.out.println(mand());
// process error and output message
StreamWatch errorWatch = new StreamWatch(p.getErrorStream(),
"ERROR");
StreamWatch outputWatch = new StreamWatch(p.getInputStream(),
"OUTPUT");
// start to watch
errorWatch.start();
outputWatch.start();
//wait for exit
int exitVal = p.waitFor();
//print the content from ERROR and OUTPUT
System.out.println("ERROR: " + errorWatch.getOutput());
System.out.println("OUTPUT: " + outputWatch.getOutput());
System.out.println("the return code is " + exitVal);
} catch (Throwable t) {
t.printStackTrace();
}
}
}
⑥ java編程，怎麼做個計算帶未知數的程序
a:b=c:?d; 封裝後的參數就這么簡單
簡單常式 這個是數學公式： d=c*(b/a);
已知 a,b,c 求未知數 d 的值
floatequation(floata,floatb,floatc){
return(float)c*(b/a);
}
⑦ JAVA中的分頁程序怎樣編寫
轉一個
jsp分頁
<%@ page contentType="text/html;charset=8859_1" %>
<%
//變數聲明
java.sql.Connection sqlCon; //資料庫連接對象
java.sql.Statement sqlStmt; //SQL語句對象
java.sql.ResultSet sqlRst; //結果集對象
java.lang.String strCon; //資料庫連接字元串
java.lang.String strSQL; //SQL語句
int intPageSize; //一頁顯示的記錄數
int intRowCount; //記錄總數
int intPageCount; //總頁數
int intPage; //待顯示頁碼
java.lang.String strPage;
int i;
//設置一頁顯示的記錄數
intPageSize = 2;
//取得待顯示頁碼
strPage = request.getParameter("page");
if(strPage==null){//表明在QueryString中沒有page這一個參數，此時顯示第一頁數據
intPage = 1;
}
else{//將字元串轉換成整型
intPage = java.lang.Integer.parseInt(strPage);
if(intPage<1) intPage = 1;
}
//裝載JDBC驅動程序
java.sql.DriverManager.registerDriver(new oracle.jdbc.driver.OracleDriver());
//設置資料庫連接字元串
strCon = "jdbc:oracle:thin:@linux:1521:ora4cweb";
//連接資料庫
sqlCon = java.sql.DriverManager.getConnection(strCon,"hzq","hzq");
//創建一個可以滾動的只讀的SQL語句對象
sqlStmt = sqlCon.createStatement(java.sql.ResultSet.TYPE_SCROLL_INSENSITIVE,java.sql.ResultSet.CONCUR_READ_ONLY);
//准備SQL語句
strSQL = "select name,age from test";
//執行SQL語句並獲取結果集
sqlRst = sqlStmt.executeQuery(strSQL);
//獲取記錄總數
sqlRst.last();
intRowCount = sqlRst.getRow();
//記算總頁數
intPageCount = (intRowCount+intPageSize-1) / intPageSize;
//調整待顯示的頁碼
if(intPage>intPageCount) intPage = intPageCount;
%>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=gb2312">
<title>JSP資料庫操作常式 - 數據分頁顯示 - JDBC 2.0 - Oracle</title>
</head>
<body>
<table border="1" cellspacing="0" cellpadding="0">
<tr>
<th>姓名</th>
<th>年齡</th>
</tr>
<%
if(intPageCount>0){
//將記錄指針定位到待顯示頁的第一條記錄上
sqlRst.absolute((intPage-1) * intPageSize + 1);
//顯示數據
i = 0;
while(i<intPageSize && !sqlRst.isAfterLast()){
%>
<tr>
<td><%=sqlRst.getString(1)%></td>
<td><%=sqlRst.getString(2)%></td>
</tr>
<%
sqlRst.next();
i++;
}
}
%>
</table>
第<%=intPage%& gt;頁 共<%=intPageCount%>頁 <%if(intPage<intPageCount){%><a href="jdbc20-oracle.jsp?page=<%=intPage+1%>">下一頁</a>& lt;%}%> <%if(intPage>1){%><a href="jdbc20-oracle.jsp?page=<%=intPage-1%>">上一頁</a>& lt;%}%>
</body>
</html>
<%
//關閉結果集
sqlRst.close();
//關閉SQL語句對象
sqlStmt.close();
//關閉資料庫
sqlCon.close();
%>
⑧ java運行的五個步驟
Java程序從源文件創建到程序運行要經過兩大步驟：1、源文件由編譯器編譯成位元組碼（ByteCode）
2、位元組碼由java虛擬機解釋運行。因為java程序既要編譯同時也要經過JVM的解釋運行，所以說Java被稱為半解釋語言（ "semi-interpreted" language）。
下面通過以下這個java程序，來說明java程序從編譯到最後運行的整個流程。代碼如下：
//MainApp.java
public class MainApp {
public static void main(String[] args) {
Animal animal = new Animal("Puppy");
animal.printName();
}
}
//Animal.java
public class Animal {
public String name;
public Animal(String name) {
this.name = name;
}
public void printName() {
System.out.println("Animal ["+name+"]");
}
}
第一步(編譯): 創建完源文件之後，程序會先被編譯為.class文件。Java編譯一個類時，如果這個類所依賴的類還沒有被編譯，編譯器就會先編譯這個被依賴的類，然後引用，否則直接引用，這個有點象make。如果java編譯器在指定目錄下找不到該類所其依賴的類的.class文件或者.java源文件的話，編譯器話報「cant find symbol」的錯誤。
編譯後的位元組碼文件格式主要分為兩部分：常量池和方法位元組碼。常量池記錄的是代碼出現過的所有token(類名，成員變數名等等)以及符號引用（方法引用，成員變數引用等等）；方法位元組碼放的是類中各個方法的位元組碼。下面是MainApp.class通過反匯編的結果，我們可以清楚看到.class文件的結構：
第二步（運行）：java類運行的過程大概可分為兩個過程：1、類的載入 2、類的執行。需要說明的是：JVM主要在程序第一次主動使用類的時候，才會去載入該類。也就是說，JVM並不是在一開始就把一個程序就所有的類都載入到內存中，而是到不得不用的時候才把它載入進來，而且只載入一次。
下面是程序運行的詳細步驟：
在編譯好java程序得到MainApp.class文件後，在命令行上敲java AppMain。系統就會啟動一個jvm進程，jvm進程從classpath路徑中找到一個名為AppMain.class的二進制文件，將MainApp的類信息載入到運行時數據區的方法區內，這個過程叫做MainApp類的載入。
然後JVM找到AppMain的主函數入口，開始執行main函數。
main函數的第一條命令是Animal animal = new Animal("Puppy");就是讓JVM創建一個Animal對象，但是這時候方法區中沒有Animal類的信息，所以JVM馬上載入Animal類，把Animal類的類型信息放到方法區中。
載入完Animal類之後，Java虛擬機做的第一件事情就是在堆區中為一個新的Animal實例分配內存, 然後調用構造函數初始化Animal實例，這個Animal實例持有著指向方法區的Animal類的類型信息（其中包含有方法表，java動態綁定的底層實現）的引用。
當使用animal.printName()的時候，JVM根據animal引用找到Animal對象，然後根據Animal對象持有的引用定位到方法區中Animal類的類型信息的方法表，獲得printName()函數的位元組碼的地址。
開始運行printName()函數。
特別說明：java類中所有public和protected的實例方法都採用動態綁定機制，所有私有方法、靜態方法、構造器及初始化方法都是採用靜態綁定機制。而使用動態綁定機制的時候會用到方法表，靜態綁定時並不會用到。
⑨ 編寫一個JAVA控制台程序
通過System.out.println的方式輸出到控制台
定義A.java文件，並輸出字元串 我是一個java程序
publicclassA{
publicstaticvoidmain(String[]args){//定義main方法
System.out.println("我是一個JAVA程序");//輸出我是一個JAVA程序到控制台
}
}⑩ 求java入門常式10個（最經典的）
public class HelloWorld
{
pulic static void main(String[] args)
{
System.out.println("HelloWorld");
}
}