内部类知识点

内部类

概念

字面意思，在类的内部编写的类就叫内部类
内部类一般来说包括这四种：1.成员内部类  2.局部内部类
                        3.匿名内部类  4.静态内部类

1.成员内部类

 在类的内部方法的外部编写的类就是成员内部类。

成员内部类特点

☄成员内部类可以无条件访问外部类的所有成员属性和成员方法
（包括private成员和静态成员）。

☄同名属性名方法名时访问外部类 外部类.this.成员名。
（MemberDemo.this.name）

☄成员内部类是依附外部类而存在的，也就是说，如果要创建成员内部类的对象，
前提是必须存在一个外部类的对象。所以在外部类访问内部类的时候必须先实例化
外部类对象。（`		MemberDemo member = new MemberDemo();
	Inner inner = member.new Inner();`）

☄成员内部类可以使用四种权限修饰符进行修饰。

☄成员内部类中不能书写静态变量和方法。

演示案例

public class MemberDemo {
	String name = "王五";
	static int age = 10;
	
	public static void show() {
		System.out.println("调用外部类中的show方法");
		
	}
	
	public void printf() {
		System.out.println("调用外部类中的打印方法");
	}
	
	//成员内部类 可以使用权限修饰符进行修饰
	public class Inner{
		//static double height=1.8;  成员内部类中不能使用static修饰变量和方法
		
		String name="张三";
		//成员内部类可以直接访问外部类的属性和方法
		public void innerShow() {
			show();
			printf();
			System.out.println(age);
			System.out.println("我是："+name);
			System.out.println("我是："+MemberDemo.this.name);//进行特指访问时 使用类名.this.变量名进行访问
		}
	}
	
	
	public static void main(String[] args) {
		//成员内部类对象的创建步骤
		//第一步需要实例化外部类对象
		//第二步正常实例化内部类对象 但是new关键字要改成 外部类对象名.new
		MemberDemo member = new MemberDemo();
		Inner ineer = member.new Inner();
		ineer.innerShow();
	} 
	
}

结果： 调用外部类中的shoW方法
      调用外部类中的打印方法
     10
  我是:张三
  我是:王五

2.局部内部类

  编写在方法的内部的类称之为局部内部类

局部内部类的特点

☄局部内部类是定义在一个方法或者一个作用域里面的类，
它和成员内部类的区别在于局部内部类的访问仅限于方法内或者该作用域内。

☄局部内部类不可使用权限修饰符 静态修饰符进行修饰 同局部变量相同

☄局部内部类可以直接访问方法中的属性

☄局部内部类 可以直接访问方法外部类中属性和方法

☄局部内部类 创建对象 要在方法内部 局部内部类的外部声明

演示案例

public class PartialDemo {
		String name = "王五";
		static int age = 10;
		
		public static void show() {
			System.out.println("调用外部类中的show方法");
			
		}
		
		public void printf() {
			System.out.println("调用外部类中的打印方法");
		}
			
		public void demo() {
			String name = "张三";
			double height = 1.8;
			//编写在方法的内部的类称之为局部内部类
			//局部内部类不可使用权限修饰符 静态修饰符进行修饰 同局部变量相同
			//局部内部类与局部变量使用范围一样 在此方法内部
			//局部内部类可以直接访问方法中的属性 重名时使用参数传递完成访问
			
			//局部内部类 可以访问方法外部类中属性和方法  
			
			 class Inner{
				  String name = "李四";				  
				  public void showInner(String name) {
					  show();
					  printf();
					  System.out.println(age);
					  System.out.println(height); 
					  System.out.println("这是:"+PartialDemo.this.name);
					  System.out.println("这是："+name);
					  System.out.println("这是："+this.name);
					 
				  }
			}
			 //局部内部类 创建对象 要在方法内部 局部内部类的外部声明
			 Inner inner=new Inner();
			 inner.showInner(name);
			 
		}
		
		public static void main(String[] args) {
			PartialDemo partialDemo = new PartialDemo();
			partialDemo.demo();
			
		}

	

}

 结果：调用外部类中的shoW万法
 调用外部类中的打印方法
 10
 1.8
这是:王五
这是:张三
这是:李四

3.匿名内部类

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

开发中，最常用到的内部类就是匿名内部类了。以接口举例，当你使用一个接口时，似乎得做如下几步操作。

1、定义子类

2、重写接口中的方法

3、创建子类对象

4、调用重写后的方法

我们的目的，最终只是为了调用方法，那么能不能简化一下，把以上四步合成一步呢？匿名内部类就是做这样的快捷方式。

条件

 匿名内部类必须继承一个父类或者实现一个父接口。

格式

new 父类名或者接口名(){
    // 方法重写
    @Override 
    public void method() {
        // 执行语句
    }
};

演示案例

以接口为例，匿名内部类的使用，代码如下：

 定义接口：

public abstract class FlyAble{
    public abstract void fly();
}

创建匿名内部类，并调用：

public class InnerDemo {
    public static void main(String[] args) {
        /*
        1.等号右边:是匿名内部类，定义并创建该接口的子类对象
        2.等号左边:是多态赋值,接口类型引用指向子类对象
        */
        FlyAble  f = new FlyAble(){
            public void fly() {
                System.out.println("我飞了~~~");
            }
        };

        //调用 fly方法,执行重写后的方法
        f.fly();
    }
}

通常在方法的形式参数是接口或者抽象类时，也可以将匿名内部类作为参数传递。
代码如下：

public class InnerDemo2 {
    public static void main(String[] args) {
        /*
        1.等号右边:定义并创建该接口的子类对象
        2.等号左边:是多态,接口类型引用指向子类对象
       */
        FlyAble  f = new FlyAble(){
            public void fly() {
                System.out.println("我飞了~~~");
            }
        };
        // 将f传递给showFly方法中
        showFly(f);
    }
    public static void showFly(FlyAble f) {
        f.fly();
    }
}

 以上两步，也可以简化为一步，代码如下：

public class InnerDemo3 {
    public static void main(String[] args) {           
        /*
           创建匿名内部类,直接传递给showFly(FlyAble f)
        */
        showFly( new FlyAble(){
            public void fly() {
                System.out.println("我飞了~~~");
            }
        });
    }

    public static void showFly(FlyAble f) {
        f.fly();
    }
}

4.静态内部类

 在类中编写的以static修饰的类称为静态内部类

静态内部类特点

☄静态内部类也是定义在另一个类里面的类，只不过在类的前面多了一个
关键字static。

☄静态内部类是不需要依赖于外部类的，这点和类的静态成员属性有点类似，
并且它不能使用外部类的非static成员变量或者方法。

☄静态内部类中即能声明静态成员也可以声明非静态成员。

演示案例

public  class StaticDemo {
	static String name="王五";
	
	public static class Inner{//四种权限修饰符可以修饰静态内部类
		 //静态内部类中不能访问外部类非静态成员 
		String name="张三";
		static int age=18;
		double height=1.8;
		public void show() {
			//重名时 访问外部类的静态变量使用类名.属性名访问
			System.out.println("这是"+name);
			System.out.println("这是"+StaticDemo.name);
			System.out.println(age);
			System.out.println(height);
		}

			
	}
	
	public static void main(String[] args) {
		//静态内部类可以直接实例化 不需要依附于外部类
		Inner inner = new Inner();
		inner.show();
		
	}

}

 结果：这是张三
 这是王五
 18
 1.8