Android : Kotlin 基础 入门

 1.Kotlin 基础 入门

   1.kotlin你好世界

fun main(args: Array<String>) {
    println("Hello, Kotlin!")
}

2.kotlin变量与输出

fun main() {
    val name = "Kotlin"
    println("Hello, $name!")
}

var

fun main() {
    val  hello = Hello()
    println("get: " + hello.name)

    //set
    hello.name = "张三"
    println("get: " + hello.name)
}

class Hello{
    var name:String?=null
        set(value) {
//            field = name
            field =  "我的名字是" + value
        }
        get() {
            return  field + "get"
        }

}

运行结果：
get: nullget
get: 我的名字是张三get

val 

fun main() {

    println(hello.age)
}

class Hello{
    // 不可变作用于set 方法 ，修改get 改变数据
    val age:Int=20
        get() {
            return field+1
        }
  
}

//运行结果
21

const 常量

fun main() {
   // const 变量的值 必须在编译期间就确定
    println(name)
    println(getName.name)
    println(Hello.name1)

}

//常量 声明
const val name = "张三"

//常量 声明  在单例中
object getName{
    const val name = "张三"
}

class Hello{
//    const val name2 = "张三"  不可以声明 

    //常量 声明  在伴生对中（companion object）
    companion object{
        const val name1 = "张三"
    }

}

Kotlin泛型

fun main() {
    val a = View.Companion.invoke<MyData>().constructor
    val b = View<MyData>().constructor
    println(a)
    println(b)
}

//泛型
class View<T>(val clazz: Class<T>){
    val constructor by lazy { clazz.getDeclaredConstructor().newInstance() }
    companion object{
        inline operator fun <reified T> invoke() = View(T::class.java)
    }
}

class MyData{
    override fun toString(): String {
        return "张三"
    }
}

sdad

10.kotlin 区间 

fun main() {
    //区间 1..100  1到100
    var arr = 1 .. 100;
    var res:Int = 0;
    //遍历
    for (num in arr){
        res +=num;
    }
    println("1加到100的结果是：$res")

    //区间 1 - 99   等于1 到 99
    var i = 1 until 100;
//    for (num in i){
//        println("num---：$num")
//    }


    //区间  跳过3个数据
    var data = 1 .. 100;
//    for (num in data step 3){
//        println("num---：$num")
//    }

    //倒序
    var data2 = data.reversed()
    for (num in data2){
        println("num---：$num")
    }

    //长度
    println("i长度"+i.count())
    println("长度"+data.count())

    for(num in 1 .. 5){
        println(num)
    }
}

163

1

21.kotlin 函数 和函数表达式

package org.example

fun main() {
    //1.
    println(sum(5,6));

    //2.
    println(getsum(6,6));

    //3.
    var i = {x:Int,y:Int -> x+y};
    println(i(5,5));


    //4.
    var sum2:(Int,Int) -> Int = {x,y -> x+y};
    println(sum2(8,9))

}

fun sum(x:Int,y:Int):Int{
    return  x+ y;
}

fun getsum(x:Int,y:Int):Int = x+ y;

22.kotlin默认参数和具名参数

package org.example
val PI =3.1415926f;//常量
fun main() {

//圆的周长 2π*半径   var sum2:(Int,Int) -> Int = {x,y -> x+y};
    var getCircumference:(Float,Float) -> Float ={Pi,radius -> 2 * Pi*radius}

    println( getCircumference(3.1415926f,6.0f));


    println(getArea(5.0f,5.0f))

    println(getVolume(3.1415926f,5.0f,5.0f));

    //具名参数
    println(getVolume2(radius=5.0f,high=5.0f));

}

//长方形面积 长乘宽
fun getArea(c:Float,k:Float):Float{
    return  c * k;
}

//圆柱体的体积 π * 半径*半径*高
fun getVolume(pi:Float,radius:Float,high:Float): Float = pi * radius *radius * high;
                // 默认参数
fun getVolume2(pi:Float = PI,radius:Float,high:Float): Float{
    return   pi * radius *radius * high;
}

