java軟體實例_怎麼理解java中的實例化呢

❶ java 中單實例和多實例是指的什麼

簡單的說單例就是
只能有一個實例，所以地方用到的實例都是同一個。
就好像家人吃飯，桌子是單例的，大家用的是同一個。而碗是多例的，每人都有自幾的。
下面是具體的例子：
Java模式之單例模式：

單例模式確保一個類只有一個實例，自行提供這個實例並向整個系統提供這個實例。

特點：

1，一個類只能有一個實例

2，自己創建這個實例

3，整個系統都要使用這個實例

例:
在下面的對象圖中，有一個"單例對象"，而"客戶甲"、"客戶乙"
和"客戶丙"是單例對象的三個客戶對象。可以看到，所有的客戶對象共享一個單例對象。而且從單例對象到自身的連接線可以看出，單例對象持有對自己的引用。

Singleton模式主要作用是保證在Java應用程序中，一個類Class只有一個實例存在。在很多操作中，比如建立目錄
資料庫連接都需要這樣的單線程操作。一些資源治理器經常設計成單例模式。

外部資源：譬如每台計算機可以有若干個列印機，但只能有一個Printer
Spooler,以避免兩個列印作業同時輸出到列印機中。每台計算機可以有若干個通信埠，系統應當集中治理這些通信埠，以避免一個通信埠被兩個請求同時調用。內部資源，譬如，大多數的軟體都有一個（甚至多個）屬性文件存放系統配置。這樣的系統應當由一個對象來治理這些屬性文件。一個例子：Windows
回收站。
在整個視窗系統中，回收站只能有一個實例，整個系統都使用這個惟一的實例，而且回收站自行提供自己的實例。因此，回收站是單例模式的應用。
兩種形式：
1，餓漢式單例類
public
class
Singleton
{
private
Singleton(){}
//在自己內部定義自己一個實例，是不是很希奇？

//注重這是private
只供內部調用
private
static
Singleton
instance
=
new
Singleton();
//這里提供了一個供外部訪問本class的靜態方法，可以直接訪問

public
static
Singleton
getInstance()
{

return
instance;

}
}
2，懶漢式單例類
public
class
Singleton
{
private
static
Singleton
instance
=
null;
public
static
synchronized
Singleton
getInstance()
{
//這個方法比上面有所改進，不用每次都進行生成對象，只是第一次

//使用時生成實例，提高了效率！

if
(instance==null)

instance＝new
Singleton();

return
instance;
}
}
第二中形式是lazy
initialization，也就是說第一次調用時初始Singleton，以後就不用再生成了。
注重到lazy
initialization形式中的synchronized，這個synchronized很重要，假如沒有synchronized，那麼使用getInstance()是有可能得到多個Singleton實例。
一般來說第一種比較安全。進入討論組討論。

❷ Java類的實例化順序是什麼樣的Java線程同步的方式有哪些

引言：java是在1990年初，被詹姆斯•高斯林等人開發的一門面向對象的編程語言。起初，java被稱為0ak，來經過發展0ak改名為java，與1995年的五月份正式向大家發布。

一、java類的實例化順序

java的實例化順序在繼承沒有的情況

單獨一個類的場景下，初始化順序為依次為靜態數據，繼承的基類的構造函數，成員變數，被調用的構造函數。

其中靜態數據只會初始化一次。（靜態數據包括靜態代碼塊和靜態變數，每個類的靜態數據只會初始化一次）

在繼承的情況下

添加兩個基類，讓繼承父親，父親繼承祖父。

繼承的情況就比較復雜了。由繼承了基類，還將往上回溯，遞歸地調用基類的無參構造方法。

在我們的例子中，在初始化靜態數據後，會先往上追溯，調用父的默認構造方法，此時再往上追溯到爺爺的默認構造方法。

無論是java還是什麼別的東西他都體現了現代社會與信息技術的不斷發展，人們在進行進行技術開發時也有了越來越多的方法。程序類的工作也有了更為快捷的方法，這為信息技術的發展也提供了更好的發展方法

❸ 用 java 編寫一個基於Web Service的軟體

1.首先說一下兩個開發webservices的工具包：axis 和XFire 本人首先接觸的是axis。
兩者比較如下：
相對於Axis來說，目前XFire相對受歡迎，加上其提供了和Spring集成的支持，在目前的Web Service開源社區擁有眾多的追隨者。並且因為XFire為Spring提供的支持，使得我們可以很容易在Spring中使用XFire構建Web Service應用。
知道了這兩個框架你研究起來也就不難了。
下面我就基於xfire說一下開發說明：
xfire對WebServices的開發非常方便，在Eclipse里開發就更方便了。總結起來有這么幾點：
1.編寫類，跟普通JAVABEAN沒什麼區別。
2.配置文件
如果是要深層次的去理解WebServices還需努力，下面是我給你找的一個網上的例子作為參考：

