From 29cbff176857653422555650c983afef4a28ae1f Mon Sep 17 00:00:00 2001 From: Zachary Ferguson Date: Tue, 6 Oct 2015 18:16:33 -0400 Subject: [java/en] Edits and additions Included an example of printf Discussed final variable initialization Gave a floating point division example Discussed boolean operators Defined the abstract and final class and compared them. Added some clarifying remarks to comments. --- java.html.markdown | 90 ++++++++++++++++++++++++++++++++++++++++++------------ 1 file changed, 71 insertions(+), 19 deletions(-) (limited to 'java.html.markdown') diff --git a/java.html.markdown b/java.html.markdown index 928eb39f..5e580f33 100644 --- a/java.html.markdown +++ b/java.html.markdown @@ -5,6 +5,7 @@ contributors: - ["Jakukyo Friel", "http://weakish.github.io"] - ["Madison Dickson", "http://github.com/mix3d"] - ["Simon Morgan", "http://sjm.io/"] + - ["Zachary Ferguson", "http://github.com/zfergus2"] filename: LearnJava.java --- @@ -31,7 +32,7 @@ import java.security.*; // the file. public class LearnJava { - // A program 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. @@ -45,6 +46,8 @@ public class LearnJava { 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 /////////////////////////////////////// // Types & Variables @@ -73,7 +76,7 @@ public class LearnJava { // Float - Single-precision 32-bit IEEE 754 Floating Point 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 @@ -86,9 +89,12 @@ 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 to another object, final int HOURS_I_WORK_PER_WEEK = 9001; - + // but they can be initialized later. + final double E; + E = 2.71828; + // Strings String fooString = "My String Is Here!"; @@ -146,6 +152,7 @@ public class LearnJava { 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*1.0))); // => 0.5 // Modulo System.out.println("11%3 = "+(11 % 3)); // => 2 @@ -158,12 +165,17 @@ 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 + >> Signed/Arithmetic right shift + >>> Unsigned/Logical right shift & Bitwise AND ^ Bitwise exclusive OR | Bitwise inclusive OR @@ -216,9 +228,8 @@ public class LearnJava { System.out.println("fooDoWhile Value: " + fooDoWhile); // For Loop - int fooFor; // for loop structure => for(; ; ) - for (fooFor = 0; fooFor < 10; fooFor++) { + for (int fooFor = 0; fooFor < 10; fooFor++) { System.out.println(fooFor); // Iterated 10 times, fooFor 0->9 } @@ -310,7 +321,8 @@ public class LearnJava { } // 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 good practice. Instead split classes into separate files. // Class Declaration Syntax: @@ -330,6 +342,8 @@ class 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; @@ -351,7 +365,7 @@ class Bicycle { // Java classes often implement getters and setters for their fields // Method declaration syntax: - // () + // () public int getCadence() { return cadence; } @@ -382,7 +396,7 @@ class Bicycle { } //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; @@ -417,26 +431,26 @@ class PennyFarthing extends Bicycle { // Example - Food: public interface Edible { - public void eat(); // Any class that implements this interface, must + public void eat(); // Any class that implements this interface, must // implement this method. } public interface Digestible { - public void digest(); + public void digest(); } // 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 @@ -451,6 +465,44 @@ public class ExampleClass extends ExampleClassParent implements InterfaceOne, public void InterfaceTwoMethod() { } } + +// There are also two special types of classes, abstract and final. + +// 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 +// concrete and abstract methods. +public abstract class Mammal() +{ + // Abstract classes can contain concrete methods. + public boolean hasHair() + { + return true; + } + + // Final methods, like, final classes cannot be overridden by a child class. + public final boolean isWarmBlooded() + { + return true; + } + + // Abstract methods are methods required to be overridden in a child class. + public abstract String getBinomialNomenclature(); +} + +// 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 Mammal +{ + public String getBinomialNomenclature() + { + return "Smilodon fatalis"; + } +} + ``` ## Further Reading -- cgit v1.2.3 From 93d7d801d8cd40417d88e67a248dd232d75cdd34 Mon Sep 17 00:00:00 2001 From: Zachary Ferguson Date: Tue, 6 Oct 2015 18:28:57 -0400 Subject: [java/en] Merged definitions of abstract and added final Merged definitions of abstract and added a definition of final classes. --- java.html.markdown | 54 +++++++++++++++++++++++++++++++----------------------- 1 file changed, 31 insertions(+), 23 deletions(-) (limited to 'java.html.markdown') diff --git a/java.html.markdown b/java.html.markdown index 34da903a..39878c8f 100644 --- a/java.html.markdown +++ b/java.html.markdown @@ -513,14 +513,9 @@ public class ExampleClass extends ExampleClassParent implements InterfaceOne, } } -<<<<<<< HEAD // There are also two special types of classes, abstract and final. -// 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 -// concrete and abstract methods. + public abstract class Mammal() { // Abstract classes can contain concrete methods. @@ -539,17 +534,6 @@ public abstract class Mammal() public abstract String getBinomialNomenclature(); } -// 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 Mammal -{ - public String getBinomialNomenclature() - { - return "Smilodon fatalis"; - } -======= // Abstract Classes // Abstract Class declaration syntax @@ -558,10 +542,13 @@ public final class SaberToothedCat extends Mammal // // Method declarations // } -// Methods can't have bodies in an interface, unless the method is -// static. Also variables are NOT final by default, unlike an interface. -// Also abstract classes CAN have the "main" method. -// Abstract classes solve these problems. +// 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 +// 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. public abstract class Animal { @@ -578,7 +565,7 @@ public abstract class Animal // No need to initialize, however in an interface // a variable is implicitly final and hence has // to be initialized. - private int age; + protected int age; public void printAge() { @@ -615,7 +602,28 @@ class Dog extends Animal pluto.eat(); pluto.printAge(); } ->>>>>>> adambard/master +} + +// Final Classes +// Final Class declaration syntax +// final { +// // 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"); + } } ``` -- cgit v1.2.3 From 01685afb8429f1b9756e97d6116ab7cbf24ce6c0 Mon Sep 17 00:00:00 2001 From: Zachary Ferguson Date: Tue, 6 Oct 2015 18:31:11 -0400 Subject: [java/en] removed excess abstract class removed excess abstract class --- java.html.markdown | 22 ---------------------- 1 file changed, 22 deletions(-) (limited to 'java.html.markdown') diff --git a/java.html.markdown b/java.html.markdown index 39878c8f..6bfa6633 100644 --- a/java.html.markdown +++ b/java.html.markdown @@ -513,28 +513,6 @@ public class ExampleClass extends ExampleClassParent implements InterfaceOne, } } -// There are also two special types of classes, abstract and final. - - -public abstract class Mammal() -{ - // Abstract classes can contain concrete methods. - public boolean hasHair() - { - return true; - } - - // Final methods, like, final classes cannot be overridden by a child class. - public final boolean isWarmBlooded() - { - return true; - } - - // Abstract methods are methods required to be overridden in a child class. - public abstract String getBinomialNomenclature(); -} - - // Abstract Classes // Abstract Class declaration syntax // abstract extends { -- cgit v1.2.3 From 420e04a5909ae309683201c9fb272ed3dc142283 Mon Sep 17 00:00:00 2001 From: Zachary Ferguson Date: Tue, 6 Oct 2015 19:07:24 -0400 Subject: [java/en] Final Methods Explained Final Methods --- java.html.markdown | 15 ++++++++++++++- 1 file changed, 14 insertions(+), 1 deletion(-) (limited to 'java.html.markdown') diff --git a/java.html.markdown b/java.html.markdown index 6bfa6633..9ab257a4 100644 --- a/java.html.markdown +++ b/java.html.markdown @@ -406,7 +406,7 @@ class Bicycle { this.name = name; } - // Function Syntax: + // Method Syntax: // () // Java classes often implement getters and setters for their fields @@ -604,6 +604,19 @@ public final class SaberToothedCat extends Animal } } +// Final Methods +public abstract class Mammal() +{ + // Final Method Syntax: + // final () + + // 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; + } +} ``` ## Further Reading -- cgit v1.2.3 From cea7db46eb1365c42d2e56a84af0ee2e3a750569 Mon Sep 17 00:00:00 2001 From: Zachary Ferguson Date: Tue, 6 Oct 2015 19:09:13 -0400 Subject: [java/en] Fixed Whitespace Converted tabs to 4 spaces for consistency. --- java.html.markdown | 126 ++++++++++++++++++++++++++--------------------------- 1 file changed, 63 insertions(+), 63 deletions(-) (limited to 'java.html.markdown') diff --git a/java.html.markdown b/java.html.markdown index 9ab257a4..5c230501 100644 --- a/java.html.markdown +++ b/java.html.markdown @@ -343,9 +343,9 @@ public class LearnJava { private static final Set COUNTRIES = new HashSet(); static { - validCodes.add("DENMARK"); - validCodes.add("SWEDEN"); - validCodes.add("FINLAND"); + validCodes.add("DENMARK"); + validCodes.add("SWEDEN"); + validCodes.add("FINLAND"); } // But there's a nifty way to achive the same thing in an @@ -505,12 +505,12 @@ public class Fruit implements Edible, Digestible { public class ExampleClass extends ExampleClassParent implements InterfaceOne, InterfaceTwo { @Override - public void InterfaceOneMethod() { - } + public void InterfaceOneMethod() { + } @Override - public void InterfaceTwoMethod() { - } + public void InterfaceTwoMethod() { + } } // Abstract Classes @@ -530,56 +530,56 @@ public class ExampleClass extends ExampleClassParent implements InterfaceOne, public abstract class Animal { - 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; - } - - // No need to initialize, however in an interface - // a variable is implicitly final and hence has - // to be initialized. - protected int age; - - public void printAge() - { - System.out.println(age); - } - - // Abstract classes can have main function. - public static void main(String[] args) - { - System.out.println("I am abstract"); - } + 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; + } + + // No need to initialize, however in an interface + // a variable is implicitly final and hence has + // to be initialized. + protected int age; + + public void printAge() + { + System.out.println(age); + } + + // Abstract classes can have main function. + 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 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 awesome SO post: http://stackoverflow.com/questions/16313649/ - public static void main(String[] args) - { - Dog pluto = new Dog(); - pluto.makeSound(); - pluto.eat(); - pluto.printAge(); - } + // Note still have to override the abstract methods in the + // abstract class. + @Override + 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 awesome 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 @@ -595,23 +595,23 @@ class Dog extends Animal // 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"); - } + // 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: + // Final Method Syntax: // final () - + // Final methods, like, final classes cannot be overridden by a child class, - // and are therefore the final implementation of the method. + // and are therefore the final implementation of the method. public final boolean isWarmBlooded() { return true; -- cgit v1.2.3 From 7aca9100a042f3813d383f979f8c32a95ecc4bbb Mon Sep 17 00:00:00 2001 From: Zachary Ferguson Date: Thu, 8 Oct 2015 00:00:37 -0400 Subject: [java/en] Fixed repitions --- java.html.markdown | 59 ++---------------------------------------------------- 1 file changed, 2 insertions(+), 57 deletions(-) (limited to 'java.html.markdown') diff --git a/java.html.markdown b/java.html.markdown index 61478968..ba602d2e 100644 --- a/java.html.markdown +++ b/java.html.markdown @@ -513,12 +513,8 @@ public class ExampleClass extends ExampleClassParent implements InterfaceOne, } } -<<<<<<< HEAD -// Abstract Classes -======= - // Abstract Classes ->>>>>>> adambard/master + // Abstract Class declaration syntax // abstract extends { // // Constants and variables @@ -535,7 +531,6 @@ public class ExampleClass extends ExampleClassParent implements InterfaceOne, public abstract class Animal { -<<<<<<< HEAD public abstract void makeSound(); // Method can have a body @@ -561,38 +556,10 @@ public abstract class Animal { System.out.println("I am abstract"); } -======= - 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; - } - - // No need to initialize, however in an interface - // a variable is implicitly final and hence has - // to be initialized. - private int age; - - public void printAge() - { - System.out.println(age); - } - - // Abstract classes can have main function. - public static void main(String[] args) - { - System.out.println("I am abstract"); - } ->>>>>>> adambard/master } class Dog extends Animal { -<<<<<<< HEAD // Note still have to override the abstract methods in the // abstract class. @Override @@ -614,32 +581,10 @@ class Dog extends Animal pluto.eat(); pluto.printAge(); } -======= - // Note still have to override the abstract methods in the - // abstract class. - @Override - 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 awesome SO post: http://stackoverflow.com/questions/16313649/ - public static void main(String[] args) - { - Dog pluto = new Dog(); - pluto.makeSound(); - pluto.eat(); - pluto.printAge(); - } ->>>>>>> adambard/master } // Final Classes + // Final Class declaration syntax // final { // // Constants and variables -- cgit v1.2.3