面向对象（下）【内部类的分类及成员内部类的直接使用】

内部类的位置：

成员位置：在成员位置定义的类，被称为成员内部类。

局部位置：在局部位置定义的类（方法内），被称为局部内部类。

class Outr{
      
      private int a = 10;
      
      //成员内部类
      class Inner{

          }
   
      public void sm（）{
         //局部内部类
         class Inner{


         }

     }
}

成员内部类的直接访问:
        外部类名.内部类名 对象名 = 外部类对象.内部类对象;

class Outer {
	private int num = 10;
	
	class Inner {
		public void show() {
			System.out.println(num);
		}
	}
}

class InnerClassDemo3 {
	public static void main(String[] args) {
		//需求：我要访问Inner类的show()方法
		//Inner i = new Inner();
		//i.show();
		
		//格式：外部类名.内部类名 对象名 = 外部类对象.内部类对象;
		Outer.Inner oi = new Outer().new Inner();
		oi.show();
	}
}

成员内部类的修饰符：
        private 为了保证数据的安全性 

       static 为了方便访问数据
            注意：静态内部类访问的外部类数据必须用静态修饰。

class Body {
           //private修饰的局部成员内部类
           //private修饰的内部类和变量只能在本类中访问
           //通常通过本类中的方法
			private class Heart {
				public void operator() {
					System.out.println("心脏搭桥");
				}
			}
			
			public void method() {
				if(如果你是外科医生) {
					Heart h = new Heart();
					h.operator();
				}
			}
		}
//nain方法中的调用
        按照我们刚才的讲解，来使用一下
		Body.Heart bh = new Body().new Heart();
		bh.operator();
		//加了private后，就不能被访问了，那么，怎么玩呢?
//正确操作：
        利用创建对象对Boby类中的方法进行调用
		Body b =  new Body();
		b.method();

 静态修饰的成员内部类---只能访问外部的静态修饰的数据---静态只能访问静态

内部类被静态修饰---其中内部类中的方法可以是静态也可以是非静态    

 //成员内部类被静态修饰后的访问方式是:
        //格式：外部类名.内部类名 对象名 = new 外部类名.内部类名();

class Outer {
	private int num = 10;
	private static int num2 = 100;
	
	//内部类用静态修饰是因为内部类可以看出是外部类的成员
	public static class Inner {
		public void show() {
			//System.out.println(num);
			System.out.println(num2);
		}
        //静态方法可以通过类名进行调用---类名.方法名
		public static void show2() {
			//System.out.println(num);
			System.out.println(num2);
		}		
	}
}

class InnerClassDemo4 {
	public static void main(String[] args) {
		//使用内部类
		// 限定的新静态类
		//Outer.Inner oi = new Outer().new Inner();
		//oi.show();
		//oi.show2();
		
		//成员内部类被静态修饰后的访问方式是:
		//格式：外部类名.内部类名 对象名 = new 外部类名.内部类名();
		Outer.Inner oi = new Outer.Inner();
		oi.show();
		oi.show2();
		
		//show2()的另一种调用方式
        //静态修饰的方法和类都可以通过类名进行调用
		Outer.Inner.show2();
	}
}

成员内部类练习一：

    要求请填空分别输出30，20，10。

注意：
        1:内部类和外部类没有继承关系。
        2:通过外部类名限定this对象
            Outer.this

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(new Outer().num); //创建匿名对象，然后调用---同样也可以实现
			System.out.println(Outer.this.num); //---通过外部类名来限定this的引用范围
		}
	}
}
class InnerClassTest {
	public static void main(String[] args) {
		Outer.Inner oi = new Outer().new Inner();
		oi.show();
	}	
}

 局部内部类
        A:可以直接访问外部类的成员
        B:在局部位置，可以创建内部类对象，通过对象调用内部类方法，来使用局部内部类功能

class Outer {
	private int num  = 10;
	
	public void method() {
		class Inner {
			public void show() {
				System.out.println(num);
				
			}
		}
		//在局部位置，可以创建内部类对象，通过对象调用内部类方法，来使用局部内部类功能
		Inner i = new Inner();
		i.show();
	}
}
class InnerClassDemo5 {
	public static void main(String[] args) {
		Outer o = new Outer();
		o.method();//通过调用method来间接的执行i.show()方法
	}
}

 面试题：
        局部内部类访问局部变量的注意事项?
        A:局部内部类访问局部变量必须用final修饰
        B:为什么呢?
            局部变量是随着方法的调用而调用，随着调用完毕而消失。
            而堆内存的内容并不会立即消失。所以，我们加final修饰。
            加入final修饰后，这个变量就成了常量。既然是常量。你消失了。
            我在内存中存储的是数据20，所以，我还是有数据在使用。

class Outer {
	private int num  = 10;
	
	public void method() {
		//int num2 = 20;
		//final int num2 = 20;
		class Inner {
			public void show() {
				System.out.println(num);
				//从内部类中访问本地变量num2; 需要被声明为最终类型
				System.out.println(num2);//20
			}
		}
		
		//System.out.println(num2);
		
		Inner i = new Inner();
		i.show();
	}
}

class InnerClassDemo5 {
	public static void main(String[] args) {
		Outer o = new Outer();
		o.method();
	}
}