removed whitespaces, fixed content extending beyond 80 chars

This commit is contained in:
Divay Prakash 2016-03-03 12:07:58 +05:30
parent 5ad208e385
commit 3bb265de2e

View File

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