一、学习从主函数开始（main）
Hello World！
- Kotlin代码
package study.base
/**
* Created by zhangxuehui on 2017/6/19.
*/
fun main(args: Array<String>) {
println("Hello World!")
}
- Java代码
package study.base;
/**
* Created by zhangxuehui on 2017/6/19.
*/
public class simple01 {
public static void main(String[] args) {
System.out.println("Hello World!");
}
}
对比：
- Kotlin不用创建类，可以直接运行main方法；
- 不需要返回类型，以及静态方法；
- println();打印语句更加简洁；
- 参数的定义方式不同：格式：[变量名]：[类型]
- 包的定义与java相同：package study.base;
- 可以省略";"
二.变量和常量
**常量定义 **
val <标识符> : <类型> = <初始化值>
- 常量（一次赋值局部变量）val
// val 一次赋值局部变量
// 方式一
val a = 1;
println(a)
// 方式二
val d:Double
var i = 1.1
d = i
println(a)
// 一次赋值之后，再次赋值会报错，如下
// val c = 2.1
// d = c//报错
变量定义
var <标识符> : <类型> = <初始化值>
- 变量 var
var a:Int = 1;//方式一，指定类型
var b = 2.1;//方式二，自动推导类型
var c = 3.2
b = c
空安全类型
- ?表示，类型可以为null
val a: Long? = null;
三. 函数fun
- 有返回值
fun sum( x:Int, y:Int):Int{
return x*y
}
- 无返回值
fun sum( x:Int, y:Int):Unit{//:Unit可以省略，相当于java 的void
println(x*y)
}
备注
1.形参必须指定类型。
2.Unit为返回一个无意义的值，相当于java 的空返回，可以省略不写。
3.Unit，可以使用return形式结束语句。
四、基本类型（main）
1.数字类型：Number
- Number类型
| 类型 | 位宽 | 实例 |
|---|---|---|
| Double | 64 | var d:Double = 1.0 |
| Float | 32 | var f:Float = 1.0F |
| Long | 64 | var l:Long = 10L |
| Int | 32 | var i:Int = 1 |
| Short | 16 | var s:Short = 1 |
| Byte | 8 | var b:Byte = 1 |
- 代码
var d:Double = 1.0 //双精度
var f:Float = 1.0F //浮点型
var l:Long = 10L//长类型
var i:Int = 1//整型
var s:Short = 1//短类型
var b:Byte = 1//字符型
显式转换
代码实现
fun main(args: Array<String>) {
val a: Long = 2;
println( a.toDouble())
}
**显示转换的方法 **
toByte(): Byte
toShort(): Short
toInt(): Int
toLong(): Long
toFloat(): Float
toDouble(): Double
toChar(): Char
2.字符类型：Char
Char类型即字符类型，不可以直接用做数值。
字符是由单引号包裹的'1'，特殊的字符通过反斜杠\转义;
下面的字符序列支持转义：
\t,\b,\n,\r,',",\和$。编码任何其他字符，使用 Unicode 转义语法：\uFF00。
我们可以将字符显示的转义为Int数字：
fun decimalDigitValue(c: Char): Int {
if (c !in '0'..'9')
throw IllegalArgumentException("Out of range")
return c.toInt() - '0'.toInt() //显示转换为数值类型
}
3.布尔类型：Boolean
Boolean类型与java相同，布尔值只有 true 或者 false，可以进行与、或、非等常规操作；
4.数组类型：Array
数组类型用Array表示，有get、set、size等方法；
- 数组的定义
定义固定长度的数组
//定义一个固定长度的数组，格式： arrayOfNulls<类型>(长度);
var arr = arrayOfNulls<Int>(10);
定义空数组
//定义一个空数组，需要指定类型
var arr: Array<Int> = emptyArray();
//定义一个空数组，需要不指定类型
var arr= emptyArray<Int>();
定义带默认值的参数（数组的装箱操作）
//推断类型
var arr3= arrayOf(1,2,3);
//指定类型，不可以通过变量设置
var arr4 = booleanArrayOf(true,false)
通过闭包初始化数组
//闭包初始化数组，格式：Array([长度],{[变量]->[表达式]})，
//例如：{i->i*i}，相当于var i = 0；i++；i = i * i；
var arr5 = Array(5,{i->i*i})
备注
1.装箱：可以理解为带初始值变量定义；
2.闭包：即lamada表达式
-
数组的使用
get与set
//设置数据 格式arr.set([位置],[具体数据])
arr.set(0, 10);
//获取数据
println(arr.get(0))
[]的使用(与java相同)
//设置数据
arr[0] = 10;
//获取数据
println(arr[0])
size方法
//获取数组的尺寸，java是使用length
println(arr.size)
indices方法
//获取全部的索引
println(arr5.indices)//输出0..4
- 数组的遍历
遍历数组的值
for(a in arr){
println(a)
}
遍历数组的索引
for(a in arr.indices){
println(a)
}
- 方法
/**
* Concatenates this string with the string representation of the given [other] object. If either the receiver
* or the [other] object are null, they are represented as the string "null".
*/
public operator fun String?.plus(other: Any?): String
/**
* Returns an array of objects of the given type with the given [size], initialized with null values.
*/
public fun <reified @PureReifiable T> arrayOfNulls(size: Int): Array<T?>
/**
* Returns an array containing the specified elements.
*/
public inline fun <reified @PureReifiable T> arrayOf(vararg elements: T): Array<T>
/**
* Returns an array containing the specified [Double] numbers.
*/
public fun doubleArrayOf(vararg elements: Double): DoubleArray
/**
* Returns an array containing the specified [Float] numbers.
*/
public fun floatArrayOf(vararg elements: Float): FloatArray
/**
* Returns an array containing the specified [Long] numbers.
*/
public fun longArrayOf(vararg elements: Long): LongArray
/**
* Returns an array containing the specified [Int] numbers.
*/
public fun intArrayOf(vararg elements: Int): IntArray
/**
* Returns an array containing the specified characters.
*/
public fun charArrayOf(vararg elements: Char): CharArray
/**
* Returns an array containing the specified [Short] numbers.
*/
public fun shortArrayOf(vararg elements: Short): ShortArray
/**
* Returns an array containing the specified [Byte] numbers.
*/
public fun byteArrayOf(vararg elements: Byte): ByteArray
/**
* Returns an array containing the specified boolean values.
*/
public fun booleanArrayOf(vararg elements: Boolean): BooleanArray
5.字符串类型：String
字符串是由 String 表示的。字符串是不变的。字符串的元素可以通过索引操作读取: s[i] 。字符串可以用 for 循环迭代：
代码
fun main(args: Array<String>) {
var str = "abc"
//可以对字符串的每个字符进行遍历
for (s in str){
println(s)
}
}
定义单行字符串
//字符串的单行定义
var str1 = "hello world！"
定义多行字符串
//字符串的多行定义，方式一，转移字符
var str2 = "方式一：\nhello world！\nhello world！"
println(str2)
//字符串的多行定义，方式二，"""，类似html<P>标签
var str3 =
"""
方式二：
hello world！
hello world！
"""
println(str3)
输出结果
字符串模版
字符串中可以包含模版表达式，模版表达式包含以下两种：
1.$:输出变量
2.${语句}：输出运算结果
备注：想要输出$符号，请使用'$'，无法使用转义符号\$
代码：$
var a:Int = 12;
//输出参数
var str:String = "a=$a"
println(str)
代码：${语句}
//输出函数或方法
var b:Int = 12;
var c:Int = 5;
var str2:String = "12+5=${a+b}\n12*5=${sum(b,c)}"
println(str2)
输出结果
五、运算符
Kotlin的运算符与java的基本相同，可以参考：运算符重载
实例
val x = (1 shl 2) and 0x000FF000
详解
- shl(bits) – 有符号左移 (相当于 Java’s <<)
- shr(bits) – 有符号右移 (相当于 Java’s >>)
- ushr(bits) – 无符号右移 (相当于 Java’s >>>)
- and(bits) – 按位与
- or(bits) – 按位或
- xor(bits) – 按位异或
- inv(bits) – 按位翻转
六、控制流
1.if表达式
语法与java相同
- 结构
if(判断) {
//代码块
} else {
//代码块
}
- 案例
var a:Int = 13;
if(a>12) {
println(a + 1)
} else {
println(a - 1)
}
2.when表达式
when表达式，相当于java 的 switch表达式；
- 普通模式
var a: Int = 11;
//普通模式
when (a) {
1 -> println(a);//单行可以省略{}
2 -> {//多行需要添加{}
println(a * a)
}
else -> {//javs使用default，这里默认else
a++;
println(a)
}
}
- 多分支合一模式
//分支合一模式
when (a) {
1, 2 -> {//多行需要添加{}
println(a * a)
}
else -> {//javs使用default，这里默认else
a++;
println(a)
}
}
- 使用in判断范围
//使用in进行范围判断模式
when (a) {
in 0..10 -> {//多行需要添加{}
println(a * a)
}
!in 0..-20 -> println(a)
else -> {//javs使用default，这里默认else
a++;
println(a)
}
}
- 使用is判断类型
//使用is进行类型判断模式，貌似意义不大，没想到使用场景
when (a) {
is Int -> {
println(a * a)
}
else -> {//javs使用default，这里默认else
a++;
println(a)
}
}
- 不设置默认值，直接通过方法判断
var str: String = "odd";
when {
isOdd(str) -> println("fun=="+str);
else -> println(str)
}
3.for循环
for循环与java有很大的差异，在Kotlin中只有一种使用in函数的方式，没有fori或foreach
- 代码实现
var arr = arrayOf(1, 2, 3)
for (i in 1..arr.size) {
println(arr[i])
}
3.while 和 do...while
while语句与java完全相同，不解释；
- while
//while
var x= -11;
while (x<0){
x++;
}
println(x)//输出0
- do...while
//while 和 do...while
do{
x++;
}while (x<0)
println(x)//输出1
七、返回与跳转
Kotlin具有三种跳转方式
-- return 返回相应参数，或结束相关语句
-- break 结束最近的闭合循环
-- continue 跳到最近的闭合循环的下一次循环
1.break 和 continue 标签
- 设置标签
//设置标签，标签可以由任何字符组成，例如
ada@ var a = 0;
loop@ var a = 0;
label@ var a = 0;
- break；
结束当前循环
var arr = Array(5, { i -> i * 2 })
a@for (a in arr) {
if (a == 6) {
break@a
}
}
- continue
跳过当前，迭代到下一次循环，
var arr = Array(5,{i->i*2})
for(a in arr){
if(a==6){
continue
}
println(a)
}
备注：是否添加@标签，貌似没有什么影响；
2.return 标签
返回函数的值，或结束当前函数（其实，就是返回一个无意义的值Unit）
代码
- 返回函数值
fun sum(x: Int, y: Int): Int {
return x * y
}
- 结束当前函数
fun sum(y: Int): Unit {
if (y == 0)
return
println(10 * y)
}
八、总结
Kotlin基础篇学习结束，整体体验下来，发现它有如下优点：
1.不用出现java常见的空异常。
2.代码特别简洁，写代码就像写文章一般。
3.减少代码量，可以更关注代码的逻辑。
4.类型推导，可以不设置类型；
5.很棒的字符串模版。
问题：在android中会有怎样的体验呢？
