面向对象--内部类--成员内部类

成员内部类

定义格式

程序示例

/*
    成员内部类：
        1、内部类可以访问外部类的成员，包括私有
        2、外部如何创建内部类对象
                  定义格式：外部类名.内部类名 对象名 = 外部类对象.内部类对象;
*/

class Outer3{
    private int num = 10;

    class Inner{
        public void show(){
            System.out.println(num);
        }
    }
}


public class InnerClassDemo3 {
    public static void main(String[] args) {
        //需求：我现在想要访问Inner类中的show()方法,就必须得创建对象
      
//        Inner inner = new Inner();
//        inner.show();
      //这样创建对象是访问不到的，因为Inner这个类是在Outer3类的内部
      //所以想要访问Inner这个类必须先创建Outer3类的对象

        //正确创建内部类的格式
        //外部类名.内部类名 对象名 = 外部类对象.内部类对象;
        Outer3.Inner oi = new Outer3().new Inner();
        oi.show();

      //等同于下面的格式
//        Outer3 outer3 = new Outer3();//先创建外部类对象
//        Outer3.Inner inner = Outer3().new Inner();//再创建内部类对象
//        inner.show();
    }
}

成员内部类常见的修饰符

程序示例

/*
        成员内部类常见的修饰符为：
            private:为了保证数据安全性
            static:为了方便访问数据

        静态修饰的特点：
            内部类如果是静态修饰的，只能访问外部类静态的成员
            内部类中成员方法如果是静态修饰的，只能访问外部类静态的成员
        
        当内部类是被静态所修饰的时候，出现了另一个创建内部类的格式
            访问格式如下：
                外部类类名.内部类类名 变量名 = new 外部类类名.内部类类名();
*/

class Outer4{
    private int num = 10;
    private static int num2 = 30;

    static class Inner4{
        public void show(){
   //内部类如果是静态修饰的，只能访问外部类静态的成员       
//            System.out.println(num);
            System.out.println(num2);
        }

        public static void show2(){
   //内部类中成员方法如果是静态修饰的，只能访问外部类静态的成员       
//            System.out.println(num);
            System.out.println(num2);
        }
    }
}

public class InnerClassDemo4 {
    public static void main(String[] args) {
        //Error:限定的新静态类，内部类是静态的可直接通过类名调用
      //而且静态内部类相当于外部类的静态成员，不能new（初始化）
//        Outer4.Inner4 oi4 = new Outer4().new Inner4();
//        oi4.show();

        //当内部类是被静态所修饰的时候，出现了另一个创建内部类的格式
        //访问格式如下：
        //外部类类名.内部类类名 变量名 = new 外部类类名.内部类类名();
      
         Outer4.Inner4 oi4 = new Outer4.Inner4();//只new了外部类因为内部类是静态的可直接访问
         oi4.show();
      //show2()是静态的内部类中的静态方法可直接通过类名调用
//        oi4.show2();
       //可直接通过类名调用
        Outer4.Inner4.show2();
    }
}

面试题

/*
  成员内部类面试题：
   class Outer {
		public int num = 10;
		class Inner {
			public int num = 20;
			public void show() {
				int num = 30;
				System.out.println(?);//num
				System.out.println(??);//this.num
				System.out.println(???);//Outer5.this.num
			}
		}
	}

	控制分别输出：30，20，10
*/

class Outer5 {
    public int num = 10;
    class Inner5 {
        public int num = 20;
        public void show() {
            int num = 30;
          
            System.out.println(num);
          
//每一个类中都有this关键字代表自身，将来谁调show()方法this就代表那个对象
            System.out.println(this.num);
          
            //Inner5与Outer5不是继承关系，没有super关键字
//            System.out.println(super.num);
          
          //Outer5.this代表Outer5的自身
            System.out.println(Outer5.this.num);
          
          //创建匿名对象调用成员变量
            System.out.println(new Outer5().num);
        }
    }
}

public class InnerClassDemo5 {
    public static void main(String[] args) {
        Outer5.Inner5 oi5 = new Outer5().new Inner5();
        oi5.show();
    }
}