23.kotlin字符串和数字之间的转换

package org.example

fun main() {
    var i = "100";
    var k = 100;
    var aa = "a3";

//    println( i == k);   //Operator '==' cannot be applied to 'String' and 'Int'

    var j = i.toInt();
    println( j == k);   //true

    println(k.toString().equals(i));      //true

    aa.toInt(); //java.lang.NumberFormatException: For input string: "a3"
}

24.Kotlin人机交互

package org.example

fun main() {
    println("请输入第一个数：")
    var numA = readLine();
    println("请输入第二个数：")
    var numB = readLine();

    println("两数之和是：${numA!!.toInt() + numB!!.toInt()}")
}

25.Kotlin异常处理

package org.example

fun main() {
    println("请输入第一个数：")
    var numA = readLine();
    println("请输入第二个数：")
    var numB = readLine();

    try {
        println("两数之和是：${numA!!.toInt() + numB!!.toInt()}")
    }catch (e:Exception){
        println("异常信息")
        println(e.message);
    }

}

26.Kontlin递归

package org.example

import java.math.BigInteger

fun main() {
   //递归延时 阶乘
    // 1  ， 2： 2 *1，   3： 3*2*1， 4： 4*3*2*1； 5： 5*4*3*2*1
    println(fact(3));        //6

    println(factBG(BigInteger("40")));
    //815915283247897734345611269596115894272000000000

}
fun fact(num:Int):Int{
    if(num == 1)return 1 else return num * fact(num -1);
}
//一个很大的数 BigInteger extends Number
fun factBG(num:BigInteger):BigInteger{
    if(num == BigInteger.ONE)return BigInteger.ONE else return num * factBG(num -BigInteger.ONE);
}

27.Kotlin尾递归优化

package org.example

fun main() {
    //递归 累加
    //1:1   2： 2+1， 3： 3+2+1，   4:4+3+2+1
//    println(allAdd((1000000)))  //java.lang.StackOverflowError 栈溢出

    println("最后结果是："+allAdd(1000000,0));    //结果是1784293664

}
//1.
//fun allAdd(num:Int):Int{
//    println("我只能抗住次 ${num} 计算");    //我只能抗住次 992039 计算
//    if (num == 1) return 1 else return  num + allAdd(num-1);
//}

//2.尾递归优化 tailrec
tailrec fun allAdd(num:Int,res:Int):Int{
    println("我计算了${num} 次 ，结果是${res}");  
    if (num == 0) return 1 else return  allAdd(num-1,res+num);
}

28.Kotlin面向对象

package org.example

//定义学生类
class Student(var name:String,var age:Int);

fun main(args: Array<String>) {
    var st = Student("张三",25);
    println("名字：${st.name}");
    println("名字：${st.age}");
}

29.kotlin静态属性和动态行为

package org.example

//定义学生类
class Student(var name:String,var age:Int){
    //方法1
    fun getPhone(){
        println("我的名字是${name} 手机号123456789");
    }
    //方法2带参数
    fun setPhone(numb:String){
        println("我的名字是${name} 设置的手机号${numb}");
    }

}

fun main(args: Array<String>) {
    var st = Student("张三",25);
    println("名字：${st.name}");
    println("名字：${st.age}");
    st.getPhone();
    st.setPhone("987654321");

}

30.kotlin面向对象实战-封装

package org.example

//定义学生类
class Student(var name:String,var age:Int){
    var money = 999;
    //方法1
    fun getPhone(){
        println("我的名字是${name} 手机号123456789");
    }
    //方法2带参数
    fun setPhone(numb:String){
        println("我的名字是${name} 设置的手机号${numb}");
    }
    //私有化 封装
    private fun geMoney(){
        println("我的余额是：${money}");
    }

}

fun main(args: Array<String>) {
    var st = Student("张三",25);
    println("名字：${st.name}");
    println("名字：${st.age}");
    st.getPhone();
    st.setPhone("987654321");

    //外部用不了
//    st.geMoney();//Cannot access 'geMoney': it is private in 'Student'

}

