apply plugin:'kotlin-android'
apply plugin:'kotlin-android-extensions'

dependencies {
 compile "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
}

buildscript {
 ext.kotlin_version = '1.1.1'
 repositories {
  jcenter()
 }
 dependencies {
  classpath 'com.android.tools.build:gradle:2.3.1'
  classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"

  // NOTE: Do not place your application dependencies here; they belong
  // in the individual module build.gradle files
 }
}

public class MainActivity extends AppCompatActivity {

 @Override
 protected void onCreate(Bundle savedInstanceState) {
  super.onCreate(savedInstanceState);
  setContentView(R.layout.activity_main);
  Toolbar toolbar = (Toolbar) findViewById(R.id.toolbar);
  setSupportActionBar(toolbar);

  FloatingActionButton fab = (FloatingActionButton) findViewById(R.id.fab);
  fab.setOnClickListener(new View.OnClickListener() {
   @Override
   public void onClick(View view) {
    Snackbar.make(view, "Replace with your own action", Snackbar.LENGTH_LONG)
      .setAction("Action", null).show();
   }
  });
 }

 @Override
 public boolean onCreateOptionsMenu(Menu menu) {
  // Inflate the menu; this adds items to the action bar if it is present.
  getMenuInflater().inflate(R.menu.menu_main, menu);
  return true;
 }

 @Override
 public boolean onOptionsItemSelected(MenuItem item) {
  // Handle action bar item clicks here. The action bar will
  // automatically handle clicks on the Home/Up button, so long
  // as you specify a parent activity in AndroidManifest.xml.
  int id = item.getItemId();

  //noinspection SimplifiableIfStatement
  if (id == R.id.action_settings) {
   return true;
  }

  return super.onOptionsItemSelected(item);
 }
}
public class Test {
 private static String str = null;

 public static void main(String[] args) {
  str = "Code4Android";
  System.out.println(str);
 }
}

class MainActivity : AppCompatActivity() {

 override fun onCreate(savedInstanceState: Bundle?) {
  super.onCreate(savedInstanceState)
  setContentView(R.layout.activity_main)
  val toolbar = findViewById(R.id.toolbar) as Toolbar
  setSupportActionBar(toolbar)

  val fab = findViewById(R.id.fab) as FloatingActionButton
  fab.setOnClickListener { view ->
   Snackbar.make(view, "Replace with your own action", Snackbar.LENGTH_LONG)
     .setAction("Action", null).show()
  }
 }

 override fun onCreateOptionsMenu(menu: Menu): Boolean {
  // Inflate the menu; this adds items to the action bar if it is present.
  menuInflater.inflate(R.menu.menu_main, menu)
  return true
 }

 override fun onOptionsItemSelected(item: MenuItem): Boolean {
  val id = item.itemId
  if (id == R.id.action_settings) {
   return true
  }
  return super.onOptionsItemSelected(item)
 }
}


object Test {
 private var str: String? = null

 @JvmStatic fun main(args: Array<String>) {
  str = "Code4Android"
  println(str)
 }
}

package com.learnrecord

/**
 *Created by Code4Android on 2017/4/21.
 */

var str: String = ""

fun main(args: Array<String>) {
 str = "Hello World!"
 println(str)
}

 val iArray: IntArray = intArrayOf(1, 2, 3)
 val sArray: Array<String> = Array<String>(3, { i -> i.toString() })
 val anyArray: Array<Any> = arrayOf(1, "2", 3.0, 4.1f) // 可將類型進行混排放入同一個數(shù)組中
 val lArray: LongArray = longArrayOf(1L, 2L, 3L)

 fun sum(a: Int, b: Int): Int {
  return a + b
 }

 fun sum(a: Int, b: Int) = a + b

 fun max1(a:Int,b:Int)=if (a>b) a else b

 fun max1(a:Int,b:Int)= if (a > b) {
  println(a)
  a
 } else {
  println(b)
  //如果我們將println(b)放到b的下面,運行會返回kotlin.Unit為無類型，返回值總是最后一個表達式的返回值或值
  b
 }
 println(max1(1,3))

 fun printInt(a: Int): Unit {
  println(a)
 }

 fun printInt(a: Int) {
  println(a)
 }

 //操作符 shl 下面對Int和Long
 var a: Int = 4
 var shl: Int = a shl (1) //Java中的左移運算符 <<
 var shr: Int = a shr (1) //Java中的右移運算符 >>
 var ushr: Int = a ushr (3) //無符號右移，高位補0 >>>
 var and: Int = 2 and (4) //按位與操作 &
 var or: Int = 2 or (4) //按位或操作 |
 var xor: Int = 2 xor (6) //按位異或操作 ^
 print("\nshl:" + shl + "\nshr:" + shr + " \nushr:" + ushr + "\nand：" + and + "\nor:" + or + "\nxor:" + xor)

