JAVASE_Day03内部类(实例/静态/局部/匿名)

package com.anonymous.javase.day03;
//实例内部类
class Outter{
	String name = "Outter";//外部类的字段
	public void testOutter(){
		//访问内部类的字段
		System.out.println(this.new Inner().name);
		//访问内部类的方法
		//this.new Inner().testInner();
		/**
		 * 注掉的原因:会和下面的函数互相调用,VM无限制调用,最后报错
		 */
	}
	class Inner{
		String name = "Inner";
		public void testInner(){
			String name  = "TestInner";
			//访问当前的方法的的name
			System.out.println(name);//TestInner
			/**
			 * 因为局部变量将全局变量的值隐藏掉了,默认遵守就近原则
			 * 这里并不将name覆盖
			 */
			//访问全局变量
			System.out.println(this.name);
			//访问外部类的字段
			System.out.println(Outter.this.name);
			//访问外部类的方法
			Outter.this.testOutter();
		}
	}
}

public class Demo2 {
	public static void main(String[] args) {
		//创建实例内部类对象
		//创建外部类对象
		Outter out = new Outter();
		System.out.println(out.name);
		out.testOutter();
		System.out.println("----------");
		//创建内部类对象
		Outter.Inner in= out.new Inner();
		in.testInner();
		
		
		//创建内部类对象格式
		//1:先创建外部类对象
		//外部类对象 外部类对象名 = new 外部类对象();
		//2:创建内部类对象
		//外部类对象.内部类对象 内部类对象名 = 外部类对象名.new 内部类对象();
		//外部类 Outter 内部类Inner
		//简化格式:Outter.Inner in = new Outter().new Inner();
		
	}
}

package com.anonymous.javase.day03;


//外部类
class OutTest{
	String name = "Jan";
	static String age = "34";
	
	public void test2(){
		//访问内部类的全局字段
		System.out.println(new InTest().name);
		//访问内部类的静态字段
		System.out.println(InTest.age);
	}
	//静态内部类
	static class InTest{
		static String age = "00";
		String name = "jieke";
		public void test1(){
			String name = "SORE";
			String age = "11";
			//访问全局(实例)变量
			System.out.println(this.name);
			//访问局部变量
			System.out.println(name);
			//访问外部类的全局(实例)字段
			System.out.println(new OutTest().name);
			//访问外部类static修饰的字段
			System.out.println(OutTest.age);
			//访问局部变量
			System.out.println(age);
			//System.out.println(this.age);
			//访问外部类静态字段..建议使用类名访问.不要使用this访问,
			//相当于对象访问,不合理
			System.out.println(InTest.age);
			
			/**
			 * 访问小总结:静态内部类中
			 * 内部类---(访问)-->外部类
			 * 访问静态字段--->使用类名直接访问--->类名.字段名
			 * 访问实例字段--->使用对象访问-->对象.字段名
			 * 
			 * 内部类----->内部类
			 * 访问全局变量--->this.字段名
			 * 访问局部变量--->字段名
			 * 静态字段-->类名.字段名
			 * 
			 * 
			 * 外部类访问内部类
			 * 访问静态字段--->类名.字段
			 * 访问实例成员--->对象.字段
			 * 
			 * 
			 * 外部类访问外部类
			 * 访问全局变量--->this.字段名
			 * 访问局部变量--->字段名
			 * 访问静态字段--->类名.字段名
			 */
			
			/**
			 * 注意事项:
			 * 不建议在静态内部类中定义静态方法,这样会造成static无法和this
			 * (super也是一样的)共存,如果必须定义静态字段,建议访问实例成员时,
			 * 使用对象访问,这样可以避免this和static共存问题
			 * 
			 */
		}
	} 
}

public class Demo3 {
	public static void main(String[] args) {
		//创建外部类对象
		OutTest outTest = new OutTest();
		outTest.test2();
		//创建内部类对象
		OutTest.InTest inTest = new OutTest.InTest();
		inTest.test1();

		//创建静态内部类语法
		//外部类类名.内部类类名 内部类名= new 外部类类名.内部类类名();
	}
}

package com.anonymous.javase.day03;
//局部内部类
public class Demo4 {
	int b = 3;
	static String gender = "男";
	public static void main(String[] args) {
		int a = 1;
		class Local{
			String name = "杰克";
			public void test(){
				String name = "ROSE";
				//访问内部类实例成员
				System.out.println(this.name);
				//访问外部类的静态变量
				System.out.println(Demo4.gender);
				//访问局部变量
				System.out.println(name);
			}
		}
		//创建内部类对象
		Local local = new Local();
		local.test();
		
	}
}

package com.anonymous.javase.day03;

interface Father{
	void test();
}

class Son implements Father{

	public void test() {
		System.out.println("简单");
	}
	
}
public class Demo5 {
	public static void demo(Father father){
		father.test();
	}
	public static void main(String[] args) {
		Demo5.demo(new Son(){
			public void test(){
				System.out.println("即可");
			}
		});
	}
}