iskm/learnxinyminutes-docs
1
0
Fork 0
mirror of https://github.com/adambard/learnxinyminutes-docs.git synced 2024-12-23 17:41:41 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

A bunch of small changes to aid clarity, brevity and/or consistency, none of which should alter the semantics.

Browse Source
This commit is contained in:
Simon Morgan 2015-05-23 12:13:07 +01:00
parent cb7339aec7
commit 933f0a461d
1 changed files with 80 additions and 91 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

171
java.html.markdown
View File

@ -1,16 +1,16 @@
--- ---
language: java language: java
contributors: contributors:
- ["Jake Prather", "http://github.com/JakeHP"] - ["Jake Prather", "http://github.com/JakeHP"]
- ["Madison Dickson", "http://github.com/mix3d"]
- ["Jakukyo Friel", "http://weakish.github.io"] - ["Jakukyo Friel", "http://weakish.github.io"]
- ["Madison Dickson", "http://github.com/mix3d"]
- ["Simon Morgan", "http://sjm.io/"]
filename: LearnJava.java filename: LearnJava.java
--- ---
Java is a general-purpose, concurrent, class-based, object-oriented computer programming language. Java is a general-purpose, concurrent, class-based, object-oriented computer
[Read more here.](http://docs.oracle.com/javase/tutorial/java/index.html) programming language.
[Read more here.](http://docs.oracle.com/javase/tutorial/java/)
```java ```java
// Single-line comments start with // // Single-line comments start with //
@ -101,10 +101,10 @@ public class LearnJava {
System.out.println(bazString); System.out.println(bazString);
// Arrays // Arrays
//The array size must be decided upon instantiation // The array size must be decided upon instantiation
//The following formats work for declaring an array // The following formats work for declaring an array
//<datatype>[] <var name> = new <datatype>[<array size>]; // <datatype>[] <var name> = new <datatype>[<array size>];
//<datatype> <var name>[] = new <datatype>[<array size>]; // <datatype> <var name>[] = new <datatype>[<array size>];
int[] intArray = new int[10]; int[] intArray = new int[10];
String[] stringArray = new String[1]; String[] stringArray = new String[1];
boolean boolArray[] = new boolean[100]; boolean boolArray[] = new boolean[100];
@ -122,17 +122,17 @@ public class LearnJava {
System.out.println("intArray @ 1: " + intArray[1]); // => 1 System.out.println("intArray @ 1: " + intArray[1]); // => 1
// Others to check out // Others to check out
// ArrayLists - Like arrays except more functionality is offered, // ArrayLists - Like arrays except more functionality is offered, and
// and the size is mutable // the size is mutable
// LinkedLists - Implementation of doubly-linked list. All of the // LinkedLists - Implementation of doubly-linked list. All of the
// operations perform as could be expected for // operations perform as could be expected for a
// a doubly-linked list. // doubly-linked list.
// Maps - A set of objects that maps keys to values. A map cannot contain // Maps - A set of objects that maps keys to values. A map cannot
// duplicate keys; each key can map to at most one value. // contain duplicate keys; each key can map to at most one value.
// HashMaps - This class uses a hashtable to implement the Map interface. // HashMaps - This class uses a hashtable to implement the Map
// This allows the execution time of basic operations, // interface. This allows the execution time of basic
// such as get and insert element, to remain constant even // operations, such as get and insert element, to remain
// for large sets. // constant even for large sets.
/////////////////////////////////////// ///////////////////////////////////////
// Operators // Operators
@ -175,10 +175,10 @@ public class LearnJava {
// The ++ and -- operators increment and decrement by 1 respectively. // The ++ and -- operators increment and decrement by 1 respectively.
// If they are placed before the variable, they increment then return; // If they are placed before the variable, they increment then return;
// after the variable they return then increment. // after the variable they return then increment.
System.out.println(i++); //i = 1, prints 0 (post-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 = 2, prints 2 (pre-increment)
System.out.println(i--); //i = 1, prints 2 (post-decrement) 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 = 0, prints 0 (pre-decrement)
/////////////////////////////////////// ///////////////////////////////////////
// Control Structures // Control Structures
@ -197,73 +197,68 @@ public class LearnJava {
// While loop // While loop
int fooWhile = 0; int fooWhile = 0;
while(fooWhile < 100) while(fooWhile < 100) {
{ System.out.println(fooWhile);
//System.out.println(fooWhile); // Increment the counter
//Increment the counter // Iterated 100 times, fooWhile 0,1,2...99
//Iterated 100 times, fooWhile 0,1,2...99
fooWhile++; fooWhile++;
} }
System.out.println("fooWhile Value: " + fooWhile); System.out.println("fooWhile Value: " + fooWhile);
// Do While Loop // Do While Loop
int fooDoWhile = 0; int fooDoWhile = 0;
do do {
{ System.out.println(fooDoWhile);
//System.out.println(fooDoWhile); // Increment the counter
//Increment the counter // Iterated 99 times, fooDoWhile 0->99
//Iterated 99 times, fooDoWhile 0->99
fooDoWhile++; fooDoWhile++;
}while(fooDoWhile < 100); } while(fooDoWhile < 100);
System.out.println("fooDoWhile Value: " + fooDoWhile); System.out.println("fooDoWhile Value: " + fooDoWhile);
// For Loop // For Loop
int fooFor; int fooFor;
//for loop structure => for(<start_statement>; <conditional>; <step>) // for loop structure => for(<start_statement>; <conditional>; <step>)
for(fooFor=0; fooFor<10; fooFor++){ for(fooFor = 0; fooFor < 10; fooFor++){
//System.out.println(fooFor); System.out.println(fooFor);
//Iterated 10 times, fooFor 0->9 // Iterated 10 times, fooFor 0->9
} }
System.out.println("fooFor Value: " + fooFor); System.out.println("fooFor Value: " + fooFor);
// For Each Loop // For Each Loop
// An automatic iteration through an array or list of objects. // An automatic iteration through an array or list of objects.
int[] fooList = {1,2,3,4,5,6,7,8,9}; int[] fooList = {1,2,3,4,5,6,7,8,9};
//for each loop structure => for(<object> : <array_object>) // for each loop structure => for(<object> : <array_object>)
//reads as: for each object in the array // reads as: for each object in the array
//note: the object type must match the array. // note: the object type must match the array.
for( int bar : fooList ){ for (int bar : fooList){
//System.out.println(bar); System.out.println(bar);
//Iterates 9 times and prints 1-9 on new lines //Iterates 9 times and prints 1-9 on new lines
} }
// Switch Case // Switch Case
// A switch works with the byte, short, char, and int data types. // A switch works with the byte, short, char, and int data types.
// It also works with enumerated types (discussed in Enum Types), // It also works with enumerated types (discussed in Enum Types), the
// the String class, and a few special classes that wrap // String class, and a few special classes that wrap primitive types:
// primitive types: Character, Byte, Short, and Integer. // Character, Byte, Short, and Integer.
int month = 3; int month = 3;
String monthString; String monthString;
switch (month){ switch (month) {
case 1: case 1: monthString = "January";
monthString = "January";
break; break;
case 2: case 2: monthString = "February";
monthString = "February";
break; break;
case 3: case 3: monthString = "March";
monthString = "March";
break;
default:
monthString = "Some other month";
break; break;
default: monthString = "Some other month";
break;
} }
System.out.println("Switch Case Result: " + monthString); System.out.println("Switch Case Result: " + monthString);
// Conditional Shorthand // Conditional Shorthand
// You can use the '?' operator for quick assignments or logic forks. // 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; int foo = 5;
String bar = (foo < 10) ? "A" : "B"; String bar = (foo < 10) ? "A" : "B";
System.out.println(bar); // Prints A, because the statement is true System.out.println(bar); // Prints A, because the statement is true
@ -287,9 +282,8 @@ public class LearnJava {
// String // String
// Typecasting // Typecasting
// You can also cast java objects, there's a lot of details and // You can also cast Java objects, there's a lot of details and deals
// deals with some more intermediate concepts. // with some more intermediate concepts. Feel free to check it out here:
// Feel free to check it out here:
// http://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html // http://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html
@ -319,9 +313,9 @@ public class LearnJava {
// Class Declaration Syntax: // Class Declaration Syntax:
// <public/private/protected> class <class name>{ // <public/private/protected> class <class name> {
// //data fields, constructors, functions all inside. // // data fields, constructors, functions all inside.
// //functions are called as methods in Java. // // functions are called as methods in Java.
// } // }
class Bicycle { class Bicycle {
@ -342,7 +336,8 @@ class Bicycle {
} }
// This is a constructor that takes arguments // 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.gear = startGear;
this.cadence = startCadence; this.cadence = startCadence;
this.speed = startSpeed; this.speed = startSpeed;
@ -388,10 +383,8 @@ class Bicycle {
//Method to display the attribute values of this Object. //Method to display the attribute values of this Object.
@Override @Override
public String toString() { public String toString() {
return "gear: " + gear + return "gear: " + gear + " cadence: " + cadence + " speed: " + speed +
" cadence: " + cadence + " name: " + name;
" speed: " + speed +
" name: " + name;
} }
} // end class Bicycle } // end class Bicycle
@ -405,26 +398,26 @@ class PennyFarthing extends Bicycle {
super(startCadence, startSpeed, 0, "PennyFarthing"); super(startCadence, startSpeed, 0, "PennyFarthing");
} }
// You should mark a method you're overriding with an @annotation // You should mark a method you're overriding with an @annotation.
// To learn more about what annotations are and their purpose // To learn more about what annotations are and their purpose check this
// check this out: http://docs.oracle.com/javase/tutorial/java/annotations/ // out: http://docs.oracle.com/javase/tutorial/java/annotations/
@Override @Override
public void setGear(int gear) { public void setGear(int gear) {
gear = 0; gear = 0;
} }
} }
//Interfaces // Interfaces
//Interface declaration syntax // Interface declaration syntax
//<access-level> interface <interface-name> extends <super-interfaces> { // <access-level> interface <interface-name> extends <super-interfaces> {
// //Constants // // Constants
// //Method declarations // // Method declarations
//} // }
//Example - Food: // Example - Food:
public interface Edible { 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 { 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 { public class Fruit implements Edible, Digestible {
@Override @Override
public void eat() { public void eat() {
//... // ...
} }
@Override @Override
public void digest() { public void digest() {
//... // ...
} }
} }
//In java, you can extend only one class, but you can implement many interfaces. // In Java, you can extend only one class, but you can implement many
//For example: // interfaces. For example:
public class ExampleClass extends ExampleClassParent implements InterfaceOne, InterfaceTwo { public class ExampleClass extends ExampleClassParent implements InterfaceOne,
InterfaceTwo {
@Override @Override
public void InterfaceOneMethod() { public void InterfaceOneMethod() {
} }
@Override @Override
public void InterfaceTwoMethod() { public void InterfaceTwoMethod() {
} }
} }
``` ```
## Further Reading ## 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) * [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) * [Java The Complete Reference](http://www.amazon.com/gp/product/0071606300)