静态变量

静态变量只能定义在方法之外、类中。静态方法、成员方法、main方法中都不能定义静态变量。但是可以被以上三个方法访问。

静态方法

四不

  • 不能定义静态变量 （方法的共同点）
  • 不能定义静态内部类 （方法的共同点）
  • 不能访问非静态变量 （成员变量）
  • 不能调用非静态方法 （成员方法）

四能 （上面四条逆否）

  • 能定义非静态内部类 理解为可以在静态方法中定义局部内部类
  • …

成员方法

二不

  • 不能定义静态变量
  • 不能定义静态内部类

五能

  • 能访问静态变量
  • 能调用静态方法
  • 能访问成员变量
  • 能调用成员方法
  • 能定义局部内部类

静态方法和成员方法总结

  • 不管是静态方法还是成员方法中，都不能定义static修饰的变量、类。也即静态变量和静态内部类
  • 不管是静态方法还是成员方法中，都可以出现局部内部类。

局部内部类

局部内部类就和方法中的局部变量一样，作用范围是方法内，无法在外边访问，随方法调用的结束而消亡。别妄想将局部内部类作为返回值返回。

成员内部类

和成员变量很类似，只不过它是一个类，不是一个变量。成员变量、成员方法这些都属于类的实例对象，成员内部类也不例外。在本类中，也不允许静态方法创建成员内部类对象

访问方式（创建对象）

其他类中访问

直接先new一个外部类实例，在通过外部类实例new内部类。

Outer outer = new Outer();

Outer.Inner inner1 = outer.new Inner();

或者写成一行

Outer.Inner inner = new Outer().new Inner();

package ljb;


/**
 * @author 李家宝
 * @date 2023/8/3 20:15
 */
public class Outer {

    class Inner{
        public static final String age="20";
        private String name;
    }
}
package ljb;

/**
 * @author 李家宝
 * @date 2023/7/30 15:46
 */
public class Test {

    public static void main(String[] args) {

        /**
         * new的时候 成员内部类不属于类的消息，属于实例
         * 所以要先new 实例 然后拿着实例new内部类
         */
        Outer.Inner inner = new Outer().new Inner();
        //或者下面这样
        Outer outer = new Outer();
        Outer.Inner inner1 = outer.new Inner();

        System.out.println(inner.age);
    }
}

在本类中访问

注意，由于成员内部类和成员变量类似的，静态方法不能访问成员变量，所以静态方法也不能访问成员内部类（创建成员内部类对象）。本类中访问则只能在成员方法中访问 直接new 对象就行

package ljb;


/**
 * @author 李家宝
 * @date 2023/8/3 20:15
 */
public class Outer {

    class Inner{
        public static final String age="20";
        private String name;
    }
    
   
    //成员内部类只能在成员方法内部访问
    public void test1(){
        Inner inner = new Inner();
        System.out.println(inner.age);
    }

}

静态内部类

静态内部类和静态变量一样，只能定义在方法外，类中，属于类的属性。

访问方式（创建对象）

其他类中访问

必须通过 外部类类名.静态内部类类名 new 外部类类名.静态内部类类名(); Outer.Inner inner = new Outer.Inner();

package ljb;
/**
 * @author 李家宝
 * @date 2023/8/3 20:15
 */
public class Outer {

    static class Inner{
        public static final String age="20";
        private String name;
    }
}
package ljb;

/**
 * @author 李家宝
 * @date 2023/7/30 15:46
 */
public class Test {

    public static void main(String[] args) {
        /**
         * new的时候 通过类名.静态内部类类名
         * 不能直接new Inner  也不能先new一个Outer对象再通过实例变量访问
         */
        Outer.Inner inner = new Outer.Inner();
        System.out.println(inner.age);
    }
}

在本类中访问

直接 new 对象就行 Inner inner = new Inner();

package ljb;


/**
 * @author 李家宝
 * @date 2023/8/3 20:15
 */
public class Outer {

    static class Inner{
        public static final String age="20";
        private String name;
    }

    public static void main(String[] args) {

        //在本类中访问直接new
        Inner inner = new Inner();
        System.out.println(inner.age);

    }
    //成员方法能访问
    public void test1(){
        Inner inner = new Inner();
        System.out.println(inner.age);
    }
    //静态方法也能访问
    public static void test2(){
        Inner inner = new Inner();
        System.out.println(inner.age);
    }
}