Add concept headings to introduction.md

ErikSchierboom · mirkoperillo · commit cc8a193e6ea6 · 2021-01-30T15:05:29.000+01:00
diff --git a/exercises/concept/arrays/.docs/introduction.md b/exercises/concept/arrays/.docs/introduction.md
@@ -1,3 +1,5 @@
+## arrays
+
 In Java, data structures that can hold zero or more elements are known as _collections_. An **array** is a collection that has a fixed size/length and whose elements must all be of the same type. Elements can be assigned to an array or retrieved from it using an index. Java arrays are zero-based, meaning that the first element's index is always zero:
 
 ```java
diff --git a/exercises/concept/basics/.docs/introduction.md b/exercises/concept/basics/.docs/introduction.md
@@ -1,3 +1,5 @@
+## basics
+
 Java is a statically-typed language, which means that everything has a type at compile-time. Assigning a value to a name is referred to as defining a variable. A variable is defined by explicitly specifying its type.
 
 ```java
diff --git a/exercises/concept/booleans/.docs/introduction.md b/exercises/concept/booleans/.docs/introduction.md
@@ -1,3 +1,5 @@
+## booleans
+
 Booleans in Java are represented by the `boolean` type, which values can be either `true` or `false`.
 
 Java supports three boolean operators: `!` (NOT), `&&` (AND), and `||` (OR).
diff --git a/exercises/concept/chars/.docs/introduction.md b/exercises/concept/chars/.docs/introduction.md
@@ -1,3 +1,5 @@
+## chars
+
 The Java `char` type represents the smallest addressable components of text.
 Multiple `char`s can comprise a string such as `"word"` or `char`s can be
 processed independently. Their literals have single quotes e.g. `'A'`.
diff --git a/exercises/concept/classes/.docs/introduction.md b/exercises/concept/classes/.docs/introduction.md
@@ -1,3 +1,5 @@
+## classes
+
 The primary object-oriented construct in Java is the _class_, which is a combination of data (_fields_) and behavior (_methods_). The fields and methods of a class are known as its _members_.
 
 Access to members can be controlled through access modifiers, the two most common ones being:
diff --git a/exercises/concept/conditionals/.docs/introduction.md b/exercises/concept/conditionals/.docs/introduction.md
@@ -1,3 +1,5 @@
+## conditionals-if
+
 ## Logical Operators
 
 Java supports the three logical operators `&&` (AND), `||` (OR), and `!` (NOT).
diff --git a/exercises/concept/constructors/.docs/introduction.md b/exercises/concept/constructors/.docs/introduction.md
@@ -1,3 +1,5 @@
+## constructors
+
 Creating an instance of a _class_ is done by calling its _constructor_ through the `new` operator. A constructor is a special type of method whose goal is to initialize a newly created instance. Constructors look like regular methods, but without a return type and with a name that matches the classes' name.
 
 ```java
diff --git a/exercises/concept/inheritance/.docs/introduction.md b/exercises/concept/inheritance/.docs/introduction.md
@@ -1,3 +1,5 @@
+## inheritance
+
 Inheritance is a core concept in OOP (Object Oriented Programming). It donates IS-A relationship.
 It literally means in programming as it means in english, inheriting features from parent(in programming features is normally functions
 and variables).
diff --git a/exercises/concept/interfaces/.docs/introduction.md b/exercises/concept/interfaces/.docs/introduction.md
@@ -1,3 +1,5 @@
+## interfaces
+
 An interface is a type containing members defining a group of related functionality. It distances the uses of a class from the implementation allowing multiple different implementations or support for some generic behavior such as formatting, comparison or conversion.
 
 The syntax of an interface is similar to that of a class except that methods appear as the signature only and no body is provided.
diff --git a/exercises/concept/numbers/.docs/introduction.md b/exercises/concept/numbers/.docs/introduction.md
@@ -1,3 +1,5 @@
+## numbers
+
 There are two different types of numbers in Java:
 
 - Integers: numbers with no digits behind the decimal separator (whole numbers). Examples are `-6`, `0`, `1`, `25`, `976` and `-500000`.
diff --git a/exercises/concept/strings/.docs/introduction.md b/exercises/concept/strings/.docs/introduction.md
@@ -1,3 +1,5 @@
+## strings
+
 A `String` in Java is an object that represents immutable text as a sequence of Unicode characters (letters, digits, punctuation, etc.). Double quotes are used to define a `String` instance:
 
 ```java
