In a related question I had some time ago, there was a link to a posting on Jeff’s blog, explaining some differences. Properties vs. Public Variables Reflection works differently on variables vs. properties, so if you rely on reflection, it’s easier to use all properties. You can’t databind against a variable. Changing a variable to … Read more
Data classes are just regular classes that are geared towards storing state, rather than containing a lot of logic. Every time you create a class that mostly consists of attributes, you make a data class. What the dataclasses module does is to make it easier to create data classes. It takes care of a lot … Read more
The built-in object can be instantiated but can’t have any attributes set on it. (I wish it could, for this exact purpose.) It doesn’t have a __dict__ to hold the attributes. I generally just do this: class Object(object): pass a = Object() a.somefield = somevalue When I can, I give the Object class a more … Read more
To be clearer, I make an example here, class ClassA { class func func1() -> String { return “func1” } static func func2() -> String { return “func2” } /* same as above final class func func2() -> String { return “func2” } */ } static func is same as final class func Because it … Read more
Actually, you can do what you want. If you want to provide multiple interfaces or a class plus interfaces, you have to have your wildcard look something like this: <T extends ClassA & InterfaceB> See the Generics Tutorial at sun.com, specifically the Bounded Type Parameters section, at the bottom of the page. You can actually … Read more
Use the abc module to create abstract classes. Use the abstractmethod decorator to declare a method abstract, and declare a class abstract using one of three ways, depending upon your Python version. In Python 3.4 and above, you can inherit from ABC. In earlier versions of Python, you need to specify your class’s metaclass as … Read more
╔═══════════════╦═══════════════════════════╦═════════════════════════════════╗ ║ ║ class ║ module ║ ╠═══════════════╬═══════════════════════════╬═════════════════════════════════╣ ║ instantiation ║ can be instantiated ║ can *not* be instantiated ║ ╟───────────────╫───────────────────────────╫─────────────────────────────────╢ ║ usage ║ object creation ║ mixin facility. provide ║ ║ ║ ║ a namespace. ║ ╟───────────────╫───────────────────────────╫─────────────────────────────────╢ ║ superclass ║ module ║ object ║ ╟───────────────╫───────────────────────────╫─────────────────────────────────╢ ║ methods ║ class methods and ║ module methods … Read more
static and class both associate a method with a class, rather than an instance of a class. The difference is that subclasses can override class methods; they cannot override static methods. class properties will theoretically function in the same way (subclasses can override them), but they’re not possible in Swift yet.
Just remove the comma like this: <article class=”column wrapper”>
With ECMAScript5’s Function.prototype.bind things get pretty clean: function newCall(Cls) { return new (Function.prototype.bind.apply(Cls, arguments)); // or even // return new (Cls.bind.apply(Cls, arguments)); // if you know that Cls.bind has not been overwritten } It can be used as follows: var s = newCall(Something, a, b, c); or even directly: var s = new (Function.prototype.bind.call(Something, null, … Read more