使用XFire+Spring構建Web Service
XFire是與Axis 2並列的新一代Web Service框架，通過提供簡單的API支持Web Service各項標准協議，幫助你方便快速地開發Web Service應用。
相對於Axis來說，目前XFire相對受歡迎，加上其提供了和Spring集成的支持，在目前的Web Service開源社區擁有眾多的追隨者。並且因為XFire為Spring提供的支持，使得我們可以很容易在Spring中使用XFire構建Web Service應用。
XFire與Axis2相比具有如下特徵：
l 支持一系列Web Service的新標准--JSR181、WSDL2.0 、JAXB2、WS-Security等；
l 使用Stax解釋XML,性能有了質的提高。XFire採用Woodstox 作Stax實現；
l 容易上手，可以方便快速地從pojo發布服務；
l 支持Spring、Pico、Plexus、Loom等容器；
l 靈活的Binding機制，包括默認的Aegis,xmlbeans,jaxb2,castor；
l 高性能的SOAP 棧設計；
l 支持Spring、Pico、Plexus、Loom等容器。
XFire與Axis1性能的比較如下：
l XFire比Axis1.3快2-6倍；
l XFire的響應時間是Axis1.3的1/2到1/5。
XFire在WebService框逗譽架山蘆段中開始較晚，它從現有的框架中借鑒了許多優秀的理念，力爭將Web Service的應用開發難度降到最低。此外，還提供了各種綁定技術、支持多種傳輸協議，對WebService體系中許多新的規范提供了支持。
下面讓我們來看一個XFire於Spring集成的helloWorld的簡單例子。
一．實現的功能和特點
本例具有如下功能和特點：
1）基於J2EE平台的Web Service服務；
2）開發方便，配置簡單；
3）與spring無縫集成。
XFire是完全基於流數據處理進行工作的系統，這意味著XFire不是將整個SOAP文檔緩存在內存中，而是以管道的方式接收SOAP流數據。這種工作方式的嘩悔轉變帶來了可觀的性能回報，同時節省了內存的佔用。
XFire從管道中接收一個SOAP請求到返回一個SOAP響應，會經歷一系列的階段。在管道調用的任何一個階段，XFire都可以添加一些額外的Handler，在對消息進行加工處理後再傳入到下一個階段中。在SOAP請求消息對Web Service發起真正調用之前，分別會經過傳輸、預轉發、轉發、策略實施、用戶信息處理、預調用、服務調用等階段。
二．開發環境
筆者的開發環境描述如下：
1） jdk: 1.5版本；
2） Tomcat：5.5.20；
3） MyEclipse:5.1.1 GA。
三．開發步驟

1. 工程與環境的建立
在MyEclipse 中新建Web工程，名為webservice_helloworld。選擇該工程後，點擊右鍵選擇MyEclipse->Add Web Service Capabilities，彈出Add Web Service Capabilities對話框，點擊「Next」，彈出Project Library Configuration對話框，默認選擇Core Libraries，點擊「Finish」按鈕，完成XFire核心包的添加。為了後續的客戶端的測試，還需讀者加入commons- httpclient.jar包到WEB-INF/lib下。
部署後可看到此時WEB-INF/lib的jar包列表如下：
activation-1.1.jar、commons -beanutils-1.7.0.jar、commons-codec-1.3.jar、commons-httpclient.jar、 commons-logging-1.0.4.jar、jaxen-1.1-beta-9.jar、jaxws-api-2.0.jar、jdom- 1.0.jar、jsr173_api-1.0.jar、mail-1.4.jar、saaj-api-1.3.jar、saaj-impl- 1.3.jar、spring-1.2.6.jar、stax-api-1.0.1.jar、wsdl4j-1.5.2.jar、wstx-asl- 3.0.1.jar、xbean-2.1.0.jar、xbean-spring-2.5.jar、xfire-aegis-1.2.2.jar、 xfire-annotations-1.2.2.jar、xfire-core-1.2.2.jar、xfire-java5-1.2.2.jar、 xfire-jaxws-1.2.2.jar、xfire-jsr181-api-1.0-M1.jar、xfire-spring- 1.2.2.jar、XmlSchema-1.1.jar
為了後續的開發和測試，在src目錄下分別建立test和webservice目錄，分別用於存放測試文件和webservice的相關類。
2．Web Service實現的編寫
在本例中，我們只是做一個helloWorld的簡單例子。Web Service服務端提供一個根據輸入的名字信息回復相應的helloWorld信息的。例如，當名字為「阿蜜果」時，恢復信息為「hello，阿蜜果」。下面讓我們一步一步來開始進行編碼。
1）web.xml的配置
一般情況下，我們通過HTTP作為Web Service的傳輸協議，這樣我們只需啟動一個Web伺服器(如Tomcat，在本例中使用的是Tomcat5.5.20)，這樣客戶端就可以通過 HTTP訪問到Web Service服務。為了集成Spring容器，XFire專門提供一個XFireSpringServlet，我們可以在web.xml中配置該 Servlet，將Spring容器中定義的Web Service在某個URI下發布。
為了能正確使用XFire，需在web.xml中進行相應配置，在該文件中配置XFire的servlet和servlet-mapping。同時因為本實例需要將XFire集成到Spring中，因而需要在web.xml文件中載入Spring的相應配置文件。在本實例中，我們首先在WEB-INF下建立兩個配置Spring配置文件，一個為applicationContext.xml，該文件用來定義本工程的bean，一個為xfire-servlet.xml，用來配置XFire的相關bean。修改後的web.xml的內容如下所示：

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="2.4" xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
<display-name>XFireService</display-name>