diff --git a/exercises/concept/switch-statement/.docs/introduction.md b/exercises/concept/switch-statement/.docs/introduction.md
@@ -1,3 +1,5 @@
+## switch-statement
+
 Like an _if/else_ statement, a `switch` statement allow you to change the flow of the program by conditionally executing code. The difference is that a `switch` statement can only compare the value of a primitive or string expression against pre-defined constant values.
 
 Some keywords are usefull when using a switch statement.
diff --git a/exercises/concept/ternary-operators/.docs/introduction.md b/exercises/concept/ternary-operators/.docs/introduction.md
@@ -1,3 +1,5 @@
+## ternary-operators
+
 The _ternary operator_ is a lightweight, compact alternative for simple _if/else_ statements. Usually used in (but not restricted to) return statements, it needs just one single line to make the decision, returning the left value if the expression is `true` and the right value if `false`, as follows:
 
 ```java

Original file line number	Diff line number	Diff line change
`@@ -1,3 +1,5 @@`
	`1`	`+## arrays`
	`2`	`+`
`1`	`3`	`In Java, data structures that can hold zero or more elements are known as _collections_. An array is a collection that has a fixed size/length and whose elements must all be of the same type. Elements can be assigned to an array or retrieved from it using an index. Java arrays are zero-based, meaning that the first element's index is always zero:`
`2`	`4`
`3`	`5`	```java
Original file line number	Diff line number	Diff line change
`@@ -1,3 +1,5 @@`
	`1`	`+## basics`
	`2`	`+`
`1`	`3`	`Java is a statically-typed language, which means that everything has a type at compile-time. Assigning a value to a name is referred to as defining a variable. A variable is defined by explicitly specifying its type.`
`2`	`4`
`3`	`5`	```java
Original file line number	Diff line number	Diff line change
`@@ -1,3 +1,5 @@`
	`1`	`+## chars`
	`2`	`+`
`1`	`3`	The Java `char` type represents the smallest addressable components of text.
`2`	`4`	Multiple `char`s can comprise a string such as `"word"` or `char`s can be
`3`	`5`	processed independently. Their literals have single quotes e.g. `'A'`.
Original file line number	Diff line number	Diff line change
`@@ -1,3 +1,5 @@`
	`1`	`+## classes`
	`2`	`+`
`1`	`3`	`The primary object-oriented construct in Java is the _class_, which is a combination of data (_fields_) and behavior (_methods_). The fields and methods of a class are known as its _members_.`
`2`	`4`
`3`	`5`	`Access to members can be controlled through access modifiers, the two most common ones being:`
Original file line number	Diff line number	Diff line change
`@@ -1,3 +1,5 @@`
	`1`	`+## conditionals-if`
	`2`	`+`
`1`	`3`	`## Logical Operators`
`2`	`4`
`3`	`5`	Java supports the three logical operators `&&` (AND), `\|\|` (OR), and `!` (NOT).
Original file line number	Diff line number	Diff line change
`@@ -1,3 +1,5 @@`
	`1`	`+## constructors`
	`2`	`+`
`1`	`3`	Creating an instance of a _class_ is done by calling its _constructor_ through the `new` operator. A constructor is a special type of method whose goal is to initialize a newly created instance. Constructors look like regular methods, but without a return type and with a name that matches the classes' name.
`2`	`4`
`3`	`5`	```java
Original file line number	Diff line number	Diff line change
`@@ -1,3 +1,5 @@`
	`1`	`+## inheritance`
	`2`	`+`
`1`	`3`	`Inheritance is a core concept in OOP (Object Oriented Programming). It donates IS-A relationship.`
`2`	`4`	`It literally means in programming as it means in english, inheriting features from parent(in programming features is normally functions`
`3`	`5`	`and variables).`
Original file line number	Diff line number	Diff line change
`@@ -1,3 +1,5 @@`
	`1`	`+## interfaces`
	`2`	`+`
`1`	`3`	`An interface is a type containing members defining a group of related functionality. It distances the uses of a class from the implementation allowing multiple different implementations or support for some generic behavior such as formatting, comparison or conversion.`
`2`	`4`
`3`	`5`	`The syntax of an interface is similar to that of a class except that methods appear as the signature only and no body is provided.`
Original file line number	Diff line number	Diff line change
`@@ -1,3 +1,5 @@`
	`1`	`+## numbers`
	`2`	`+`
`1`	`3`	`There are two different types of numbers in Java:`
`2`	`4`
`3`	`5`	- Integers: numbers with no digits behind the decimal separator (whole numbers). Examples are `-6`, `0`, `1`, `25`, `976` and `-500000`.