|
package bedeck;
public class BedeckDome {
/*
* 實例變量
* */
//類中不能實例化對象
public String str1; //無初始值，可以被任何類訪問
protected String str2; //無初始化值，可以被同一包中的所有類訪問，可以被所有子類訪問
private String str3; //無初始化值，只能夠被當前類的方法訪問
String str4 ; //無初始化值，可以被同一包中的所有類訪問
String str5 = "str5"; //有初始值
/*
* 類變量
* */
static String strA,strB,strC; //無初始值
static String strD = "strD"; //有初始值
/*
*實例變量初始化器
* */
{
str1 = "str1"; //對字符串，str1,str2初始值
str2 = "str2";
strC = "strC"; //實例變量初始化器可以對類變量進行初始化，但達不到預期的結果，值為null
}
/*
* 類變量初始化器
* */
static{
strA = "strA"; //對字符串，strA,strB初始化
strB = "strB";
//str3 = ""; //不可以對實例變量進行初始化，否則出錯
}
/*
* 構造方法
* */
BedeckDome(){ //可加修飾符，也可不加
}
/*
* main()方法
* */
public static void main(String args[]){
/*
* 定義s1,s2為局部變量,注：局部變量不能有public,static,private等修飾符
* */
String s1 ;
String s2 ="s2"; //初始化
BedeckDome id2 = new BedeckDome(); //實例化對象
System.out.println("輸出類BedeckDome中實例變量中字符串的值:\t str1="+id2.str1+",str2="+id2.str2+",str3="+id2.str3+",str4="+id2.str4);
System.out.println("輸出類bedeckDome中類變量的值1:\t"+id2.strA);
id2.str(); //用實例化對象調用str()方法
id2.callC1_Test();
/*
*同一包中的使用test類中的變量和方法
* */
Test t = new Test();
System.out.println("test類中的pulbic變量:"+t.test_str1);
System.out.println("test類中的protected變量:"+t.test_str2);
//變量test_str3則無法在此類中輸出
System.out.println("test類中的缺省修飾符變量:"+t.test_str4);
/*
* 方法同理
* */
}
public void str(){
System.out.println("另一種輸出類BedeckDome中實例變量中字符串的值:\t str1="+str1+",str2="+str2+",str3="+str3+",str4="+str4+"\n");
System.out.println("輸出類bececkDome中的變量的值2:\t"+strA);
System.out.println("輸出類bececkDome中的變量的值3:\t"+BedeckDome.strA);
/*
* 訪問內部類中的方法和變量
* */
System.out.println(" 訪問內部類中的變量");
Internal it = new Internal();
it.innerOut();
System.out.println("內部類中的變量：\t internal_str1="+it.internal_str1);
}
public void callC1_Test(){
C1 cc = new C1();
System.out.println(""+cc.c1_str1());
System.out.println(cc.c1_str2());
}
/*
* 方法中定義類
* */
public void innerD(){
class innerD_class{
//類體
}
}
/*
* 定義了一個缺省修飾符的內部類,注：內部類不可以定義靜態方法和類變量
* */
class Internal{
String internal_str1 = "internal_str1"; //定義了一個內部類變量
/*
* 構造方法
* */
Internal(){}
public void innerOut(){
BedeckDome dbInternal = new BedeckDome(); //建立一個實例化對象，dbInternal
/*
* 內部類可以訪問外部類的變量
* */
//dbInternal.str(); //不能訪問方法
System.out.println("輸出類InternalDome中的實例變量值:\t"+dbInternal.str5);
System.out.println("輸出類InternalDome中類變量值:\t"+dbInternal.strC+"\t類變量中的另一種輸出方式:\t"+strC);
System.out.println("輸出類部類Internal中定義變量的值：\t"+internal_str1);
}
/*
* 類嵌套
* */
class InIn{
//類體
}
}
/*
* 定義一個被保護的內部類，該類只能被該類和子類訪問
* */
protected class ProInternal{
// 類體
}
}
/*
* 該類主要講解靜態方法，與非靜態方法和修飾符調用情況
* */
class C1{
public String c1_Str1; //無初始值，可以被任何類訪問
protected String c1_Str2; //無初始化值，可以被同一包中的所有類訪問，可以被所有子類訪問
private String c1_str3; //無初始化值，只能夠被當前類的方法訪問
String c1_St4 = "c1_Str4";
static String c1_Str5;
/*
* 構造方法
* */
C1(){
}
/*
* 實例化C1
* */
/*
* 該方法可以包含靜態的東本，也可以包含非表態的東西
* */
public String c1_str1(){
C1 ca = new C1();
String c1_str = ca.c1_St4;
return c1_str; //可以寫成 return c1_Str4(實例變量) ,也可以寫成c1_Str5（類變量）
}
/*
* 方方法只能包含表態的東西，如果要包含非表態的東西，那么就得實例化
* */
public static String c1_str2(){
/*
C1 c11 = new C1();
return c11.c1_Str5;
*/
return C1.c1_Str5; //可以寫成 return c1_Str5（類變量） ，但不能寫 return c1_Str4(實例變量)
}
}
|