adambard/learnxinyminutes-docs
1
1
Fork 0
mirror of https://github.com/adambard/learnxinyminutes-docs.git synced 2024-12-23 07:12:31 +03:00
Code Issues 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
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 //
@ -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
@ -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.
// 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";
switch (month) {
case 1: monthString = "January";
break;
case 2:
monthString = "February";
case 2: monthString = "February";
break;
case 3:
monthString = "March";
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)