new site

src/site/_includes/language-tour/classes/index.markdown

 Dart is an object-oriented language with classes
 and single inheritance. The root class is
 [Object](http://api.dartlang.org/dart_core/Object.html).
 
 ### Instance variables
 
 Here's how you declare
 a class with instance variables
 (also known as member variables):
 
@@ skipping 23 matching lines @@
 }
 {% endhighlight %}
 
 #### Instance variable initialization
 
 If you initialize an instance variable
 where it is declared
 (instead of in a constructor or method),
 the initial value must be a compile-time constant.
 
-<aside class="note" markdown="1">
-**Note:** This restriction is currently under review.
+<aside>
+  <div class="alert alert-info">
+    <strong>Note:</strong>
+    This restriction is currently under review.
+  </div>
 </aside>
 
 An example of a compile-time constant is a number literal:
 
 {% highlight dart %}
 class Point {
   num x = 0,
       y = 0;
 }
 {% endhighlight %}
@@ skipping 15 matching lines @@
   Point(num x, num y) {
     // There's a better way to do this, stay tuned.
     this.x = x;
     this.y = y;
   }
 }
 {% endhighlight %}
 
 The `this` keyword references the current instance.
 
-<aside class="note" markdown="1">
-**Note:** Use `this` only when there is a name
-conflict. Otherwise, Dart style omits the `this`.
+<aside>
+  <div class="alert alert-info">
+    <strong>Tip:</strong>
+    Use <code>this</code> only when there is a name
+    conflict. Otherwise, Dart style omits the <code>this</code>.
+  </div>
 </aside>
 
 The pattern of assigning a constructor argument to
 a member variable is so common, Dart has syntactic sugar
 to make it easy.
 
 {% highlight dart %}
 class Point {
   num x, y;
 
@@ skipping 132 matching lines @@
 
 {% highlight dart %}
 void main() {
   var a = const Point(1, 1);
   var b = const Point(1, 1);
 
   assert(a === b); // They are the same instance!
 }
 {% endhighlight %}
 
-<aside class="note" markdown="1">
-**Note:** Other examples of compile-time
-constants are literal numbers and literal strings.
+<aside>
+  <div class="alert alert-info">
+    <strong>Tip:</strong>
+    Other examples of compile-time
+    constants are literal numbers and literal strings.
+  </div>
 </aside>
 
 #### Factory constructors
 
 Use the `factory` keyword
 when implementing a constructor that
 doesn't always create a new instance of its class.
 For example, a factory constructor
 might return an instance from a cache,
 or it might return an instance of a subclass.
@@ skipping 33 matching lines @@
 {% endhighlight %}
 
 As for other constructors,
 to invoke a factory constructor you use the `new` keyword:
 
 {% highlight dart %}
 var logger = new Logger('UI');
 logger.log('Button clicked');
 {% endhighlight %}
 
-<aside class="note" markdown="1">
-**Note:** Factory constructors have no access to `this`.
+<aside>
+  <div class="alert alert-info">
+    <strong>Tip:</strong>
+    Factory constructors have no access to <code>this</code>.
+  </div>
 </aside>
 
 ### Methods
 
 Methods are functions that
 provide behavior for an object.
 
 #### Instance methods
 
 Instance methods on objects can access instance variables and `this`.
@@ skipping 52 matching lines @@
 rect.right = 12;
 assert(rect.left == -8);
 {% endhighlight %}
 
 With getters and setters, you can start
 with instance variables,
 later wrapping them with methods,
 all without changing client code.
 
 <section id="classes-operators" markdown="1">
-#### Operators
+#### Operators as methods
 
 Because operators are just instance methods with special names,
 you can override [many operators](#op-methods).
 Here's an example of a class that overrides the `+` and `-` operators.
 
 {% highlight dart %}
 class Vector {
   final int x,y;
   const Vector(this.x, this.y);
 
@@ skipping 15 matching lines @@
 main() {
   final v = new Vector(2,3);
   final w = new Vector(2,2);
 
   assert(v.x == 2 && v.y == 3);         // v   == (2,3)
   assert((-v).x == -2 && (-v).y == -3); // -v  == (-2,-3)
   assert((v+w).x == 4 && (v+w).y == 5); // v+w == (4,5)
   assert((v-w).x == 0 && (v-w).y == 1); // v-w == (0,1)
 }{% endhighlight %}
 
-<aside class="note" markdown="1">
-**Implementation note:**
-Overriding `-` affects only the binary subtraction operator.
-To override the unary form of `-`,
-you must use the special identifier **negate**.
+<aside>
+  <div class="alert alert-info">
+    <strong>Tip:</strong>
+    Overriding <code>-</code> affects only the binary subtraction operator.
+    To override the unary form of <code>-</code>,
+    you must use the special identifier <b>negate</b>.
+  </div>
 </aside>
 
 </section>
 </section>
 
 
 ### Abstract classes {#classes-abstract}
 
 Dart supports abstract classes and methods.
 Use the **abstract** keyword whenever you
@@ skipping 99 matching lines @@
 }
 
 main() {
   var a = new Point(2, 2);
   var b = new Point(4, 4);
   var distance = Point.distanceBetween(a,b);
   assert(distance < 2.9 && distance > 2.8);
 }
 {% endhighlight %}
 
-<aside class="note" markdown="1">
-  **Best practice:** Consider using top-level functions,
-  instead of static methods, for common or widely
-  used utilities and functionality.
+<aside>
+  <div class="alert alert-info">
+    <strong>Tip:</strong>
+    Consider using top-level functions,
+    instead of static methods, for common or widely
+    used utilities and functionality.
+  </div>
 </aside>
 
 #### Static variables
 
 Static variables (class variables) are useful for class-wide state and
 constants.
 
 {% highlight dart %}
 class Color {
   static final RED = const Color('red');
   final String name;
   const Color(this.name);
 }
 
 main() {
   assert(Color.RED.name == 'red');
 }
 {% endhighlight %}