tweeked extensions to call from java, cleaned up ranges a bit, and cleaned up some of the null stuff

coderdude1 · coderdude1 · commit a2cc64c34af5 · 2019-10-21T11:53:19.000-05:00
diff --git a/src/main/java/me/kotlinintegration/UseAKotlinClass.java b/src/main/java/me/kotlinintegration/UseAKotlinClass.java
@@ -1,11 +1,13 @@
 package me.kotlinintegration;
 
 import me.kotlindemo.classes.Person;
+import me.kotlindemo._03_extensionsKt;
 
 public class UseAKotlinClass {
     public static void main(String[] args) {
         UseAKotlinClass useAKotlinClass = new UseAKotlinClass();
         useAKotlinClass.printADataClass();
+        useAKotlinClass.useAnExtensionFunction();
     }
 
     private void printADataClass() {
@@ -18,7 +20,8 @@ private void printADataClass() {
     }
 
     private void useAnExtensionFunction() {
+        System.out.println("\n  Use a kotlin extension function from java");
         String blah = "blah";
-//        blah.doo
+        System.out.println("Using a kotlin extension function: " +_03_extensionsKt.doodify(blah));
     }
 }
diff --git a/src/main/kotlin/me/kotlindemo/01_IntroToKotlin.kt b/src/main/kotlin/me/kotlindemo/01_IntroToKotlin.kt
@@ -174,11 +174,6 @@ fun simpleForLoopOverRange() {
     for (counter in 1..5) println("    Counter $counter")
 }
 
-fun progression() {
-    println("\n  loop with progression of 2 and a range")
-    for(counter in 1..10 step 2) println("    progression of 2: $counter")
-}
-
 /**
  * >>>>> Ranges
  */
@@ -196,6 +191,12 @@ fun doingStuffWithRanges() {
     print("\n\n    Counting downward\n      ")
     for (i in 10 downTo 1) { print("$i,") }
 
+    print("\n\n    Counting downward with a step\n      ")
+    for (i in 10 downTo 1 step 2) { print("$i,") }
+
+    print("\n\n    Counting downward differently doesn't work\n      ")
+    for (i in 10..1) { print("$i,") } //note the intellij highlighting asking to use a downTo
+
     print("\n\n    using range in a if statement\n      ")
     val somenum = 8
     if (somenum in 1..10) { println("$somenum is in the range") }
@@ -204,23 +205,45 @@ fun doingStuffWithRanges() {
 fun loops() {
     println("\n>>>> Loops")
     simpleForLoopOverRange()
-    progression()
     doingStuffWithRanges()
 }
 
 /**
  * >>>>  NULLABLE STUFF
+ * by default kotlin expects everything to be not null.  it won't let you assign stuff to be null
+ *
+ * if you want something nullable you have to expliclity indicate a property is nullable.  Kotlin will then
+ * require any code using it to declare nullability
  */
 
 fun nullableParams(one: String? = "blah", two: String? = null) { //? means this param is nullable,
     println("  nullableParamsToFun: fun with nulllable props one: $one two: $two")
 }
 
+//val blah: String = null //compile error since blah is defined by default as non-null
+fun nullableAssignments() {
+    var nullableString: String? = "blah"
+//    nullableString.length //compile error about nullableString can be null and you need to do stuff
+    var lengthOfString = nullableString?.length //use safecall to access length
+
+    //Elvis operator ?: used for null checks
+    val stringAllCaps = nullableString?.capitalize() ?: "not today"
+}
+
 fun safeCallOperator(one: String?) {
 //    println("one: ${one.toUpperCase()}") //can throw an NPE since one is nullable, compile time warning
     println("  safeCallOperator: one: ${one?.toUpperCase()}") //? is safecall, ie if not null then toUpperCase(), can be chained ie x?.y?.z?
 }
 
+/**
+ * Kotlin requires you to explicitly allow an NPE to be thrown, by default it forces you to deal with it
+ * using the safecall/elvis (or let/apply blocks) which do not throw an NPE
+ */
+fun allowNPE(nulledString: String? = null) {
+//    nulledString?.length ?: throw java.lang.NullPointerException() //same as following line
+    nulledString!!.length //throw the npe same as previous line
+}
+
 fun nullableStuff() {
     println("\n>>>>Nullable stuff")
     nullableParams(one = null)
@@ -232,10 +255,6 @@ fun nullableStuff() {
     }
 }
 
-fun allowNPE(nulledString: String? = null) {
-    nulledString!!.length //throw the npe
-}
-
 /**
  *   EXCEPTIONS
  *      kotlin does not support Checked Exceptions

Original file line number	Diff line number	Diff line change
`@@ -1,11 +1,13 @@`
`1`	`1`	`package me.kotlinintegration;`
`2`	`2`
`3`	`3`	`import me.kotlindemo.classes.Person;`
	`4`	`+import me.kotlindemo._03_extensionsKt;`
`4`	`5`
`5`	`6`	`public class UseAKotlinClass {`
`6`	`7`	`public static void main(String[] args) {`
`7`	`8`	`UseAKotlinClass useAKotlinClass = new UseAKotlinClass();`
`8`	`9`	`useAKotlinClass.printADataClass();`
	`10`	`+ useAKotlinClass.useAnExtensionFunction();`
`9`	`11`	`}`
`10`	`12`
`11`	`13`	`private void printADataClass() {`
`@@ -18,7 +20,8 @@ private void printADataClass() {`
`18`	`20`	`}`
`19`	`21`
`20`	`22`	`private void useAnExtensionFunction() {`
	`23`	`+ System.out.println("\n Use a kotlin extension function from java");`
`21`	`24`	`String blah = "blah";`
`22`		`-// blah.doo`
	`25`	`+ System.out.println("Using a kotlin extension function: " +_03_extensionsKt.doodify(blah));`
`23`	`26`	`}`
`24`	`27`	`}`