Constructors in Kotlin

First way with empty values

// (name: String, surname: String)  default constructor signature
class Person(name: String, surname: String) {

    // init block , represents the body of default constructor 
    init {
        Log.d("primary", "Hello");
    }

    // secondary constructor 
    // this(name,"") call to default constructor
    constructor(name : String):this(name,""){
        Log.d("secondary", "Hello");
    }
}

why this(name,"")

If the class has a primary constructor, each secondary constructor needs to delegate to the primary constructor, either directly or indirectly through another secondary constructor(s). Delegation to another constructor of the same class is done using the this keyword:

or

kotlin won't allow to use null like this(name,null) so use ? to represent null values with type, surname: String?

class Person(name: String, surname: String?) {

    init {
        Log.d("primary", "Hello");
    }

    constructor(name : String):this(name,null){
        Log.d("secondary", "Hello");
    }
}

Well init is not body of constructor. It is called after primary constructor with the context of primary constructor.

As given in Official documentation:

The primary constructor cannot contain any code. Initialization code can be placed in initializer blocks, which are prefixed with the init keyword:

class Customer(name: String) {
    init {
        logger.info("Customer initialized with value ${name}")
    }
}

Note that parameters of the primary constructor can be used in the initializer blocks. They can also be used in property initializers declared in the class body:

class Customer(name: String) {
    val customerKey = name.toUpperCase()
}

In fact, for declaring properties and initializing them from the primary constructor, Kotlin has a concise syntax:

class Person(val firstName: String, val lastName: String, var age: Int) {
    // ...
}

---

As per your question you can add a constructor to accept one parameter like following:

class Person(name: String, surname: String) {

    constructor(name: String) : this(name, "") {
        // constructor body
    }

    init {
        Log.d("App", "Hello");
    }
}

But it doesn't look right as we are unnecessary passing second argument empty string. So we can order constructor like following:

class Person(name: String) {

    constructor(name: String, surname: String) : this(name) {
        // constructor body
    }

    init {
        Log.d("App", "Hello");
    }
}

Hope it helps.

Secondary Constructors

The class can also declare secondary constructors, which are prefixed with constructor:

class Person {
    constructor(parent: Person) {
        parent.children.add(this)
    } } 

If the class has a primary constructor, each secondary constructor needs to delegate to the primary constructor, either directly or indirectly through another secondary constructor(s). Delegation to another constructor of the same class is done using the this keyword:

class Person(val name: String) {
    constructor(name: String, parent: Person) : this(name) {
        parent.children.add(this)
    } }

see https://kotlinlang.org/docs/reference/classes.html Secondary Constructors part