内部类的几种样式

最近在使用activeMQ的时候,使用的是consumer.setMessageListener(new MessageListener() {}来异步接收消息,所有又复习了一遍内部类

                       //我想在外部类获取到这个 message,如何获取?
                       consumer.setMessageListener(new MessageListener() {
				@Override
				public void onMessage(Message message) {
					TextMessage tm = null;
					String msg;
					if(message instanceof ActiveMQTextMessage){
						tm = (TextMessage) message;
						try {  
							msg = tm.getText();
                                               }
                                         }
                                }
                        }

package innerClass;
/**
 * 常规内部类:没有用static修饰且定义在外部类类体中的内部类。
 * new一个内部类,格式为:外部类.内部类 内部类对象名=【外部类对象名.new 内部类()】,即【new.外部类().new 内部类()】
 * @author SailingChao
 *
 */
public class CommonInnerClass {
	private String outerString="outer";
	private static String staticStr="staticStr";
	static int x=1;
	class Inner {
		private String innerString="i am innner";
		public void innerMethod() {
			System.out.println(x++ + "   内部类直接访问外部类变量:outerString="+outerString+staticStr);
			outerMethod();
			System.out.println(x++ + "   内部类直接访问外部类的方法:outerMethod()");
			System.out.println(x++ + "   内部类直接访问外部类变量:outerString="+outerString);
		}
	}
	
	public CommonInnerClass() {
		super();
	}
	public void outerMethod(){
		outerString +="----11111";
	}
	public void getInner() {
		/*
		 * 在外部类的非静态方法中,可以直接new内部类对象
		 */
		Inner in=new Inner();
		System.out.println(x++ +"   在外部类非静态方法中创建内部类对象 Inner in=new Inner();");
		System.out.println(x++ +"   in.innerString="+in.innerString);
		in.innerMethod();
	}
	public static void main(String[] args) {
		
		CommonInnerClass ciClass=new CommonInnerClass();
		/*
		 * 在外部类的静态方法中,new一个内部类对象,需要通过外部类的实例才能创建对象
		 * 格式如下:外部类.内部类 内部类对象名=【外部类对象名.new 内部类()】,即【new.外部类().new 内部类()】
		 */
		CommonInnerClass.Inner in=ciClass.new Inner();
		//Inner in2=new Inner();
		System.out.println(x++ + "   外部类访问内部类,要加内部类对象名:in.innerString="+in.innerString);
		in.innerMethod();
		ciClass.getInner();
	}
}

package innerClass;
/**
 * 静态内部类:static修饰的内部类;
 * new一个静态内部类,格式:外部类.内部类 内部类对象名=new【外部类名.内部类()】
 * @author SailingChao
 *
 */
public class StaticInnerClass {
	public static String staticOuterStr="StaticOuterStr";
	public String outerStr="OuterStr";
	public static class Inner{
		private String in="innerStr";
		public void innerMethod(){
			System.out.println("静态内部类可直接访问外部类的static成员:staticOuterStr="+staticOuterStr);
			System.out.println("静态内部类只能通过对象引用来访问外部类的实例变量:new StaticInnerClass().outerStr="+new StaticInnerClass().outerStr);
			System.out.println("内部类的实例变量:in="+in);
		}
	}
	public static void main(String[] args) {
		StaticInnerClass staticIC = new StaticInnerClass();
		/*
		 * 静态内部类可以通过new【外部类名.内部类()】
		 */
		StaticInnerClass.Inner staticInClass=new StaticInnerClass.Inner();
		staticInClass.innerMethod();
	}
}

package innerClass;
/**
 * 局部内部类:在方法体或语句块内部定义的类;
 * 它不能加任何访问修饰符,因为它只对局部块有效;
 * 在定义的方法外不能创建局部内部类的对象
 * @author SailingChao
 *
 */
public class PartialInnerClass {
	private String outerStr="outerStr";
	private static String staticStr="staticStr";
	public Object outerMethod(){
		//Illegal modifier for parameter outerM; only final is permitted
		//static String outerM="outerMethodStr";
		String outerM="outerMethodStr";
		final String finalStr="finalStr";
		class Innner{
			//The method innerMethod cannot be declared static; static methods can only be declared in a static or top level type
			@Override
			public String toString(){
				System.out.println("方法中的内部类可以访问外部类成员:outerStr="+outerStr+staticStr);
				System.out.println("内部类要想访问方法的参数或成员,则这些成员或参数必须由final修饰。所以 outerM 访问不到");
				System.out.println("内部类可以访问final修饰的方法的成员 :finalStr="+finalStr);
				return finalStr;
			}
		}
		return new Innner();
	}
	
	public static void main(String[] args) {
		PartialInnerClass partInner=new PartialInnerClass();
		System.out.println("return回来的方法内的final成员:finalStr="+partInner.outerMethod());
	}
}

package innerClass;

import org.omg.CORBA.PUBLIC_MEMBER;

/**
 * 匿名内部类
 * 1, 定义一个类的最终目的就是创建它的实例,如果某个类的实例只用一个,则可以把类的定义和创建放到一起完成,即在定义一个类的时候,就创建这个类。
 *    以这种方法定义的,没有名字的类就称之为匿名内部类。
 * 2, 匿名内部类的创建格式为:【new ClassOrInterfaceName(){}】
 * 3, 匿名内部类可以继承一个类或实现一个接口,这里的ClassOrInterfaceName是匿名内部类所继承的类名或实现的接口名。
 * 	    但匿名内部类不能同时实现一个接口和继承一个类,也不能实现多个接口。如果实现了一个接口,该类是Object类的直接子类。
 *    匿名类继承一个类或实现一个接口,不需要extends和implements关键字。
 * 4, 由于匿名内部类没有名称,所以类体中不能定义构造方法,由于不知道类名也不能使用关键字来创建该类的实例。实际上匿名内部类的定义、构造、和第一次使用都发生在同样一个地方。
 *    此外,上式是一个表达式,返回的是一个对象的引用,所以可以直接使用或将其复制给一个对象变量, TypeName obj=new Name(){}
 *    同样,也可以将构造的对象作为调用的参数,someMethod(new Name(){}
 * @author SailingChao
 *
 */
public class AnonymousInnerClass {
	private String outerStr="outerStr";
	private static String staticStr="staticStr";
	public Object outerMethod(String arg){
		String outerM=arg;
		final String finalStr="finalStr--"+arg;
		return new Object(){
			public void innerMethod(){
				
			}
			public String toString(){
				return "匿名内部类访问外部类的成员变量:静态和非静态的="+outerStr+"---"+staticStr+"内部类要想访问方法的参数或成员,则这些成员或参数必须由final修饰。所以 outerM 访问不到"+"finalStr="+finalStr;
			}
		};
	}
	public static void main(String[] args) {
		AnonymousInnerClass anInnerClass=new AnonymousInnerClass();
		System.out.println(anInnerClass.outerMethod("arg"));
	}
}


评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值