diff options
Diffstat (limited to 'java.html.markdown')
| -rw-r--r-- | java.html.markdown | 738 |
1 files changed, 572 insertions, 166 deletions
diff --git a/java.html.markdown b/java.html.markdown index 3dd65679..dd875c16 100644 --- a/java.html.markdown +++ b/java.html.markdown @@ -1,25 +1,42 @@ --- - language: java contributors: - - ["Jake Prather", "http://github.com/JakeHP"] - - ["Madison Dickson", "http://github.com/mix3d"] - - ["Jakukyo Friel", "http://weakish.github.io"] + - ["Jake Prather", "https://github.com/JakeHP"] + - ["Jakukyo Friel", "https://weakish.github.io"] + - ["Madison Dickson", "https://github.com/mix3d"] + - ["Simon Morgan", "https://sjm.io/"] + - ["Zachary Ferguson", "https://github.com/zfergus2"] + - ["Cameron Schermerhorn", "https://github.com/cschermerhorn"] + - ["Rachel Stiyer", "https://github.com/rstiyer"] + - ["Michael Dähnert", "https://github.com/JaXt0r"] + - ["Rob Rose", "https://github.com/RobRoseKnows"] + - ["Sean Nam", "https://github.com/seannam"] 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.](https://docs.oracle.com/javase/tutorial/java/) ```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. + * JavaDoc comments look like this. Used to describe the Class or various + * attributes of a Class. + * Main attributes: + * + * @author Name (and contact information such as email) of author(s). + * @version Current version of the program. + * @since When this part of the program was first added. + * @param For describing the different parameters for a method. + * @return For describing what the method returns. + * @deprecated For showing the code is outdated or shouldn't be used. + * @see Links to another part of documentation. */ // Import ArrayList class inside of the java.util package @@ -27,41 +44,107 @@ 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 { - // A program must have a main method as an entry point - public static void main (String[] args) { + // 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 + /////////////////////////////////////// + // Input/Output + /////////////////////////////////////// + + /* + * Output + */ + + // Use System.out.println() to print lines. System.out.println("Hello World!"); System.out.println( "Integer: " + 10 + " Double: " + 3.14 + " 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("World"); + // Use System.out.printf() for easy formatted printing. + System.out.printf("pi = %.5f", Math.PI); // => pi = 3.14159 + + /* + * Input + */ + + // use Scanner to read input + // must import java.util.Scanner; + Scanner scanner = new Scanner(System.in); + + // read string input + String name = scanner.next(); + + // read byte input + byte numByte = scanner.nextByte(); + + // read int input + int numInt = scanner.nextInt(); + + // read long input + float numFloat = scanner.nextFloat(); + + // read double input + double numDouble = scanner.nextDouble(); + + // read boolean input + boolean bool = scanner.nextBoolean(); /////////////////////////////////////// - // Types & Variables + // Variables /////////////////////////////////////// + /* + * Variable Declaration + */ // Declare a variable using <type> <name> + int fooInt; + // Declare multiple variables of the same + // type <type> <name1>, <name2>, <name3> + int fooInt1, fooInt2, fooInt3; + + /* + * Variable Initialization + */ + + // Initialize a variable using <type> <name> = <val> + int barInt = 1; + // Initialize multiple variables of same type with same + // value <type> <name1>, <name2>, <name3> + // <name1> = <name2> = <name3> = <val> + int barInt1, barInt2, barInt3; + barInt1 = barInt2 = barInt3 = 1; + + /* + * Variable types + */ // Byte - 8-bit signed two's complement integer // (-128 <= byte <= 127) byte fooByte = 100; + // If you would like to interpret a byte as an unsigned integer + // then this simple operation can help + int unsignedIntLessThan256 = 0xff & fooByte; + // this contrasts a cast which can be negative. + int signedInt = (int) fooByte; + // Short - 16-bit signed two's complement integer // (-32,768 <= short <= 32,767) short fooShort = 10000; // Integer - 32-bit signed two's complement integer // (-2,147,483,648 <= int <= 2,147,483,647) - int fooInt = 1; + int bazInt = 1; // Long - 64-bit signed two's complement integer // (-9,223,372,036,854,775,808 <= long <= 9,223,372,036,854,775,807) @@ -69,14 +152,18 @@ public class LearnJava { // L is used to denote that this variable value is of type Long; // anything without is treated as integer by default. - // Note: Java has no unsigned types + // Note: byte, short, int and long are signed. They can have positive and negative values. + // There are no unsigned variants. + // char, however, is 16-bit unsigned. // Float - Single-precision 32-bit IEEE 754 Floating Point + // 2^-149 <= float <= (2-2^-23) * 2^127 float fooFloat = 234.5f; - // f is used to denote that this variable value is of type float; + // f or F is used to denote that this variable value is of type float; // otherwise it is treated as double. // Double - Double-precision 64-bit IEEE 754 Floating Point + // 2^-1074 <= x <= (2-2^-52) * 2^1023 double fooDouble = 123.4; // Boolean - true & false @@ -86,8 +173,38 @@ public class LearnJava { // Char - A single 16-bit Unicode character char fooChar = 'A'; - // final variables can't be reassigned to another object + // final variables can't be reassigned, final int HOURS_I_WORK_PER_WEEK = 9001; + // but they can be initialized later. + 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 fooBigInteger = new BigInteger(fooByteArray); + + // BigDecimal - Immutable, arbitrary-precision signed decimal number + // + // A BigDecimal takes two parts: an arbitrary precision integer + // unscaled value and a 32-bit integer scale + // + // BigDecimal allows the programmer complete control over decimal + // rounding. It is recommended to use BigDecimal with currency values + // and where exact decimal precision is required. + // + // 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!"; @@ -100,19 +217,55 @@ public class LearnJava { System.out.println(barString); System.out.println(bazString); + // String Building + // #1 - with plus operator + // That's the basic way to do it (optimized under the hood) + String plusConcatenated = "Strings can " + "be concatenated " + "via + operator."; + System.out.println(plusConcatenated); + // Output: Strings can be concatenated via + operator. + + // #2 - with StringBuilder + // This way doesn't create any intermediate strings. It just stores the string pieces, and ties them together + // when toString() is called. + // Hint: This class is not thread safe. A thread-safe alternative (with some impact on performance) is StringBuffer. + StringBuilder builderConcatenated = new StringBuilder(); + builderConcatenated.append("You "); + builderConcatenated.append("can use "); + builderConcatenated.append("the StringBuilder class."); + System.out.println(builderConcatenated.toString()); // only now is the string built + // Output: You can use the StringBuilder class. + + // StringBuilder is efficient when the fully constructed String is not required until the end of some processing. + StringBuilder stringBuilder = new StringBuilder(); + String inefficientString = ""; + for (int i = 0 ; i < 10; i++) { + stringBuilder.append(i).append(" "); + inefficientString += i + " "; + } + System.out.println(inefficientString); + System.out.println(stringBuilder.toString()); + // inefficientString requires a lot more work to produce, as it generates a String on every loop iteration. + // Simple concatenation with + is compiled to a StringBuilder and toString() + // Avoid string concatenation in loops. + + // #3 - with String formatter + // Another alternative way to create strings. Fast and readable. + String.format("%s may prefer %s.", "Or you", "String.format()"); + // Output: Or you may prefer String.format(). + // 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>]; - int [] intArray = new int[10]; - String [] stringArray = new String[1]; - boolean boolArray [] = new boolean[100]; + // 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]; // Another way to declare & initialize an array - int [] y = {9000, 1000, 1337}; - String names [] = {"Bob", "John", "Fred", "Juan Pedro"}; - boolean bools[] = new boolean[] {true, false, false}; + int[] y = {9000, 1000, 1337}; + String names[] = {"Bob", "John", "Fred", "Juan Pedro"}; + boolean bools[] = {true, false, false}; // Indexing an array - Accessing an element System.out.println("intArray @ 0: " + intArray[0]); @@ -121,18 +274,31 @@ public class LearnJava { intArray[1] = 1; 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 + // 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 - // 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 mapping of key Objects to value Objects. Map is + // an interface and therefore cannot be instantiated. + // The type of keys and values contained in a Map must + // be specified upon instantiation of the implementing + // class. Each key may map to only one corresponding value, + // and each key may appear only once (no duplicates). + // 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-amortized even for large sets. + // TreeMap - A Map that is sorted by its keys. Each modification + // maintains the sorting defined by either a Comparator + // supplied at instantiation, or comparisons of each Object + // if they implement the Comparable interface. + // Failure of keys to implement Comparable combined with failure to + // supply a Comparator will throw ClassCastExceptions. + // Insertion and removal operations take O(log(n)) time + // so avoid using this data structure unless you are taking + // advantage of the sorting. /////////////////////////////////////// // Operators @@ -145,7 +311,8 @@ 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 (0.5 truncated down) + System.out.println("1/2 = " + (i1 / i2)); // => 0 (int/int returns int) + System.out.println("1/2.0 = " + (i1 / (double)i2)); // => 0.5 // Modulo System.out.println("11%3 = "+(11 % 3)); // => 2 @@ -158,27 +325,32 @@ public class LearnJava { System.out.println("2 <= 2? " + (2 <= 2)); // => true System.out.println("2 >= 2? " + (2 >= 2)); // => true + // Boolean operators + System.out.println("3 > 2 && 2 > 3? " + ((3 > 2) && (2 > 3))); // => false + System.out.println("3 > 2 || 2 > 3? " + ((3 > 2) || (2 > 3))); // => true + System.out.println("!(3 == 2)? " + (!(3 == 2))); // => true + // Bitwise operators! /* - ~ Unary bitwise complement - << Signed left shift - >> Signed right shift - >>> Unsigned right shift - & Bitwise AND - ^ Bitwise exclusive OR - | Bitwise inclusive OR + ~ Unary bitwise complement + << Signed left shift + >> Signed/Arithmetic right shift + >>> Unsigned/Logical right shift + & Bitwise AND + ^ Bitwise exclusive OR + | 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. // 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 @@ -187,7 +359,7 @@ public class LearnJava { // If statements are c-like int j = 10; - if (j == 10){ + if (j == 10) { System.out.println("I get printed"); } else if (j > 10) { System.out.println("I don't"); @@ -197,80 +369,116 @@ 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 (int fooFor = 0; fooFor < 10; fooFor++) { + System.out.println(fooFor); + // Iterated 10 times, fooFor 0->9 } System.out.println("fooFor Value: " + fooFor); + // Nested For Loop Exit with Label + outer: + for (int i = 0; i < 10; i++) { + for (int j = 0; j < 10; j++) { + if (i == 5 && j ==5) { + break outer; + // breaks out of outer loop instead of only the inner one + } + } + } + // 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( int bar : fooList ){ - //System.out.println(bar); + // The for loop is also able to iterate over arrays as well as objects + // that implement the Iterable interface. + int[] fooList = {1, 2, 3, 4, 5, 6, 7, 8, 9}; + // 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 } // 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. + // Starting in Java 7 and above, we can also use the String type. + // Note: Do remember that, not adding "break" at end any particular case ends up in + // executing the very next case(given it satisfies the condition provided) as well. 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); + + // Try-with-resources (Java 7+) + // Try-catch-finally statements work as expected in Java but in Java 7+ + // the try-with-resources statement is also available. Try-with-resources + // simplifies try-catch-finally statements by closing resources + // automatically. + + // In order to use a try-with-resources, include an instance of a class + // in the try statement. The class must implement java.lang.AutoCloseable. + try (BufferedReader br = new BufferedReader(new FileReader("foo.txt"))) { + // You can attempt to do something that could throw an exception. + System.out.println(br.readLine()); + // In Java 7, the resource will always be closed, even if it throws + // an Exception. + } catch (Exception ex) { + //The resource will be closed before the catch statement executes. + System.out.println("readLine() failed."); + } + // No need for a finally statement in this case, the BufferedReader is + // already closed. This can be used to avoid certain edge cases where + // a finally statement might not be called. + // To learn more: + // https://docs.oracle.com/javase/tutorial/essential/exceptions/tryResourceClose.html + + // 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 - + System.out.println("bar : " + bar); // Prints "bar : A", because the + // statement is true. + // Or simply + System.out.println("bar : " + (foo < 10 ? "A" : "B")); + //////////////////////////////////////// - // Converting Data Types And Typecasting + // Converting Data Types //////////////////////////////////////// // Converting data @@ -286,13 +494,6 @@ public class LearnJava { // Long // 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: - // http://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html - - /////////////////////////////////////// // Classes And Functions /////////////////////////////////////// @@ -311,17 +512,41 @@ public class LearnJava { // toString returns this Object's string representation. System.out.println("trek info: " + trek.toString()); - } // End main method -} // End LearnJava class + // 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 { + COUNTRIES.add("DENMARK"); + COUNTRIES.add("SWEDEN"); + COUNTRIES.add("FINLAND"); + } + // 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"); + add("FINLAND"); + }} + + // The first brace is creating a new AnonymousInnerClass and the + // second one declares an instance initializer block. This block + // is called when the anonymous inner class is created. + // This does not only work for Collections, it works for all + // non-final classes. -// You can include other, non-public outer-level classes in a .java file + } // 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. -// //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 { @@ -331,31 +556,43 @@ 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 + // Java has no implementation of static constructors, but + // has a static block that can be used to initialize class variables + // (static variables). + // This block will be called when the class is loaded. + static { + className = "Bicycle"; + } // Constructors are a way of creating classes // This is a constructor public Bicycle() { + // You can also call another constructor: + // this(1, 50, 5, "Bontrager"); gear = 1; cadence = 50; speed = 5; name = "Bontrager"; } - // 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; this.name = name; } - // Function Syntax: + // Method Syntax: // <public/private/protected> <return type> <function name>(<args>) // Java classes often implement getters and setters for their fields // Method declaration syntax: - // <scope> <return type> <method name>(<args>) + // <access modifier> <return type> <method name>(<args>) public int getCadence() { return cadence; } @@ -364,34 +601,27 @@ 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; } //Method to display the attribute values of this Object. - @Override + @Override // Inherited from the Object class. public String toString() { - return "gear: " + gear + - " cadence: " + cadence + - " speed: " + speed + - " name: " + name; + return "gear: " + gear + " cadence: " + cadence + " speed: " + speed + + " name: " + name; } } // end class Bicycle @@ -400,65 +630,236 @@ class PennyFarthing extends Bicycle { // (Penny Farthings are those bicycles with the big front wheel. // They have no gears.) - public PennyFarthing(int startCadence, int startSpeed){ + public PennyFarthing(int startCadence, int startSpeed) { // Call the parent constructor with super 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; + this.gear = 0; } - } -//Interfaces -//Interface declaration syntax -//<access-level> interface <interface-name> extends <super-interfaces> { -// //Constants -// //Method declarations -//} +// Object casting +// Since the PennyFarthing class is extending the Bicycle class, we can say +// a PennyFarthing is a Bicycle and write : +// Bicycle bicycle = new PennyFarthing(); +// This is called object casting where an object is taken for another one. There +// are lots of details and deals with some more intermediate concepts here: +// https://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html + +// 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 { - public void digest(); + public void digest(); + // Since Java 8, interfaces can have default method. + public default void defaultMethod() { + System.out.println("Hi from default method ..."); + } } - -//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() { - //... - } + public void eat() { + // ... + } @Override - public void digest() { - //... - } + 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 InterfaceOneMethod() { + public void InterfaceTwoMethod() { + } - } +} + +// Abstract Classes + +// Abstract Class declaration syntax +// <access-level> abstract class <abstract-class-name> extends +// <super-abstract-classes> { +// // Constants and variables +// // Method declarations +// } +// Abstract Classes cannot be instantiated. +// Abstract classes may define abstract methods. +// Abstract methods have no body and are marked abstract +// Non-abstract child classes must @Override all abstract methods +// from their super-classes. +// Abstract classes can be useful when combining repetitive logic +// with customised behavior, but as Abstract classes require +// inheritance, they violate "Composition over inheritance" +// so consider other approaches using composition. +// https://en.wikipedia.org/wiki/Composition_over_inheritance + +public abstract class Animal +{ + private int age; + + public abstract void makeSound(); + + // Method can have a body + public void eat() + { + System.out.println("I am an animal and I am Eating."); + // Note: We can access private variable here. + age = 30; + } + + public void printAge() + { + System.out.println(age); + } + + // Abstract classes can have main method. + public static void main(String[] args) + { + System.out.println("I am abstract"); + } +} + +class Dog extends Animal +{ + // Note still have to override the abstract methods in the + // abstract class. @Override - public void InterfaceTwoMethod() { + public void makeSound() + { + System.out.println("Bark"); + // age = 30; ==> ERROR! age is private to Animal + } - } + // NOTE: You will get an error if you used the + // @Override annotation here, since java doesn't allow + // overriding of static methods. + // What is happening here is called METHOD HIDING. + // Check out this SO post: http://stackoverflow.com/questions/16313649/ + public static void main(String[] args) + { + Dog pluto = new Dog(); + pluto.makeSound(); + pluto.eat(); + pluto.printAge(); + } } +// Final Classes + +// Final Class declaration syntax +// <access-level> final <final-class-name> { +// // Constants and variables +// // Method declarations +// } + +// Final classes are classes that cannot be inherited from and are therefore a +// final child. In a way, final classes are the opposite of abstract classes +// because abstract classes must be extended, but final classes cannot be +// extended. +public final class SaberToothedCat extends Animal +{ + // Note still have to override the abstract methods in the + // abstract class. + @Override + public void makeSound() + { + System.out.println("Roar"); + } +} + +// Final Methods +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. + 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: +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; + + public EnumTest(Day day) { + this.day = day; + } + + public void tellItLikeItIs() { + switch (day) { + case MONDAY: + System.out.println("Mondays are bad."); + break; + case FRIDAY: + System.out.println("Fridays are better."); + break; + case SATURDAY: + case SUNDAY: + System.out.println("Weekends are best."); + break; + default: + System.out.println("Midweek days are so-so."); + break; + } + } + + public static void main(String[] args) { + EnumTest firstDay = new EnumTest(Day.MONDAY); + firstDay.tellItLikeItIs(); // => Mondays are bad. + EnumTest thirdDay = new EnumTest(Day.WEDNESDAY); + thirdDay.tellItLikeItIs(); // => Midweek days are so-so. + } +} + +// Enum types are much more powerful than we show above. +// The enum body can include methods and other fields. +// You can see more at https://docs.oracle.com/javase/tutorial/java/javaOO/enum.html + ``` ## Further Reading @@ -467,22 +868,26 @@ The links provided here below are just to get an understanding of the topic, fee **Official Oracle Guides**: -* [Java Tutorial Trail from Sun / Oracle](http://docs.oracle.com/javase/tutorial/index.html) +* [Java Tutorial Trail from Sun / Oracle](https://docs.oracle.com/javase/tutorial/index.html) + +* [Java Access level modifiers](https://docs.oracle.com/javase/tutorial/java/javaOO/accesscontrol.html) -* [Java Access level modifiers](http://docs.oracle.com/javase/tutorial/java/javaOO/accesscontrol.html) +* [Object-Oriented Programming Concepts](https://docs.oracle.com/javase/tutorial/java/concepts/index.html): + * [Inheritance](https://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html) + * [Polymorphism](https://docs.oracle.com/javase/tutorial/java/IandI/polymorphism.html) + * [Abstraction](https://docs.oracle.com/javase/tutorial/java/IandI/abstract.html) -* [Object-Oriented Programming Concepts](http://docs.oracle.com/javase/tutorial/java/concepts/index.html): - * [Inheritance](http://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html) - * [Polymorphism](http://docs.oracle.com/javase/tutorial/java/IandI/polymorphism.html) - * [Abstraction](http://docs.oracle.com/javase/tutorial/java/IandI/abstract.html) +* [Exceptions](https://docs.oracle.com/javase/tutorial/essential/exceptions/index.html) -* [Exceptions](http://docs.oracle.com/javase/tutorial/essential/exceptions/index.html) +* [Interfaces](https://docs.oracle.com/javase/tutorial/java/IandI/createinterface.html) -* [Interfaces](http://docs.oracle.com/javase/tutorial/java/IandI/createinterface.html) +* [Generics](https://docs.oracle.com/javase/tutorial/java/generics/index.html) -* [Generics](http://docs.oracle.com/javase/tutorial/java/generics/index.html) +* [Java Code Conventions](https://www.oracle.com/technetwork/java/codeconvtoc-136057.html) -* [Java Code Conventions](http://www.oracle.com/technetwork/java/codeconv-138413.html) +* New features in Java 8: + * [Lambda expressions (functional programming)](https://docs.oracle.com/javase/tutorial/java/javaOO/lambdaexpressions.html) + * [Date and time API (java.time package)](http://www.oracle.com/technetwork/articles/java/jf14-date-time-2125367.html) **Online Practice and Tutorials** @@ -490,13 +895,14 @@ The links provided here below are just to get an understanding of the topic, fee * [Codingbat.com](http://codingbat.com/java) +* [Codewars - Java Katas](https://www.codewars.com/?language=java) **Books**: * [Head First Java](http://www.headfirstlabs.com/books/hfjava/) -* [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) +* [Thinking in Java](http://www.mindview.net/Books/TIJ/) +* [Objects First with Java](https://www.amazon.com/Objects-First-Java-Practical-Introduction/dp/0132492660) +* [Java The Complete Reference](https://www.amazon.com/gp/product/0071606300) |