<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/applicationContext.xml,/WEB-INF/xfire-servlet.xml</param-value>
</context-param>
<listener>
<listener-class> org.springframework.web.context.ContextLoaderListener
</listener-class>
</listener>
<listener>
<listener-class> org.springframework.web.util.IntrospectorCleanupListener
</listener-class>
</listener>



<servlet>
<servlet-name>xfire</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>xfire</servlet-name>
<url-pattern>*.ws</url-pattern>
</servlet-mapping>
<servlet>

<servlet-name>xfireServlet</servlet-name>
<servlet-class>org.codehaus.xfire.spring.XFireSpringServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>xfireServlet</servlet-name>

<url-pattern>/service/*</url-pattern>
</servlet-mapping>

</web-app>

2）Web Service的介面類HelloWorld.java和對應實現類HelloWorldImpl.java

為了用Web Service完成HelloWorld功能，我們首先在src/webservice目錄下建立介面類HelloWold.java。它僅包含一個sayHelloWorld(String name)的方法，其詳細內容如下：

package webservice;

/** *//**
*HelloWorld的介面類.
*/
publicinterface HelloWorld {
/** *//**
*對名字為name的人打招呼.
*@paramname名字
*@return返回打招呼的字元串
*/
String sayHelloWorld(String name);
}
我們還需要建立一個對應的實現類，來實現sayHelloWorld的功能，該實現類即為HelloWorldImpl.java。該類的詳細內容如下：
package webservice;
/** *//**
*HelloWorld的實現類.
*/
publicclass HelloWorldImpl implements HelloWorld {
public String sayHelloWorld(String name) {
String helloWorld = "hello," + name;
return helloWorld;
}
}

3）Spring配置文件applicationContext.xml和xfire-servlet.xml的配置

首先我們在applicationContext.xml文件中配置對應的bean——HelloWorldBean，該xml文件的內容如下：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
"http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
<bean id="HelloWorldBean" class="webservice.HelloWorldImpl"/>
</beans>
這個配置文件很簡單，在此不詳述。

XFire為Spring 提供了方便易用的導出器XFireExporter，藉助該導出器的支持，我們可以在Spring容器中將一個POJO導出為Web Service。HelloWorld是業務服務類，在此擁有一個sayHelloWorld的方法，我們希望將此方法開放為Web Service。在實際應用中，如果某個類具有眾多的方法，而其中的某些方法不需要開放為Web Service的情況下，我們可以定義一個窄介面，該介面中只需定義那些開放為Web Service的業務方法。

將一個業務類所有需要開放為Web Service的方法通過一個窄介面來描述是值得推薦的作法，這讓Web Service的介面顯得很「干凈」。其次，XFire的導出器也需要服務介面的支持，因為它採用基於介面的動態代理技術。

窄介面中的方法在真實的系統中可能需要引用其它的業務類或DAO獲取資料庫中的真實數據，為了簡化實例，我們在此簡化了實例。

下面讓我們看看在xfire-servlet.xml文件中導出器的設置，該文件內容如下：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
"http://www.springframework.org/dtd/spring-beans.dtd">
<beans>

<import resource="classpath:org/codehaus/xfire/spring/xfire.xml" />
<!—定義訪問的url-->
<bean class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
<property name="urlMap">
<map>
<entry key="/HelloWorldService.ws">
<ref bean="HelloWorldService" />
</entry>
</map>
</property>
</bean>


<bean id="baseWebService" class="org.codehaus.xfire.spring.remoting.XFireExporter" lazy-init="false" abstract="true">

<property name="serviceFactory" ref="xfire.serviceFactory" />

<property name="xfire" ref="xfire" />
</bean>
<bean id="HelloWorldService" parent="baseWebService">

<property name="serviceBean" ref="HelloWorldBean" />

<property name="serviceClass" value="webservice.HelloWorld" />
</bean>
</beans>

在上面的配置中，我們可以看到，在該配置文件中引入了xfire.xml這個Spring配置文件。它是在XFire核心JAR包中擁有一個預定義的 Spring配置文件，它定義了XFire在Spring中必須用到的一些Bean和資源，需要引入這個預定義的配置文件。從該配置文件中可以看出，我們通過XFireExporter將業務類導出為Web Service，對於任何導出器，我們都需要引入XFire環境，即serviceFactory和xfire，這是標準的配置。ServiceFactory是XFire的核心類，它可以將一個POJO生成為一個Web Service。