31.kotlin面向对象-继承(open和override)

package org.example

/**
 * 父类   open
 */
open class Fathor{
    open var chact:String ="性格类向";

    //允许子类重写方法 加上 open
    open fun action(){
        println("公共场合喜欢大声喧哗")
    }
}

/**
 * 子类 继承父类  open
 */
class Son:Fathor(){
    //子类重新父类的变量
    override var chact:String ="性格外向";

    //子类重新父类的方法
    override fun action(){
        println("儿子很乖，在公共场合很有礼貌")
    }

}

fun main() {
    //继承父类 拥有父类的所有属性
    var son1 = Son();
    println("儿子的性格 : ${son1.chact}");
    son1.action();


}

32.kotlin抽象类和继承

package org.example

/**
 * 抽象类
 * abstract
 */
abstract class Human(var name:String){
    //抽象方法
    abstract fun eat();
}


/**
 * 继承抽象类 必须实现抽象类中的方法
 */
class Man(name: String) :Human(name){
    override fun eat() {
        println("${name} 大口大口的吃 哇哇哇");
    }

}

/**
 * 继承抽象类 必须实现抽象类中的方法
 */
class WoMan(name: String) :Human(name){
    override fun eat() {
        println("${name} 小口小口的吃");
    }

}

fun main() {
    //调用抽象类方法
   var manHuman = Man("大胖子");
    manHuman.eat()

    var womanHuman = WoMan("小姑凉");
    womanHuman.eat()

}

33.kotlin面向对象-多态

package org.example

/**
 * 抽象类
 * abstract
 */
abstract class Human(var name:String){
    //抽象方法
    abstract fun eat();
    abstract fun pee();
}


/**
 * 继承抽象类 必须实现抽象类中的方法
 */
class Man(name: String) :Human(name){
    override fun eat() {
        println("${name} 大口大口的吃 哇哇哇");
    }

    override fun pee(){
        println("${name} 站着尿尿");
    }

}

/**
 * 继承抽象类 必须实现抽象类中的方法
 */
class WoMan(name: String) :Human(name){
    override fun eat() {
        println("${name} 小口小口的吃");
    }
    override fun pee(){
        println("${name} 蹲着尿尿");
    }

}

fun main() {
    //调用抽象类方法
   var manHuman = Man("大胖子");
    manHuman.eat();

    var womanHuman = WoMan("小姑凉");
    womanHuman.eat()

    var people1 =  Man("张三");
    var people2 =  WoMan("李四");
    var people3 =  Man("王五");
    var people4 =  WoMan("王麻子");
    
    //list 集合
    var peopleList =  listOf(people1,people2,people3,people4);
    for (d in peopleList ){
        //多态
        d.pee();
    }

}

34.kotlin面向对象-抽象类和接口

package org.example

/**
 * 接口 是事物的能力
 * 抽象类 是事物的本质
 * */
interface IMan {

    fun sex(){
        println("interface 20");
    };

    fun age();

    //接口中的抽象方法
    abstract fun ab();

}

//实现接口中的方法  或者 改成抽象类 abstract class
abstract class Man1:IMan{
    fun dat(){
        println("abstract 18");
    }
    //实现抽方法
    override fun ab() {
        println("abstract ab()");

    }
}

//写个类实现抽象方法
class shix : Man1(){
    //重写
    override fun age() {
        println(" override shix  18");
    }

}


//实现接口中的方法  或者 改成抽象类 abstract class
class Man2:IMan{
    override fun age() {
        println("重写接口IMan中的age方法");
    }

    override fun ab() {
        TODO("Not yet implemented")
    }

    //调用接中IMan的方法
    override fun sex() {
        super.sex()
    }
}

// 写一个抽象类
abstract class Human3{
    //抽象方法
    abstract fun eat();
}

/**
 * 接口 是事物的能力
 * 抽象类 是事物的本质
 * */
//Man8 类继承抽象类 重新抽象方法 抽象类要带括号 ()
//Man8 又继承接口 ，也要重新接口中的方法
class Man8:Human3(),IMan{
    //重写抽象类中的方法
    override fun eat() {
        println("Man8 重写抽象类中的方法eat()");
    }

