Javase之内部类概述

内部类概述

把类定义在其他类的内部就称为内部类

class A{

	class B{

	}

}

B就称为内部类，A称为外部类。

内部类的访问特点
1. 内部类直接访问外部类成员，包括私有。
2. 外部类要访问内部类要创建对象。
3. 内部类可用static修饰，它可以看作外部类的成员。
内部类的位置
1. 成员位置：在成员位置定义的类，称为成员内部类。
2. 局部位置：在局部位置定义的类，称为局部内部类。
```
class Outer{

	private int num = 10;

	//成员内部类

	class Inner1{

	}

	public void method(){

		//局部内部类

		class Inner2{

		}

	}

}
```
- 成员内部类
  - 访问方式：外部类名.内部类名对象名 = 外部类对象.内部类对象 （因为一般非静态成员可只能通过对象访问）
    
    Outer.Inner obj = new Outer().new Inner();
  - 修饰符
    
    private ：保证数据的安全行。
    
    static ：为了方便访问数据。
    
    注意：静态内部类访问外部成员时，只能访问外部的静态成员。
    
    此时访问内部类的方式为：外部类名.内部类名对象名 = new 外部类名.内部类名（）; （因为静态成员可直接通过类名访问）
    
    eg: Outer.Inner obj = new Outer.Inner();
  - 注意：
    
    1.内部类与外部类没有继承关系。
    
    2.内部类若要访问外部类的非静态成员，要通过外部类名限定this对象。(Outer.this)
```
class Outer{

	public int num = 10;

	class Inner1{

		public int num = 20;

		public void show(){

			int num = 30;

			System.out println(num);

			System.out println(this.num);

			System.out println(outer.this.num);

		}

	}

}
```
    out:
    
    30
    
    20
    
    10
- 局部内部类
  
  1.可直接访问外部类的成员。
  
  2.在局部位置，可创建内部类对象，通过对象调用内部类的方法，来使用局部内部类的功能。
  - 局部内部类访问局部变量的注意事项：
    1.局部内部类访问的局部变量必须要被final修饰。
    
    2.原因：局部变量随着方法的调用而调用，方法调用完毕就消失。而堆内存的内容不会立即消失，所以，要用final修饰局部变量。加入final修饰后，所有调用这个变量的地方就变成常量数据，常量在内存中存在是固定的，故即使局部变量随着方法调用而消失，数据依旧存在。
```
class Outer{

	private int num1 = 10;

	public void method(){

		//局部内部类

		final int num2 = 20;

		class Inner{

			public void show(){

				System.out.println(num1);

				//从内部类访问本地变量num2；num2需要被申明为最终类型。

				System.out.println(num2);

			}

		}

	}

}
```

匿名内部类

内部类的简化写法

前提：存在一个类（抽象类）或接口。

格式：

new 类名（抽象类名）或接口名（）{

重写方法；

}

本质：是一个继承该类或实现改接口的子类的匿名对象。

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

class Outer {
    public void method() {
        new Inter(){
            public void show() {
                System.out.println("show");
            }
            //只调用一个匿名内部类的方法时直接在new出的对象后面加要调用的方法名。
        }.show();
        //若要调用匿名内部类的多个方法则把匿名内部类变成有名的。(通过多态)
        Inter i = new Inter(){
            public void show() {
                System.out.println("show");
            }
             public void show2() {
                System.out.println("show2");
            }            
        }
        i.show();
        i.show2();
    }
}
class Main {
    public static void main(String[] args) {
        Outer o = new Outer();
        o.method();
    }
}

匿名内部类的应用

interface Inter {
    public abstract void show();
}

class InterTest {
    //接口作为形参，要的不是接口而是接口的实现类
    public void method(Inter p) {
        p.show();
    }
}

class InterImp implement Inter {
    public void show() {
        System.out.println("show");
    }
}

class Outer {
    public static void main(String[] args) {
        InterTest it = new InterTest();
        Inter i = new InterImp();
        it.show();
        
        //匿名内部类在开发中的使用
        //匿名内部类的本质是继承该类或实现改接口的子类的匿名对象。
        //作用：方法结束匿名内部类就被回收节省资源。
        it.show(new Inter() {
            public void show() {
       	 		System.out.println("show");
    		}
        });
    }
}

匿名内部类的案例

补齐代码：
interface Inter { void show();}

class Outer {
//补齐代码
}

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

//要求输出“hello world”

 interface Inter { void show();}

 class Outer {
     //补齐代码
     public static Inter method(){
         return new Inter(){
             public static void show(){
                 System.out.println("hello world");
             }  
         };
     }
 }

 class Main {
     public static void main(String[] args){
         Outer.method().show();
         //由Outer.method()可以看出method()为静态方法，而Outer.method().show();
         //则说明method()方法的返回值类型为Inter所以
     }
 }