在本實例中，我們通過定義一個baseWebService，其餘的webService配置都將該bean作為父bean，這樣可以簡化Spring的配置，不需要多次引入serviceFactory和xfire。

3. Web Service的測試

在上一步操作完成之後，我們的這個簡單的Web Service已經編寫完畢，下面讓我們來看看自己的勞動成果吧。

在瀏覽器中輸入地址：http://localhost:8080/webservice_helloworld/HelloWorldService.ws?wsdl，我們可以看到HelloWorldService對應的WSDL信息，閱讀這個WSDL文檔，我們可以知道HelloWorld的sayHelloWorld方法已經被成功地發布為Web Service了。只要拿到這個WSDL就可以開發相應的客戶端調用程序了。

XFire為訪問服務端Web Service提供了各種方便的方式：我們一般根據服務地址和窄介面類創建客戶調用程序。

在不能獲得服務窄介面類的情況下，XFire允許我們通過WSDL文件生成客戶端調用程序，通過指定服務介面的方式調用服務。

1）通過WSDL文件生成客戶端調用程序

首先我們通過http://localhost:8080/webservice_helloworld/HelloWorldService.ws?wsdl我們可以獲得WSDL文件HelloWorldService.wsdl，並將其放在src目錄下面，接著我們通過程序訪問該WSDL文件，並調用需測試的方法。此時測試類WebServiceClientTest.java的內容如下所示：

package test;

import org.codehaus.xfire.client.Client;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;
import webservice.HelloWorld;

/** *//**
*Copyright2007GuangZhouAmigo.
*Allrightreserved.
*HelloWorld的webservice的測試類.
*@author<a href="mailto:[email protected]">AmigoXie</a>
*@version1.0
*Creationdate:2007-9-16-下午05:36:05
*/
publicclass WebServiceClientTest {
HelloWorld helloWorld = null;

publicstaticvoid main(String[] args) throws Exception {
WebServiceClientTest test = new WebServiceClientTest();
test.testClient();
}

publicvoid testClient() throws Exception {
String wsdl = "HelloWorldService.wsdl"; //對應的WSDL文件
Resource resource = new ClassPathResource(wsdl);
Client client = new Client(resource.getInputStream(), null); //根據WSDL創建客戶實例

Object[] objArray = new Object[1];
objArray[0] = "阿蜜果";
//調用特定的Web Service方法
Object[] results = client.invoke("sayHelloWorld", objArray);
System.out.println("result: " + results[0]);
}
}
運行該類，可得到如下輸出結果：

result: hello,阿蜜果

可看出運行結果正確。

2）根據服務地址創建客戶端調用程序

接著讓我們來看一個根據服務地址創建客戶端調用程序的例子。我們可以通過測試類來測試Web Service的正確性，下面讓我們來看一個簡單的測試類，首先我們在src/test目錄建立WebServiceClientTest.java文件，並在src目錄下建立客戶端調用的Spring配置文件client.xml。在client.xml配置文件中我們定義了一個testWebService的bean，該bean訪問wsdlDocumentUrl為http://localhost:8080/webservice_helloworld/HelloWorldService.ws?wsdl的WSDL。該xml文件的詳細內容如下：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
"http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
<bean id="testWebService" class="org.codehaus.xfire.spring.remoting.XFireClientFactoryBean">
<property name="serviceClass">
<value>webservice.HelloWorld</value>
</property>
<property name="wsdlDocumentUrl">
<value>http://localhost:8080/webservice_helloworld/HelloWorldService.ws?wsdl</value>
</property>
</bean>
</beans>

在WebServiceClientTest.java文件中獲得HelloWorld，並調用它的sayHelloWorld方法來完成測試，該類的詳細內容如下所示：

package test;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.;
import webservice.HelloWorld;

/** *//**
*HelloWorld的webservice的測試類.
*/
publicclass WebServiceClientTest {
HelloWorld helloWorld = null;

publicstaticvoid main(String[] args) {
WebServiceClientTest test = new WebServiceClientTest();
test.testClient();
}

publicvoid testClient() {
ApplicationContext ctx = new (
"client.xml");
helloWorld = (HelloWorld) ctx.getBean("testWebService");
System.out.println(helloWorld.sayHelloWorld("阿蜜果"));
}
}

在啟動webservice_helloworld工程的情況下，運行WebServiceClientTest類，可看到控制台包含如下信息：

hello,阿蜜果

由此可看出調用Web Service成功。

四．總結

與Axis 相比，在實施Web Service時XFire更加簡潔高效，並且XFire對Spring提供了強大的支持，可以非常方便地在Spring中使用XFire實施Web Service，因此XFire在短短的時間里成為了受Web Service開發者喜愛的框架。

XFire為客戶端提供了多種訪問Web Service的方式，如果可以獲取客戶端的窄介面類，則可以採用窄介面類調用Web Service。如果僅能獲取WSDL，XFire也可以採用動態反射的機制調用Web Service。XFire為Eclipse提供了一個可以根據WSDL生成客戶端存根代碼的插件，相信XFire也將為其它非Java語言提供類似的插件。

