Error: Variable with Getter/Setter Cannot Have an Initial Value

Variable with getter/setter cannot have initial value, on overridden stored property

In swift you are able to override properties only with computed properties (which are not able to have default values) with same type. In your case, if you wish override test property in SecondViewController you need write something like this:

override var test: Float {
    get {
        return super.test
    }
    set {
        super.test = newValue
    }
}

And there is no way to override didSet/willSet observers directly; you may do this by write other methods invoked in observers and just override them:

FirstViewController:

internal var test: Float = 32.0 {
    willSet {
        test_WillSet(newValue)
    }
    didSet {
        test_DidSet(oldValue)
    }
}

func test_WillSet(newValue: Float) {}
func test_DidSet(oldValue: Float) {}

SecondViewController:

override func test_WillSet(newValue: Float) {
    super.test_WillSet(newValue)
}
override func test_DidSet(oldValue: Float) {
    super.test_DidSet(oldValue)
}

Set a default value for a property with defined getter and setter

In Swift, getters and setters are used for computed properties - there is no storage for the property and thus, in your case, simpleDescription can't be set in a setter.

If you need a default value, use:

class SimpleClass {
  var simpleDescription: String = "default description"
}

if you want to initialize use:

class SimpleClass {
  var simpleDescription: String
  init (desc: String) {
    simpleDescription = desc
  }
}

Kotlin property with getter. Can I not specify an initial value?

Change the var to val and it should work:

....
val instance: MyClass
....

A variable property (var) not only assumes a getter, but also a setter. Since you provided no setter, a default one was generated set(value) { field = value }. Despite is uselessness in this situation, the default setter uses field, thus requires its initialization.

Custom variable setter with a default value

The syntax of your custom setter is wrong here.

Check for the correct one here: https://developer.apple.com/library/prerelease/content/documentation/Swift/Conceptual/Swift_Programming_Language/Properties.html

Swift: Why does a variable with a setter must also have a getter?

Quick answer for the quick question "Why?":

Once you add a get (or set) to a property, it turns into a Computed Property. Computed properties may be read-only, thus requiring only a getter, but they may not be write-only. So if you add a setter to a property, you turn it into a computer property hence you must add a getter as well.

EDIT: Following comments, Why can Computed Properties be read-only, but not write-only?

I can't find official documentation to back this up, so the following explanation is solely based on my logical point of view:

Computed Properties don't store actual data on their variables; instead they compute data to display.

var a:Int = 5 // Stored property
var timesTen:Int { // Computed Property
    get {
        return a * 10
    }
}

From the example above: a is a Stored property. Therefore, its get method automatically returns a's value. Now think of timesTen: What's its value? Since it doesn't store any value in timesTen variable, you must tell the computed property how and where to read its "value" from. So that's why you can't use a computed property for writing-only purposes.

---

Workaround / How to avoid it

For simple properties you may use didSet or willSet to achieve the desired purpose:

var proxy: MyProxy?
{
    willSet { if _proxy == nil && newValue != nil { _proxy = newValue } }
}

If you are using Swift 2.x, you may use the guard statement to for a cleaner code:

var proxy: MyProxy?
{
    willSet { 
         guard (_proxy == nil && newValue != nil) else { return }
         _proxy = newValue
    }
}

---

Another observation

If _proxy is not required to be private you may remove it completely, using only one variable/property instead of two:

var proxy: MyProxy!
{
    willSet { 
         guard (proxy == nil && newValue != nil) else { return }
         // By not preventing `willSet` to continue, `newValue` will automatically assigned to `proxy`
    }
}

Object.defineProperty() default value with getter/setter

Use a function scoped variable to back the defined property and set that variable's initial value to the default:

function LivingThing(){
    self = this;
    var isAlive = true;

    Object.defineProperty(self, 'isAlive', {
        get: function(){
            return isAlive;
        },
        set: function(newValue){
            isAlive = newValue;
        },
        configurable: true
    });

    self.kill = function(){
        self.isAlive = false;
    };
}

http://jsfiddle.net/329ntgcL/5/

writable isn't necessary because you have a setter. That's what's causing your error. You can either have value/writable (data descriptor) OR get/set (accessor descriptor).

As a result, when you call var l = new LivingThing, l.isAlive == true and after you call l.kill(), l.isAlive == false

How to print default value of class object when using setters and getters

Your constructor should be like:

class Warriors:
    def __init__(self, name="no name"):
        self.__name = name

---

Related Topics