Tight coupling is when a group of classes are highly dependent on one another. This scenario arises when a class assumes too many responsibilities, or when one concern is spread over many classes rather than having its own class. Loose coupling is achieved by means of a design that promotes single-responsibility and separation of concerns. … Read more
There are a bunch of reasons here: http://macresearch.org/difference-between-alloc-init-and-new Some selected ones are: new doesn’t support custom initializers (like initWithString) alloc-init is more explicit than new General opinion seems to be that you should use whatever you’re comfortable with.
Use an interface when you want to force developers working in your system (yourself included) to implement a set number of methods on the classes they’ll be building. Use an abstract class when you want to force developers working in your system (yourself included) to implement a set numbers of methods and you want to … Read more
You could try this: List<Int32> copy = new List<Int32>(original); or if you’re using C# 3 and .NET 3.5, with Linq, you can do this: List<Int32> copy = original.ToList(); I see that this answer is still getting upvotes. Well, here’s a secret for ya: the above answer is still using a foreach. Please don’t upvote this … Read more
The clearest way to express polymorphism is via an abstract base class (or interface) public abstract class Human{ … public abstract void goPee(); } This class is abstract because the goPee() method is not definable for Humans. It is only definable for the subclasses Male and Female. Also, Human is an abstract concept — You … Read more
Firstly (IMO) don’t listen to people who say friend is not useful. It IS useful. In many situations you will have objects with data or functionality that are not intended to be publicly available. This is particularly true of large codebases with many authors who may only be superficially familiar with different areas. There ARE … Read more
On invoking overridable method from constructors Simply put, this is wrong because it unnecessarily opens up possibilities to MANY bugs. When the @Override is invoked, the state of the object may be inconsistent and/or incomplete. A quote from Effective Java 2nd Edition, Item 17: Design and document for inheritance, or else prohibit it: There are … Read more
[Executive Summary: Use ++i if you don’t have a specific reason to use i++.] For C++, the answer is a bit more complicated. If i is a simple type (not an instance of a C++ class), then the answer given for C (“No there is no performance difference”) holds, since the compiler is generating the … Read more
Using prototypes: function Box(color) // Constructor { this.color = color; } Box.prototype.getColor = function() { return this.color; }; Hiding “color” (somewhat resembles a private member variable): function Box(col) { var color = col; this.getColor = function() { return color; }; } Usage: var blueBox = new Box(“blue”); alert(blueBox.getColor()); // will alert blue var greenBox = … Read more
Most answers here focus on OOP but encapsulation begins much earlier: Every function is an encapsulation; in pseudocode: point x = { 1, 4 } point y = { 23, 42 } numeric d = distance(x, y) Here, distance encapsulates the calculation of the (Euclidean) distance between two points in a plane: it hides implementation … Read more