在Axis2中也開始使用Stax來處理XML，還有Xfire不支持WSDL2.0, 而Axis2支持WSDL2.0。
還可使用Xfire的後續版本，Apache CXF (相當於 Xfire2.0).

❹ 求一個簡單的Java實例

package tmp;

import java.awt.BorderLayout;

public class ShowIcon extends JFrame {

private JPanel contentPane;

/**
* Launch the application.
*/
public static void main(String[] args) {
ShowIcon frame = new ShowIcon();
frame.setVisible(true);
}

/**
* Create the frame.
*/
public ShowIcon() {
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setBounds(100, 100, 450, 300);
contentPane = new JPanel();
contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));
contentPane.setLayout(new BorderLayout(0, 0));
setContentPane(contentPane);

JLabel lbl = new JLabel("New label");
contentPane.add(lbl, BorderLayout.CENTER);
ImageIcon icon=new ImageIcon(getClass().getResource("/abc.jpg"));
lbl.setIcon(icon);
}

}
//圖春或片abc.jpg放到源代碼文件滾森雀下一大早般為src

❺ 如何編寫你的第一個Java程序 3種方法來編寫你的第一個Java程序

目錄方法1：編寫你的第一個Java程序1、要開始用Java編寫程序，先設置你的工作環境。2、任何一種類似記事本的程序都能夠用於Java編程。3、確保安裝了Java軟體開發工具包方法2：Hello World 程序1、我們將首先創建一個能列印"Hello World"的程序。2、聲明類和main方法。3、編寫將列印出"Hello World"的代碼行。4、把這些都放在一起。5、保存文件，並打開命令提示符或終端來編譯程序。6、運行程序。7、恭喜，你方法3：輸入和輸出1、我們現在將擴展我們的Hello World程序，以接受用戶的輸入。2、導入Scanner（掃描儀，由於編程時使用Scanner，故下文用Scanner）類。3、在main方法中，創建Scanner對象的一個新實例（instance）。4、提示用戶輸入。5、要求Scanner對象接受用戶鍵入的下一行，並將其存儲在變數中。6、向用戶顯示問候語。7、一起保存以上代碼。8、編譯並運行。Java是James Gosling於1995年創建的一種面向對象的編程語言，它用「欄位」（fields，描述對象的屬性），和「方法」（methods，對象可以執行的操作），將概念表示為「對象」（objects）。Java是一種「編寫一次，就可以在任何地方運行」的編程語言，可以在任何裝有Java虛擬機（JVM）的平台上運行。由於Java是一種用上大量英文單詞的編程語言，母語為英語的初學者很容易學習和理解，非英語母語者只要下一番苦功也能很快上手。本教程介紹如何用Java編寫程序。
方法1：編寫你的第一個Java程序
1、要開始用Java編寫程序，先設置你的工作環境。許多程序員使用集成開發環境（Integrated Development Environment，IDE）進行Java編程，比如Eclipse和NetBeans。但是不必使用臃腫的IDE，也可以編寫Java程序並編譯它。
2、任何一種類似記事本的程序都能夠用於Java編程。高級程序員有時更喜歡使用終端內的文本編輯器，如Vim和Emacs。我們推薦一個可以安裝在基於Windows和Linux系統（Mac、Ubuntu等）的文本編輯器：SublimeText。我們將在本教程中使用它。
3、確保安裝了Java軟體開發工具包。你要用它來編譯程序。在基於Windows的操作系統中，如果環境變數不正確，則可能在運行javac時出錯。有關JDK安裝的詳細信息，可以參閱如何安裝Java軟體開發工具包，以避免此錯誤。
方法2：Hello World 程序
1、我們將首先創建一個能列印"Hello World"的程序。在文本編輯器中，創建一個新文件，並將其另存為"HelloWorld.java"。HelloWorld是類名，你需要讓類名與文件同名。
2、聲明類和main方法。main方法 public static void main(String[] args)是程序運行時執行的方法。這個main方法在每個Java程序中都以相同方式調用。
public class HelloWorld { public static void main(String[] args) { }}
3、編寫將列印出"Hello World"的代碼行。
System.out.println("Hello World.");讓我們看看這一行的組成成分：System 告訴系統執行某些操作。
out 告訴系統我們要輸出一些內容。
println ?代表"列印行（print line）"，我們用它告訴系統在輸出中列印一行文字。
("Hello World.") 周圍的圓括弧表示方法 System.out.println()接受一個參數。在本例中，該參數是字元串"Hello World."
注意，Java中有一些我們必須遵守的規則：必須始終在每行末尾添加分號。
Java區分大小寫，因此必須以正確的大小寫寫入方法名、變數名和類名，否則將出現錯誤。
某個方法或循環的特定代碼塊包含在花括弧中。
4、把這些都放在一起。最後Hello World程序應如下所示：
public class HelloWorld { public static void main(String[] args) {System.out.println("Hello World."); }}
5、保存文件，並打開命令提示符或終端來編譯程序。打開保存HelloWorld.java的文件夾，並鍵入javac HelloWorld.java。這告訴Java編譯器你想要編譯HelloWorld.java。如果有錯誤，編譯器會告訴你做錯了什麼。否則，你不應該看到來自編譯器的任何消息。如果現在查看helloworld.java所在的目錄，應該會看到helloworld.class。這是Java用來運行程序的文件。
6、運行程序。我們終於可以運行我們的程序了！在命令提示符或終端中，鍵入java HelloWorld。這是在告訴Java你想運行HelloWorld類。你應該看到控制台出現 "Hello World"。
7、恭喜，你完成了第一個Java程序！
方法3：輸入和輸出
1、我們現在將擴展我們的Hello World程序，以接受用戶的輸入。在我們的Hello World程序中，我們列印出一個字元串供用戶查看，但是只有當程序能夠接收用戶輸入信息，才能稱之為程序的交互功能。我們現在將擴展程序，提示用戶輸入他或她的名字，然後用名字問候用戶。
2、導入Scanner（掃描儀，由於編程時使用Scanner，故下文用Scanner）類。在Java中，我們有一些可以訪問的內置庫，但是我們必須導入它們。其中一個庫是java.util，它包含我們獲取用戶輸入所需的Scanner對象。為了導入Scanner類，我們在代碼的開頭添加了以下行。
import java.util.Scanner;這告訴程序我們想使用java.util包中的Scanner對象。
如果希望訪問java.util包中的每個對象，只需在代碼的開頭編寫import java.util.*; 即可。
3、在main方法中，創建Scanner對象的一個新實例（instance）。Java是一種面向對象的編程語言，因此它使用對象來表示概念。Scanner對象是含有欄位和方法的對象。為了使用Scanner類，我們必須創建一個新的Scanner對象、它可以填充的欄位和使用的方法。示例如下：
Scanner userInputScanner = new Scanner(System.in);userInputScanner是剛剛創建的Scanner對象實例的名稱。注意名稱是用駱駝體（每個單詞首字母大寫）寫的，這是Java中變數命名的規定。
我們使用 new 運算符創建對象的新實例。因此在本例中，我們通過 new Scanner(System.in)，創建了Scanner對象的新實例。
Scanner對象接受一個參數，該參數告訴對象要掃描什麼。在本例中，我們輸入System.in 作為參數。System.in告訴程序掃描來自系統的輸入，這是用戶將在程序中鍵入的輸入。
4、提示用戶輸入。我們必須提示用戶輸入，以便用戶知道何時在控制台中鍵入內容。這可以通過System.out.print或System.out.println實現。
System.out.print("What's your name? ");
5、要求Scanner對象接受用戶鍵入的下一行，並將其存儲在變數中。Scanner將始終接收用戶鍵入的數據。下面的行將要求Scanner接受用戶鍵入的姓名，並將其存儲在變數中：
String userInputName = userInputScanner.nextLine();在Java中，使用對象方法的規定是objectName.methodName(parameters)。在userInputScanner.nextLine()中，我們使用剛才給出的名稱調用Scanner對象，然後調用它的方法nextLine() ，該方法不接受任何參數。
注意，接下來程序將把下一行存儲在一個"字元串"對象中。我們已將字元串對象命名為userInputName
6、向用戶顯示問候語。現在我們已經存儲了用戶名，我們可以列印一個問候語給用戶。還記得我們在main類中編寫的 System.out.println("Hello World."); 嗎？我們剛剛編寫的所有代碼都應該放在這一行上面。現在我們可以修改這一行，如：
System.out.println("Hello " + userInputName + "!");我們把"hello"、用戶名和"！" 通過編寫 "Hello " + userInputName + "!" 連起來的方式，稱為字元串串聯。
這里我們有三個字元串："Hello "、userInputName和"！"。Java中的字元串是不可更改的。因此，當我們連接這三個字元串時，我們實際上創建了一個包含問候語的新字元串。
然後將這個新字元串作為參數輸入System.out.println。
7、一起保存以上代碼。我們的代碼現在應該如下所示：
import java.util.Scanner;public class HelloWorld { public static void main(String[] args) {Scanner userInputScanner = new Scanner(System.in);System.out.print("What's your name? ");String userInputName = userInputScanner.nextLine();System.out.println("Hello " + userInputName + "!"); }}
8、編譯並運行。進入命令提示符或終端，並運行與我們在第一次迭代HelloWorld.java時運行的命令。我們必須首先編譯程序:javac helloworld.java。然後我們可以運行它：java HelloWorld。
小提示Java是一種面向對象的編程語言，建議你閱讀更多關於面向對象編程語言的基礎知識，非常有用。
面向對象編程有許多特徵。其中三個主要特徵是：封裝：限制訪問對象某些組件的能力。Java為欄位和方法提供私有（private）、受保護（protected）和公共（public）三種修飾符。
多態：對象可以轉換標識。在Java中，可以將一個對象轉換為另一個對象，以使用另一個對象的方法。
繼承：使用與當前對象位於同一層次結構中的另一個類的欄位和方法的能力。

