黑马程序员——内部类

------- android培训、java培训、期待与您交流！ ----------

内部类的定义：

           将一个类定义在另一个类的里面，对里面那个类就称为内部类，也可以叫做内置类，内嵌类。

内部类的访问特点：

           内部类可以直接访问外部类中的成员，包括私有的成员

            外部类想要访问内部类中的成员，必须要建立内部类的对象

class Outer{
	private int x = 5;
	
	class Inner{//内部类
		public int y = 10;
		public void show(){
			System.out.println("Inner "+x);//可以直接访问外部类的成员变量
		}
	}
	public void outerShow(){
		Inner in = new Inner();//创建内部类对象
		System.out.println(in.y);//访问内部类的成员
	}
}

         当内部类中出现同名的成员变量时，如果变量前面没有指定的引用，则访问最近的，否则访问指定的，例如：

    

class Outer{
	private int x = 5;
	
	class Inner{//内部类
		public int x = 10;
		public void show(){
			int x = 15;
			System.out.println("Inner "+x);//访问方法内部的x=15
			System.out.println("Inner "+this.x);//访问内部类中的x=10,访问本类的成员变量，默认省略的是this.
			System.out.println("Inner "+Outer.this.x);//访问外部类中的x=5，同时自没有同名的变量时，访问外部类省略的是Outer.this.
		}
	}

内部类的访问格式：

        1 . 当内部类定义在外部类的成员位置上，而且非私有的，可以在外部其他类中直接建立内部类的对象

             格式：

                  外部类名.内部类名   变量名 = 外部类对象.内部类对象

                  

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

        2 . 当内部类在成员位置上时，就可以被成员修饰符所修饰

                private ： 将内部类在外部类中进行封装

                static  ： 内部类具备static的一些特性

                当内部类被static修饰后，只能直接访问外部类中的static成员，出现了访问局限

                在外部其他类中，访问static内部类的非静态成员和静态成员：

                      

class Outer{
	private static int x = 5;
	
	static class Inner{//内部类
		public void show(){
			System.out.println("Inner "+x);//x必须是静态的
		}
	    public static void method(){//内部类中的静态成员
	    	System.out.println("static method");
	    }
	}
}
public class Test1 {

	public static void main(String[] args) {
		new Outer.Inner().show();//直接访问静态内部类中的非静态成员
		Outer.Inner.method();//直接访问静态内部类中的静态成员
	}
}

              注意： 当内部类中定义了静态成员时，该内部类必须是静态的。

                            当外部类中的静态方法访问内部类是，内部类必须是静态的。

             3 . 当内部类定义在局部时：

                       1 . 不可以被成员修饰符修饰

                        2. 可以直接访问外部类中的成员，因为还持有外部类的引用（Outer.this.），但是不可以访问他所在的

                              局部中的变量，只能访问被final修饰的局部变量。

class Outer{
	private  int x = 5;
	
	 public void method(){
		 final int y = 10;
		 class Inner{//内部类定义在局部
			 public void show(){
				 System.out.println("Inner "+x);//直接访问外部类的成员变量
				 System.out.println("Inner "+y);//只能访问被final修饰的y
			 }
		 }
		 new Inner().show();//method方法使用内部类，创建内部类的对象
	 } 
}
public class Test1 {

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

内部类的定义原则：

              当描述事物时（类是用来描述事物的），事物的内部还有事物，该事物用内部类来描述。

              因为内部事物在使用外部事物的内容。

匿名内部类：

            1 . 匿名内部类其实就是内部类的简写格式

            2 . 定义匿名内部类的前提：

                        内部类必须是继承一个类或者是实现接口

            3 . 匿名内部类的格式： 

                            new 父类或者接口（）{定义子类的内容}

            4 . 其实匿名内部类就是一个匿名的子类对象，而且这个对象有点胖，可以理解为带内容的对象

            5 . 匿名内部类中定义的方法最好不要超过三个

interface Inter{//内部类的父类接口
	void method();
}
class Test{
	public static Inter function(){
		return new Inter(){//匿名内部类
			public void method(){
				System.out.println(3<<3);
			}
		};
	}
}
public class Test1 {

	public static void main(String[] args) {
		Test.function().method();//调用method方法
	}
}

      匿名内部类的不足： 

                        1  代码的阅读性比较差

                        2  不能调用匿名子类的特有方法，只能调用父类定义的方法。