fun main(args: Array<String>) {
println("Hello, Kotlin!")
}fun main() {
val name = "Kotlin"
println("Hello, $name!")
}
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
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;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;
}
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"
}package org.example
fun main() {
println("请输入第一个数：")
var numA = readLine();
println("请输入第二个数：")
var numB = readLine();
println("两数之和是：${numA!!.toInt() + numB!!.toInt()}")
}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);
}
}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);
}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);
}
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}");
}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");
}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'
}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();
}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()
}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();
}
}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();
}
}
}**
* 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
}
/**
* 枚举 enum
* */
enum class Week{
星期一,星期二,星期三,星期四,星期五,星期六,星期日
}
fun main() {
println(Week.星期一);
println(Week.星期二);
//枚举索引 0
println(Week.星期一.ordinal);
}
/**
* 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();
}
}
}
/**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);
}
}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"));
}
/**
* 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("男");
}/**
* 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) }
}
/**
* 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
}