m，若没有，则编译失败，若为Zi f = new Zi();则打印Zi中的num，此时Zi类中不定义num打印为3，因为继承了父类的num。

开发是不会出现此类情况，因为父类中定义的东西直接拿过来用就可以，不用再在子类中定义。

10-8，多态-成员函数

1，成员函数(非静态)

编译时，参考引用型变量所属的类中是否有调用的函数，有则编译通过，没有则编译失败。

运行时，参考的是对象所属的类中是否有调用的函数。

简单说：编译看等号左边，运行看等号右边。

class Fu {
	void show() {
		System.out.println("fu show...");
	}
}
class Zi extends Fu {
	void show() {
		System.out.println("zi show...");
	}
}
class DuoTaiDemo {
	public static void main(String[] args) {
		Fu f = new Zi();
		f.show();
	}
}

f为引用变量，Zi为对象，在堆中开辟空间，引用变量f指向Zi对象的地址，调用show方法时，show方法进栈，带有this引用，指向Zi对象的地址，在Zi对象中找有没有show方法，若有，则执行Zi中的show方法，若没有，则在super指向的父类中找show方法，有则执行父类中的show方法，若没有则编译失败。

10-9，多态-静态函数

静态函数：

编译时，参考引用变量所属的类中是否有调用的静态方法。

运行时，参考引用变量所属的类中是否有调用的静态方法。

简单说：编译和运行都看等号左边。

其实对于静态方法是不需要有对象的，直接用类名调用即可。

class Fu {
	static void method() {
		System.out.println("fu static method");
	}
}
class Zi extends Fu {
	static void method() {
		System.out.println("zi static method");
	}
}
class DuoTaiDemo {
	public static void main(String[] args) {
		Fu f = new Zi();
		f.method(); //打印fu static method
		Fu.method();
		Zi.method();
	}
}

静态方法加载进静态方法区。Static修饰的函数不受对象控制，不需要创建对象直接用类名调用即可。

Fu f是创建了一个Fu类对象的引用，若用f调用静态方法，则直接执行Fu类静态方法区中的method函数，静态方法中没有this。

10-10，内部类-概述

1，内部类也生成.class文件，文件名格式为：外部类名$内部类名.class。

2，内部类访问特点：

(1)内部类可以直接访问外部类中的成员，包括私有的。

(2)外部类要访问内部类，必须建立内部的对象。

内部类一般用于类的设计。

3，何时使用内部类？

分析事物时，发现该事物描述中还有事物，而且这个事物还在访问被描述事物的内容，这时就将这个内部的事物定义成内部类来描述。

例如：

class Outer {
	private int num = 3;
	class Inner { //内部类
		void show() {
			System.out.println("show run..." + num);
		}
	}
	public void method() {
		Inner in = new Inner(); //在外部类中定义内部类的对象，访问内部类中的内容
		in.show();
	}
}
class InnerClassDemo {
	public static void main(String[] args) {
		Outer out = new Outer();
		out.method();
	}
}

10-11，内部类-修饰符

1，内部类可以被修饰符修饰，如private ,public ,static等。

2，例如：

class Outer {
	private static int num = 31; //静态函数访问静态成员
	class Inner { //内部类
		void show() {
			System.out.println("show run ... " + num);
		}
		/*
		static void function() {
			System.out.println("function run ... " + num);
		}
		*/
	}
	public void method() {
		Inner in = new Inner();
		in.show();
	}
}
class InnerClassDemo {
	public static void main(String[] args) {
		Outer out = new Outer();
		out.method();
		//直接访问外部类中的内部类中的成员。
		Outer.Inner in = new Outer().new Inner();
		in.show();
		//如果内部类是静态的，相当于一个外部类
		Outer.Inner in = new Outer.Inner(); //外部类一加载，该静态内部类就存在了。
		in.show();
		//如果内部类是静态的，成员是静态的
		Outer.Inner.function();//静态直接用类名调用
	}
}

10-12，内部类-细节

细节1：

class Outer {
	int num = 3;
	class Inner {
		int num = 4;
		void show() {
			int num = 5;
			System.out.println(num);//打印5
		}
	}
	void method() {
		new Inner.show();
	}
}
class InnerClassDemo {
	public static void main(String[] args) {
		new Outer().method();
	}
}

若内部类的show方法打印this.num，则这个this指代的是Inner类的对象，打印4；

若内部类的show方法打印Outer.this.num，则指代了Outer类的对象，打印3。

细节2：

为什么内部类能直接访问外部类中的成员呢？

因为内部类持有了外部类的引用。格式为：外部类名.this，如：Outer.this.num，指的是Outer中的num。

10-13，内部类-局部内部类

内部类可以存放在局部位置上。

内部类在局部位置上只能访问局部中被final修饰的局部变量。

例如：

class Outer {
	int num = 3;
	Object method(final int y) {
		final int x = 9;
		class Inner { //局部内部类，在method方法中
			void show() {
				//局部内部类访问局部变量，局部变量必须被final修饰。
				System.out.println("show..." + y);
			}
		}
		Objec

Java基础10--多态--内部类(二)