    //重写接口中的方法
    override fun age() {
        println("Man8中的eat()");
    }

    //重写接口中的方法
    override fun ab() {
        TODO("Not yet implemented")
    }
}

class Man9:Human3(){
    override fun eat() {
        println("Man9中的eat()");
    }

}



fun main() {

//    interface 20
//    abstract ab()
//    override shix  18

    var man = shix();
    man.sex();  //调接口中的方法
    man.ab();
    man.age();
    println("------------");

    var ma2 = Man2();
    ma2.sex();
    ma2.age();

//    interface 20
//    重写接口IMan中的age方法

    var man3 = Man8();
    man3.eat();
    man3.age()

    var man4 = Man9();
    man4.eat();

    var house = listOf<Human3>(man3,man4);
    for (p in house){
        if (p is Man8){
            p.eat();
        }
    }



}

35.kotlin面向对象-代理和委托 by

**
 * kotlin面向对象-代理和委托  by 代理
 *  object  表示 单例
 * */
//定义接口
interface Wuqiku{
    //接口 武器方法
    fun wuqi();
}

//狙击手重写接口中的方法
// by 代理  有了步兵的武器   Bubing() 方法会被 回创建两次
class jujishou : Wuqiku by Bubing(){
    override fun wuqi() {
        println("我是狙击手 要拿巴雷特");
        Bubing().wuqi();
    }
}

//2.单例 object 狙击手重写接口中的方法
// by 代理  有了步兵的武器  优化 设置了object 只会创建一次
class jujishou2 : Wuqiku by Bubing2{
    override fun wuqi() {
        println("我是狙击手 要拿巴雷特");
        Bubing2.wuqi();
    }
}


//步兵重写接口中的方法
class Bubing : Wuqiku{
    override fun wuqi() {
        println("我是步兵 要拿AK47");
    }
}

//2.单例 object 步兵重写接口中的方法
object Bubing2 : Wuqiku{
    override fun wuqi() {
        println("我是步兵 要拿AK47");
    }
}


fun main(){
    //设置了 by  有AK 和 巴雷特
    var j = jujishou();
    j.wuqi();

    var b = Bubing();
    b.wuqi();

    //比较
    var c = Bubing();
    println(b == c); //false


    //object
    var bb = Bubing2;
    var cc = Bubing2;
    println(bb == cc); //true


}

36.kotlin面向对象-枚举 enum

/**
 * 枚举 enum
 * */
enum class Week{
    星期一,星期二,星期三,星期四,星期五,星期六,星期日
}

fun main() {
    println(Week.星期一);

    println(Week.星期二);

    //枚举索引 0
    println(Week.星期一.ordinal);
}

37.kotlin面向对象-印章类 Sealed class

/**
 * Sealed class 在意的 class 的类型
 *  子类有限的class
 * enum 枚举 在意的是数据
 * */
sealed class Human{
    fun sayHello(){
        println("hello");
    }
    class Man():Human();
    class WoMan():Human();

}

fun main() {
    //不能被实例化
//    var human = Human();

    var a:Human = Human.Man();
    var b:Human = Human.WoMan();
    var c:Human = Human.WoMan();

    //集合
    var datalist = listOf(a,b,c);
    for (d in datalist){
        if (d is Human.WoMan){
            d.sayHello();
        }
    }
}

2.kotlin函数式编程入门

/**forEach()方法 接收的是一个函数
 *
 * public inline fun <T> Iterable<T>.forEach(action: (T) -> Unit): Unit {
 *     for (element in this) action(element)
 * }
 * */
//函数 变 参数
var print = fun (p:String):Unit{
    println(p);
}
fun main() {
        //不限定
//    var data = listOf("小二","王五",123,213.0F);

    //listOf<String> 限定集合类型为String
    var names = listOf<String>("小二","张三","李四","王五",);
    //遍历集合
    names.forEach( print);

    //2.
    for (a in names){
        println(a);
    }

    //3.
    names.forEach {
        a -> println(a);
    }

    //4. 里面有个it 变量
    names.forEach {
        println(it);
    }
}

