JAVA学习篇12——内部类

内部类：成员内部类、局部内部类、匿名内部类
     * 内部类里面可以定义普通的方法
     * 内部类里面可以定义静态方法，但是内部类的类名必须为静态的
     * 非静态的方法调用：外部类.内部类      实例化名  =  new 外部类().new 内部类();
     * 静态方法的调用：    外部类.内部类      实例化名  =  new 外部类.内部类();
 作用：隐藏、多重继承、权限
成员内部类：
           定义在类中方法体外。

//外部类
public class Outer {
	  //成员内部类
	  static class Inner{
		//非静态的方法
		public void method(){
			System.out.println("这是内部类的一个普通的方法");
		}		
		public static void method1(){
			System.out.println("内部类的静态方法");
		}
	}
}
class InnerTest{
	public static void main(String[] args) {
		//内部类里面的静态方法访问格式：  外部类.内部类.静态方法()
		Outer.Inner.method1();
//		new Inner();  这种访问Inner类是错误的，找不到内部类
		
		//非静态的方法调用的实例化
//		Outer.Inner  inn = new Outer().new Inner();
//		inn.method();
		
		Outer.Inner inner = new Outer.Inner();//这种方法可以调用静态和非静态的方法
		inner.method();
                inner.methed1();
	}
}

其结果为：

内部类的静态方法
这是内部类的一个普通的方法
内部类的静态方法

内部类取变量的实例：

public class OuterDemo {

	int num = 20;
	static int num1 = 30;
	public void show(){
		System.out.println("这是外部类的成员方法");
	}
	static class inner{
		int num = 200;
		static int num1 = 300;
		//内部类非静态成员方法，局部变量没有静态
		public void show(){
			 int num = 2000;
			System.out.println("这是静态内部类的成员方法");
			System.out.println("内部类的局部变量"+num);
			System.out.println("内部类的非静态成员变量"+this.num);//获取内部类的非静态成员变量
			System.out.println("内部类的静态成员变量"+num1);//获取内部类的静态成员变量
			System.out.println("外部类非静态成员变量"+new OuterDemo().num);//获取外部类非静态成员变量
			System.out.println("外部类静态成员变量"+OuterDemo.num1);//获取外部类静态成员变量
			System.out.println("-----------------------------------");
		}
		//内部类静态成员方法
		//this和静态成员方法不能共存
		public static void show1(){
			 int num = 20000;
			System.out.println("这是静态内部类的静态成员方法");
			System.out.println("内部类的局部变量"+num);
			System.out.println("内部类的非静态成员变量"+new inner().num);//获取内部类的非静态成员变量
			System.out.println("内部类的静态成员变量"+num1);//获取内部类的静态成员变量
			System.out.println("外部类非静态成员变量"+new OuterDemo().num);//获取外部类非静态成员变量
			System.out.println("外部类静态成员变量"+OuterDemo.num1);//获取外部类静态成员变量
		}
	}	
}
class Test{
	public static void main(String[] args) {
		OuterDemo.inner in =  new OuterDemo.inner();
		in.show();
		in.show1();
	}
}

输出结果为：

这是静态内部类的成员方法
内部类的局部变量2000
内部类的非静态成员变量200
内部类的静态成员变量300
外部类非静态成员变量20
外部类静态成员变量30
-----------------------------------
这是静态内部类的静态成员方法
内部类的局部变量20000
内部类的非静态成员变量200
内部类的静态成员变量300
外部类非静态成员变量20
外部类静态成员变量30

关于私有化的成员内部类：（与私有化的成员变量类似，利用get方法）
比如：
private class Inner{}
public Inner getInn(){   //get方法，返回的是一个对象
        return new Inner();
    }

局部内部类：
            定义在方法体内

//定义一个抽象类
abstract class A{
	public abstract void show1();
}
//外部类
public class OuterDemo1 {

	int num = 10;
	//方法
	public void show(){
		final int num1  =30;
		int num2 = 50;
		//局部内部类
		 class inner2{
			 int num = 20;
			 public void showTime(){
				 int num = 40;
				 System.out.println(OuterDemo1.this.num);//外部类成员变量
				 System.out.println(num2);//外部类局部变量
				 System.out.println(this.num);//局部内部类的成员变量
				 System.out.println(num);//局部内部类的成员变量
			 }  
			 public void show1(){
				 System.out.println("000000000000000000");
			 }
		 }
		 new inner2().showTime();
		 new inner2().show1();
	}
	//在无返回值得情况下，用下列的方法能调用所需函数，但是当函数多的时候，局限性大，就比较麻烦，下面是更常用的方法
	//定义一个带返回参数的方法，Object为超级父类，返回一个对象
	public Object show2(){
		//定义一个局部内部类继承A类
		 class inner2 extends A{
			 //toString默认为Object的一个方法，这里就是重写toString方法
			 public String toString(){
				 return "呵呵哒";
			 }		
			 //重写A类里面的show1方法
			 public void show1(){
				 System.out.println("66666666666666");
			 }
		 }
		 return new inner2();
	}
}

class Test111{
	public static void main(String[] args) {
		OuterDemo1 ou =new OuterDemo1();
		ou.show();//调用show方法
		Object obj = ou.show2();//show2是有返回值的，返回一个对象，最开始我们不知道是哪个对象，所以用Object来接收
		System.out.println(obj);//默认调用我们上面重写的toString方法
//		obj.show1();	用这个方法不能调用show1方法，因为show1是inner2类所独有的方法，Object没有该方法
//		inner2 in = (inner2)obj; 用这个方法并不能将obj强转为inner2类，因为系统找不到inner2类
		A aa = (A)obj;//这里利用多态的性质，将obj转为inner2的父类A，因为show1方法是inner2类继承到A类的。
		//多态性质：前期定义的方法可以访问后期定义的内容。所以用该方法可以调用自己想用的方法。
		aa.show1();
	}
}

结果为：

10
50
20
40
000000000000000000
呵呵哒
66666666666666

匿名内部类：
                 匿名内部类必须要继承一个父类或则实现一个接口
                 匿名内部类的名称必须和接口或则父类的名称一致

class Father{
	public void show(){}
	public void sing1(){}
}
interface Mather{
	void sing();
}
public class OuterDemo3 {
	//成员匿名对象类
	Mather mather = new Mather(){
		public void sing() {
			// TODO Auto-generated method stub
			System.out.println("妈妈喜欢唱歌");
		}
		
	};
	//局部匿名对象类
	public void show(){
		new Father(){
			public void smoke(){
				System.out.println("爸爸喜欢吸烟");
			}
		}.smoke();
	}
}
class Test12{
	public static void main(String[] args) {
		OuterDemo3 ad = new OuterDemo3();
		ad.mather.sing();//访问成员匿名对象类的方法
		ad.show();
	}
}

输出结果：

妈妈喜欢唱歌
爸爸喜欢吸烟