2 files changed, 27 insertions, 26 deletions
diff --git a/java.html.markdown b/java.html.markdown
index 7b59b085..621d500c 100644
--- a/java.html.markdown
+++ b/java.html.markdown
@@ -173,7 +173,7 @@ public class LearnJava {
         // Char - A single 16-bit Unicode character
         char fooChar = 'A';
 
-        // final variables can't be reassigned to another object,
+        // final variables can't be reassigned,
         final int HOURS_I_WORK_PER_WEEK = 9001;
         // but they can be initialized later.
         final double E;
@@ -703,15 +703,21 @@ public class ExampleClass extends ExampleClassParent implements InterfaceOne,
 //     // Method declarations
 // }
 
-// Marking a class as abstract means that it contains at least one abstract
-// method that must be defined in a child class. Similar to interfaces, abstract
-// classes cannot be instantiated, but instead must be extended and the abstract
-// methods defined. Different from interfaces, abstract classes can contain a
-// mixture of concrete and abstract methods. Methods in an interface cannot
-// have a body, unless the method is static, and variables are final by default,
-// unlike an abstract class. Also abstract classes CAN have the "main" method.
+// Abstract Classes cannot be instantiated.
+// Abstract classes may define abstract methods.
+// Abstract methods have no body and are marked abstract
+// Non-abstract child classes must @Override all abstract methods
+// from their super-classes.
+// Abstract classes can be useful when combining repetitive logic
+// with customised behavior, but as Abstract classes require
+// inheritance, they violate "Composition over inheritance"
+// so consider other approaches using composition.
+// https://en.wikipedia.org/wiki/Composition_over_inheritance
+
 public abstract class Animal
 {
+    private int age;
+
     public abstract void makeSound();
 
     // Method can have a body
@@ -722,17 +728,12 @@ public abstract class Animal
         age = 30;
     }
 
-    // No need to initialize, however in an interface
-    // a variable is implicitly final and hence has
-    // to be initialized.
-    private int age;
-
     public void printAge()
     {
         System.out.println(age);
     }
 
-    // Abstract classes can have main function.
+    // Abstract classes can have main method.
     public static void main(String[] args)
     {
         System.out.println("I am abstract");
diff --git a/javascript.html.markdown b/javascript.html.markdown
index 85c8a52d..4ed8f849 100644
--- a/javascript.html.markdown
+++ b/javascript.html.markdown
@@ -103,7 +103,7 @@ false;
 
 // ... which works with more than just strings
 "1, 2, " + 3; // = "1, 2, 3"
-"Hello " + ["world", "!"] // = "Hello world,!"
+"Hello " + ["world", "!"]; // = "Hello world,!"
 
 // and are compared with < and >
 "a" < "b"; // = true
@@ -222,7 +222,7 @@ while (true){
 var input;
 do {
     input = getInput();
-} while (!isValid(input))
+} while (!isValid(input));
 
 // The `for` loop is the same as C and Java:
 // initialization; continue condition; iteration.
@@ -293,7 +293,7 @@ myFunction("foo"); // = "FOO"
 // automatic semicolon insertion. Watch out for this when using Allman style.
 function myFunction(){
     return // <- semicolon automatically inserted here
-    {thisIsAn: 'object literal'}
+    {thisIsAn: 'object literal'};
 }
 myFunction(); // = undefined
 
@@ -388,7 +388,7 @@ myFunc(); // = undefined
 // through `this`, even if it wasn't attached when it was defined.
 var myOtherFunc = function(){
     return this.myString.toUpperCase();
-}
+};
 myObj.myOtherFunc = myOtherFunc;
 myObj.myOtherFunc(); // = "HELLO WORLD!"
 
@@ -397,7 +397,7 @@ myObj.myOtherFunc(); // = "HELLO WORLD!"
 
 var anotherFunc = function(s){
     return this.myString + s;
-}
+};
 anotherFunc.call(myObj, " And Hello Moon!"); // = "Hello World! And Hello Moon!"
 
 // The `apply` function is nearly identical, but takes an array for an argument
@@ -420,7 +420,7 @@ boundFunc(" And Hello Saturn!"); // = "Hello World! And Hello Saturn!"
 
 // `bind` can also be used to partially apply (curry) a function.
 
-var product = function(a, b){ return a * b; }
+var product = function(a, b){ return a * b; };
 var doubler = product.bind(this, 2);
 doubler(8); // = 16
 
@@ -430,11 +430,11 @@ doubler(8); // = 16
 
 var MyConstructor = function(){
     this.myNumber = 5;
-}
+};
 myNewObj = new MyConstructor(); // = {myNumber: 5}
 myNewObj.myNumber; // = 5
 
-// Unlike most other popular object-oriented languages, JavaScript has no 
+// Unlike most other popular object-oriented languages, JavaScript has no
 // concept of 'instances' created from 'class' blueprints; instead, JavaScript
 // combines instantiation and inheritance into a single concept: a 'prototype'.
 
@@ -451,7 +451,7 @@ var myObj = {
 var myPrototype = {
     meaningOfLife: 42,
     myFunc: function(){
-        return this.myString.toLowerCase()
+        return this.myString.toLowerCase();
     }
 };
 
@@ -515,7 +515,7 @@ MyConstructor.prototype = {
 };
 var myNewObj2 = new MyConstructor();
 myNewObj2.getMyNumber(); // = 5
-myNewObj2.myNumber = 6
+myNewObj2.myNumber = 6;
 myNewObj2.getMyNumber(); // = 6
 
 // Built-in types like strings and numbers also have constructors that create
@@ -540,7 +540,7 @@ if (new Number(0)){
 // you can actually add functionality to a string, for instance.
 String.prototype.firstCharacter = function(){
     return this.charAt(0);
-}
+};
 "abc".firstCharacter(); // = "a"
 
 // This fact is often used in "polyfilling", which is implementing newer
@@ -556,7 +556,7 @@ if (Object.create === undefined){ // don't overwrite it if it exists
         Constructor.prototype = proto;
         // then use it to create a new, appropriately-prototyped object
         return new Constructor();
-    }
+    };
 }
 ```