1.kotlin图片处理

import java.awt.image.BufferedImage
import java.io.File
import javax.imageio.ImageIO

fun main() {
//    imge1();
//    imge2();
//    imge3();
    image4();
}

fun imge1(){
    //内存中创建一个宽高为100的图片
    var image = BufferedImage(100,100,BufferedImage.TYPE_INT_RGB);
    //x y  设置颜色                红 绿 蓝 0x00ff00
    image.setRGB(0,0, 0xff0000);
    // 把图片写到文件中 图片格式，图片名字
    ImageIO.write(image,"bmp", File("logo.bmp"));
}

fun imge2(){
    //内存中创建一个宽高为100的图片
    var image = BufferedImage(100,100,BufferedImage.TYPE_INT_RGB);
    //x y  设置颜色                红 绿 蓝 0x00ff00
    var x = 0 .. 99;

    for(a in x){
        //一行红的
        image.setRGB(a,0, 0xff0000);
    }

    for(a in x){
        //一行绿的
        image.setRGB(a,1, 0x00ff00);
    }

    for(a in x){
        //一行蓝的
        image.setRGB(a,2, 0x0000ff);
    }


    // 把图片写到文件中 图片格式，图片名字
    ImageIO.write(image,"bmp", File("logo2.bmp"));
}


fun imge3(){
    //内存中创建一个宽高为100的图片
    var image = BufferedImage(100,100,BufferedImage.TYPE_INT_RGB);
    //x y  设置颜色                红 绿 蓝 0x00ff00
    var x = 0 .. 99;
    var y = 0 .. 99;
    for(a in x){
        for (b in y){
            //循环生成了一张红色图片
            image.setRGB(a,b, 0xff0000);
        }
    }

    // 把图片写到文件中 图片格式，图片名字
    ImageIO.write(image,"bmp", File("logo3.bmp"));
}

/**
 * public inline fun <T> T.apply(block: T.() -> Unit): T {
 *     contract {
 *         callsInPlace(block, InvocationKind.EXACTLY_ONCE)
 *     }
 *     block()
 *     return this
 * }
 * */
fun image4(){
    //内存中创建一个宽高为100的图片
    var image = BufferedImage(100,100,BufferedImage.TYPE_INT_RGB);
    // 设置颜色                红 绿 蓝 0x00ff00
    var w = 0 .. 99;    //宽度
    var h = 0 .. 99;    //高度
    image.apply {
       for (i in w){
           for(j in h){
               setRGB(i,j,0x00ff00);
           }
       }
    }
    // 把图片写到文件中 图片格式，图片名字
    ImageIO.write(image,"bmp", File("logo4.bmp"));

}

2.Kotlin高阶函数实战(传统函数演示)

/**
 * Kotlin 的 data class 是一种特殊类型的类，它主要用于简化对象表示和序列化。一个 data class 自动生成以下几种方法：
 * equals()
 * hashCode()
 * toString()
 * copy()
 * 它还自动生成 getters 和 setters。
 *
 * */
data class Student(var name:String,var age:Int,var sex:String,var clazz:String)

//数据
var data = listOf<Student>(
    Student("张三",18,"男","java"),
    Student("李四",20,"女","php"),
    Student("王五",18,"男","php"),
    Student("周芷若",25,"女","java"),
    Student("张三丰",18,"男","android"),
    Student("小二",21,"女","android"),
    Student("鲁班",18,"男","android"),
);

//查找男的方法
fun getMan(str:String){
    //用于保存查找出来的数据
    var slStudent = ArrayList<Student>();

    //筛选
    for (a in data){
        if(a.sex == str){
            slStudent.add(a);
        }
    }

    //遍历
    for(stu in slStudent){
        println("名字：${stu.name} 年龄：${stu.age} 性别：${stu.sex} 班级： ${stu.clazz}");
    }
}

