如何使自定义监听器而不必每次实例化类 [英] how to make a custom listener without instantiating the class each time
本文介绍了如何使自定义监听器而不必每次实例化类的处理方法，对大家解决问题具有一定的参考价值，需要的朋友们下面随着小编来一起学习吧！
问题描述
有用于从一个Java类发送消息到另一个自定义侦听，然而当收听者用来发送将创建一个新的JFrame窗口每个听者将消息发送到其它类时间消息时，问题它最终被众多的JFrame窗口栈。
的原因是，我要为听者创建Java类的实例，因为它是需要实例化监听器
=监听器（OnSendResultListener）新ConnectionUtility（假）;
所以每次的Java类发送短信息到其他Java类它创建另一个ConnectionUtitlity（）对象和启动一个新的JFrame窗口。不是我想要的。但如果我尝试通过在ConnectionUtility类的构造函数传递一个布尔perameter确定要避免这种情况，当实例是真实的（真实的），或者当监听器被实例化（假的），它会崩溃。所以这并没有帮助，因为实例化侦听器时删除之类的部分不允许它的工作。
我如何使用一个简单的监听器，从一个活动将消息发送到另一个，并提醒行动，没有这个不必实例超类或封装类？
在Android中我会用这个广播接收机。但在Java桌面应用程序如何得到这个工作？
例如code为两个Java类，MultiThreader和ConnectionUtility
MultiThreader类实现监听器并发送消息给ConnectionUtility类
公共类MultiThreader {
构造类实例化从ConnectionUtility OnSendResultListener对象投
公共MultiThreader（）{ 监听=（OnSendResultListener）新ConnectionUtility（假）;
}
作为嵌套的内部类的MultiThreader类的内部侦听器接口
公共接口OnSendResultListener { 公共无效onStringResult（字符串transferString）;}
在MultiThreader类调用监听器方法
公共无效sendStatus（字符串状态）{ listener.onStringResult（状态）; }
在MutliThreader一流的呼叫通过发送字符串消息ConnectionUtility类
使用监听器
sendStatus（文件发送到服务器，成功）;
connectionUtility类从MultiThreader类接收消息
公共类ConnectionUtility javax.swing.JFrame中延伸
实现MultiThreader.OnSendResultListener {
用于接收来自MultiThrader类的消息回调方法和
表明在接收这些消息时
@覆盖
公共无效onStringResult（字符串transferString）{ jTextArea1.setText（displayString）; //设置TEXTAREA串接收 }
编辑：如下图所示每个门类齐全code例如
公共类MultiThreader实现Runnable {私人Socket套接字;
公众诠释fileSizeFromClient;
FOS的FileOutputStream = NULL;
二BufferedInputStream为= NULL;
BOS的BufferedOutputStream = NULL;
DataInputStream以DIS = NULL;
DataOutputStream类DOS = NULL;
的ScheduledThreadPoolExecutor STPE;
私人OnSendResultListener侦听器;公共MultiThreader（插座S）{
插座=秒;
STPE =新的ScheduledThreadPoolExecutor（5）;
监听=（OnSendResultListener）新ConnectionUtility（）;
}@覆盖
公共无效的run（）{ 长的serialNumber = 0;
INT缓冲区大小= 0; //获取输入流
尝试{
双=新的BufferedInputStream（socket.getInputStream（））;
DIS =新DataInputStream所（之二）;
}赶上（IOException异常前）{
。Logger.getLogger（MultiThreader.class.getName（））日志（Level.SEVERE，空，前）;
} sendStatus（新建连接strarted）; //读取来自服务器的流
尝试{
fileSizeFromClient = dis.readInt（）;
sendStatus（+ fileSizeFromClient从客户文件大小）;
的serialNumber = dis.readLong（）;
sendStatus（+的serialNumber从客户串行mumber）;
}赶上（IOException异常前）{
。Logger.getLogger（MultiThreader.class.getName（））日志（Level.SEVERE，空，前）;
} 尝试{
BUFFERSIZE = socket.getReceiveBufferSize（）;
sendStatus（缓冲区大小+缓冲区大小）;
}赶上（SocketException前）{
。Logger.getLogger（MultiThreader.class.getName（））日志（Level.SEVERE，空，前）;
} 字符串serialString =将String.valueOf（的serialNumber）; 文件文件目录=新的文件（C：+文件分割符+下载+文件分割符+的serialNumber +文件分割符）;
fileDirectory.mkdir（）; 档案文件=新的文件（C：+文件分割符+下载+文件分割符+的serialNumber +文件分割符+JISSend.pdf）;
尝试{
file.createNewFile（）;
}赶上（IOException异常前）{
。Logger.getLogger（MultiThreader.class.getName（））日志（Level.SEVERE，空，前）;
}
尝试{
FOS =新的FileOutputStream（文件）;
BOS =新的BufferedOutputStream（FOS）;
DOS =新的DataOutputStream类（BOS）;
}赶上（FileNotFoundException异常前）{
。Logger.getLogger（MultiThreader.class.getName（））日志（Level.SEVERE，空，前）;
} 诠释计数= 0;
字节[]缓冲区=新的字节[fileSizeFromClient] 尝试{ INT totalBytesRead = 0; 而（totalBytesRead＆LT; fileSizeFromClient）{
INT bytesRemaining = fileSizeFromClient - totalBytesRead;
INT读取动作= dis.read（缓冲液，0，（int）的Math.min（buffer.length，bytesRemaining））; 如果（读取动作== -1）{
打破;
}其他{ dos.write（缓冲液，0，读取动作）;
totalBytesRead + =读取动作; }
} }赶上（IOException异常前）{
。Logger.getLogger（MultiThreader.class.getName（））日志（Level.SEVERE，空，前）;
}
尝试{ DOS =新的DataOutputStream类（socket.getOutputStream（））; }赶上（IOException异常前）{
。Logger.getLogger（MultiThreader.class.getName（））日志（Level.SEVERE，空，前）;
} stpe.schedule（新CompareFiles（），0，TimeUnit.SECONDS）;
stpe.schedule（新CloseResources（），2，TimeUnit.SECONDS）; } //结束run方法 公共类CompareFiles实现Runnable { @覆盖
公共无效的run（）{ INT returnInt = 0;
FIS的FileInputStream = NULL; 档案文件=新的文件（C：/DOWNLOAD/JISSend.pdf）;
尝试{
FIS =新的FileInputStream（文件）;
}赶上（FileNotFoundException异常前）{
。Logger.getLogger（MultiThreader.class.getName（））日志（Level.SEVERE，空，前）;
} INT文件长度=（int）的file.length（）; sendStatus（数据库文件的大小派+文件长度）; 如果（文件长度== fileSizeFromClient）{ sendStatus（文件发送到服务器，成功）;
returnInt = 1; }否则如果（文件长度！= fileSizeFromClient）{ sendStatus（错误，文件发送失败）;
returnInt = 2; }
尝试{
dos.writeInt（returnInt）;
}赶上（IOException异常前）{
。Logger.getLogger（MultiThreader.class.getName（））日志（Level.SEVERE，空，前）;
} } //结束run方法
} //类comparefiles结束 公共类CloseResources实现Runnable { @覆盖
公共无效的run（）{ 尝试{
fos.flush（）;
bis.close（）;
bos.close（）;
透露（）;
dos.close（）;
socket.close（）;
}赶上（IOException异常前）{
。Logger.getLogger（MultiThreader.class.getName（））日志（Level.SEVERE，空，前）;
} } //结束run方法
} //类closeResources结束 公共接口OnSendResultListener {
公共无效onStringResult（字符串transferString）;
} 公共无效sendStatus（字符串状态）{
listener.onStringResult（状态）;
} } //结束类multithreader
公共类ConnectionUtility javax.swing.JFrame中的扩展工具
MultiThreader.OnSendResultListener { 串outputLine =; 布尔亚军= TRUE;
PrintWriter的出来;
在的BufferedReader;
ServerSocket的ServerSocket的;
Socket套接字;
布尔startserver的= TRUE;
公共静态字符串displayString =; 私人ConnectionUtility（）{ 的initComponents（）; this.startServer = startserver的;
this.setVisible（真）;
serverRunner（）; 文件fileOne =新的文件（C：/ DBFILES）;
如果（！fileOne.exists（））{
fileOne.mkdir（）;
} 文件FileTwo传送=新的文件（C：/ DBFilesOut）;
如果（！fileTwo.exists（））{
fileTwo.mkdir（）;
} }@燮pressWarnings（未登记）
//＆LT;主编倍defaultstate =崩溃DESC =生成code＆GT;
私人无效的initComponents（）{ JLabel1所做=新javax.swing.JLabel中的（）;
jScrollPane1 =新javax.swing.JScrollPane中的（）;
jTextArea1 =新javax.swing.JTextArea中的（）; setDefaultCloseOperation（javax.swing.WindowConstants.EXIT_ON_CLOSE）; jLabel1.setFont（新java.awt.Font中（MS UI哥特式，0，36））; // NOI18N
jLabel1.setText（TankInspectionSystem）; jTextArea1.setColumns（20）;
jTextArea1.setRows（5）;
jScrollPane1.setViewportView（jTextArea1）; javax.swing.GroupLayout布局=新javax.swing.GroupLayout（的getContentPane（））;
的getContentPane（）的setLayout（布局）。
layout.setHorizontalGroup（
layout.createParallelGroup（javax.swing.GroupLayout.Alignment.LEADING）
.addGroup（layout.createSequentialGroup（）
.addGap（72，72，72）
.addComponent（JLabel1所做）
.addContainerGap（76 Short.MAX_VALUE））
.addGroup（javax.swing.GroupLayout.Alignment.TRAILING，layout.createSequentialGroup（）
.addContainerGap（javax.swing.GroupLayout.DEFAULT_SIZE，Short.MAX_VALUE）
.addComponent（jScrollPane1，javax.swing.GroupLayout。preFERRED_SIZE，383，javax.swing.GroupLayout。preFERRED_SIZE）
.addContainerGap（javax.swing.GroupLayout.DEFAULT_SIZE，Short.MAX_VALUE））
）;
layout.setVerticalGroup（
layout.createParallelGroup（javax.swing.GroupLayout.Alignment.LEADING）
.addGroup（layout.createSequentialGroup（）
.addGap（37，37，37）
.addComponent（JLabel1所做）
.addGap（34，34，34）
.addComponent（jScrollPane1，javax.swing.GroupLayout。preFERRED_SIZE，179，javax.swing.GroupLayout。preFERRED_SIZE）
.addContainerGap（37，Short.MAX_VALUE））
）; 包（）;
} //＆LT; /编辑倍＆GT; //变量声明 - 不修改
私人javax.swing.JLabel中JLabel1所做;
私人javax.swing.JScrollPane中jScrollPane1;
私人javax.swing.JTextArea中jTextArea1;
//变量声明结束 公共无效serverRunner（）{ 亚军= TRUE; 尝试{
ServerSocket的=新的ServerSocket（6789，100）; 的System.out.println（）; }赶上（IOException异常前）{
。Logger.getLogger（ConnectionUtility.class.getName（））日志（Level.SEVERE，空，前）;
} 而（亚军）{ 尝试{
插座=的ServerSocket.accept（）; addAndDisplayTextToString（新的连接，INET套接字地址＆gt;＆GT;＆gt;中+ socket.getPort（））;
的System.out.println（displayString）;
}赶上（IOException异常前）{
。Logger.getLogger（ConnectionUtility.class.getName（））日志（Level.SEVERE，空，前）;
} MultiThreader多=新MultiThreader（插座）;
线程t =新主题（多）;
t.start（）; } //结束，而亚军循环 } //结束serverRunner方法 公共静态无效addAndDisplayTextToString（字符串了setString）{ StringBuilder的STB =新的StringBuilder（displayString）; 了setString =了setString +\\ n; 如果（stb.toString（）==）{
stb.append（了setString）;
}否则如果（stb.toString（）！=）{
stb.insert（0，了setString）;
} INT计数器= 0; 的for（int i = 0; I＆LT; stb.length（）;我++）{
如果（stb.substring（I，I + 1）.equals（\\ n））{
反++;
}
} //得到\\ N的最后一个索引
INT lastIndex的= stb.lastIndexOf（\\ n）; INT最大= 4;
如果（计数器＆GT; =最大值）{ stb.delete（lastIndex的，stb.length（））;
的System.out.println（）; } displayString = stb.toString（）; } @覆盖
公共无效onStringResult（字符串transferString）{
addAndDisplayTextToString（transferString）;
jTextArea1.setText（displayString）;}} //类ConnectionUtility
解决方案
如果你只想要一个对象的单个实例，不管你怎么称呼它，做的：
公共类为MyObject { 私有静态为MyObject实例; 公共静态的getInstance为MyObject（..）{
如果（比如！= NULL）{
返回实例;
}
例如回报=新MyObject来（..）;
} //私有构造函数，以避免新的实例
私人为MyObject（..）{..}
}为MyObject anObject = MyObject.getInstance（..）; //总是返回同一个实例
在'..'表示任意参数。我通常在构造和使用其制定者的对象传递一个方面，它取决于操作什么，我希望它做的如setMessage（..）来改变输出或setCallListener（..），以回调重定向到另一个对象。
不知道这是你在找什么，但有一种感觉是这样的。
编辑：
看到你的code后，再怎么样在ConnectionUtility：
MultiThreader多=新MultiThreader（插座，这一点）;
和在MultiThreader：
公共MultiThreader（插座S，OnSendResultListener resultListener）{
插座=秒;
STPE =新的ScheduledThreadPoolExecutor（5）;
听众= resultListener;
}
请注意，单一实例方法也应该工作，只是觉得这可能是最简单的解决方案，你可以直接用它传递的这个（自实施正确的接口）。
have a custom listener used for sending a message from one java class to another, however when the listener is used to send a message a new JFrame window is created every time the listener sends a message to the other class, the problem that it ends up being a stack of many Jframe windows.
the reason is that I have to create an instance of the java class for the listener because it is needed to instantiate the listener
listener = (OnSendResultListener) new ConnectionUtility(false);
so every time the java class sends a short text message to the other java class it creates another ConnectionUtitlity() object and that launches a new JFrame window. not what i want. but if i try to avoid this by passing a boolean perameter in the ConnectionUtility class constructor to determine when the instantiation is real (true) or when the listener is instantiated (false) it will crash. so this does not help either, because removing parts of the class when instantiated for the listener does not allow it to work.
how do i use a simple listener to send messages from one activity to another and alert it to actions, without this having to instantiate the superclass or encapsulating class?
in Android i would use a broadcast receiver for this. but in a java desktop app how to get this to work?
example code for two java classes, MultiThreader and ConnectionUtility
MultiThreader class implements listener and sends message to ConnectionUtility class
public class MultiThreader {
constructor for class instantiates OnSendResultListener object cast from ConnectionUtility
public MultiThreader() {
listener = (OnSendResultListener) new ConnectionUtility(false);
}
listener interface nested as inner class inside of the MultiThreader class
public interface OnSendResultListener {
public void onStringResult(String transferString);
}
method for calling listener in MultiThreader class
public void sendStatus(String status){
listener.onStringResult(status);
}
call in MutliThreader class to send string message to ConnectionUtility class by using listener
sendStatus("File sent to server, Successful");
connectionUtility class receives messages from MultiThreader class
public class ConnectionUtility extends javax.swing.JFrame
implements MultiThreader.OnSendResultListener {
callback method used to receive messages from MultiThrader class and indicate when those messages are received
@Override
public void onStringResult(String transferString) {
jTextArea1.setText(displayString); // sets textArea to string received
}
EDIT: complete code example shown below for each class
public class MultiThreader implements Runnable {
private Socket socket;
public int fileSizeFromClient;
FileOutputStream fos = null;
BufferedInputStream bis = null;
BufferedOutputStream bos = null;
DataInputStream dis = null;
DataOutputStream dos = null;
ScheduledThreadPoolExecutor stpe;
private OnSendResultListener listener;
public MultiThreader(Socket s) {
socket = s;
stpe = new ScheduledThreadPoolExecutor(5);
listener = (OnSendResultListener) new ConnectionUtility();
}
@Override
public void run() {
long serialNumber = 0;
int bufferSize = 0;
// get input streams
try {
bis = new BufferedInputStream(socket.getInputStream());
dis = new DataInputStream(bis);
} catch (IOException ex) {
Logger.getLogger(MultiThreader.class.getName()).log(Level.SEVERE, null, ex);
}
sendStatus("New connection strarted");
// read in streams from server
try {
fileSizeFromClient = dis.readInt();
sendStatus("File size from client " + fileSizeFromClient);
serialNumber = dis.readLong();
sendStatus("Serial mumber from client " + serialNumber);
} catch (IOException ex) {
Logger.getLogger(MultiThreader.class.getName()).log(Level.SEVERE, null, ex);
}
try {
bufferSize = socket.getReceiveBufferSize();
sendStatus("Buffer size " + bufferSize);
} catch (SocketException ex) {
Logger.getLogger(MultiThreader.class.getName()).log(Level.SEVERE, null, ex);
}
String serialString = String.valueOf(serialNumber);
File fileDirectory = new File("C:" + File.separator + "DOWNLOAD" + File.separator + serialNumber + File.separator);
fileDirectory.mkdir();
File file = new File("C:" + File.separator + "DOWNLOAD" + File.separator + serialNumber + File.separator + "JISSend.pdf");
try {
file.createNewFile();
} catch (IOException ex) {
Logger.getLogger(MultiThreader.class.getName()).log(Level.SEVERE, null, ex);
}
try {
fos = new FileOutputStream(file);
bos = new BufferedOutputStream(fos);
dos = new DataOutputStream(bos);
} catch (FileNotFoundException ex) {
Logger.getLogger(MultiThreader.class.getName()).log(Level.SEVERE, null, ex);
}
int count = 0;
byte[] buffer = new byte[fileSizeFromClient];
try {
int totalBytesRead = 0;
while(totalBytesRead < fileSizeFromClient){
int bytesRemaining = fileSizeFromClient - totalBytesRead;
int bytesRead = dis.read(buffer, 0, (int)Math.min(buffer.length, bytesRemaining));
if(bytesRead == -1){
break;
}else{
dos.write(buffer, 0, bytesRead);
totalBytesRead += bytesRead;
}
}
} catch (IOException ex) {
Logger.getLogger(MultiThreader.class.getName()).log(Level.SEVERE, null, ex);
}
try {
dos = new DataOutputStream(socket.getOutputStream());
} catch (IOException ex) {
Logger.getLogger(MultiThreader.class.getName()).log(Level.SEVERE, null, ex);
}
stpe.schedule(new CompareFiles(), 0, TimeUnit.SECONDS);
stpe.schedule(new CloseResources(), 2, TimeUnit.SECONDS);
} // end run method
public class CompareFiles implements Runnable {
@Override
public void run() {
int returnInt = 0;
FileInputStream fis = null;
File file = new File("C:/DOWNLOAD/JISSend.pdf");
try {
fis = new FileInputStream(file);
} catch (FileNotFoundException ex) {
Logger.getLogger(MultiThreader.class.getName()).log(Level.SEVERE, null, ex);
}
int fileLength = (int) file.length();
sendStatus("Size of database file sent " + fileLength);
if(fileLength == fileSizeFromClient){
sendStatus("File sent to server, Successful");
returnInt = 1;
}else if(fileLength != fileSizeFromClient){
sendStatus("ERROR, file send failed");
returnInt = 2;
}
try {
dos.writeInt(returnInt);
} catch (IOException ex) {
Logger.getLogger(MultiThreader.class.getName()).log(Level.SEVERE, null, ex);
}
} // end run method
} // end of class comparefiles
public class CloseResources implements Runnable {
@Override
public void run() {
try {
fos.flush();
bis.close();
bos.close();
dis.close();
dos.close();
socket.close();
} catch (IOException ex) {
Logger.getLogger(MultiThreader.class.getName()).log(Level.SEVERE, null, ex);
}
} // end run method
} // end of class closeResources
public interface OnSendResultListener {
public void onStringResult(String transferString);
}
public void sendStatus(String status){
listener.onStringResult(status);
}
} // end class multithreader
public class ConnectionUtility extends javax.swing.JFrame implements
MultiThreader.OnSendResultListener {
String outputLine = "";
boolean runner = true;
PrintWriter out;
BufferedReader in;
ServerSocket serversocket;
Socket socket;
boolean startServer = true;
public static String displayString = "";
private ConnectionUtility() {
initComponents();
this.startServer = startServer;
this.setVisible(true);
serverRunner();
File fileOne = new File("C:/DBFiles");
if(!fileOne.exists()){
fileOne.mkdir();
}
File fileTwo = new File("C:/DBFilesOut");
if(!fileTwo.exists()){
fileTwo.mkdir();
}
}
@SuppressWarnings("unchecked")
// <editor-fold defaultstate="collapsed" desc="Generated Code">
private void initComponents() {
jLabel1 = new javax.swing.JLabel();
jScrollPane1 = new javax.swing.JScrollPane();
jTextArea1 = new javax.swing.JTextArea();
setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);
jLabel1.setFont(new java.awt.Font("MS UI Gothic", 0, 36)); // NOI18N
jLabel1.setText("TankInspectionSystem");
jTextArea1.setColumns(20);
jTextArea1.setRows(5);
jScrollPane1.setViewportView(jTextArea1);
javax.swing.GroupLayout layout = new javax.swing.GroupLayout(getContentPane());
getContentPane().setLayout(layout);
layout.setHorizontalGroup(
layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGroup(layout.createSequentialGroup()
.addGap(72, 72, 72)
.addComponent(jLabel1)
.addContainerGap(76, Short.MAX_VALUE))
.addGroup(javax.swing.GroupLayout.Alignment.TRAILING, layout.createSequentialGroup()
.addContainerGap(javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
.addComponent(jScrollPane1, javax.swing.GroupLayout.PREFERRED_SIZE, 383, javax.swing.GroupLayout.PREFERRED_SIZE)
.addContainerGap(javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE))
);
layout.setVerticalGroup(
layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGroup(layout.createSequentialGroup()
.addGap(37, 37, 37)
.addComponent(jLabel1)
.addGap(34, 34, 34)
.addComponent(jScrollPane1, javax.swing.GroupLayout.PREFERRED_SIZE, 179, javax.swing.GroupLayout.PREFERRED_SIZE)
.addContainerGap(37, Short.MAX_VALUE))
);
pack();
}// </editor-fold>
// Variables declaration - do not modify
private javax.swing.JLabel jLabel1;
private javax.swing.JScrollPane jScrollPane1;
private javax.swing.JTextArea jTextArea1;
// End of variables declaration
public void serverRunner(){
runner = true;
try {
serversocket = new ServerSocket(6789, 100);
System.out.println();
} catch (IOException ex) {
Logger.getLogger(ConnectionUtility.class.getName()).log(Level.SEVERE, null, ex);
}
while(runner){
try {
socket = serversocket.accept();
addAndDisplayTextToString("new connection, inet socket address >>> " + socket.getPort());
System.out.println(displayString);
} catch (IOException ex) {
Logger.getLogger(ConnectionUtility.class.getName()).log(Level.SEVERE, null, ex);
}
MultiThreader multi = new MultiThreader(socket);
Thread t = new Thread(multi);
t.start();
} // end while runner loop
} // end serverRunner method
public static void addAndDisplayTextToString(String setString){
StringBuilder stb = new StringBuilder(displayString);
setString = setString + "\n";
if(stb.toString() == ""){
stb.append(setString);
}else if(stb.toString() != ""){
stb.insert(0, setString);
}
int counter = 0;
for(int i = 0; i < stb.length(); i++){
if(stb.substring(i, i + 1).equals("\n")){
counter++;
}
}
// get the last index of "\n"
int lastIndex = stb.lastIndexOf("\n");
int maximum = 4;
if(counter >= maximum){
stb.delete(lastIndex, stb.length());
System.out.println();
}
displayString = stb.toString();
}
@Override
public void onStringResult(String transferString) {
addAndDisplayTextToString(transferString);
jTextArea1.setText(displayString);
}
} // class ConnectionUtility
解决方案
If you only want a single instance of an object no matter where you call it, do:
public class MyObject {
private static MyObject instance;
public static MyObject getInstance(..) {
if (instance != null) {
return instance;
}
return instance = new MyObject(..);
}
// private constructor to avoid new instances
private MyObject(..) { .. }
}
MyObject anObject = MyObject.getInstance(..); // always returns the same instance
The '..' indicate arbitrary parameters. I usually pass a Context upon construction and from thereon use setters on the object to manipulate it depending on what I want it to do e.g. setMessage(..) to change output or setCallListener(..) to redirect callbacks to another object.
Not sure this is what you are looking for but had the feeling it was something like this.
Edit:
After seeing your code, then how about in ConnectionUtility :
MultiThreader multi = new MultiThreader(socket, this);
And in MultiThreader:
public MultiThreader(Socket s, OnSendResultListener resultListener) {
socket = s;
stpe = new ScheduledThreadPoolExecutor(5);
listener = resultListener;
}
Note that the single instance method should also work, just think this might be the simplest solution as you can pass it directly using this (since implementing the right interface).
这篇关于如何使自定义监听器而不必每次实例化类的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！
查看全文
