java内部类

java有四种内部类：

1.static inner classes（nested classes)：静态内部类(嵌套内部类)

2.member inner classes：成员内部类

3.local inner classes：局部内部类

4.anonymous inner classes：匿名内部类

 

成员内部类：

class Outer{
	int num = 30;
	class Inner{//成员内部类
		int num = 20;
		public void print() {
			int num = 10;
			System.out.println("in Inner print()");
			System.out.println("num1: "+num);//10
			System.out.println("num2: "+this.num);//20
			System.out.println("num3: "+Outer.this.num);//30
		}
	}
	//在外围类的里面使用内部类
	public void test() {
		Inner in = new Inner();
		in.print();
	}
}
public class MemberInnerTest {

	public static void main(String[] args) {
		/*
		//外围类的实例对象
		Outer out = new Outer();
		out.test();
		*/
		Outer.Inner in = new Outer().new Inner();
		in.print();
	}

}

静态内部类：

class Outer{
	static int num = 30;//必须是静态的
	static class Inner{
		int num = 20;
		public void print() {
			int num = 10;
			System.out.println("in Inner print()");
			System.out.println("num1: "+num);
			System.out.println("num2: "+this.num);
			System.out.println("num2: "+Outer.num);
		}
	}
	public void test() {
		Inner in = new Inner();
		in.print();
	}
}
public class StaticInnerTest {

	public static void main(String[] args) {
		/*
		Outer out = new Outer();
		out.test();
		*/
		Outer.Inner in = new Outer.Inner();
		in.print();
	}
	
}

局部内部类：

class Outer{
	int num = 30;
	public void test(){
		int mynum = 40;//外围局部变量，默认final
		class Inner{
			int num = 20;
			public void print() {
				int num = 10;
				System.out.println("in Inner print()");
				System.out.println("num1: "+num);
				System.out.println("mynum: "+mynum);
				System.out.println("num2: "+this.num);
				System.out.println("num3: "+Outer.this.num);
			}
		}//end Inner
		Inner in = new Inner();
		in.print();
	}//end test
}
public class LocalInnerTest {

	public static void main(String[] args) {
		
		Outer out = new Outer();
		out.test();
		
	}

}

匿名内部类：

interface A{
	public void print();
}
class Outer{
	public void test() {
	/*
		class Inner implements A{
			public void print() {
				System.out.println("in Inner print()");
			}
		}//end Inner
		A a = new Inner();//产生局部内部类的实例对象
		test2(a); //把实例对象做为参数
	*/
		
	//匿名内部类
	//省略了局部内部类的构建过程和省略了实例对象的创建过程
	//new了一个没有名字的内部类，是一个实现了A接口的子类型
	//new后面跟接口或父类的名字，重写接口或父类中的方法
	test2(new A() {
		public void print() {
			System.out.println("in Inner print()");
		}
	});
	
	}//end test
	
	public void test2(A a) {
		a.print();
	}
}
public class AnonymousInnerTest {

	public static void main(String[] args) {
		new Outer().test();
	}

}

 

内部类中有static修饰的方法和变量，则内部类必须声明为静态内部类

静态内部类中，可以有非静态的方法和变量

 

执行顺序：

1、加载分类静态成员      子类的静态属性

2、加载父类非静态属性     调用父类的构造器

3、加载子类的非静态属性     调用子类的构造器

public class A {
      	
	static {
		System.out.println("A 静态代码块");
	}

	private static String staticStr = getStaticStr();
	private String str = getStr();

	{
		System.out.println("A 代码块");
	}

	public A() {
		System.out.println("A 构造方法");
	}

	private static String getStaticStr() {
		System.out.println("A 静态方法");
		return null;
	}

	private String getStr() {
		System.out.println("A 实例属性初始化");
		return null;
	}

	public static class B extends A {
		private static String staticStr = getStaticStr();
		static {
			System.out.println("B 静态代码块");
		}

		public B() {
			System.out.println("B 构造方法");
		}

		{
			System.out.println("B 构造块");
		}

		private String str = getStr();

		private static String getStaticStr() {
			System.out.println("B 静态方法");
			return null;
		}
		private String getStr() {
			System.out.println("B 方法");
			return null;
		}
	}

	public static void main(String[] args) {	        
		    new B();	    
	}
}

 

在主函数中生成一个int数组，在类中对其最大值最小值进行筛选，然后通过静态内部类中的get方法获取到最大最小值

class MaxMin{	
	public static class Result{		
		private int min;		
		private int max;				
		public Result(int maxn, int mixn) {					
			this.min = mixn;			
			this.max = maxn;
			}
		public int getMin() {
			return min;
			}
		public int getMax() {
			return max;		
			}
		}
	public static Result getResult(int[] ary) {
		// TODO Auto-generated method stub
		int min = Integer.MAX_VALUE;
		int max = Integer.MIN_VALUE;
		for(int d : ary){
			if(d > max){
				max = d;
			}else if(d <= min){
				min = d;
			}
		}
		return new Result(max, min);
		}
	}
public class test {
	public static void main(String[] args) {
		int[] ary = new int[5];
		for(int i = 0; i < 5; i++){
			ary[i] = (int) (100*Math.random());
		}
		System.out.println("Original array is: ");
		for(int d : ary){
			System.out.println(d);
		}
		System.out.println("The biggest in ary is: " + MaxMin.getResult(ary).getMax());
		System.out.println("The smallest in ary is: " + MaxMin.getResult(ary).getMin());	
	}
}