❻ JAVA語言的GUI實例

GUI做的計算器，可以查考一下，組件、事件等

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class Calculator extends JFrame{

private Container container;//框架
private JTextField tf;//定殲斗義文本框
private Panel panel;
private String cmd;
private double result;//運算結果
private boolean start;//運算開始判斷

Calculator(){

super("計算器");
container = getContentPane();
container.setLayout(new BorderLayout());

//添加文本框
tf = new JTextField("0.0");
container.add(tf,BorderLayout.NORTH);
tf.setHorizontalAlignment(JTextField.RIGHT);
tf.setEditable(false);

//嵌套容器
panel = new Panel();
container.add(panel);

start = true;
result = 0;
//最後坦肢運算等號
cmd = "=";

ActionListener insert = new InsertAction();
ActionListener command = new CommandAction();

/讓改世/調用創建Button方法
addButton("1",insert);
addButton("2",insert);
addButton("3",insert);
addButton("0",insert);
addButton("*",command);
addButton("Back",insert);
addButton("4",insert);
addButton("5",insert);
addButton("6",insert);
addButton("+",command);
addButton("/",command);
addButton("Clear",insert);
addButton("7",insert);
addButton("8",insert);
addButton("9",insert);
addButton("-",command);
addButton(".",insert);
addButton("=",command);
setSize(400,200);
}

private void addButton(String str,ActionListener listener){

//添加Button方法(操作類型、注冊監聽器)
JButton button=new JButton(str);
button.addActionListener(listener);
panel.setLayout(new GridLayout(3,6));
panel.add(button);
}

private class InsertAction implements ActionListener{

//插入,insert
public void actionPerformed(ActionEvent event){
String input=event.getActionCommand();
if (start)
{
tf.setText("");
start=false;
}
if(input.equals("Back"))
{
String str=tf.getText();
if(str.length()>0)
tf.setText(str.substring(0,str.length()-1));
}
else if(input.equals("Clear"))
{
tf.setText("0");
start=true;
}
else
tf.setText(tf.getText()+input);
}
}

private class CommandAction implements ActionListener{

//計算,command
public void actionPerformed(ActionEvent e){

String command=e.getActionCommand();
if(start)
{
cmd=command;
}
else
{
calculate(Double.parseDouble(tf.getText()));
cmd=command;
start=true;
}
}
}

public void calculate(double x){

//加減乘除運算
if (cmd.equals("+")) result+=x;
else if (cmd.equals("-")) result-=x;
else if (cmd.equals("*")) result*=x;
else if (cmd.equals("/")) result/=x;
else if (cmd.equals("=")) result= x;
tf.setText(""+ result);
}

public static void main(String []args){

Calculator mycalculator=new Calculator();
mycalculator.setLocation(300,300);
mycalculator.setVisible(true);
}

}