shl:8
shr:2 
ushr:0
and：0
or:6
xor:4

 fun forLoop(array: Array<String>) {
  //第一種方式直接輸出字符（類似java foreach）
  for (str in array) {
   println(str)
  }
  //Array提供了forEach函數(shù)
  array.forEach {
   println(it)
   }
  //array.indices是數(shù)組索引
  for (i in array.indices) {
   println(array[i])
  }
  //(類似javafor(int i=0;i<arry.length;i++))
  var i = 0
  while (i < array.size) {
   println(array[i++])
  }
 }

fun whenFun(obj: Any) {
  when (obj) {
   25 -> println("25")
   "Kotlin" -> println("Kotlin")
   !is String -> println("Not String")
   is Long -> println("Number is Long")
   else -> println("Nothing")
  }
 }

//@定義label，一般用在內(nèi)層循環(huán)中跳到外層循環(huán):i in 0..2等價于java中 for（int i=0;i<=2;i++）效果
 loop@ for (i in 0..2) {
  for (j in 0..3) {
   println("i:" + i + " j:" + j)
   if (j == 2)
   //continue@loop//跳到外層循環(huán)，繼續(xù)往下執(zhí)行
    break@loop //跳到外層循環(huán)label處，跳出改層循環(huán)
  }
 }

 //倒序輸出5 4 3 2 1 0
 for (i in 5 downTo 0) {
  println(i)
 }
 //設(shè)置輸出數(shù)據(jù)步長
  for (i in 1..5 step 3) print(i) // 輸出 14
  //step和downTo混合使用
  for (i in 5 downTo 1 step 3) print(i) //輸出52

/*** constructor:構(gòu)造函數(shù)
 * constructor無修飾符(如：private)時，constructor可以省略：
 * 當是無參構(gòu)造函數(shù)時，整個構(gòu)造函數(shù)部分也可以省略，省略的構(gòu)造函數(shù)默認是public的
 * 由于primary constructor不能包含任何代碼，因此使用 init 代碼塊對其初始化,
 * 同時可以在初始化代碼塊中使用構(gòu)造函數(shù)的參數(shù)
 */
open class People private constructor(var id: String, var name: String) {
 //可以類中初始化屬性：
 var customName = name.toUpperCase() //初始化屬性
 //次構(gòu)造函數(shù)，使用constructor前綴聲明，且必須調(diào)用primary constructor，使用this關(guān)鍵字
 constructor( id: String, name: String, age: Int) : this(id, name) {
  println("constructor")
 }
 init {
  println("初始化操作，可使用constructor參數(shù)")
 }
 //需要open修飾，子類才可以
 open fun study() {
  print("study")
 }
 //People前的冒號":"是繼承的意思，實現(xiàn)類接口的時候也是冒號
class Student(id: String, name: String) : People(id, name) {
 var test: Number = 3
 private var name1: String?
  get() {
   return name1
  }
  set(value) {
   name1 = value
  }
 //override修飾的方法，默認是可以被繼承的。若希望不被繼承，可以使用 final 關(guān)鍵詞修飾
 override fun study() {
  super.study()
 }
}

}

