summaryrefslogtreecommitdiffhomepage
path: root/java.html.markdown
diff options
context:
space:
mode:
authorLevi Bostian <levi.bostian@gmail.com>2015-05-25 10:23:56 -0500
committerLevi Bostian <levi.bostian@gmail.com>2015-05-25 10:23:56 -0500
commit4d77e1678019f6584001c5826c108b5fb3a38cfe (patch)
tree5d7c45d14d45a4d8c0392bb6a0a8a6c14173506d /java.html.markdown
parentf46db74bd4c5b9e196caa07cc41a60c80012842a (diff)
parentb72c575c0442006c4eed1da46e1f6a0129f55d99 (diff)
Merge pull request #1111 from drguildo/master
A bunch of small changes to aid clarity, brevity and/or consistency, …
Diffstat (limited to 'java.html.markdown')
-rw-r--r--java.html.markdown197
1 files changed, 93 insertions, 104 deletions
diff --git a/java.html.markdown b/java.html.markdown
index 10dd498c..f6bc82c6 100644
--- a/java.html.markdown
+++ b/java.html.markdown
@@ -1,16 +1,16 @@
---
-
language: java
contributors:
- ["Jake Prather", "http://github.com/JakeHP"]
- - ["Madison Dickson", "http://github.com/mix3d"]
- ["Jakukyo Friel", "http://weakish.github.io"]
+ - ["Madison Dickson", "http://github.com/mix3d"]
+ - ["Simon Morgan", "http://sjm.io/"]
filename: LearnJava.java
-
---
-Java is a general-purpose, concurrent, class-based, object-oriented computer programming language.
-[Read more here.](http://docs.oracle.com/javase/tutorial/java/index.html)
+Java is a general-purpose, concurrent, class-based, object-oriented computer
+programming language.
+[Read more here.](http://docs.oracle.com/javase/tutorial/java/)
```java
// Single-line comments start with //
@@ -31,17 +31,17 @@ import java.security.*;
// the file.
public class LearnJava {
- // A program must have a main method as an entry point
+ // A program must have a main method as an entry point.
public static void main (String[] args) {
- // Use System.out.println to print lines
+ // Use System.out.println() to print lines.
System.out.println("Hello World!");
System.out.println(
"Integer: " + 10 +
" Double: " + 3.14 +
" Boolean: " + true);
- // To print without a newline, use System.out.print
+ // To print without a newline, use System.out.print().
System.out.print("Hello ");
System.out.print("World");
@@ -69,7 +69,7 @@ public class LearnJava {
// L is used to denote that this variable value is of type Long;
// anything without is treated as integer by default.
- // Note: Java has no unsigned types
+ // Note: Java has no unsigned types.
// Float - Single-precision 32-bit IEEE 754 Floating Point
float fooFloat = 234.5f;
@@ -86,7 +86,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 to another object.
final int HOURS_I_WORK_PER_WEEK = 9001;
// Strings
@@ -101,10 +101,10 @@ public class LearnJava {
System.out.println(bazString);
// Arrays
- //The array size must be decided upon instantiation
- //The following formats work for declaring an array
- //<datatype>[] <var name> = new <datatype>[<array size>];
- //<datatype> <var name>[] = new <datatype>[<array size>];
+ // The array size must be decided upon instantiation
+ // The following formats work for declaring an array
+ // <datatype>[] <var name> = new <datatype>[<array size>];
+ // <datatype> <var name>[] = new <datatype>[<array size>];
int[] intArray = new int[10];
String[] stringArray = new String[1];
boolean boolArray[] = new boolean[100];
@@ -122,17 +122,17 @@ public class LearnJava {
System.out.println("intArray @ 1: " + intArray[1]); // => 1
// Others to check out
- // ArrayLists - Like arrays except more functionality is offered,
- // and the size is mutable
+ // ArrayLists - Like arrays except more functionality is offered, and
+ // the size is mutable.
// LinkedLists - Implementation of doubly-linked list. All of the
- // operations perform as could be expected for
- // a doubly-linked list.
- // Maps - A set of objects that maps keys to values. A map cannot contain
- // duplicate keys; each key can map to at most one value.
- // HashMaps - This class uses a hashtable to implement the Map interface.
- // This allows the execution time of basic operations,
- // such as get and insert element, to remain constant even
- // for large sets.
+ // operations perform as could be expected for a
+ // doubly-linked list.
+ // Maps - A set of objects that maps keys to values. A map cannot
+ // contain duplicate keys; each key can map to at most one value.
+ // HashMaps - This class uses a hashtable to implement the Map
+ // interface. This allows the execution time of basic
+ // operations, such as get and insert element, to remain
+ // constant even for large sets.
///////////////////////////////////////
// Operators
@@ -160,13 +160,13 @@ public class LearnJava {
// Bitwise operators!
/*
- ~ Unary bitwise complement
- << Signed left shift
- >> Signed right shift
- >>> Unsigned right shift
- & Bitwise AND
- ^ Bitwise exclusive OR
- | Bitwise inclusive OR
+ ~ Unary bitwise complement
+ << Signed left shift
+ >> Signed right shift
+ >>> Unsigned right shift
+ & Bitwise AND
+ ^ Bitwise exclusive OR
+ | Bitwise inclusive OR
*/
// Incrementations
@@ -175,10 +175,10 @@ public class LearnJava {
// The ++ and -- operators increment and decrement by 1 respectively.
// If they are placed before the variable, they increment then return;
// after the variable they return then increment.
- System.out.println(i++); //i = 1, prints 0 (post-increment)
- System.out.println(++i); //i = 2, prints 2 (pre-increment)
- System.out.println(i--); //i = 1, prints 2 (post-decrement)
- System.out.println(--i); //i = 0, prints 0 (pre-decrement)
+ System.out.println(i++); // i = 1, prints 0 (post-increment)
+ System.out.println(++i); // i = 2, prints 2 (pre-increment)
+ System.out.println(i--); // i = 1, prints 2 (post-decrement)
+ System.out.println(--i); // i = 0, prints 0 (pre-decrement)
///////////////////////////////////////
// Control Structures
@@ -197,73 +197,68 @@ public class LearnJava {
// While loop
int fooWhile = 0;
- while(fooWhile < 100)
- {
- //System.out.println(fooWhile);
- //Increment the counter
- //Iterated 100 times, fooWhile 0,1,2...99
+ while(fooWhile < 100) {
+ System.out.println(fooWhile);
+ // Increment the counter
+ // Iterated 100 times, fooWhile 0,1,2...99
fooWhile++;
}
System.out.println("fooWhile Value: " + fooWhile);
// Do While Loop
int fooDoWhile = 0;
- do
- {
- //System.out.println(fooDoWhile);
- //Increment the counter
- //Iterated 99 times, fooDoWhile 0->99
+ do {
+ System.out.println(fooDoWhile);
+ // Increment the counter
+ // Iterated 99 times, fooDoWhile 0->99
fooDoWhile++;
- }while(fooDoWhile < 100);
+ } while(fooDoWhile < 100);
System.out.println("fooDoWhile Value: " + fooDoWhile);
// For Loop
int fooFor;
- //for loop structure => for(<start_statement>; <conditional>; <step>)
- for(fooFor=0; fooFor<10; fooFor++){
- //System.out.println(fooFor);
- //Iterated 10 times, fooFor 0->9
+ // for loop structure => for(<start_statement>; <conditional>; <step>)
+ for (fooFor = 0; fooFor < 10; fooFor++) {
+ System.out.println(fooFor);
+ // Iterated 10 times, fooFor 0->9
}
System.out.println("fooFor Value: " + fooFor);
// For Each Loop
// An automatic iteration through an array or list of objects.
- int[] fooList = {1,2,3,4,5,6,7,8,9};
- //for each loop structure => for(<object> : <array_object>)
- //reads as: for each object in the array
- //note: the object type must match the array.
+ int[] fooList = {1, 2, 3, 4, 5, 6, 7, 8, 9};
+ // for each loop structure => for (<object> : <array_object>)
+ // reads as: for each object in the array
+ // note: the object type must match the array.
- for( int bar : fooList ){
- //System.out.println(bar);
+ for (int bar : fooList) {
+ System.out.println(bar);
//Iterates 9 times and prints 1-9 on new lines
}
// Switch Case
// A switch works with the byte, short, char, and int data types.
- // It also works with enumerated types (discussed in Enum Types),
- // the String class, and a few special classes that wrap
- // primitive types: Character, Byte, Short, and Integer.
+ // It also works with enumerated types (discussed in Enum Types), the
+ // String class, and a few special classes that wrap primitive types:
+ // Character, Byte, Short, and Integer.
int month = 3;
String monthString;
- switch (month){
- case 1:
- monthString = "January";
- break;
- case 2:
- monthString = "February";
+ switch (month) {
+ case 1: monthString = "January";
break;
- case 3:
- monthString = "March";
+ case 2: monthString = "February";
break;
- default:
- monthString = "Some other month";
+ case 3: monthString = "March";
break;
+ default: monthString = "Some other month";
+ break;
}
System.out.println("Switch Case Result: " + monthString);
// Conditional Shorthand
// You can use the '?' operator for quick assignments or logic forks.
- // Reads as "If (statement) is true, use <first value>, otherwise, use <second value>"
+ // Reads as "If (statement) is true, use <first value>, otherwise, use
+ // <second value>"
int foo = 5;
String bar = (foo < 10) ? "A" : "B";
System.out.println(bar); // Prints A, because the statement is true
@@ -287,9 +282,8 @@ public class LearnJava {
// String
// Typecasting
- // You can also cast java objects, there's a lot of details and
- // deals with some more intermediate concepts.
- // Feel free to check it out here:
+ // You can also cast Java objects, there's a lot of details and deals
+ // with some more intermediate concepts. Feel free to check it out here:
// http://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html
@@ -319,9 +313,9 @@ public class LearnJava {
// Class Declaration Syntax:
-// <public/private/protected> class <class name>{
-// //data fields, constructors, functions all inside.
-// //functions are called as methods in Java.
+// <public/private/protected> class <class name> {
+// // data fields, constructors, functions all inside.
+// // functions are called as methods in Java.
// }
class Bicycle {
@@ -342,7 +336,8 @@ class Bicycle {
}
// This is a constructor that takes arguments
- public Bicycle(int startCadence, int startSpeed, int startGear, String name) {
+ public Bicycle(int startCadence, int startSpeed, int startGear,
+ String name) {
this.gear = startGear;
this.cadence = startCadence;
this.speed = startSpeed;
@@ -388,10 +383,8 @@ class Bicycle {
//Method to display the attribute values of this Object.
@Override
public String toString() {
- return "gear: " + gear +
- " cadence: " + cadence +
- " speed: " + speed +
- " name: " + name;
+ return "gear: " + gear + " cadence: " + cadence + " speed: " + speed +
+ " name: " + name;
}
} // end class Bicycle
@@ -405,26 +398,26 @@ class PennyFarthing extends Bicycle {
super(startCadence, startSpeed, 0, "PennyFarthing");
}
- // You should mark a method you're overriding with an @annotation
- // To learn more about what annotations are and their purpose
- // check this out: http://docs.oracle.com/javase/tutorial/java/annotations/
+ // You should mark a method you're overriding with an @annotation.
+ // To learn more about what annotations are and their purpose check this
+ // out: http://docs.oracle.com/javase/tutorial/java/annotations/
@Override
public void setGear(int gear) {
gear = 0;
}
-
}
-//Interfaces
-//Interface declaration syntax
-//<access-level> interface <interface-name> extends <super-interfaces> {
-// //Constants
-// //Method declarations
-//}
+// Interfaces
+// Interface declaration syntax
+// <access-level> interface <interface-name> extends <super-interfaces> {
+// // Constants
+// // Method declarations
+// }
-//Example - Food:
+// Example - Food:
public interface Edible {
- public void eat(); //Any class that implements this interface, must implement this method
+ public void eat(); // Any class that implements this interface, must
+ // implement this method.
}
public interface Digestible {
@@ -432,33 +425,31 @@ public interface Digestible {
}
-//We can now create a class that implements both of these interfaces
+// We can now create a class that implements both of these interfaces.
public class Fruit implements Edible, Digestible {
@Override
public void eat() {
- //...
+ // ...
}
@Override
public void digest() {
- //...
+ // ...
}
}
-//In java, you can extend only one class, but you can implement many interfaces.
-//For example:
-public class ExampleClass extends ExampleClassParent implements InterfaceOne, InterfaceTwo {
+// In Java, you can extend only one class, but you can implement many
+// interfaces. For example:
+public class ExampleClass extends ExampleClassParent implements InterfaceOne,
+ InterfaceTwo {
@Override
public void InterfaceOneMethod() {
-
}
@Override
public void InterfaceTwoMethod() {
-
}
}
-
```
## Further Reading
@@ -500,5 +491,3 @@ The links provided here below are just to get an understanding of the topic, fee
* [Objects First with Java](http://www.amazon.com/Objects-First-Java-Practical-Introduction/dp/0132492660)
* [Java The Complete Reference](http://www.amazon.com/gp/product/0071606300)
-
-