fun main() {
    //用于保存查找出来的数据
    var slStudent = ArrayList<Student>();

    //筛选
    for (a in data){
        if(a.clazz == "php"){
            slStudent.add(a);
        }
    }

    //遍历
    for(stu in slStudent){
        println("名字：${stu.name} 年龄：${stu.age} 性别：${stu.sex} 班级： ${stu.clazz}");
    }

    //调用封装的方法
    getMan("男");
}

3.kotlin高阶函数实战(map,filter,groupBy,minBy,maxBy,find,any)

/**
 * Kotlin 的 data class 是一种特殊类型的类，它主要用于简化对象表示和序列化。一个 data class 自动生成以下几种方法：
 * equals()
 * hashCode()
 * toString()
 * copy()
 * 它还自动生成 getters 和 setters。
 *
 * */
data class Student(var name:String,var age:Int,var sex:String,var clazz:String)

//数据
var data = listOf<Student>(
    Student("张三",18,"男","java"),
    Student("李四",20,"女","php"),
    Student("王五",18,"男","php"),
    Student("周芷若",25,"女","java"),
    Student("张三丰",18,"男","android"),
    Student("小二",21,"女","android"),
    Student("鲁班",18,"男","android"),
);


fun main() {
    //最大年龄 maxBy
    println(data.maxBy { it.age })

    //最小年龄 mixBy
    println(data.minBy { it.age })

    // filter 过滤
    println(data.filter { (it.age <20) and (it.sex == "男") })

    //map 把某个属性映射成新的集合
    var mapdata = data.map { "${it.age} : ${it.name}" }
    println(mapdata);

    //any Boolean 校验
    println(data.any { it.age == 20 })

    //count 统计
    println(data.count { it.age == 20 })

    //find 查找一条符合记录了数据
    println(data.find { it.age < 20 })

    //groupBy 分组
    //{java=[Student(name=张三, age=18, sex=男, clazz=java), Student(name=周芷若, age=25, sex=女, clazz=java)], php=[Student(name=李四, age=20, sex=女, clazz=php), Student(name=王五, age=18, sex=男, clazz=php)], android=[Student(name=张三丰, age=18, sex=男, clazz=android), Student(name=小二, age=21, sex=女, clazz=android), Student(name=鲁班, age=18, sex=男, clazz=android)]}
    var res = data.groupBy { it.clazz }
    println(res)
    // 按班级分组后 获取 key 为 java 的数据
    data.groupBy { it.clazz }.get("java")?.forEach { println(it) }
    

}

4.kotlin高阶函数实战-自定义DSL入门

/**
 * Kotlin 的 data class 是一种特殊类型的类，它主要用于简化对象表示和序列化。一个 data class 自动生成以下几种方法：
 * equals()
 * hashCode()
 * toString()
 * copy()
 * 它还自动生成 getters 和 setters。
 *
 * */
data class Student(var name:String,var age:Int,var sex:String,var clazz:String)

//数据
var data = listOf<Student>(
    Student("张三",18,"男","java"),
    Student("李四",20,"女","php"),
    Student("王五",18,"男","php"),
    Student("周芷若",25,"女","java"),
    Student("张三丰",18,"男","android"),
    Student("小二",21,"女","android"),
    Student("鲁班",18,"男","android"),
);

/**DSL 入门
 * 在 Kotlin 中，infix fun 是用于定义接受两个参数的函数的一种语法形式。
 * 它允许你将函数作为前缀操作符来调用，而不需要显式地使用括号。
 *
 * 需要注意的是，infix fun 只适用于单参数（只有一个参数声明）的函数。
 * 如果函数有多个参数，你需要使用常规的函数声明语法，并在调用时使用括号来传递参数。
 * */
infix fun List<Student>.按年龄查找学生(age:Int){
    filter { it.age == age }.forEach { println(it) }
}

infix fun List<Student>.查找学生年龄小于(age:Int){
    filter { it.age < age }.forEach (::println)
}


fun main() {

    //DSL入门
    data 按年龄查找学生 20
    data 查找学生年龄小于 20

}

扫描二维码关注公众号，回复： 17339953 查看本文章