内部类（还缺一个内部匿名类，以后补）

/**
 * 内部类测试
 * 成员：内部类
 * 成员方法中：内部类
 * 
 */
package test;

import java.util.ArrayList;
import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

//抽象类
abstract class Father{
	
	Integer num;//初始值为null
	//abstract int n;-----------error
	//abstract Integer num2;-----------error，类似virtual也不能修饰成员变量

	Father(){//给类成员变量初始化		
	}
	public Integer print(){//子类可以覆盖
		return null;		
	}
	abstract void prin();//子类必须实现	
	
	static void p(){//可以定义静态方法	
		System.out.println("father");
	}
	//abstract static void pp();---------error，静态方法，属于类，不能交给子类实现，所以类自己就需要实现
	
}
class Son extends Father{

	@Override
	void prin() {//子类必须实现父类的抽象方法
	// TODO Auto-generated method stub
		
	}
	static void p(){//可以覆盖父类的静态方法----不覆盖时，Son.p()调用的是Father的静态方法
		System.out.println("Son");
	}
}

//内部类
class Outers{
	int Outint;//0
	
	Outers(){
		
	}
	void print(){
		System.out.println("Outer");
		System.out.println("Outint="+Outint);
	}
	/**
	 * 成员：内部类
	 * 实例化方法：Outers.Inners inners = outers.new Inners();
	 * 可以static修饰，那么也收到static的约束	
	 */
	
	class Inners{
		int inner_val;
		void print(int v){
			System.out.println("Inner");
			System.out.println("Inner,Outint="+Outint);
			Outint = v;//Inners属于实例，这里改变了实例的成员变量
		}
	}
	//成员内部类，可以被继承
	class Innerson extends Inners{
		
	}
	/**
	 * 方法中定义的内部类
	 * 对于其它类不可见，但可以被该内部类创建的实例对象可以传递给其他类访问
	 * 只能访问方法中的final局部变量
	 * 不能加public等类型修饰符和static修饰符，但可以final和abstract
	 */
	Object func(){
		final int funcint = 0;//final必须显示初始化，不能使用默认值
		class Inners{
			void print(){
				System.out.println("Innerfunc");
				System.out.println("Innerfunc,Outint="+Outint);
				System.out.println("Innerfunc,funcint="+funcint);//方法中定义的内部类，只能访问方法中的final局部变量
			}

			@Override
			public String toString() {
				return "hello Outer";
			}
			
			
		}
		Inners inner = new Inners();//实例对象inner可以传递给其他类访问
		inner.print();
		return (Object)inner;
	}
	//验证：方法中定义的内部类，对于其它类不可见，但可以被该内部类创建的实例对象可以传递给其他类访问
	void trym(){
		Object o = func();		
		System.out.println(o.toString());
	}
	//验证：方法中定义的内部类，可以abstract修饰
	void func2(){
		final int funcint = 0;//final必须显示初始化，不能使用默认值
		abstract class Inners{
			void print(){
				System.out.println("Innerfunc");
				System.out.println("Innerfunc,Outint="+Outint);
				System.out.println("Innerfunc,funcint="+funcint);//方法中定义的内部类，只能访问方法中的final局部变量
			}
		}
		class Inson extends Inners{
			
		}
		
	}
	//方法中定义的内部类，实例对象传递给其他类访问
	Outers.Inners funcOI(){
		final int funcint = 0;//final必须显示初始化，不能使用默认值
		class Inners extends Outers.Inners{
			void print(){
				System.out.println("Innerfunc");
				System.out.println("Innerfunc,Outint="+Outint);
				System.out.println("Innerfunc,funcint="+funcint);//方法中定义的内部类，只能访问方法中的final局部变量
			}

			@Override
			public String toString() {
				return "hello Outer";
			}
			
		}
		Inners inner = new Inners();//实例对象inner可以传递给其他类访问
		inner.print();
		System.out.println("class Inners extends Outers.Inners");
		return (Outers.Inners)inner;
		
	}
	Outers.Inners temp = funcOI();//temp 是Outers的成员变量，这里初始化，相当于在Outers的构造函数开始时初始化
	
}


public class Test {
	/**
	 * @param args
	 * 
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Son son = new Son();
		Son.p();
		
		//内部类
		Outers outers = new Outers();
		outers.print();
		System.out.println("----------------------");
		Outers.Inners inners = outers.new Inners();
		inners.print(3);//改变了outers的状态		
		outers.print();
		System.out.println("----------------------");
		Outers.Inners t = outers.temp;//不会执行funcOI()
		System.out.println(t.toString());
		
		System.out.println("----------------------");
		Outers.Inners t2 = outers.funcOI();
		System.out.println("----------------------");
		
		outers.trym();//hello Outer	
		
	}
	
	

	
}