adambard/learnxinyminutes-docs
1
1
Fork 0
mirror of https://github.com/adambard/learnxinyminutes-docs.git synced 2024-12-23 15:24:09 +03:00
Code Issues Projects Releases Wiki Activity

Merge pull request #2170 from divayprakash/typos-fix3

Browse Source 
[java/en] removed whitespaces, fixed content extending beyond 80 chars
This commit is contained in:
ven 2016-03-12 09:30:03 +01:00
commit 4ad29330a0
1 changed files with 32 additions and 59 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

91
java.html.markdown
View File

@ -17,9 +17,11 @@ programming language.
```java
// Single-line comments start with //
/*
Multi-line comments look like this.
*/
/**
JavaDoc comments look like this. Used to describe the Class or various
attributes of a Class.
@ -30,11 +32,12 @@ import java.util.ArrayList;
// Import all classes inside of java.security package
import java.security.*;
// Each .java file contains one outer-level public class, with the same name as
// the file.
// Each .java file contains one outer-level public class, with the same name
// as the file.
public class LearnJava {
// In order to run a java program, it must have a main method as an entry point.
// In order to run a java program, it must have a main method as an entry
// point.
public static void main (String[] args) {
// Use System.out.println() to print lines.
@ -60,7 +63,8 @@ public class LearnJava {
*/
// Declare a variable using <type> <name>
int fooInt;
// Declare multiple variables of the same type <type> <name1>, <name2>, <name3>
// Declare multiple variables of the same
// type <type> <name1>, <name2>, <name3>
int fooInt1, fooInt2, fooInt3;
/*
@ -69,7 +73,8 @@ public class LearnJava {
// Initialize a variable using <type> <name> = <val>
int fooInt = 1;
// Initialize multiple variables of same type with same value <type> <name1>, <name2>, <name3> = <val>
// Initialize multiple variables of same type with same
// value <type> <name1>, <name2>, <name3> = <val>
int fooInt1, fooInt2, fooInt3;
fooInt1 = fooInt2 = fooInt3 = 1;
@ -119,18 +124,15 @@ public class LearnJava {
final double E;
E = 2.71828;
// BigInteger - Immutable arbitrary-precision integers
//
// BigInteger is a data type that allows programmers to manipulate
// integers longer than 64-bits. Integers are stored as an array of
// of bytes and are manipulated using functions built into BigInteger
//
// BigInteger can be initialized using an array of bytes or a string.
// BigInteger can be initialized using an array of bytes or a string.
BigInteger fooBigInteger = new BigInteger(fooByteArray);
// BigDecimal - Immutable, arbitrary-precision signed decimal number
//
// A BigDecimal takes two parts: an arbitrary precision integer
@ -142,16 +144,13 @@ public class LearnJava {
//
// BigDecimal can be initialized with an int, long, double or String
// or by initializing the unscaled value (BigInteger) and scale (int).
BigDecimal fooBigDecimal = new BigDecimal(fooBigInteger, fooInt);
// Be wary of the constructor that takes a float or double as
// the inaccuracy of the float/double will be copied in BigDecimal.
// Prefer the String constructor when you need an exact value.
BigDecimal tenCents = new BigDecimal("0.1");
// Strings
String fooString = "My String Is Here!";
@ -184,7 +183,7 @@ public class LearnJava {
intArray[1] = 1;
System.out.println("intArray @ 1: " + intArray[1]); // => 1
// Others to check out
// Other data types worth checking out
// ArrayLists - Like arrays except more functionality is offered, and
// the size is mutable.
// LinkedLists - Implementation of doubly-linked list. All of the
@ -212,7 +211,7 @@ public class LearnJava {
System.out.println("1+2 = " + (i1 + i2)); // => 3
System.out.println("2-1 = " + (i2 - i1)); // => 1
System.out.println("2*1 = " + (i2 * i1)); // => 2
System.out.println("1/2 = " + (i1 / i2)); // => 0 (int/int returns an int)
System.out.println("1/2 = " + (i1 / i2)); // => 0 (int/int returns int)
System.out.println("1/2 = " + (i1 / (double)i2)); // => 0.5
// Modulo
@ -242,7 +241,7 @@ public class LearnJava {
| Bitwise inclusive OR
*/
// Incrementations
// Increment operators
int i = 0;
System.out.println("\n->Inc/Dec-rementation");
// The ++ and -- operators increment and decrement by 1 respectively.
@ -314,7 +313,6 @@ public class LearnJava {
// for each loop structure => for (<object> : <iterable>)
// reads as: for each element in the iterable
// note: the object type must match the element type of the iterable.
for (int bar : fooList) {
System.out.println(bar);
//Iterates 9 times and prints 1-9 on new lines
@ -364,7 +362,6 @@ public class LearnJava {
String bar = (foo < 10) ? "A" : "B";
System.out.println(bar); // Prints A, because the statement is true
////////////////////////////////////////
// Converting Data Types And Typecasting
////////////////////////////////////////
@ -387,7 +384,6 @@ public class LearnJava {
// with some more intermediate concepts. Feel free to check it out here:
// http://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html
///////////////////////////////////////
// Classes And Functions
///////////////////////////////////////
@ -409,7 +405,6 @@ public class LearnJava {
// Double Brace Initialization
// The Java Language has no syntax for how to create static Collections
// in an easy way. Usually you end up in the following way:
private static final Set<String> COUNTRIES = new HashSet<String>();
static {
validCodes.add("DENMARK");
@ -420,7 +415,6 @@ public class LearnJava {
// But there's a nifty way to achieve the same thing in an
// easier way, by using something that is called Double Brace
// Initialization.
private static final Set<String> COUNTRIES = new HashSet<String>() {{
add("DENMARK");
add("SWEDEN");
@ -436,11 +430,9 @@ public class LearnJava {
} // End main method
} // End LearnJava class
// You can include other, non-public outer-level classes in a .java file,
// but it is not good practice. Instead split classes into separate files.
// Class Declaration Syntax:
// <public/private/protected> class <class name> {
// // data fields, constructors, functions all inside.
@ -454,7 +446,6 @@ class Bicycle {
private int speed; // Private: Only accessible from within the class
protected int gear; // Protected: Accessible from the class and subclasses
String name; // default: Only accessible from within this package
static String className; // Static class variable
// Static block
@ -476,7 +467,6 @@ class Bicycle {
speed = 5;
name = "Bontrager";
}
// This is a constructor that takes arguments
public Bicycle(int startCadence, int startSpeed, int startGear,
String name) {
@ -501,23 +491,18 @@ class Bicycle {
public void setCadence(int newValue) {
cadence = newValue;
}
public void setGear(int newValue) {
gear = newValue;
}
public void speedUp(int increment) {
speed += increment;
}
public void slowDown(int decrement) {
speed -= decrement;
}
public void setName(String newName) {
name = newName;
}
public String getName() {
return name;
}
@ -566,10 +551,8 @@ public interface Digestible {
public void digest();
}
// 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
public void eat() {
// ...
@ -585,7 +568,6 @@ public class Fruit implements Edible, Digestible {
// interfaces. For example:
public class ExampleClass extends ExampleClassParent implements InterfaceOne,
InterfaceTwo {
@Override
public void InterfaceOneMethod() {
}
@ -604,14 +586,13 @@ public class ExampleClass extends ExampleClassParent implements InterfaceOne,
// // Method declarations
// }
// Marking a class as abstract means that it contains abstract methods that must
// be defined in a child class. Similar to interfaces, abstract classes cannot
// be instantiated, but instead must be extended and the abstract methods
// defined. Different from interfaces, abstract classes can contain a mixture of
// Marking a class as abstract means that it contains abstract methods that
// must be defined in a child class. Similar to interfaces, abstract classes
// cannot be instantiated, but instead must be extended and the abstract
// methods defined. Different from interfaces, abstract classes can contain a
// concrete and abstract methods. Methods in an interface cannot have a body,
// unless the method is static, and variables are final by default, unlike an
// abstract class. Also abstract classes CAN have the "main" method.
// mixture of unless the method is static, and variables are final by default,
// unlike an abstract class. Also abstract classes CAN have the "main" method.
public abstract class Animal
{
public abstract void makeSound();
@ -656,7 +637,7 @@ class Dog extends Animal
// @Override annotation here, since java doesn't allow
// overriding of static methods.
// What is happening here is called METHOD HIDING.
// Check out this awesome SO post: http://stackoverflow.com/questions/16313649/
// Check out this SO post: http://stackoverflow.com/questions/16313649/
public static void main(String[] args)
{
Dog pluto = new Dog();
@ -695,33 +676,29 @@ public abstract class Mammal()
// Final Method Syntax:
// <access modifier> final <return type> <function name>(<args>)
// Final methods, like, final classes cannot be overridden by a child class,
// and are therefore the final implementation of the method.
// Final methods, like, final classes cannot be overridden by a child
// class, and are therefore the final implementation of the method.
public final boolean isWarmBlooded()
{
return true;
}
}
// Enum Type
//
// An enum type is a special data type that enables for a variable to be a set
// of predefined constants. The variable must be equal to one of the values that
// have been predefined for it. Because they are constants, the names of an enum
// type's fields are in uppercase letters. In the Java programming language, you
// define an enum type by using the enum keyword. For example, you would specify
// a days-of-the-week enum type as:
// of predefined constants. The variable must be equal to one of the values
// that have been predefined for it. Because they are constants, the names of
// an enum type's fields are in uppercase letters. In the Java programming
// language, you define an enum type by using the enum keyword. For example,
// you would specify a days-of-the-week enum type as:
public enum Day {
SUNDAY, MONDAY, TUESDAY, WEDNESDAY,
THURSDAY, FRIDAY, SATURDAY
}
// We can use our enum Day like that:
public class EnumTest {
// Variable Enum
Day day;
@ -734,16 +711,13 @@ public class EnumTest {
case MONDAY:
System.out.println("Mondays are bad.");
break;
case FRIDAY:
System.out.println("Fridays are better.");
break;
break;
case SATURDAY:
case SUNDAY:
System.out.println("Weekends are best.");
break;
break;
default:
System.out.println("Midweek days are so-so.");
break;
@ -793,7 +767,6 @@ The links provided here below are just to get an understanding of the topic, fee
* [Codingbat.com](http://codingbat.com/java)
**Books**:
* [Head First Java](http://www.headfirstlabs.com/books/hfjava/)
@ -802,4 +775,4 @@ 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)
* [Java The Complete Reference](http://www.amazon.com/gp/product/0071606300)