Java内部类的概述和访问特点，成员内部类，局部内部类，匿名内部类

内部类的概述和访问特点

/*
    内部类的概述和访问特点
	 
	 内部类的概述
	     把类定义在其他类的内部，这个类就被称为内部类
 	
	内部类的访问特点;
	   A:内部类可以直接访问外部类的成员，包括私有
	   B:外部类要访问内部类的成员，必须创建对象
*/
/*
  内部类的位置
        成员位置：在成员方法的位置定义的类被称为成员内部类
		局部位置：在局部位置（成员方法中）定义的类被称为局部内部类
*/

/*
     成员内部类
	     如何访问成员内部类
		 格式：
		     外部类名.内部类名 对象名 = new 外部类对象().new内部对象(); 
*/
class Out{
	private int num =  10;
	
	class Inner{
		public void show(){
			System.out.println(num);
		}
	}
}
class Dome{
	public static void main(String[] args){
		//格式：
		   // 外部类名.内部类名 对象名 = new 外部类对象().new内部对象();
		   Outer.Inner oi = new Outer().new Inner();
		   io.show();
	} 
}

成员内部类

//成员内部类的修饰符
/*
  成员内部类的修饰符
    第一个 private：为了保证数据的安全性
	  
  案例：我有一身体，身体内有心脏
	    class Body{
			   private class Heart{
				   public void operator(){
					    System.out.println("心脏搭桥");
				   }
			   }
			public void method(){
				if(如果你是医生){
					Heart  h = new Heart();
					h.operator();
				}
			}   
		}  
		
		按照我们刚才的讲解，来使用一下
		Boy.Heart bh = new Body().new Heart();
		bh.operator();
		加了private后，就不能被访问了
		Body b = new Body();
		b.method();
*/

/*
     成员内部类的修饰符
             static：为了数据访问更方便
			    注意：静态内部类访问的外部数据必须用静态修饰
*/
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 Dome{
	public static void mian(String[] args){
	     //使用内部类
		 //编译错误：限定新静态类
		 //Outer.Inner oi = new Outer().new Inner();
		 //oi.show();
		 //oishow2();
		 
		 //成语内部类被静态修饰后的访问方式是：
		 //格式：外部类名.内部类名  对象名 = 外部类名.内部类名();
		 
		 //静态可以通过类名调用
		 //show2的另一种调用方式
		 Outer.Inner.show2();
	}
}
/*
  面试题：
      要求：分别输出30 20 10；
	注意：
       1.内部类和外部类没有继承关系
       2.通过外部类名限定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);
		   }
	   }
}
class  Dome{
	public static void mian(String[] args){
		Outer.Inner oi = new Outer().new Inner();
		oi.show();
	}
}

局部内部类

/*
      局部内部类
              A:可以直接访问外部类的成员
			  B:在局部位置，可以创建内部类对象，通过调用内部类方法，来使用内部类功能
			  
	面试题：
        局部内部类访问局部变量的注意事项？
           A:局部内部类访问局部变量，局部变量必须用final修饰		
			B:为什么？
                局部变量是随着方法的调用而调用，随着调用完毕而消失。
                而对内存的内容并不会立即消失。所以我们加fianl修饰。
                加入final修饰后，这个变量就变成了常量。既然是常量。你消失了
                而我在内存中存储的是数据20，所以，我还是有数据在使用				
			  
*/
class Outer{
	private int num = 10;
	
	public void methon(){
		final int num2 = 20;
		class Inner{
			public void show(){
				System.out.println(num);
				//从内部类中访问本地变量num2;需要被声明为最终型
				System.out.println(num2);
			}
		}
		Inner i = new Inner();
		i.show();
	}
}
class  Dome{
	public static void mian(String[] args){
		Outer o = new Outer();
		o.methon();
	}
}

匿名内部类

/*
     匿名内部类
	       就是内部类的简化写法
		   
	前提:存在一个类或者接口	   
	     这里的类可以是具体的类也可以是抽象类
	 
	 格式：
	    new 类名或者接口名（）{
			重写方法；
		}
	 本质;
	     是一个继承来该类或者实现了该接口的子类匿名对象。
*/
interface Inter{
	public static void show();
	public static void show2();
}
class Outer{
	//一个方法的时候
	publc void method(){
		new Inter(){
			public static void show(){
				System.out.println("show");
			}
		}.show();
	}
	//两个方法时候，就需要写两次匿名对象一次只可以调用一次
	publc void method(){
		new Inter(){
			public static void show(){
				System.out.println("show");
			}
			public static void show2(){
				System.out.println("show2");
			}
		}.show();
	}
	publc void method(){
		new Inter(){
			public static void show(){
				System.out.println("show");
			}
			public static void show2(){
				System.out.println("show2");
			}
		}.show2();
	}
	//如果我是有很多个方法，就很麻烦了
	//那么，我们有没有改进方法呢？
	//多态
	Inter i = new Inter(){
		    public static void show(){
				System.out.println("show");
			}
			public static void show2(){
				System.out.println("show2");
			}
	};
	i.show();
	i.show2();
}
class Dome{
	public static void main(String[] args){		
	         Outer id = new Outer();
			 id.method();
	} 
}
/*
  匿名内部类在开发中的使用
*/
interface Person{
      public  abstract void study();	
}
class PersonDome{
	//接口名作为形式参数
	//其实这里需要的不是接口，而是该接口的实现类的对象
	public void method(Person p){
		p.study();
	}
}
//实现类
class Studtent implements Person{
	public void study{
		System.out.println("好好学习，天天向上");
	}
}
class Dome{
	public static void main(String[] args){
		PersonDome i = new PersonDome();
		Person p = new Studtent();
		i.method(p);
		
		//匿名内部类在开发中的使用 
		//匿名内部类的本质继承类或者实现了接口的子类匿名对象
		i.method(new Person(){
			public void study(){
				System.out.println("好好学习，天天向上");
			}
		});
	}
}
/*
    面试题
	按照要求，补齐代码
	  interface Inter{void show();}
	  class Outer{//补齐代码}
	  class OutDome{
		  public static void mian(string[] args){
			  Outer.method.show();
		  }
	  }
	  要求在控制台输出“Hello Word”
*/
 interface Inter{
	 void show();
}
class Outer{
		 public static inter method(){
			return new Inter(){
				 public void show(){
					 System.out.println("Hello Word");
				 }
			 };
		 }
}
class OutDome{
	public static void mian(string[] args){
		  Outer.method.show();
		  /*
		  1.Outer.method()可以看出method应该是Outer中的一个静态方法
		  2.Outer.method.show();可以看出methon()方法的返回值是一给个对象
		          又因为接口Inter中有一个show方法，所以我认为method()方法的返回值类型是一个接口
		  */
    }
}