内部类概述

在 Java 中，可以将一个类定义在另一个类里面或者一个方法里面，这样的类称为内部类。

成员内部类
局部内部类
匿名内部类

成员内部类

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


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

class InnerClassDemo {
	public static void main(String[] args) {
		// 访问Inner类的show()方法

        //格式：外部类名.内部类名 对象名 = 外部类对象.内部类对象;
		Outer.Inner oi = new Outer().new Inner();
		oi.show();
	}
}

而成员内部类的使用，一般来说，在实际开发中是不会这样直接使用的，因为一般内部类就是为了不让外界直接访问的

因此，对Inner的show()方法进行保护，使用private为了保证数据的安全性


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

class InnerClassDemo {
	public static void main(String[] args) {
		// 访问Inner类的show()方法
        Outer o = new Outer();
        o.GetShow();
	}
}

使用static修饰让数据访问更加方便

被静态修饰的成员内部类只能访问外部类的静态成员
内部类被静态修饰后方法
- 静态方法
- 非静态方法


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

		public static void show2() {
			System.out.println(num2);
		}		
	}
}

class InnerClassDemo {
	public static void main(String[] args) {
		Outer.Inner oi = new Outer.Inner();
		oi.show();
		oi.show2();
		System.out.println("----------");
		//show2()的另一种调用方式
		Outer.Inner.show2();	
	}
}

思考

问

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

class Outer {
	public int num = 10;
	class Inner {
		public int num = 20;
		public viod show() {
			int num  = 30;
			System.out.println(?);
			System.out.println(?);
			System.out.println(?);
		}
	}
}

答

class Outer {
	public int num = 10;
	class Inner {
		public int num = 20;
		public viod show() {
			int num  = 30;
			System.out.println(num);
			System.out.println(this.num);
			System.out.println(Outer.this.num);
		}
	}
}
      class InnerClassDemo4 {
          public static void main(String[] args) {
              Outer.Inner oi = new Outer().new Inner();
              oi.show();
          }
      }

注意：

内部类和外部类没有继承关系
通过外部类名限定this对象，（Outer.this）

局部内部类

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

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 InnerClassDemo4 {
	public static void main(String[] args) {
        // 创建外部类对象，调用method()方法
		Outer o = new Outer();
		o.method();
	}
}

思考

问

局部内部类如何访问局部变量？

答

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

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

局部内部类访问局部变量必须用final修饰

局部变量是随着方法的调用而调用，随着调用完毕而消失。
而堆内存的内容并不会立即消失。所以，我们加final修饰。
加入final修饰后，这个变量就成了常量。既然是常量。你消失了。
在内存中存储的是数据20，所以，我还是有数据在使用。

匿名内部类

匿名内部类可以使你的代码更加简洁，你可以在定义一个类的同时对其进行实例化。它与局部类很相似，不同的是它没有类名，如果某个局部类你只需要用一次，那么你就可以使用匿名内部类

前提

存在一个类或者接口
这里的类可以是具体类也可以是抽象类。

格式

new 类名或者接口名(){
    重写方法;
}

本质

是一个继承了该类或者实现了该接口的子类匿名对象。

interface Inter {
	public abstract void show();
}

class Outer {
	public void method() {
        // new 类名或者接口名(){}
		new Inter() {
            // 重写方法
			public void show() {
				System.out.println("show");
			}
		};
	}
}

调用

因此既然new Inter(){};这一坨是一个对象，那么对象调用show()方法还不简单？

// 接口
interface Inter {
	public abstract void show();
}

class Outer {
	public void method() {
        // new 类名或者接口名(){}
		new Inter() {
            // 重写方法
			public void show() {
				System.out.println("show");
			}
		}.show();
	}
}

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

如果Inter接口有两个方法，那如何调用？

interface Inter {
	public abstract void show();
	public abstract void show2();
}

class Outer {
	public void method() {

		
		//二个方法的时候
        // 编译看左边，运行看右边
		Inter i = new Inter() { //多态
			public void show() {
				System.out.println("show");
			}
			
			public void show2() {
				System.out.println("show2");
			}
		};
		
		i.show();
		i.show2();
	}
}

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

思考

问

如何使用PersonDemo调用study()方法？

interface Person {
	public abstract void study();
}

class PersonDemo {
	//接口名作为形式参数
	//其实这里需要的不是接口，而是该接口的实现类的对象
	public void method(Person p) {
		p.study();
	}
}

答

看到此，一般会想到使用具体类来实现接口，在实现类中重写study()方法即可

//实现类
class Student implements Person {
	public void study() {
		System.out.println("好好学习,天天向上");
	}
}

class InnerClassTest {
	public static void main(String[] args) {
		//测试
		PersonDemo pd = new PersonDemo();
		Person p = new Student();
		pd.method(p);
	}
}

这种方然固然可行，那么采用匿名内部类的方式来实现：

class InnerClassTest {
	public static void main(String[] args) {
		// 测试
		PersonDemo pd = new PersonDemo();
        // 匿名内部类的本质是继承类或者实现了接口的子类匿名对象
		pd.method(new Person(){
			public void study() {
				System.out.println("好好学习,天天向上");
			}
		});
	}
}

这种方式占内存较少，占用内存即可及时回收，一般在Android中使用的比较多，因为只使用一次，匿名回收，使用结束即回收

思考

问

按照要求，补齐代码
    interface Inter { 
    	void show(); 
	}
    class Outer { 
        //补齐代码 
    }
    class OuterDemo {
        public static void main(String[] args) {
              Outer.method().show();
          }
    }
    要求在控制台输出”HelloWorld”

答

首先从Outer.method()直接通过类名访问方法，可以判断出是一个静态方法
Outer.method().show()后面还跟着调用show()方法，即可知道Outer.method()返回值是一个对象，对象为Inter

   interface Inter { 
   	void show(); 
}
   class Outer { 
       // 返回对象为Inter的静态方法
       public static Inter method(){
           // 返回接口对象
           return new Inter(){
               public void show(){
                   System.out.println("HelloWorld");
               }
           }
       }
   }
   class OuterDemo {
       public static void main(String[] args) {
             Outer.method().show();
         }
   }

你学废了吗？