public class StaffJ<T> {
 private String name;
 private String position;
 private T age;
 public String getName() {
  return name;
 }
 public void setName(String name) {
  this.name = name;
 }
 public String getPosition() {
  return position;
 }

 public void setPosition(String position) {
  this.position = position;
 }
 public T getAge() {
  return age;
 }
 public void setAge(T age) {
  this.age = age;
 }
}

data class Staff<T>(var name: String, val position: String,var age:T)

 var staff = Staff("code4Android","Android工程師","22") //實例化對象

 staff.position="前端"

fun main(arg:Array<String>){
 var staff = Staff("code4Android","Android工程師","22") //實例化對象
 staff.name="code4Android2"
 var staff1=staff.copy()
 //使用copy的時候可以指定默認值，可以指定任意個用逗號","隔開
 var staff2=staff.copy(name="ccc",position = "kotlin")
 println("name:${staff2.name} position:${staff2.position} age ${staff2.age}")
 //staff.position="Kotiln" //val不能再次賦值
 var anotherStaff= Staff("code4Android","Android工程師",22) //實例化對象

 println("staff toString(): ${staff.toString()} anotherStaff toString(): ${anotherStaff.toString()}")
 println("staff hashCode(): ${staff.hashCode()} anotherStaff hashCode(): ${anotherStaff.hashCode()}")
 println("staff is equals another staff ? ${staff.equals(anotherStaff)}")
}

 var name:String="Code4Android"
 println("我的名字叫$name")
 println("我的名字叫${name}")

/**
 * java允許使用匿名內(nèi)部類;kotlin也有類似的概念，稱為對象表達式-object expressions
 */
open class KeyBord{
 open fun onKeyEvent(code:Int):Unit = Unit
}

 
/**匿名內(nèi)部類**/
var key=object :KeyBord(){
 override open fun onKeyEvent(code:Int):Unit = Unit
}

enum class Color{
 RED,BLACK,BLUE,GREEN,WHITE
}
fun display(){
 var color:Color=Color.BLACK
 Color.valueOf("BLACK") // 轉(zhuǎn)換指定name為枚舉值，若未匹配成功，會拋出IllegalArgumentException
 Color.values() //已數(shù)組的形式，返回枚舉值
 println(color.name)////獲取枚舉名稱
 println(color.ordinal)//獲取枚舉值在所有枚舉數(shù)組中定義的順序,0開始
}

/**
 * fun receiverType.functionName(params){
 *body
 *}
 * receiverType : 待擴展的類名
 * .   ：修飾符為擴展符
 * functionName ：為自定義的擴展函數(shù)名,
 * params  ：為自定義的擴展函數(shù)參數(shù)，可為空
 * 擴展函數(shù)作用域，受函數(shù)的visibility modifiers影響
 * 擴展函數(shù)并沒有對原類做修改，而是為被擴展類的對象添加新的函數(shù)。
 * 有一條規(guī)則，若擴展函數(shù)和類原有函數(shù)一致，則使用該函數(shù)時，會優(yōu)先使用類本身的函數(shù)。
 */
class Employee(var name: String) {
 fun print() {
  println("Employee")
 }
}

//擴展函數(shù)
fun Employee.println() {
 print("println:Employee name is $name")
}


/**
 * 可以擴展一個空對象
 */
fun Any?.toString1(): String {
 if (this == null)
  return "toString1:null"
 else {
  return "toString1" + toString()
 }
}

/**
 * 擴展屬性
 * 由于擴展屬性實際上不會向類添加新的成員,
 * 因此無法讓一個擴展屬性擁有一個后端域變量. 所以,對于擴展屬性不允許存在初始化器.
 * 擴展屬性的行為只能通過明確給定的取值方法與設(shè)值方法來定義，也就意味著擴展屬性只
 * 能被聲明為val而不能被聲明為var.如果強制聲明為var，即使進行了初始化，
 * 在運行也會報異常錯誤，提示該屬性沒有后端域變量。
 */
val Employee.lastName: String
 get() {
  return "get:"+name
 }

