1.HelloWorld
fun main(args: Array<String>) {//相当于Java的main()函数
println("Hello Kotlin!")
2.Kotlin当中的基本数据类型(与Java有些不同)
Kotlin当中的基本数据类型基本上和Java差不多，但是不存在装箱和拆箱的概念，还有就是声明那可真不太一样：
变量的声明涉及到两个关键字：
Kotlin中有两个关键字定义变量，这两个关键字外形看着差别很小就只差了一个字母，但实际差别很大的。
var是一个可变变量，这是一个可以通过重新分配来更改为另一个值的变量。这种声明变量的方式和Java中声明变量的方式一样。
val是一个只读变量，这种声明变量的方式相当于java中的final变量。一个val创建的时候必须初始化，因为以后不能被改变。
注意的是Kotlin当中并不存在int和Integer等类似的基础类型对应的关键字，而只存在Int,Byte,Boolean等等基础类型关键字，所以根本不存在拆箱和装箱。有同学以为我值域是不是忘记填啦，我当然不是忘记啦！这要靠你们自己来完成填写，Kotlin当中获取基础类型的最大值和最小值非常简单，比如，我拿Int类型为例：
var maxInt:Int = Int.MAX_VALUE
println("Int类型的最大值是："+maxInt)
var minInt:Int = Int.MIN_VALUE
println("Int类型的最小值是："+minInt)
3.Java支持自动类型转换，Kotlin可不支持
Java当中char–>int–>long,int—>float等等都可以自动转换，Kotlin可不支持，为啥呢？降低不必要的错误
4.Java当中的原始祖类是Object,而Kotlin却是Any
Kotlin当中Any的源码如下：
package kotlin
/**
* The root of the Kotlin class hierarchy. Every Kotlin class has [Any] as a superclass.
*/
public open class Any {
/**
* Indicates whether some other object is "equal to" this one. Implementations must fulfil the following
* requirements:
*
* * Reflexive: for any non-null reference value x, x.equals(x) should return true.
* * Symmetric: for any non-null reference values x and y, x.equals(y) should return true if and only if y.equals(x) returns true.
* * Transitive: for any non-null reference values x, y, and z, if x.equals(y) returns true and y.equals(z) returns true, then x.equals(z) should return true
* * Consistent: for any non-null reference values x and y, multiple invocations of x.equals(y) consistently return true or consistently return false, provided no information used in equals comparisons on the objects is modified.
*
* Note that the `==` operator in Kotlin code is translated into a call to [equals] when objects on both sides of the
* operator are not null.
*/
public open operator fun equals(other: Any?): Boolean
/**
* Returns a hash code value for the object. The general contract of hashCode is:
*
* * Whenever it is invoked on the same object more than once, the hashCode method must consistently return the same integer, provided no information used in equals comparisons on the object is modified.
* * If two objects are equal according to the equals() method, then calling the hashCode method on each of the two objects must produce the same integer result.
*/
public open fun hashCode(): Int
/**
* Returns a string representation of the object.
*/
public open fun toString(): String
}
这个Java当中的Object比较有着很大的不一样，Any只存在着三个方法：
equals(),hashCode,toString，要想知道为什么，就坚持学到后面，答案会揭晓的。
5.Kotlin如何处理空指针？
在学习这个问题之前，我们回想一下我们在敲写Java代码的时候如何处理java当中的空指针呢？比如：我们在设计Android新闻客户端就经常需要处理的问题：
public static String getNetJson(){
String strJson = "";//存储网络请求的Json格式的数据
//当从服务器请求到数据
//return json
//当服务器端异常的时候
return null;
}
public static void main(String[] args){
//解析Json格式数据
String strJson = getNetJson();
if(strJson != null){
//解析数据并且将把数据显示到控件上
}else{
//提示用户，服务器异常，数据请求失败
}
}
上述代码只是伪代码，不是真实的功能代码，你可以看出，Java处理空指针真是繁琐麻烦，那么Kotlin如何处理呢？其实Kotlin已经将空类型进行隔离处理了，什么是隔离处理呢？
Kotlin当中所有的类型都分为“可空类型”和“非空类型”，比如：”String”和”String?”，String就是非空类型，String?就是可空类型，非空类型是不允许被null赋值的，否则，代码会编译报错，而可空类型就是可以允许被null赋值，比如以下方法是会报错的：
fun getNetJson():String{
return null;//String是非空类型的，所以编译不能通过
}
那么如何处理null类型呢？
println(getNetJson()?.length)//当getNetJsonwei为null时输出null,不为空时输出getNetJson()的长度
getNetJson?.return//当getNetJsonwei为null时返回
还有一种情况，当你使用的是可空类型，比如一下代码：
var str:String? = "dsada"
println(str.length)//编译器报错，因为str可能为null,为null的时候是不能调用length的
有时候我们特别肯定尽管我的变量是声明的可空类型，但是肯定不会出现null的情况，那么你可以这么写，从而告诉编译器，放心编译把，肯定没null值的：
var str:String? = "dsada"
println(str!!.length)
这么一比较，是不是觉得Kotlin处理null指针太人性化了啊。
6.KotLin中的类型转换
Java当中的类型转换是指存在继承关系的，子类可以向上自动转型为父类，而父类转子类则需要强制转换。而Kotlin中的类型转换是使用as关键字
fun main(args: Array<String>) {
var p:Person? = Student("ellen",23)
var s:Student? = p as Student//把Person类型的p转换为Student类型
println(s?.name+":"+s?.age)
}
class Student(name: String, age: Int) : Person(name, age)
open class Person{
public var name:String = ""
public var age:Int = 0
constructor(name:String,age:Int){
this.age = age
this.name =name
}
}
7.Kotlin中的外号是咋回事儿？
当你的村子里出了一个3胞胎，长的一摸一样，那么如何区分他们呢？如同Java当中在一个类中同时使用了多次名字相同但是包名路径不一样的类，Java当中是这么处理的，就是带上包路径来区分，这样真是太繁琐麻烦了，每次使用都还要加上包路径，简直都不能好好敲代码了，Kotlin就不存在这种麻烦，Kotlin处理这种情况的方法叫别名机制，就是“取个外号”，用外号来区分它们。比如下面的代码：
A包的Student
package A
open class Student{
init {
println("俺是A包中的Student")
}
}
B包的Student
package B
open class Student{
init {
println("俺是B包中的Student")
}
}
C包的Student
package C
import A.Student as AS//将A包下的Student类取外号为"AS"
import B.Studnet as BS//将B包下的Student类取外号为"BS"
open class Student{
init {
println("我是C包中的Student")
}
}
fun main(args: Array<String>) {
var astudent:AS = AS()//通过外号来创建实例对象
var bstudent:BS = BS()//通过外号来创建实例对象
var cstudent:Student = Student()
}
输出：
俺是A包中的Student
额是B包中的Student
我是C包中的Student
8.Kotlin的“区间”
Java当中并没有区间的类，这是Kotlin独特具有，类名叫Range
整型区间：
var intRange:IntRange = 0..1024//区间为[0,1024]，注意是全闭的
var intRange2:IntRange = 0 until 1024//区间为[0,1024),注意是半闭半开的，包头不包尾
println("50是否存在与区间[0,1024]:"+intRange.contains(50))
println("-3是否存在与区间[0,1024):"+intRange.contains(-3))
//遍历区间
for(i in intRange){
println(i)
}
9.Kotlin的数组
class Teacher(var name:String,var age:Int){}
fun main(args: Array<String>) {
var intArray:IntArray = intArrayOf(2,3,4,5)//Int数组
var teacherArray:Array<Teacher> = arrayOf(
Teacher("庞统",53),
Teacher("刘备",44),
Teacher("关羽",43),
Teacher("张飞",42))//Teacher数组
//数组的修改
teacherArray[0] = Teacher("诸葛亮",40)
//数组的遍历
for(i in intArray){
println(i)
}
for(teacher in teacherArray){
println(teacher.name+":"+teacher.age)
}
}
输出：
2
3
4
5
诸葛亮:40
刘备:44
关羽:43
张飞:42
10.kotlin中的 “==” 与 “===”
在kotlin中”==”就是equals()的功能，比较的内容，而“===”判断的是两个的引用值，也就是判断这两个引用是否指向同一个对象,代码演示：
var intRange1:IntRange = 0..1024
var intRange2:IntRange = 0..1024
println(intRange1 == intRange2)
println(intRange1 === intRange2)
输出：
true
false
