在不实现的情况下操作抽象 class

Question

I have an Runnable abstract class winch represent a socket to a peer.

I have to keep a reference of all the socket I have created so I choose to wrap it into a manager class for creating sockets and add them into a list

import java.util.concurrent.Executors

internal interface SocketInterface {
    fun onSocketConnected()
}

abstract class Socket(val host: String) : Runnable, SocketInterface {
    override fun run() {
        //Connected
        onSocketConnected()
    }
}

abstract class SocketManager : SocketInterface {
    private val executorService = Executors.newSingleThreadExecutor()
    var sockets = mutableListOf<Socket>()

    fun addSocket(host: String) {
        //val socket = Socket(host)
        executorService.execute(socket)
        sockets.add(socket)
    }
}

class Main {
    val manager = object : SocketManager() {
        override fun onSocketConnected() {
            //Peer connected correctly
        }
    }
    //add new socket to manager
    manager.addSocket('google.com')

}

But the line

//val socket = Socket(host)

is on error that saying that an abstract class cannot be instantiated.

I want that my manager don't care about implementing until it is instantiating in the top level application (Main)

EDIT: I found a temporary solution implementing a default value to the abstract method onSocketConnected inside the SocketManager

abstract class SocketManager : SocketInterface {
    private val executorService = Executors.newSingleThreadExecutor()
    var sockets = mutableListOf<Socket>()

    override fun onSocketConnected() {/* Log.d('tag', 'uglySolution'*/}

    fun addSocket(host: String) {
        //val socket = Socket(host)
        executorService.execute(socket)
        sockets.add(socket)
    }
}

But looks like ugly and not standard

Answer 1

For the moment, I resolve the problem like this.

But I don't think it's the proper way, let me know if u found any solution.

import java.util.concurrent.Executors

abstract class Socket(val host: String) : Runnable, SocketInterface {
    override fun run() {
        onAbstractSocketConnected()
    }
}
internal interface SocketInterface {
    fun onAbstractSocketConnected()
}


abstract class SocketManager : SocketInterface, SocketManagerInterface {
    private val executorService = Executors.newSingleThreadExecutor()
    var sockets = mutableListOf<Socket>()

    fun addSocket(host: String) {
        val socket = object : Socket(host){
            override fun onAbstractSocketConnected(){
                onSocketConnected()
            }
        }
        executorService.execute(socket)
        sockets.add(socket)
    }
}
internal interface SocketManagerInterface {
    fun onSocketConnected()
}

class Main {
    val manager = object : SocketManager() {
        override fun onSocketConnected() {
            //Override now
            Log.d("DEBUG", "socket is connected")
        }
    }
    //add new socket to manager
    manager.addSocket('google.com')
}