day04(权限修饰符，内部类，局部内部类，匿名内部类)

权限修饰符，

　　　　Public  >protected >default > private

　　　　public 公共权限   随便都可以访问

　　　　protected  子类可以访问权限  （子类跨包访问父类）

package day04.demo01;
public class Demo02 {
    public void public01(){}
    protected static void protected01(){
    	System.out.println("protected");
    }
    static void default01(){
    	System.out.println("default");
    }
    private static void private01(){
    	System.out.println("private");
    }
}

 方法定义在demo01下    在demo02下进行调用   

　　　　default 默认权限  同一包下    出了包 就访问不到default01方法

　　　　private  出了当前类 其他类都不能访问

内部类，

　　1.在类的内部，创建类，这个类称为内部类 这个类跟普通类没有区别

　   　2.内部类和类只是内部和外部的关系，不是子父类的关系 ，但可以使用this关键字

class Outer{
	 int num=10;
	public void method(){
		System.out.println("Out Method");
	}
	class Inner{//內部类
		int num=20;
		public void method(){
			System.out.println("Inner Method");
			System.out.println(num);//20   就近原则
			System.out.println(this.num);//使用this调用当前类下成员变量
			System.out.println(Outer.this.num);//使this指向Outer类中的成员变量
			Outer.this.method();//调用Outer下的method方法
		}
	}
}

　说明  在Inner的对象中有一个值指向了Outer对象

　

输出结果
Inner Method
20
20
10
Out Method

　　

局部内部类，

     位置：方法中　

class Outer{
	 int num=10;
	public  void method(){
		class Inner{//內部类  创建在在方法中   称为   局部内部类
			int num=20;
			public void method(){
				System.out.println("Inner Method");
				System.out.println(num);//20
				System.out.println(this.num);//使用this调用Outer类下成员变量 20
				System.out.println(Outer.this.num);//10
			}
		}
		Inner i=new Inner();//必须在Inner类后调用   否则无法识别
		i.method();
		System.out.println(i.num);//20
	}
	
}

　　

输出结果：
Inner Method
20
20
10
20

　　

匿名内部类，

　　一般的实现接口类

　　

interface Inter01 {
	public abstract void eat();
}

public class Animal implements Inter01 {
	public void eat() {
		System.out.println("eat");
	}

	public static void main(String[] args) {
		Animal a = new Animal();
		a.eat();
	}
}

　　使用匿名内部类：创建一个类（抽象类，接口）   并创建该类的对象  实现方法

　　　　　　优点：如果一个实现接口类只调用一次，使用内部来调取，会节约内存

　　　　注意事项：

　　　　　　在方法中匿名内部类外  定义一个变量  如果匿名内部类使用了该变量  则改变量需要使用final 修饰    

　　　　　　原因：因为这个匿名内部类对象执行完以后还会存在   在匿名内部类中会调用到该变量  

　　　　　　 如果该变量在执行方法完后，会消失，所以该变量必须被final修饰成为常量存储在方法区的常量池中。

class Test {
	public void method() {
		final int num=10;
		new Inter01() {
			@Override
			public void eat() {
				System.out.println(num);
			}
		};
	}
}