|
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(实例变量)
}
}
|