全局变量和局部变量的区别：全局变量是作用，在定义的时候可以不给于初始值；而局部变量作用于当前的方法，在定义的是要对齐进行设置初始值。当你定义一个局部变量的时候，若你没有给它进行初始化的操作是，系统会给出一条提示信息，提示你定义的变量没有进行初始化。例：

void example(){
    int i;
    i++;
}

如上面代码当编译器在执行i++的时候，编译器会提示你i没有进行初始化操作。
如果我们将一个基本数据类型定义为成员变量，结果会有点小小的不同，原因是因为任何的方法都可以初始化这个成员边变量，如果要求我们在使用前为其赋予一个合适的值，那是不太现实的，如果我们赋予一个没有用的值，这样也是不安全的。所以，一个类中的所有的基本数据类型的成员变量都会保证获得一个初始值。例：

class Measurement{    
    boolean t;    
    char c;    
    byte b;    
    short s;    
    int i;    
    long l;    
    float f;   
    double d;
    void print(){
        System.out.println("数据类型 \t 值如下 \n" +
                            "boolean \t"+ t +"\n" +
                            "char \t" +c +"\n"+
                            "byte \t" +b +"\n"+
                            "short \t" +s +"\n"+
                            "int \t" +i +"\n"+ 
                           "long \t" +l +"\n"+
                            "float \t" +f +"\n"+
                            "double \t" +d +"\n");
    }
}
public class initialValues {
    public static void main(String[] args){
        Measurement d =new Measurement();
        d.print();   
   }
}

这个例子向我们显示了基本数据类型成员变量的默认的初始值，其中char的值为空，没有数据打印出来。
构造函数的初始化：
1、初始化的顺序：在一个类里面成员变量初始化的顺序是由变量在类中 定义的顺序决定的，即使变量的定义在各种方法之间，它们 仍会在这些方法调用之前进行初始化操作。例：

    class Score{
            Score(int score){ 
               System.out.println("score("+score+")"); 
           }
        }
    class Stu{
        Score sc = new Score(1);//在构造函数之前
        Stu(){
            //在构造函数中
            System.out.println("Stu()");
             sc3 = new Score(33);//从新初始化sc3
        }
        Score sc2 = new Score(2);//在构造函数之后
        void f(){
            System.out.println("f()");
        }
        Score sc3 = new Score(3);//在结束部分
    }
public class Example {
    public static void main(String[] args) {
        Stu st = new Stu();
        st.f();
    }
}

在上述代码中我们故意在构造函数之前、构造函数中、构造函数之后和结束部分定义了变量，它的输出结果为：

score(1)
score(2)
score(3)
Stu()
score(33)
f()

先输出的是我们定义的变量，这就证明了我们在类里面定义的变量会在调用方法之前得到初始化的操作。
2、静态数据的初始化：如果数据是静态的，如果它是一个基本数据类型的变量，而且我们没有对它进行初始化赋值，这样的话他会获得与自己数据类型相同的标准的初始值；如果它是指向一个对象，除非新建一个对象，并将这两个对象相连接起来，否则的话它会得到一个空值。如果想在定义的时候初始化，但是由于static的值只有一个储存区域，这样的话我们就会想我们到底在什么时候对这个储存区域进行初始化的操作呢？

class Queue{
    //创建一个队列的类
    Queue(int marker){
        System.out.println("marker("+marker+")");
    }
    void ming(int marker){
        System.out.println("marker("+marker+")");
    }
}
class Maidan{
    static Queue q1 =new Queue(1);
    Maidan(){
        System.out.println("Maidan()");
        q2.ming(1);
    }
    void ming2(int marker){
        System.out.println("ming2("+marker+")");
    }
    static Queue q2 = new Queue(2);
}
class Scl{
    Queue q3 =new Queue(3);
    static  Queue q4 = new Queue(4);
    Scl(){
        System.out.println("Scl()");
        q4.ming(2);
    }
    void ming3(int marker){
        System.out.println("ming3("+marker+")");
    }    
static Queue q5 =new Queue(5);
}
public class Example2 {
    public static void main(String[] args) { 
       System.out.println("在main方法中创建学校类");
        new Scl();
        System.out.println("在main方法中创建学校类");
        new Scl();
        maidan.ming2(1);
        scl.ming3(1);
    }    
static Maidan maidan =new Maidan();
static Scl scl = new Scl();
}

Queue允许我们检查一个类的创建过程，而Maidan和Scl可以定义位于Queue中的static成员变量。
static的初始化只有在必要的时候才会进行，上述代码中如果我们不定义Maidan类或者我们不调用Maidan.q1或者Maidan.q2的话static Queue q1和q2永远不会被创建；只有我们访问了一次static之后，它们才会被创建并且static对象不会重新初始化。所以它们初始化的顺序是首先static，然后是非static对象
3、明确进行的静态初始化：

class Exmple{
    static int i;
    static {
          i=47;
      }
}

java允许我们将其他的static的初始化操作划分到类里面的静态块里面处理。上述代码中一个方法它只有一个static关键字，后面跟随一个方法主体，它和其他的static初始化一样，只会被执行一次。
4、 非静态实例的初始化：针对每个非静态对象的初始化，java1.1提供一种类似于的语法格式。实例化从句

{
  c1 = new Mug(1);
  c2 = new Mug(2);
  System.out.println("c1和c2是构造函数");
}

他看起来和静态初始化很像，只是没有static关键字，匿名内部类的初始化的语法格式