最近在使用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"));
}
}