Why this syntax?

But in both examples we are using default values so why does one have an underscore and '=' sign while the other doesn't? Also why don't we have to specify the type in the convenience init? I didn't get that part. Thanks for your help :)

The override method we are using default values in a different way than the init method. In the override, our super class method doesn't have a default value, so we have to modify the functionality of the input to allow for an optional parameter.

The second one we don't, specifically because we're directly calling pass through methods from the top down in a cascading style to provide each init functions desired parameters.

With the first one, we can completely omit sending any parameters and it still functions as our default is 10.

In the other one, we expect the user to submit a single parameter, and then we use passthru to complete our 'default' values to the final destination which is the super class init method.

We can run: ** tshirt.discountedPrice()** but we can't run var tshirt = Clothing() as the second one requires the description parameter, and our 'store' knows that the cost of this is going to be 99 dollars, and be a product of calvin klein.. So, it'll call it like this:

• ( convenience init )
  • (init within the Clothing class)
  • set self.description
  • (init within the super class or in this case Products Class )
    • set Product price to 99
    • set Product Designer to Calvin Klein

Which, the end result is we have a fully instantiated object with all the necessary elements. This is part of object instantiation and object inheritance. It can be confusing, not only in swift, but once you understand it you'll get that "AH-HA!" moment.

Yes, these are syntax rules.

When you are overriding a method from your super class, you use the override keyword. The entire declaration of this method ( including parameters that it takes ) has to be the same as in the original. Doing what we did, we allow for the use of an optional.

When initializing an instance of a class, you can use the pasthru method, and convenience methods to handle any default settings you may need to pass through that are the same upon multiple types..

Take this example ( ported from what i am working on in ruby right now )

Class User {
   let type: String
   let username: String
   init (username:String, type:String) {
      self.type = type
      self.username = username
   }
}

class Admin:User {
    init (username:String, type:String) {
          super.init(username: username, type: type)
    }
   convenience init(username:String) {
        self.init(username: username, type: "Admin")
   }
}

class General:User {
    init (username:String, type:String) {
          super.init(username: username, type: type)
    }
   convenience init(username:String) {
        self.init(username: username, type: "General")
   }
}

Happy to help out. Glad you understand it better now. With a single pair of classes it can be hidden as to why and how it would be useful, its not until you can see it in a larger scale that it truly becomes apparent. Have your "AH-HA!" moment?