package com.imooc;

/*
 * 成员变量：在类中定义，用来描述对象将要有什么
 * 局部变量：在类的方法中定义，在方法中临时保存数据
 * 静态变量 ：static 它属于整个类所共有，静态成员可以使用类名直接访问，也可以使用对象进行访问；
 * java中会给程序变量一个初始值，不会给局部变量初始值，若局部变量不给初始值，不能通过编译；
 */
public class Demo {

    int age = 18;
    static String stuName="Mary";

    public int Age1()
    {
        int age = 0;
        return age;
    }

    public int Age2()
    {
        int age = 0;
        return this.age;
    }

    public static void main(String []args)
    {
        Demo d = new Demo();
        int a1 = d.Age1();
        System.out.println(a1);//此时输出结果是局部变量的值，0；
                              //要想输出成员变量的值，应该是return this.age;
        int a2 = d.Age2();
        System.out.println(a2);//此时输出的结果是成员变量age的值18;

        System.out.println(d.stuName);//通过对象访问静态变量
        System.out.println(Demo.stuName);//通过类直接访问静态变量；两种方法均可输出
                                         //stuName的值
    }
}

问题描述：
在Mymethod中，有static函数，有普通函数，如果想在static函数中调用普通函数，会报标题错误。
问题原因：
static函数是静态函数，可以有类名::fun直接调用，即使没有Mymethod对象也可以调用，不需要分配对象空间；
而普通函数必须由Mymthod对象调用，及分配了对象空间才有这个函数的意义。
问题解决：
1、把普通函数改为static【建议】
2、声明一个Mymethod对象，使用对象.fun来调用
转载于:https://www.cnblogs.com/judes/p/9211973.html

一、java对象初始化过程
　　第一步，加载该类，一个java对象在初始化前会进行类加载，在JVM中生成Class对象。加载一个类会进行如下操作，下面给出递归描述。(关于Class对象详见反射 点击这里)
　　　　如果该类有父类，则先加载其父类。　　　　
　　　　i 初始化该类静态成员
　　　　ii 执行该类静态代码块
　　第二步，创建对象,如果该类有父类，则创建对象时会先创建其父类的对象，外层包裹子类的属性和方法，然后返回子类的引用，下面给出递归描述。
　　　　如果该类有父类，先创建父类的对象。
　　　　i 初始化该类普通成员。　　
　　　　ii 执行普通代码块。
　　　　iii 调用该类构造方法。 
二、案例测试
　　该类对象作为成员变量

public class Info{
    public Info(String s) {
        System.out.println(s);
    }
}

　　父类

public class Parent {
    
    public static Info info = new Info("Parent static member");      //静态成员
     
    public Info info2 = new Info("Parent common member");            //普通成员
    
    static {                                                         //静态代码块
        System.out.println("parent static block");
    }
    
    {                                                                //普通代码块
        System.out.println("parent common block");
    }
    
    public Parent() {                                                //父类构造方法
        System.out.println("Parent.Parent()");
    }
}

　　子类

public class Child extends Parent{
    
    public static Info info = new Info("Child static member");       //静态成员
    
    public Info info2 = new Info("Child common member");             //普通成员
    
    static {                                                         //静态代码块
        System.out.println("Child static block");
    }
    
    {                                                                //普通代码块
        System.out.println("Child  common block");
    }
    
    public Child() {                                                 //子类构造方法
        System.out.println("Child.Child()");
    }
}

 下面测试类的加载过程，我们不创建对象，而是直接加载类，并且是加载子类

public class InitObjectTest{
    public static void main(String[] args) {
        try{
            //Class.forName("Parent");
            Class.forName("Child");
        }catch(Exception e){
            
        }
        //System.out.println("=============== now , we create an Object below ===========");
        //new Parent();
    }
}

测试结果：

 
测试结果符合上面所写的加载类的规则，先初始化父类静态成员，再执行父类静态块，然后初始化子类静态成员，最后执行子类静态块。我们可以看到静态成员确实在类加载时初始化。
注意：类的加载只进行一次，之后创建对象将不再进行类加载，这也是为什么静态代码块只执行一次的原因。
 
下面，将父类加载与创建父类对象分开，观察测试结果
 