❼ 怎麼理解java中的實例化呢

Java中的實例化,其實理解起來也挺簡單，其實就是創建對象
例如：Car car = new Car();
通常把這條語句的動作稱之為創建一個對象，也就是所謂的實例化過程.
在這句話中,Car是一個"汽車類",這個"類"可以理解成是一個"工廠里的模具",然後我們可以根據這個"模具"來創造出"一個具體的產品",這個"具體的產品",也就是所謂的"實例化對象"。
所謂的實例化,就是根據"類",來創造出一個一個具體的對象!

❽ Java中實例是什麼意思

new 一個對象是實例嗎？
對，是實例，你說的沒錯。可以把這個new出來的對象叫做實例，說白了就是這個new出來的「東西」，叫它對象也可以，叫它實例也可以，對象和實例在這個角度上來講是等價的。
這樣：
Java中使用 new關鍵字加上構造方法，來創建一個對象，下面是一個名為Cat的類,
public class Cat {
public Cat() {
System.out.println("這是構造方法");
}
}
使用new + 構造方法來創建一個對象，那麼也就是
Cat c = new Cat();
前半部分，Cat c 的意思是，在內存中分配一個變數，名字叫c，這個變數是Cat類型的，它的值是什麼？
一會兒在說；
後半部分，new Cat(); 這就是new關鍵字和構造方法來創建一個對象，Cat()是構造方法的名字沒錯吧？想造出一個對象來，就這么寫，語法規定的，沒有為什麼；
new Cat(); 說明 new這個Cat類的一個對象，程序運行的時候，會調用構造方法Cat()，等這個構造方法執行完了，這個Cat類型的對象也就造出來了，真正的出現在內存當中了；
使用new關鍵字造出來的對象，被分配在內存的堆區(heap)，而且等這個對象真正出來之後，還會做一件重要的事情：
我們這個對象是被分配在內存中的，那麼內存地方大了，這個對象在哪裡呢？怎麼找到它呢？new關鍵字創建出一個對象之後，會把這個對象在內存中的地址返回，通過這個地址就可以找到這個對象，那麼我們上面的寫法,
Cat c = new Cat();
意思就是說，把這個對象在內存中的地址賦值給變數c，這就是Java中引用概念，c就叫做引用，或者叫引用變數，或者直接叫變數，沒問題，都是它；
c的值就是一個內存地址，或者叫引用地址，通過這個地址，就可以准確的找到我們剛才創建出來的對象，以後我們要使用這個對象做一些事情，調用此對象的方法什麼的，都用過這個引用，ok？
----
注意，我再說一遍，好多人都搞不清楚，這個c到底是對象還是引用，好多人說c就是Cat類的一個實例，這是非常錯誤的，c就是引用，不是對象！我們new出來的這個東西，真正在內存中的這個東西叫做對象，叫做實例

