?

＊＊＊對象作為參數傳遞＊＊＊
class passparam
{ int x;
? public static void main(String[] args)
? { passparam obj = new passparam();
??? obj.x=5;
??? change(obj);
??? System.out.println(obj.x);
??? //如果change方法不是靜態的，想調用它就得寫成? new passparam().change(obj);
? }
? public static void change(passparam obj) //如果這個函數前面沒加static編譯出錯，因為非靜態方法，不能被靜態方法直接調用，main

是一個靜態方法。
? { obj.x=3;}
}
結果：? 3

＊＊＊數組作為參數傳遞＊＊＊
class passparam
{ int x;
? public static void main(String[] args)
? { passparam obj = new passparam();
??? int []x=new int[1];
??? x[0]=5;
??? change(x);
??? System.out.println(x[0]);
? }
? public static void change(int[] x)
? { x[0]=3; }
}???
結果：? 3

＊＊＊靜態變量、靜態方法的使用＊＊＊
靜態變量相當于全局變量

class Chinese
{ static string country="中國";? //如果改為private static string country="中國" 下面的兩處調用，就會出錯
? String name;
? int age;
? static void sing()
?{ System.out.println("啊~~")
? void singOurCountry()
?{ System.out.println(country);
?? sing();
?}
}
class TestChinese
{ public static void main(String[] args)
? { System.out.println(Chinaese.country); //static 靜態變量可以直接引用
??? Chinese ch1=new Chinese();
??? ch1.singOurCountry();
??? System.out.println(ch1.country);
??? Chinese.sing();? //靜態方法的引用
??? new.Chinese.sing(); // 用對象引用方法?
? }
}

--------------------------------
class Chinese
{ private static int count=0; //定義一個靜態整形變量
? static?????? //靜態代碼塊?? 類在第一次使用時，初使化
? { count=2;?? //這個類在第一次使用時，count被初使化
??? System.out.println("static code")
? }
? String name;
? int age;
? public Chinese()
? { System.out.println(++count); }
?}
class TestChinese
{ public static void main(String[] age){
? System.out.println("static begin")
? new Chinese();
? System.out.println("end")?
? new Chinese();
? new Chinese();
?}
}
輸出結果為
static begin
static code
? 3
end
?? 4
?? 5

------------------------------------
＊＊靜態方法? 注意：
? 1、在靜態方法里只能直接調用同類中其它的靜態成員（包括變量和方法）。這是因為，對于非靜態方法和變量，需要先創建類的實例對象后

才可使用，而靜態方法在使用前不用創建任何對象。
? 2、靜態方法不能以任何方式引用this和super關鍵字。與上面的的道理一樣，因為靜態方法在使用前不用創建任何實例對象，當靜態方法被

調用時，this所引用的對象根本就沒有產生。
? 3、main()方法是靜態的，因此JVM在執行main方法時不創建main方法所在類的實例對象，因而在main()方法中，我們不能直接訪問該類中的

非靜態成員，必須創建該類的一個實例對象后，才能通過這個對象去訪問類中的非靜態成員。

class B{

?public void b(){ System.out.print("000");}
?public static void e(){}
?public void c(){b();
???????????????? e();
??????????????? }? //類中的非靜態方法可以調用該類中的其它非靜態方法，和靜態方法
}
class A{
?public static void main(String[] args){
? new B().c();
?
?}
}

----------------------------------------
＊＊靜態代碼塊
?1、一個類中可以使用不包含在任何方法中的靜態代碼塊（static block），當類被載入時，靜態代碼塊被執行，且只被執行一次,靜態塊經常

來進行類屬性的初始化。
?2、類中的靜態代碼塊被自動執行，盡管我們產生了類的多個實例對象，但其中的靜態代碼塊只被執行了一次。當一個程序中用到了其他的類

，類是在第一次被使用的時候才被裝載，而不是在程序啟動時就裝載程序中所有可能要用到的類。?

---------------------------
＊＊＊單態設計模式＊＊＊? 使類在內存中只創建一個實例對象
class Chinese
{
private static Chinese objRef = new Chinese();? //這里必須用static，由于1、下面是用靜態方法調用? 2、如果不用static就會陷入死

循環中，因為每創建一個objRef對象，就會重新載入Chinese類，然后又調用objRef類。
? private static int count=0;
? public static Chinese getInstance()????? //Chinese 為這個方法的返回類型,??? 這個方法是用靜態方法來調用靜態變量
?{ return objRef; }
? private Chinese() //單態設計模式要把構造函數設為私有的
?{ System.out.println(++count); }
?

?}
class TestChinese
{ public static void main(String[] age){
? Chinese obj1 = chinese.getInstance();
? Chinese obj2 = chinese.getInstance();
? System.out.println(obj1==obj2);?? //返回結果為true
? new Chinese(); //此處出錯，因為構造函數已經是私有的了，所以不能再這樣定義對象了。
? }
}
注意：1，構造函數必須設為private
????? 2, 類里面定義的對象必須是private，static,也可以加上final
????? 3, 類里面要有一個調用對象的類，這個類必須是public,static,和類形是這個類的名　,類中的其它要調用的方法還用public
--------------
單態設計模式 ：? 所謂類的單態設計模式，就是采取一定的方法保證在整個的軟件系統中，對某個類只能存在一個對象實例，并且該類只提供

一個取得其對象實例的方法，如果我們要讓類在一個虛擬機中只能產生一個對象，我們首先必須將類的構造方法的訪問權限設置為private，這

樣，就不能用new操作符在類的外部開始產類的對象了，但在類內部仍可以產生該類的對象。因為在類的外部開始還無法得到類的對象，只能調

用該類的某個靜態方法以返回類內部創建的對象，靜態方法只能訪問類中的靜態成員變量，所以，指向類內部產生的該類對象的變量也必須定

義成靜態的。

--------------------------------------------------------
＊＊＊嵌套類＊＊＊
1.嵌套類可以直接訪問嵌套它的類成員，包括private成員，但是，嵌套類的成員卻不能被嵌套它的類直接訪問。
2.在類中直接定義的嵌套類的使用范圍，僅限于這個類的內部，也就是說，A類里定義了一個B類，那么B為A所知，卻不被A的外面所知。內部類

的定義和普通類的定義沒什么區別，它可以直接訪問和引用它的外部類的所有變量和方法，就像外部類中的其他非static成員的功能一樣，和

外部類不同的是，內部類可以聲明為private或protected.
3.內部類可以用static來修飾，這樣相當于是一個外部定義的類，它的用法就和外部類一樣了，所以static的內部類中可聲明static成員，

static的內部類不能再使用外層封裝類的非static的成員變量，staic嵌套類很少使用.

class Outer
{ int outer_i=100;
? void test()
? { Inner in=new Inner();
??? in.display();
? }
? class Inner
? { void display()
??? { System.out.println("display: outer_i="+outer_i); }
? }
}
class? InnerClassDemo
{? public static void main(String[] args)
?? { Outer outer=new Outer();
???? outer.test();
?? }
}
輸出結果：display: outer_i=100
------------------------------------------------------------------
經驗： 當一個類中的程序代碼要用到另外一個類的實例對象，而另外一個類中的程序代碼又要訪問第一個類中的成員，將另外一個類做成第一

個類的內部類，程序代碼就要容易編寫得多，這樣的情況在實際應用中非常之多!
---------------------------------------------------------------------
***如果函數的局部變量(函數的形參也是局部變量)，內部類的成員變量，外部類的成員變量重名，我們應該按下面的程序代碼所使用的方式來

明確指定我們真正要訪問的變量。

pulic class Outer
{ private int size;
? public class Inner
? { private int size;
??? public void doStuff(int size)
??? { size++;? //引用的是doStuff函數的形參
????? this.size++; //引用的是Inner類中的成員變量
????? Outer.this.size++; //引用的Outer類中的成員變量
??? }
?? }
}
?
----------------------------------------------
****內部類如何被外部引用****
內部類也可以通過創建對象從外部類之外被調用，只要將內部類聲明為Public即可。

class Outer
{ private int size=10;
? public class Inner? //被外部引用，必須聲明為public
? { public void doStuff()
??? { System.out.println(++size); }
? }
}
public class TestInner
{ public static void main(String[] args)
? { Outer a =new Outer();
??? Outer.Inner b=a.new Inner();
??? b.doStuff();
? }
}?

--------------------------------------------------
****方法中定義的內部類****
class Outer
{ int outer_i=100;
? void test()
? { for (int i=0;i<5;i++)
??? {? class Inner? //方法中定義的內部類
?????? {? void display()
????????? { System.out.println("display: outer_i="+outer_i);}
?????? }????
????????? Inner inner=new Inner();
????????? inner.display();
???? }
? }
}
class InnerClassDemo
{ public static void main(String args[]){
? Outer outer=new Outer();
? outer.test();
?}
}
結果：??
display: outer_i=100
display: outer_i=100
display: outer_i=100
display: outer_i=100
display: outer_i=100

*在方法中定義的內部類只能訪問方法中的final類型的局部變量，因為用final定義的局部變量相當于是一個常量，它的生命周期超出方法運行

的生命周期。
class InOut
{ String str=new String("Between");
? public void amethod(final int iArgs)
? { int it315;
??? class Bicycle
??? {? public void sayHello()
?????? {? System.out.println(str);
????????? System.out.println(iArgs);
?????? }
??? }
? }
}
在內部類中的sayHello方法中，我們可以訪問變量iArgs和str,但不能訪問it315??
------------------------------------------------------------

*****使用文檔注釋******
對于類的說明應在類定義之前，對于方法的說明應在方法定義之前。
import java.io.*;
/**
?* Title: engineero類<br>
?* Description: 通過engineer類來說明java中的文檔注釋<br>
?* Copyright: (C) 2003 www.it315.org<br>
?* Company: IT人資訊交流網<br>
?* @author 張孝祥
?* @version 1.00
*/
?public class engineer
?{
?? public String Engineer_name;
? /**
?? * 這是engineer對象的構造函數
?? * @param name engineer的名子
? */
?public engineer(String name)
?{
?}
/**
?* 這是repairing方法的說明
?* @param sum 需要修理的機器總數
?* @param alltime需要修理的總時間
?* @return Repairing的數量
*/
?public int repairing (int sum, int alltime)
?{
? }
}
-----------------------------------------------------------------
<br> 在html中換行，而帶有@標志的屬性會自動換行，結尾就省略了<br>
@author <作者姓名>? 用于類的說明，表示這個java程序的作者
@version<版本信息>? 用于類的說明，表示這個java程序的開發版本。
@param<參數名稱><參數說明> 用于方法的說明，表示方法所引入的參數，及其參數對應的說明
@return<返回值說明> 用于方法的說明，表示此方法的返回值表示的意義。
----------------------------------------------------------------
在dos下 存放文件的目錄下輸入
javadoc -d engineer -version -author engineer.java
javadoc 就會生成這個類的說明文件
-d 用來制定說明文件存放的目錄
engineer 為說明文件所存放的目錄名;
-version 代表要求javadoc程序在說明文件中加入版本信息
-author 表示要求javadoc程序在說明文件中加入作者信息

總結

以上是生活随笔為你收集整理的java学习笔记(四)----对象、数组作为参数传递，静态变量、静态方法的使用，内部类，使用文档注释的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。