public class InitObjectTest{
    public static void main(String[] args) {
        try{
            //Class.forName("Parent");
            Class.forName("Parent");
        }catch(Exception e){
            
        }
        System.out.println("=============== now , we create an Object below ===========");
        new Parent();
    }
}

 
测试结果：

 
测试结果符合上面的规则，我们先显示的加载了Parent类，所以后面在new Parent（）时就没有再加载类了。在创建对象时，先初始化普通成员，再执行普通代码块，最后调用构造方法。
 
下面加上子类进行测试。

public class InitObjectTest{
    public static void main(String[] args) {
        try{
            //Class.forName("Parent");
            //Class.forName("Parent");
        }catch(Exception e){
            
        }
        System.out.println("=============== now , we create an Object below ===========");
        new Child();
    }
}

测试结果：

 
当我们没有显示的加载类时，new对象时，会自动加载类。而输出的前四行就是，加载类的反应。后面的六行是创建对象的反应，先初始父类的普通成员，再执行父类的普通代码块，然后调用父类构造方法，然后进行子类的类似操作。完全符合上面描述的创建过程。
 
下面测试，先加载父类，然后直接创建子类对象。

public class InitObjectTest{
    public static void main(String[] args) {
        try{
            //Class.forName("Parent");
            Class.forName("Parent");
        }catch(Exception e){
            
        }
        System.out.println("=============== now , we create an Object below ===========");
        new Child();
    }
}

测试结果：

 
首先就加载了父类，在创建子类对象时需要加载子类，加载子类时，需要加载父类，而父类在之前就已经加载过了，所以这里并没有再次加载。
 三、总结
　　到此，静态成员、静态代码块、普通成员、普通代码块、构造方法以及父类的这些模块之间的执行时序就讲完了。分成加载和创建两个步骤来看，十分清晰，每个步骤中又涉及父类的加载，这是一个递归的过程。成员的初始化在代码块的执行之前，因为代码块可能会操作成员。代码块常常用于初始化成员。
　　本文个人编写，水平有限，如有错误，恳请指出，欢迎讨论分享
转载于:https://www.cnblogs.com/wanghang-learning/p/9275183.html

关于为什么局部内部类只能访问final变量和非静态成员内部类为什么不能定义static成员的问题，csdn的解答比较清楚，借鉴：

第一个问题：LLC必须访问方法内中final的变量或者参数归根到底是由于LLC所在方法中的局部变量的生命周期要短于LLC的生命周期。 

    描述：LLC定义在方法的内部，它可以访问方法中的变量和参数，当方法被调用时，局部变量和参数在栈内存中入栈，然后再在堆内存中创建一个内部类对象，方法调用结束后栈内存中的变量和参数就出栈消亡了，但是堆内存中的内部类对象是在没有对象变量引用它的时候才会被垃圾回收器给回收了，所以完全可能一个方法已调用结束（局部变量已死亡），但该局部类的对象仍然活着。即：局部类的对象生命期会超过局部变量。如果此时再调用LLC对象的方法，会由于局部变量不能访问发生编译错误， 

    解决办法：LLC对象可以访问同一个方法中被定义为final的局部变量。定义为final后，编译程序的实现方法：将所有的LLC对象要访问的final型局部变量，都拷贝成为该内部类对象中的一个数据成员。这样，即使栈中局部变量（含final）已死亡，但由于它是final,其值永不变，因而LLC对象在局部变量死亡后，照样可以访问final型局部变量。

第二个问题：这个跟编译器的内存处理有关系，静态成员变量需要在一开始就分配内存进行初始化，而一般的类成员只是在类实例化的时候才会为止分配内存初始化，从方面来说，假如允许非静态类中有静态成员变量，如下面所示： 

    class A{ 
        public class B{ 
            static string var_a; 
        } 
    } 


那么在程序一开始就需要给A.B.var_a分配内存并初始化，假如这个成立了，那么A.B也应该会有相应的内存，但是由于B只是A的一个非静态成员变量，在类A还没有实例化的时候就以及有了相应的内存(也就是非静态成员变量只有在类的实例中才会有相应的内存位置)，这样跟原来的标准有冲突，假如JAVA编译器（或者JAVA虚拟机）支持这种做法（其实也是可以实现的），这有的后果会导致编译器混乱无序的，大大增加了编译器的难度和复杂性，每一种语言都有预先制定好的语言标准，相对应的编译器都是基于这种标准来实现的，假如随意突破这种标准，那只会导致灾难性的后果而已。

参考： 
http://topic.csdn.net/u/20091003/18/c2d31cda-0e0f-4598-8f2e-becfb718c14b.html?17058