package hello;

public class test_jiuye_peixun {
 int z=8;
 static String country="China";  //3
 String name ;                   //3
 public static void main(String[] args) {    
  int x=5;
  change(x);
  System.out.println("x="+x); // 结果x=5

test_jiuye_peixun obj= new test_jiuye_peixun ();
  obj.z=2;
  change(obj);
  System.out.println("z="+obj.z);// 结果 z=4
  change2(obj);
  System.out.println("z="+obj.z); // 结果 z=4
  // 3
  System.out.println("chainease country is "+ country); 
  System.out.println("33333 chainease country is "+obj.country);
  obj.singOurCountry();
  test_jiuye_peixun.singOurCountry2(); //直接访问静态成员方法 ，  可用类名直接访问
  System.out.println("22222 chainease country is "+test_jiuye_peixun.country);
  //4
  System.out.println("begin executing main method");
  new staticCode();
  new staticCode();  //由于是静态 的所以只执行了一次即 static code is loading 只打印了一句
  //内部类可以通过创建对象从外部类之外被调用，只要将内部类声明为public即可。
  staticCode S_code= new staticCode();
  staticCode.Inner  iner2 = S_code.new Inner();
  iner2.display(); //通过创建外部类staticCode的实例对象，然后再通过staticCode实例对象创建Inner类的实例对象

S_code.inner.display();  //这时第2种方法，可以的 原因是由于staticCode 类里有 public Inner inner;

}
 private static void change(int y) {
  y=3;
 }

private static void change(test_jiuye_peixun obj) {
  obj.z=4;
 }

private static void change2(test_jiuye_peixun obj) {
  obj=new test_jiuye_peixun();
  obj.z=10;
  System.out.println("222222z="+obj.z);  // 结果 z=10
 }

// 3
 void singOurCountry(){
  System.out.println("啊，我是="+country);  // 结果 
  test_jiuye_peixun.country="japan";
  singOurCountry2(); 直接访问静态成员方法
  //用static修饰的代码块表示静态代码块，当Java虚拟机（JVM）加载类时，就会执行该代码块
 }
 static void singOurCountry2(){
  System.out.println("33333啊，我是="+country);  // 结果 
 }

//4    这个输出在运行的第一句就打印出来了
 static{
  System.out.println("test_jiuye_peixun  is loading"); 
 }

}
// 4 
class staticCode {
 public Inner inner;
 static String country4="english";
 int aa=12;
 private int bb=12;
 static {
  country4="de_guo";
  System.out.println("static code is loading"); 
 }
 void test(){
  Inner2 in2 =new Inner2();
  in2.display2();
  Inner in1 =new Inner();
  in1.display();
 } 
 public class Inner { // 内部类   
  void display(){
   System.out.println(aa);
   System.out.println(++bb);
  }
 }

static class Inner2 { // 内部类   
  void display2(){
   staticCode Scode =new staticCode();
   System.out.println(Scode.aa);  //非静态成员变量不能被一个静态内部类成员调用，所以要new一个对象
  }
 }
}

//final 定义的变量相当于一个常量
 class InOut{
  String str= new String("between");
  public void amethod(final int iArgs){
  int it315 = 0;
   class Bycyle{
    public void sayH(){
     System.out.println(str); 
     System.out.println(iArgs);  
    }
   }
  }
 }