iskm/learnxinyminutes-docs
1
0
Fork 0
mirror of https://github.com/adambard/learnxinyminutes-docs.git synced 2025-05-06 14:58:31 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge pull request #1111 from drguildo/master

Browse Source 
A bunch of small changes to aid clarity, brevity and/or consistency, …
This commit is contained in:
Levi Bostian 2015-05-25 10:23:56 -05:00
commit 4d77e16780
1 changed files with 93 additions and 104 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

111
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 //
@ -31,17 +31,17 @@ import java.security.*;
// the file. // the file.
public class LearnJava { 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) { 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("Hello World!");
System.out.println( System.out.println(
"Integer: " + 10 + "Integer: " + 10 +
" Double: " + 3.14 + " Double: " + 3.14 +
" Boolean: " + true); " 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("Hello ");
System.out.print("World"); System.out.print("World");
@ -69,7 +69,7 @@ public class LearnJava {
// L is used to denote that this variable value is of type Long; // L is used to denote that this variable value is of type Long;
// anything without is treated as integer by default. // 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 - Single-precision 32-bit IEEE 754 Floating Point
float fooFloat = 234.5f; float fooFloat = 234.5f;
@ -86,7 +86,7 @@ public class LearnJava {
// Char - A single 16-bit Unicode character // Char - A single 16-bit Unicode character
char fooChar = 'A'; 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; final int HOURS_I_WORK_PER_WEEK = 9001;
// Strings // Strings
@ -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
@ -197,9 +197,8 @@ 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++;
@ -208,9 +207,8 @@ public class LearnJava {
// 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++;
@ -221,7 +219,7 @@ public class LearnJava {
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);
@ -234,36 +232,33 @@ public class LearnJava {
// 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; break;
default: default: monthString = "Some other month";
monthString = "Some other month";
break; 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
@ -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,9 +383,7 @@ 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 +
" speed: " + speed +
" name: " + name; " name: " + name;
} }
} // end class Bicycle } // end class Bicycle
@ -405,14 +398,13 @@ 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
@ -424,7 +416,8 @@ class PennyFarthing extends Bicycle {
// 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,7 +425,7 @@ 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() {
@ -445,20 +438,18 @@ public class Fruit implements Edible, Digestible {
} }
} }
//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)