黑马程序员技术交流社区

标题: 求救啊，我快要疯了！！！ [打印本页]
作者: 嘿～～    时间: 2014-4-17 09:13
标题: 求救啊，我快要疯了！！！
本帖最后由 嘿～～ 于 2014-4-17 11:12 编辑

静态代码块，普通代码块，静态构造函数，普通构造函数，成员变量（显示和隐式）执行顺序哪位高手能讲解一下吗？？？？最好能给个代码说明一下啊，求救啊！！！这个弄不明白，我都没法往下看了！！
非常感谢大家，我快被这个执行顺序弄疯了！！！！！
作者: 月光海    时间: 2014-4-17 09:34
静态代码块是给类初始化的时候执行的，普通代码块是new对象的时候执行到，静态构造函数不可以用，普通构造函数是给对象初始化用的，成员变量的隐式赋值是早于构造函数，原因很简单，如果构造函数先执行了，然后再执行成员变量的隐式赋值，那构造函数的赋值就没有了。至于没有静态构造函数，构造函数是为了将一个类实例化一个对象才需要使用的，进行一些必备的初始化操作（即使你没写任何代码，实际上运行库也帮你添了很多操作）。何为静态，就是全局的，已经初始化过的，静态函数就是指该函数不和具体对象相关，只和类相关，但是构造函数是和对象直接关联的，这两个东西从面向对象的概念上完全不可能融合在一起。运行下我的代码就知道了，
  1. package io.demo;

  3. import java.util.Properties;

  5. public class SystemDemo {

  7.         public static void main(String[] args) {
  8.                 // TODO Auto-generated method stub
  9.                         Person p=new Person("lisi",33);
  10.                         p.name="zhangsan";
  11.         }

  13. }
  14. class Person
  15. {
  16.        
  17.         String name;
  18.         int age;
  19.         Person(String name,int age)
  20.         {
  21.                 System.out.println("构造函数");
  22.                 this.name=name;
  23.                 this.age=age;
  24.         }
  25.         static
  26.         {
  27.                
  28.                 System.out.println("静态代码块");
  29.         }
  30.         {
  31.                
  32.                 System.out.println("普通代码块");
  33.         }
  34. }
复制代码
作者: ⒈心只霸占沵    时间: 2014-4-17 09:43
  1. class Person
  2. {
  3.         public static String nationality;//国籍 静态成员
  4.         public String name;//姓名 非静态成员
  5.         public int age;
  6.          //静态代码块,用于初始化静态成员，或者要在类生成字节码时加载一些数据
  7.           //当把这个类加载到内存中时，调用，第一次用需要加载，第二次就不用了，所以只运行一次
  8.         static{
  9.                 //-------------1------
  10.                 nationality="china";//初始化静态成员
  11.         }
  12.         //静态构造函数,用于给所有Person的实例进行初始化，就是说当我们常见某个对象的实例时，如果没有指定姓名年龄，它就是张三，18
  13.         {
  14.                 //-------------2------
  15.          name="张三";
  16.                  age=18;
  17.         }
  18.         //显示构造函数，如果没写构造函数，默认隐式的为：public Person(){} 如果写了,隐式的就被覆盖了
  19.         public Person(String name,int age){
  20.                 //------------3--------------
  21.                 this.name=name;
  22.                 this.age=age;
  23.         }
  24.         //如果没有写构造的话，默认的就是它，如果写了它就会被覆盖，所以如果Person p=new Person()这样就找不到无参构造，一般都会加上
  25.         public Person(){
  26.                 --------------4--------------
  27.         }
  28.        
  29. }
  30. class Test
  31. {
  32.         //第一次创建对象时，需要将这个类加载到内存
  33.         Person p1=new Person();//因为是第一次用到Person，需要加载，说以会是 1,2,4
  34.         Person p2=new Person("王五",34);//因为不是第一次用到Persn,无需加载 ，1不在执行  顺序：2,3
  35. }
  36.       
复制代码
作者: shi0000    时间: 2014-4-17 09:49
静态即表示属于类的，非静态的属于对象。
构造方法没有静态的。成员变量能够被public，private等修饰，当public修饰 时，表示在类外可以被直接
当private修饰时，被封装起来，外部不能直接访问
public class Exam {

        private String name="lisi";        //私有化成员变量，外部调用时，只能采用下边的getName（）方法
        public String age="40";                //公有成员变量，可直接使用对象.age调用
        static void show(){
                System.out.println("属于类的静态show（）");
        }                                                //静态 的，属于类，可以直接Exam.show()
       
        Exam(){
               
        }       //在不写构造函数时，系统默认有一个无参构造方法
        public String getName() {
                return name;
        }
        public void setName(String name) {
                this.name = name;
        }
}
class Test{

        public static void main(String[] args){
                Exam e=new Exam();
                Exam.show();
                System.out.println(e.age);
        }
   
}
作者: 491138002    时间: 2014-4-17 09:51
public class Demo {
    Demo(){
        System.out.println("构造方法");
    }
    {
        System.out.println("构造代码块");//实例化对象的时候才会去调用！
    }
    static{
        System.out.println("静态代码块");
    }
   
    public static void main(String[] args) {
        new Demo();
        new Demo();//再次创建对象，证明无论创建几次对象，静态代码块都只执行一次
        System.out.println("普通代码块");
    }
}
作者: 吴莫    时间: 2014-4-17 10:29
静态构造函数真心没听过，我也不明白啊，普通构造函数在创建有参的情况下，一般都建一个无参的构造函数。静态代码块只是在JVM加载类时，只执行一次；后面在创建对象new Person();也不会执行了。
作者: skill20    时间: 2014-4-17 11:32
  1. class Test1
  2. {
  3.         /*private static int i=0;
  4.         public static int aMethod()
  5.                 {
  6.                  i++;
  7.                 return i;
  8.                 } */
  9.         public static void main(String[] args)
  10.         {
  11.         //Test1 test = new Test1();
  12.         Demo a = new Demo();
  13.         System.out.println("__________________");
  14.         Demo b = new Demo(50);
  15.         //Test1.aMethod();  
  16.         //System.out.println(Test1.aMethod());
  17.         //System.out.println(a.getI());
  18.         //System.out.println(a.getI());
  19.         }
  20. }
  21. class Demo
  22. {
  23.         private int age;
  24.         public int getI()
  25.         {
  26.                 return age;
  27.         }
  28.         Demo()
  29.         {
  30.                 System.out.println("无参数构造函数");
  31.         }
  32.         Demo(int age)
  33.         {
  34.                 //if(age < 0 | age > 120)
  35.                         System.out.println("构造函数代码块");
  36.                 //else
  37.                         this.age = age;
  38.         }
  39.         static
  40.         {
  41.                 System.out.println("静态代码块");       
  42.         }
  43.         {
  44.                 System.out.println("普通代码块");
  45.         }
  46. }
复制代码
  运行下就可以了；非静态成员变量在构造函数前出初始化，静态成员变量随着类的加载而加载。



欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2