❾ java編程實例

我是Java初學者，我看了你的問題後想了很久終於把它做出來了，你看看吧，方法不是很好，但能滿足你的要求：

import java.util.Scanner;
public class Check2{
int t;
char[] chs = new char[500]; //輸入的句子不能超過500個字元
Check2() {
String str;
Scanner sc = new Scanner(System.in);
System.out.println("請輸入字元串(輸入的字元串不能超過500個字元）：");
str = sc.nextLine();
t=str.length();
for (int i = 0; i < t; i ++) {
chs[i] = str.charAt(i); //將輸入的字元串裝入數組
}
}
}

class FuZhi{
char[] letter=new char[52]; //將52個字母（含大小寫）裝入數組
FuZhi(){
char p;
int i=0,j=26;
for(p='A';p<='Z';p++){
letter[i]=p; //這句剛才寫掉了，加上去後程序就完整了
i++; //將A-Z裝入數組
}
for(p='a';p<='z';p++){
letter[j]=p; //將a-z裝入數組，並且從數組的第26個開始裝入（letter[0]-letter[25]已被裝入了字母）
j++;
}
}
}

class display{
public static void main(String[] args){
char temp;
int t;
int[] n= new int [52]; //用於統計每個字元出現的次數

Check2 k =new Check2();
FuZhi m=new FuZhi();

for(int j=0;j<52;j++){
t=0; //令t為0，，並且使上一個字母統計完成後
//將其再次初始化（如A統計完成後，當程序統計B出現的次數時，使B的初始次數為0）
for(int i=0;i<k.t;i++){
if(m.letter[j]==k.chs[i]){ //比較字元是否相同，如相同，使t自加一
t++;
n[j]=t; //數組n來統計每個字母出現的次數，即其中的每一個元素代表一個字母在程序中出現的次數
}
}
}
System.out.println("總共輸入了"+k.t+"個字元:\n"+"其中");
for(int i=0;i<52;i++){
System.out.println("字母"+m.letter[i]+"出現的次數為："+n[i]+"次");
}
}
}

寫掉了一句「letter[i]=p;」，現在已經補上了，程序可以運行了，你試一下吧！！！

❿ java編程運算幾個具體實例

三個案例
1、編寫一個方法fun_01(),
判斷一個整數是否包含數字7.

public class Test01{

public static void main(String[] args) {
Scanner sc =new Scanner(System.in);
System.out.println("請輸入數值: ");
int num = sc.nextInt();
System.out.println(func2( num));
}
public static boolean fun_01(int num){
int n;

boolean flag=false;

while(num!=0){

n=num%10;

if(n==7){

flag=true;

break;

}

num /= 10;

}

return flag;
}
}

2.metod2(),
對輸入的任意字元串「1,4,7,13,5,17,9」
轉換為數組元素是整數元素
，需要保存在整形數組中且實現排序輸出「1 4 5 7 9 13 17」
public class Demo {

public static void main(String[] args) {
// String str =("1,4,7,13,5,17,9");
Scanner sc = new Scanner(System.in);
System.out.println("請輸入數字字元串，並用逗號隔開");
String str = sc.next();
metod2(str);
}
public static void metod2(String str){
String array[] = str.split(",");
int p[]=new int[array.length];
for(int i=0;i<array.length;i++){
p[i]=Integer.parseInt(array[i]);
}
//Arrays.sort(p);
for(int i=0;i<p.length-1;i++){
for(int j=0;j<p.length-1-i;j++){
if(p[j]>p[j+1]){
int temp =p[j];
p[j]=p[j+1];
p[j+1]=temp;
}
}
}
for(int i=0;i<p.length;i++){
System.out.print(p[i]+" ");
}

}
}

3，編寫一個方法，傳入數值，列印出金字塔

public static void print(int num){
for(int i=0;i<num;i++){
for(int k=0;k<num-i-1;k++){
System.out.print(" ");
}
for(int j=0;j<2*i+1;j++){
System.out.print("*");
}
System.out.println();
}
}

導航:首頁 > 編程語言 > java軟體實例

java軟體實例

一、java類的實例化順序

與java軟體實例相關的資料