fun main(arg: Array<String>) {
 var employee = Employee("Code4Android")
 employee.print()
 employee.println()
 println(employee.toString1())
 println(employee.lastName)
}

**
 * 被代理接口
 */
interface Base {
 fun display()
}

/**
 * 被代理類
 */
open class BaseImpl : Base {
 override fun display() = print("just display me.")
}

/**
 * 代理類，使用:以及關(guān)鍵詞by進行聲明
 * 許代理屬性和其他繼承屬性共用
 * class Drived(base: Base) : Base by base,BaseImpl()
 */
class Drived(base: Base) : Base by base

//使用
fun show() {
 var b = BaseImpl()
 var drived = Drived(b)
 drived.display()

}

**
 * 代理類型：
 * 懶加載：Lazy
 * 觀察者：Delegates.observable()
 * 非空屬性：Delegates.notNull<>()
 */
class Water {

 public var weight:Int by Delegates.notNull()
 /**
  * 代理屬性
  */
 public val name: String by lazy {
  println("Lazy.......")
  "Code4Android"
 }
 public var value: String by Delegates.observable("init value") {
  d, old, new ->
  println("$d-->$old->$new")
 }
}

fun main(arg: Array<String>) {
 show()
 var water = Water()
 println(water.name)
 println(water.name)
 water.value = "11111"
 water.value = "22222"
 water.value = "33333"
 println(water.value)
 println(water.value)
 //必須先賦值否則IllegalStateException: Property weight should be initialized before get.
 water.weight=2
 print(water.weight)
}

val String.lastChar: Char
 get() = this[this.length - 1]

class A(val p: Int)

 //1,反射得到運行時的類引用:
 val c = Student::class
 //2,函數(shù)引用
 fun isOdd(x: Int) = x % 2 != 0
 val numbers = listOf(1, 2, 3)
 println(numbers.filter(::isOdd)) 

 //3，屬性引用(在此引用main函數(shù)主體外聲明的變量)
 println(::x.get())
 ::x.set(2)
 println(x)
 //4，::x 表達式評估為 KProperty<Int> 類型的屬性，它允許我們使用 get() 讀它的值或者使用名字取回它的屬性
 val prop = A::p
 println(prop.get(A(1))) 

 //5，對于擴展屬性
 println(String::lastChar.get("abc")) 

 //6，與 java 反射調(diào)用
 println(A::p.javaClass),
 var f: Array<Field> = A::p.javaClass.declaredFields

open class People constructor(var id: String, var name: String){
 //可以類中初始化屬性：
 var customName = name.toUpperCase() //初始化屬性

 //使用constructor前綴聲明，且必須調(diào)用primary constructor，使用this關(guān)鍵字
 constructor( id: String, name: String, age: Int) : this(id, name) {
  println("constructor")
 }

 init {
  println("初始化操作，可使用constructor參數(shù)")
 }
 //,Kotlin的class并不支持static變量,所以需要使用companion object來聲明static變量,
 // 其實這個platformStatic變量也不是真正的static變量,而是一個伴生對象,
 companion object {
  val ID = 1
 }
}

/**
 * 使用object定義類，該類的實例即為單例，訪問單例直接使用類名，不能通過構(gòu)造函數(shù)進行訪問，不允許有構(gòu)造函數(shù)
 * Place.doSomething() // 訪問單例對象
 */
object Singleton {
 fun doSomething() {
  println("doSomething")
 }
}


/**
 * 實例化的時候，單例是懶加載，當使用的時候才去加載；而對象表達式是在初始化的地方去加載。
 *
 * 當在類內(nèi)部使用 object 關(guān)鍵詞定義對象時，允許直接通過外部類的類名訪問內(nèi)部對象進而訪問其相關(guān)屬性和方法，相當于靜態(tài)變量
 * 可以使用companion修飾單例，則訪問其屬性或方法時，允許省略單例名
 * MyClass.doSomething() // 訪問內(nèi)部單例對象方法
 */
class MyClass {
 companion object Singleton {
  fun doSomething() {
   println("doSomething")
  }
 }
}