者文_
者文_

Kotlin语法进阶

一、类

image

1.1 类声明

Kotin中使用关键字class声明类，且默认是public。如果一个类没有类体，可以省略花括号

class Invoice { /*……*/ }
class Test

关于类，有几个细节需要注意：

  1. Kotlin中的成员变量必须初始化
  2. 类默认不可以被继承，如需被继承，需要加上open关键字
  3. Kotlin中用:表示继承与实现，即同时表示Java中的extends与implement
  4. Kotlin类中override变成关键字，且省略了protected关键字，即override函数可见性继承自父类

1.2 构造函数

//Java 格式
public class User {
    int id;
    public User(int id, String name) {
        this.id = id;
    }
}

//kotlin格式
class User {
    val id: Int
    constructor(id: Int) {
        this.id = id
    }
}

Koltin中定义一个构造函数，使用constructor关键字，默认为public。一般不会像前述方式实现，而是通过主构造器实现。

主构造函数

一个类可以有一个主构造函数以及一个或多个次构造函数。

主构造函数是类头的一部分：它跟在类名（与可选的类型参数）后。

class Person constructor(firstName: String) { /*……*/ }
//如果主构造函数没有任何注解或者可见性修饰符，可以省略这个 constructor 关键字，等价于
class Person(firstName: String) { /*……*/ }

//如果构造函数有注解或可见性修饰符，这个 constructor 关键字是必需的，并且这些修饰符在它前面
class Customer public @Inject constructor(name: String) { /*……*/ }

关于主构造函数，主要有两部分内容需要关注，即初始化代码块与属性声明

  • 初始化代码块

    主构造函数不能包含任何代码，所以初始化的代码放到init 关键字作为前缀的初始化块（initializer blocks）中

    class Test constructor(num : Int){
    init {
        println("num = $num")
    }
}

var test = Test(1)    //类实例化

    init代码块执行顺序：在次构造函数之前，主构造函数之后执行

    init代码块可以写多个

  • 属性声明

    可以直接在主构造函数中简便声明属性

    class Test(val num1 : Int, var num2 : Long, val str : String){
    ...
}
//等价于
class Test(num1 : Int, num2 : Long, str : String){
    val num1: Int = num1
    var num2: Long = num2
    val str: String = str
    ...
}

次构造函数

Kotlin中支持二级构造函数。以constructor关键字作为前缀

class Person {
    var children: MutableList = mutableListOf();
  constructor(parent: Person) {
        parent.children.add(this)
  }
}

如果类有一个主构造函数，每个次构造函数需要委托给主构造函数，可以直接委托或者通过别的次构造函数间接委托。
委托到同一个类的另一个构造函数用 this 关键字

class User constructor(var name: String) {
    constructor(name: String, id: Int) : this(name) {
    }
    constructor(name: String, id: Int, age: Int) : this(name, id) {
    }
}

如果类主构造函数的所有参数都具有默认值，编译器将生成一个额外的无参数构造函数，它将使用默认值。

fun main(args: Array) {
    var test = Test()         //num1 = 10  num2 = 20
    var test1 = Test(1,2)     //num1 = 1   num2 = 2
    var test2 = Test(4,5,6)       //num1 = 4   num2 = 5   num1 = 4     num2 = 5    num3 = 6
}

class Test constructor(num1: Int = 10 , num2: Int = 20){
    init {
        println("num1 = $num1\t num2 = $num2")
    }

    constructor(num1 : Int = 1, num2 : Int = 2, num3 : Int = 3) : this(num1 , num2){
        println("num1 = $num1\t num2 = $num2 \t num3 = $num3")
    }
}

类实例化

创建一个类的实例，调用类的构造函数即可

val invoice = Invoice()

val customer = Customer("Joe Smith")

注意 Kotlin 并没有 new 关键字

二、属性与字段

2.1 属性声明

类中属性用关键字var或val进行声明

class Address {
    var name: String = "Holmes, Sherlock"
    var street: String = "Baker"
    var city: String = "London"
    var state: String? = null
}

属性使用：直接用名称引用即可

 fun copyAddress(address: Address): Address {
      val result = Address() // Kotlin 中没有“new”关键字
      result.name = address.name // 将调用访问器
      result.street = address.street
      // ……
      return result
  }

2.2 属性访问器

在Java中，需要加上getter方法和setter方法才可以调用属性，而在Kotlin中可直接用名称引用，这时因为其隐含默认实现了getter和setter（读访问器与写访问器）

class User {
    var name = "Czh"
    var userName: String
        get() = name 
        set(value) {
            name = value
        }

    //用val只读标识只读
    val sex: String
        get() = "男"
}

这里有几个细节需要重点说明一下：

  1. val修饰的只读属性，不能有写访问器setter()
  2. 关键字get和set分别对应getter和setter
  3. getter与setter自定义实现位于声明的变量下方
  4. setter函数的参数为value，且使用时需要设置幕后字段

简单来说，Kotlin中每个成员变量就是一个属性，每个属性中包含了(Field + Getter + Setter)

属性访问器可见性

可以根据实际情况修改属性访问器的可见性

var str1 = "kotlin_1"
      private set       //setter()访问器的私有化,且拥有默认实现

var str3 = "kotlin_3"
      private get       //编译出错，因为不能有getter()的访问器可见性

属性引用

属性与方法一样，可以获取其引用。分为类获取属性引用和实例获取属性引用

  • 类获取属性引用

    // 通过类对象获取该类的属性引用
val ageRef = Person::age
// 通过类名属性引用操作该属性时需要一个Receiver
val person = Person(18, "Kotlin")
// 通过属性引用调用get方法
val age = ageRef.get(person)

  • 实例获取属性引用

    // 通过实例获取该类的属性引用
val ageRef = person::age
// 使用时无需Receiver
ageRef.set(30)

其中获取类中属性引用时，其属性必须对获取方式可见。

2.3 幕后字段

Kotlin 的类不能直接声明域变量，如果属性需要，kotlin会自动提供。

在属性的取值方法或设值方法中, 使用 field 标识符可以引用这个backing field

var counter = 0 // 注意：这个初始器直接为后端域变量
    set(value) {
        if (value >= 0) field = value
    }

field 标识符只能在属性的访问器内使用

更好的理解backing field，需要知道Kotlin中，访问一个属性的实质是什么？

属性的读写，实质是执行了属性的getter与setter访问器

class Person {
    var name:String = "Paul"
      get() = "i am getter,name is Jake"
}

var person = Person()
val name = person.name
println("打印结果:$name")   //打印结果:i am getter,name is Jake

class Person {
    var name:String = "Paul"
        set(value) {
           println("执行了写访问器，参数为：$value") 
        }
}

var person = Person()
person.name = "hi,this is new value"    //执行了写访问器，参数为：hi,this is new value
println("打印结果:${person.name}")      //打印结果:Paul

注意：前述给属性赋值，执行了写访问器setter，但是没有属性赋值，所以还是返回默认值

如果按照Java的方法实现setter，则会直接报错

class Person {
var name = ""
  set(value) {
      this.name = value //报错
  }
}

上述代码会直接内存溢出错误，反编译为Java代码

/**java*/
public final class Person {
    @NotNull
    private String name = "Paul";

    @NotNull
    public final String getName() {
        return this.name;
    }

    public final void setName(@NotNull String value) {
        this.setName(value);    //setName递归调用
    }
}

若无field字段，在set方法中进行属性赋值会出现递归调用的情况。

Kotlin中，如果属性至少一个访问器使用默认实现，则会自动提供幕后字段，用关键字field表示，其只能在getter与setter内访问。

class Person {
    var name:String = ""
    get() = field 
    set(value) {
        field = value
    }
}

class Person {
    var name:String = ""
}

上述两个属性声明是等价的。

通过backing field可以帮助我们在属性访问器做一系列操作

class Person(var gender:Gender){
    var name:String = ""
      set(value) {
            field = when(gender){
              Gender.MALE -> "Jake.$value"
                Gender.FEMALE -> "Rose.$value"
          }
        }
}

enum class Gender{
    MALE,
    FEMALE
}

2.4 幕后属性

有时我们希望一个属性：对外表现为只读，对内表现为可读可写，我们将这种属性称为幕后属性

private var _table: Map? = null
public val table: Map
    get() {
        if (_table == null) {
            _table = HashMap() // 初始化
        }
        return _table ?: throw AssertionError("Set to null by another thread")
    }

将_table属性声明为private,因此外部是不能访问的，内部可以访问，外部访问通过table属性，而table属性的值取决于_table，这里_table就是幕后属性。

三、可见性修饰符

  1. public：表示公有，系统默认使用此修饰符

  2. internal：表示模块 ，例如创建一个函数仅开放给module内部使用，不想对library的使用者可见，这是就应该用internal可见性修饰符

  3. protected：表示私有+子类。此修饰符不能用于顶层声明。

  4. private：表示私有 。

    Java中private表示类中可见，作为内部类时对外部类可见。

    Kotlin中private表示类中或所在文件内可见，作为内部类时对外部类不可见

    class Sample {
    private val propertyInClass = 1 // 仅 Sample 类中可见
}

private val propertyInFile = "A string." //整个文件可见

    class Outter {
    fun method() {
        val inner = Inner()
        
        val result = inner.number * 2 // 报错，对外部类不可见
    }
    class Inner {
        private val number = 1
    }
}

四、继承类

4.1 定义

定义继承类的关键字为：open。其中类、成员，方法都要使用open关键字，不过对于abstract类默认具有open属性。

open class Demo{

    open var num = 3
    open fun foo() = "foo"
    open fun bar() = "bar"
}

class DemoTest : Demo(){
    // Kotlin使用继承是使用`:`符号
}

其中在 Kotlin 中，所有类都有一个共同的超类 Any，这对于没有超类型声明的类是默认超类

class Example // 从 Any 隐式继承

Any 有三个方法：equals()、 hashCode() 与 toString()。

修饰符 相应类的成员 注解
final 不能被覆写 在kotlin中默认所有的方法和类都是final属性
open 可以被覆写 需要被明确指出
abstract 必须要覆写 不能被实例化，默认具有open属性。
override 覆写超类的方法 如果没有被指定为final，则默认具有open属性

4.2 构造函数

主要分为实现类无主构造函数和有主构造函数。

实现类无主构造函数

这种情况，次构造函数必须使用super关键字初始化基类型或委托给另一个构造函数

class MyView : View{

    constructor(context: Context) : super(context)

    constructor(context: Context, attrs: AttributeSet?) : super(context, attrs)

    constructor(context: Context, attrs: AttributeSet?, defStyleAttr: Int)
        : super(context, attrs, defStyleAttr)
}

存在主构造函数

这种情况，其基类必须用实现类主构造函数的参数就地初始化

class MyView(context: Context?, attrs: AttributeSet?, defStyleAttr: Int)
    : View(context, attrs, defStyleAttr) {

    constructor(context: Context?) : this(context,null,0)
    
    constructor(context: Context?,attrs: AttributeSet?) : this(context,attrs,0)
}

4.3 重写与重载

重写

当基类中的函数，没有用open修饰符修饰的时候，实现类中不得出现与基类相同函数名的函数

open class Demo{
    fun test(){}
}

class DemoTest : Demo(){
    fun test(){}   //编辑器直接报红报错
    override fun test(){}   //同样报错
}

当一个基类去继承另外一个基类时，第二个基类不想去覆盖掉第一个基类的方法时，第二个基类的该方法使用final修饰符修饰。

open class A{
    open fun foo(){}
}

open class B : A(){
    // 这里使用final修饰符修饰该方法，禁止覆盖掉类A的foo()函数
    final override fun foo(){}
}

重载

Kotlin中函数重载与Java一致

open class Demo{
    open fun foo() = "foo"
}

class DemoTest : Demo(){

    fun foo(str: String) : String{
        return str
    }

    override fun foo(): String {
        return super.foo()
    }
}

属性重写

在基类中声明的属性，可在其实现类中重写该属性。

  1. 该属性必须以override关键字修饰
  2. 重写前后属性类型保持一致
  3. 仅可重写属性的Getter
  4. 可以用var重写基类的val修饰的属性，反之不行
open class Demo{
    open var num = 3
}

class DemoTest : Demo(){
    override var num: Int = 10
}

open class Demo{
    open val valStr = "我是用val修饰的属性"
}

class DemoTest : Demo(){
    override var valStr: String = "abc"
        set(value){field = value}
}

//重写属性的时候不用get() = super.xxx,因为这样的话，不管你是否重新为该属性赋了新值，还是支持setter(),在使用的时候都调用的是基类中的属性值。
class DemoTest : Demo(){

    override var valStr: String = "abc"、
        get() = super.valStr
        set(value){field = value}
}

fun main(arge: Array>){
    println(DemoTest().valStr)  //我是用val修饰的属性

    val demo = DemoTest()
    demo.valStr = "1212121212"
    println(demo.valStr)    //我是用val修饰的属性
}

重写属性的时候不用get() = super.xxx,因为这样的话，不管你是否重新为该属性赋了新值，还是支持setter(),在使用的时候都调用的是基类中的属性值。

open class Demo{
    open val valStr = "我是用val修饰的属性"
}

class DemoTest : Demo(){
    override var valStr: String = "abc"、
        get() = super.valStr
        set(value){field = value}
}

println(DemoTest().valStr)  //我是用val修饰的属性
val demo = DemoTest()
demo.valStr = "1212121212"
println(demo.valStr)    //我是用val修饰的属性

4.4 初始化顺序

open class Base(val name: String) {

    //基类初始化块
    init { println("Initializing Base") }
    //基类属性初始化
    open val size: Int = 
    name.length.also { println("Initializing size in Base: $it") }
}

class Derived(
    name: String,
    val lastName: String
) : Base(name.capitalize().also { println("Argument for Base: $it") }) {

    //子类初始化块
    init { println("Initializing Derived") }

    //子类属性初始化
    override val size: Int =
    (super.size + lastName.length).also { println("Initializing size in Derived: $it") }
}

fun main() {
    val d = Derived("hello", "world")
}

Argument for Base: Hello        // 基类init代码块
Initializing Base
Initializing size in Base: 5    //基类属性初始化
Initializing Derived            //子类init代码块
Initializing size in Derived: 10    //子类属性初始化

可知继承类的执行顺序是：先基类的init代码块，然后是基类的属性初始化，接下来是子类的init代码块与属性的初始化。

五、接口与枚举

image

5.1 接口定义

使用关键字 interface 来定义接口，且一个类或对象可以实现一个或多个接口

interface MyInterface {
    fun bar()
    fun foo() {
      // 可选的方法体
    }
}

class Child : MyInterface {
    override fun bar() {
    // 方法体
    }
}

5.2 属性与方法

接口属性

接口属性主要有如下特点：

  1. 属性要么是抽象，要么提供访问器的实现
  2. 不可以有幕后字段
interface Demo3Interface{
    val num1: Int   //抽象的
    val num2 : Int  
}

class Demo3(override val num1: Int, override val num2: Int) : Demo3Interface{
    fun sum() : Int{
        return num1 + num2
    }
}

var demo = Demo3(1,2)
println(demo.sum()) // 3

interface Demo3Interface{

    // val num3: Int = 3  这种方式不提供，会直接报错的
    val num3: Int
    get() = 3

    val num4: Int
}

class Demo3(override val num1: Int, override val num2: Int) : Demo3Interface{

    // 提供访问器实现
    override val num3: Int
    get() = super.num3

    // 手动赋值
    override var num4: Int = 4

    fun result() : Int{
        return num3 + num4
    }
}

fun main(args: Array) {
    println(demo.result())      // 7

    // 在这里也可以改变接口属性的值
    demo.num4 = 10
    println(demo.result())  // 13
}

接口方法

接口方法主要有如下特点：

  1. 不带结构体的函数可以省略大括号
  2. 不用强制重写带结构体的函数，可直接调用
interface Demo2Interface{

    fun fun1()  //无参无返回
    fun fun2(num: Int)  //有参无返回
    fun fun3(num: Int) : Int    //有参有返回

    // 有结构体， 可以不重写
    fun fun4() : String{
        return "fun4"
    }

    fun fun5(){}    //等价fun1
}

class Demo2 : Demo2Interface{

    override fun fun1() {
        println("我是fun1()方法")
    }

    override fun fun2(num: Int) {
        println("我是fun2()方法，我的参数是$num")
    }

    override fun fun3(num: Int): Int {
        println("我是fun3()方法，我的参数是$num，并且返回一个Int类型的值")
        return num + 3
    }

    override fun fun4(): String {
        println("我是fun4()方法，并且返回一个String类型的值")
        return super.fun4()
    }
}

fun main(args: Array) {
    var demo = Demo2()

    demo.fun1()
    demo.fun2(5)
    println(demo.fun3(10))
    println(demo.fun4())

    //可以不重写该方法直接调用
    demo.fun5()
}
/************输出结果***************/
我是fun1()方法
我是fun2()方法，我的参数是5
我是fun3()方法，我的参数是10，并且返回一个Int类型的值
13
我是fun4()方法，并且返回一个String类型的值
fun4

5.3 冲突解决

某些场景下，可能出现不同父类存在相同方法名的方法，导致子类实现时冲突，用用super<接口名>.方法名来区分

interface A {
    fun foo() { print("A") }
    fun bar()
}

interface B {
    fun foo() { print("B") }
    fun bar() { print("bar") }
}

class C : A {
    override fun bar() { print("bar") }
}

class D : A, B {
    override fun foo() {
        super.foo()
        super.foo()
    }

    override fun bar() {
        super.bar()
    }
}

5.4 枚举定义

声明格式：

enum class 类名{
      ...
}

enum class State{
    NORMAL,NO_DATA,NO_INTERNET,ERROR,OTHER
}

//访问枚举常量
State.NORMAL.name
State.NO_DATA.name

Kotlin中枚举的特点是：

  1. 每一个枚举常量都是一个对象，用逗号分隔
  2. 访问方式为：枚举类名.枚举常量.属性

枚举匿名类

实现枚举常量的匿名类，须提供一个定义在枚举类内部的抽象方法，且必须在枚举变量后面，最后一个枚举变量用分号结束。

enum class ConsoleColor {
    BLACK {
        override fun print() {
            println("我是枚举常量 BLACK ")
        }
    },
    GREEN {
        override fun print() {
            println("我是枚举常量 GREEN ")
        }
    };

    abstract fun print()
}

fun main(args: Array) {
    ConsoleColor.BLACK.print()  //我是枚举常量 BLACK 
}

5.5 枚举类使用

枚举类对象内置两个属性：

  • name：枚举对象名称
  • ordinal：枚举对象索引

枚举类同时提供了values()和valueOf()方法来检测指定的名称与枚举类中定义的任何枚举常量是否匹配，且提供enumValues()和 enumValueOf()函数以泛型的方式访问枚举类中的常量

enum class Color(var argb : Int){
    RED(0xFF0000),
    WHITE(0xFFFFFF),
    BLACK(0x000000),
    GREEN(0x00FF00)
}  

println("name = " + Color.RED.name + "\tordinal = " + Color.RED.ordinal)
println("name = " + Color.WHITE.name + "\tordinal = " + Color.WHITE.ordinal)
println("name = " + Color.BLACK.name + "\tordinal = " + Color.BLACK.ordinal)
println("name = " + Color.GREEN.name + "\tordinal = " + Color.GREEN.ordinal)

/************输出结果*********/
name = RED      ordinal = 0
name = WHITE    ordinal = 1
name = BLACK    ordinal = 2
name = GREEN    ordinal = 3

println(enumValues().joinToString { it.name })
println(enumValueOf("RED"))

/************输出结果*********/
RED, WHITE, BLACK, GREEN
RED

println(Color.valueOf("RED"))
println(Color.values()[0])
println(Color.values()[1])
println(Color.values()[2])
println(Color.values()[3])

 /************输出结果*********/
RED
RED
WHITE
BLACK
GREEN

枚举的一些其他特性：

  • 可以定义扩展方法和扩展属性
  • 可以用在条件分支when
  • 有顺序，可以用来比较大小
  • 可以应用在区间
  • 也是类，可以实现接口

六、数据类

Kotlin中提供了关键字data，声明一个类为数据类

data class 类名(var param1 ：数据类型,...){}
//或者
data class 类名 可见性修饰符 constructor(var param1 : 数据类型 = 默认值,...)

数据类的主要特点是：

  1. 没有结构体的时候，大括号{}可省略
  2. 主构造函数至少存在一个参数，用var或val修饰
  3. 不能是抽象的，开放的或者内部的
  4. 可以实现接口或继承其他类
//kotlin
data class User(val name : String, val pwd : String)

上述代码等价于

//Java
public class User {
    private String name;
    private String pwd;

    public User(String name, String pwd) {
        this.name = name;
        this.pwd = pwd;
    }
    // ......
    
    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", pwd='" + pwd + '\'' +
                '}';
    }
}

copy

如需复制一个数据对象并改变它的一些属性，其余保持不变，可用其copy函数。

val mUser = User("kotlin","123456")
println(mUser)  // User(name=kotlin, pwd=123456)
val mNewUser = mUser.copy(name = "new Kotlin")
println(mNewUser)   // User(name=new Kotlin, pwd=123456)

解构声明

解构声明即把一个对象 解构成很多变量。

Kotlin中定义一个数据类，则系统会默认自动根据参数的个数生成component1() ... componentN()函数。其...,componentN()函数就是用于解构声明

val mUser = User("kotlin","123456")
val (name,pwd) = mUser
println("name = $name\tpwd = $pwd")

备注：

关于data数据类序列化问题，参考资料：https://cloud.tencent.com/developer/article/1587304

七、密封类

密封类用来表示受限的类继承结构：当一个值为有限几种的类型、而不能有任何其他类型时。某种意义上讲，它相当于是枚举类的扩展

密封类的子类必须是在密封类的内部或必须存在于密封类的同一文件

kotlin1.5放宽了限制，只需要保证 Sealed Classes 和它的子类，在同一个包名和 module 下面即可。

声明

定义密封类的关键字：sealed，声明格式为：

sealed class SealedExpr()

sealed class Expr {
    data class Const(val number: Double) : Expr()
    data class Sum(val e1: Expr, val e2: Expr) : Expr()
}
object NotANumber : Expr()  // 子类可以定在密封类外部

密封类不能被实例化，类似抽象类。通过反编译可知，内部的子类编译为静态内部类

使用

密封类主要的作用在于限制继承，起到划分子类的作用，也可保证安全。一般与when合用。

sealed class SealedClass{
    class SonClass1: SealedClass(){}

    class SonClass2: SealedClass(){}
}

fun check(fatherClass: FatherClass): String =
when(fatherClass){
    is SonClass1 -> "1"
    is SonClass2 -> "2"
    else ->
    throw IllegalArgumentException("Unknown Class")
}

fun main(args: Array){
    val son1 = SonClass1();
    val result = check(son1)
    println(result)
}

前述代码，每在SealedClass密封类添加一个子类，when结构就会检查到增加了子类，必须给when结构添加分支，否则编译报错

密封类一般也称为枚举类的扩展，sealed不能修饰interface、abstract class

和抽象类类似，Sealed Class可用于表示层级关系。它的子类可以是任意的类：data class、普通Kotlin对象、普通的类，甚至也可以是另一个密封类

sealed class ResponseResult {
    data class Success(val data:T):ResponseResult()

    data class Failure(val throwable: Throwable?):ResponseResult()

    override fun toString(): String {
        return when(this) {
            is Success<*> -> "Success=[data=$data]"
            is Failure -> "Failure[throwable=$throwable]"
        }
    }
}

inline fun  ResponseResult.doSuccess(success:(T) -> Unit) {
    if (this is ResponseResult.Success) {
        success(data)
    }
}

inline fun  ResponseResult.doFailure(failure:(Throwable?) -> Unit) {
    if (this is ResponseResult.Failure) {
        failure(throwable)
    }
}

fun main() {
    val result = if(true) {
        ResponseResult.Success(xxx)
    } else {
        ResponseResult.Failure(xxx)
    }
    
    result.doSuccess{
        
    }
    
    result.doError{
        
    }
}

八、其它类

8.1 抽象类

定义

用关键字abstract声明抽象类

抽象类和普通类的区别在于：抽象类除了可以有其自己的属性、构造函数、方法等组成部分，还包含了抽象函数以及抽象属性。

abstract class Lanauage{
    val TAG = this.javaClass.simpleName  // 自身的属性

    fun test() : Unit{

    }
    abstract var name : String           // 抽象属性
    abstract fun init()                  // 抽象方法
}

class TestAbstarctA : Lanauage(){

    override var name: String
    get() = "Kotlin"
    set(value) {}

    override fun init() {
        println("我是$name")
    }
}

val mTestAbstarctA = TestAbstarctA()
println(mTestAbstarctA.name)    //Kotlin
mTestAbstarctA.init()   //我是Kotlin

抽象类的主要特点为：

  1. 不能被直接实例化
  2. 抽象成员只有定义，没有实现
  3. 只能继承一个抽象类
  4. 可以覆写抽象类父类的函数

8.2 嵌套类

定义

类可以嵌套在其他类中，嵌套类默认是静态的。

class Other{           // 外部类
    val numOuther = 1

    class Nested {      // 嵌套类
        fun init(){
            println("执行了init方法")
        }
    }
}

Other.Nested().init()      // 调用格式为：外部类.嵌套类().嵌套类方法/属性

嵌套类的主要特点为：

  1. 调用嵌套类属性或方法格式：外部类.嵌套类().嵌套类方法/属性
  2. 无法访问外部类的属性和成员

8.3 内部类

声明一个内部类使用inner关键字。

内部类会带有一个对外部类的对象的引用，能够访问外部类的成员，但内部类不能在接口或非内部嵌套类中声明。

class Other{            // 外部类
    val numOther = 1

    inner class InnerClass{     // 嵌套内部类
        val name = "InnerClass"
        fun init(){
            println("我是内部类")
        }
    }
}

Other().InnerClass().init()  // 调用格式为：外部类().内部类().内部类方法/属性

8.4 匿名内部类

通过object来创建匿名内部类

interface OnClickListener{
    fun onItemClick(str : String)
}

class Other{
    
  private lateinit var listener : OnClickListener

    fun setOnClickListener(listener: OnClickListener){
        this.listener = listener
    }
    
    fun testListener(){
        listener.onItemClick("我是匿名内部类的测试方法")
    }
}    

// 测试匿名内部类
val other = Other()
other.setOnClickListener(object : OnClickListener{
    override fun onItemClick(str: String) {
        // todo
        println(str)
    }
})
other.testListener()

8.5 局部类

局部类即定义在方法中的类

    val numOther = 1

    fun partMethod(){
        var name : String = "partMethod"

        class Part{
            var numPart : Int = 2

            fun test(){
                name = "test"
                numPart = 5
                println("我是局部类中的方法")
            }
        }

        val part = Part()
        println("name = $name \t numPart = " + part.numPart + "\t numOther = numOther")
        part.test()
        println("name = $name \t numPart = " + part.numPart + "\t numOther = numOther")
    }
}

Other().partMethod()

/***********输出结果***********/
name = partMethod    numPart = 2    numOther = 1
我是局部类中的方法
name = test      numPart = 5    numOther = 1

局部类的主要特点是：

  1. 局部类只能在定义该局部类的方法中使用。
  2. 定义在实例方法中的局部类可以访问外部类的所有变量和方法。但不能修改
  3. 局部类中的可以定义属性、方法，并且可以修改局部方法中的变量

九、类型别名

类型别名是为现有类型提供替代名称，例如用较短名称替代原有类型，解决代码过于冗余与臃肿的问题，关键字为typelias

类名

// 类型别名，切记声明在顶部
typealias First = TypeAliasDemoTestFirst

class TypeAliasDemoTestFirst{
    fun show(){
        println("name : ${this.javaClass.simpleName}")
    }
}

val first = First()
first.show()

typealias NestA = DemoClassTestNest.A

class DemoClassTestNest{
    class A{
        fun show(){
            println("name : ${this.javaClass.simpleName}")
        }
    }
}

val nestA = NestA()
nestA.show()

函数参数

typealias Predicate = (T) -> Boolean

fun foo(p: Predicate) = p(42)

fun main() {
    val f: (Int) -> Boolean = { it > 0 }
    println(foo(f)) // 输出 "true"

    val p: Predicate = { it > 0 }
    println(listOf(1, -2).filter(p)) // 输出 "[1]"
}

属性名冲突解决

在开发中，处理json字符串转换成实体类的时候，会出现属性名和关键字冲突的问题

对于Java，使用@SerializedName注解解决

public class Test{
    private int id;
    private String name;
    @SerializedName("swicth")
    private int s;
}

对于Kotlin，只需将属性名包括在符号``中即可

data class TestBean(val id : Int,
                val name : String,
              val `package` : String)

十、解构声明

解构声明：将一个对象解构为多个变量的操作。data数据类默认支持解构声明，会生成component()方法。

data class Book(var name: String, var price: Float)

val (name, price) = Book("Kotlin入门", 66.6f) //解构声明
println(name)   //Kotlin入门
println(price)  //66.6

实现原理

数据类之所以可以使用解构声明，因为编译器默认为它声明了类似函数

operator fun component1(): String {
    return name
}

operator fun component2(): Float {
    return price
}

其中的 component1() 和 component2() 函数是在 Kotlin 中广泛使用的 约定原则 的另一个例子，为 name、price变量赋值相当于分别调用了 Book 对象的component1()、component2()函数

image

自定义解构声明

对于普通类，可以手动声明类似operator fun component1()的方法，来实现解构声明功能

class Book(var name: String, var price: Float) {
    operator fun component1(): String {
        return name
    }

    operator fun component2(): Float {
        return price
    }
}

fun main(args: Array) {
    val (name, price) = Book("Kotlin入门", 66.6f)
    println(name)   //Kotlin入门
    println(price)  //66.6
}

数组、集合解构声明

Kotlin 中数组，list、map系列集合默认也支持解构声明的功能

fun main(args: Array) {
    val array = arrayOf(1, 2, 3)
    val (a1, a2, a3) = array
    
    val list = listOf(1, 2, 3)
    val (b1, b2, b3) = list
    
    val map = mapOf("key1" to 1, "key2" to 2, "key3" to 3)
    for ((key, value) in map) {
        println("$key-$value")
    }
}

解构声明忽略

如果在解构声明中不需要某个变量，那么可以用下划线_取代其名称，这样也就不会调用相应的componentN()操作符函数：

val (_, price) = Book("Kotlin入门", 66.6f)

十一、对象表达式与对象声明

11.1 对象表达式

对象表达式是在使用他们的地方立即执行

创建一个继承某个（或某些）类型的匿名类的对象，我们一般会这么写：

window.addMouseListener(object : MouseAdapter() {
    override fun mouseClicked(e: MouseEvent) { /*……*/ }

    override fun mouseEntered(e: MouseEvent) { /*……*/ }
})

kotlin和Java在创建匿名类的方式相似，只不过将new换成了object

定义一个接口与抽象类，kotlin可以一个匿名对象搞定，而java需要定义两个匿名对象类

abstract class Person {
    abstract fun play()
}
interface Move {
    fun walk()
}
//对象表达式
val a: Any = object : Person(), Move {
    override fun walk() {
        println("walk")
    }
    override fun play() {
        println("play")
    }
}


fun main(args: Array) {
    //调用
    if (a is Person) {
        a.play()
    }
    if (a is Move) {
        a.walk()
    }
}

越过类定义

通过对象表达式，可以越过类的定义，直接得到一个对象

fun foo() {
    val adHoc = object {
        var x: Int = 0
        var y: Int = 0
    }
    print(adHoc.x + adHoc.y)
}

返回值类型

匿名对象可以用作只在本地和私有作用域中声明的类型。

  1. 作为公有函数的返回类型或公有属性类型，实际类型为匿名对象的超类型
  2. 如果是私有，则为匿名对象类型
class C {
    // 私有函数，所以其返回类型是匿名对象类型
    private fun foo() = object {
        val x: String = "x"
    }

    // 公有函数，所以其返回类型是 Any
    fun publicFoo() = object {
        val x: String = "x"
    }

    fun bar() {
        val x1 = foo().x        // foo私有函数，没问题，
        val x2 = publicFoo().x  // 错误：公用函数返回超类型，未能解析的引用“x”
    }
}

对象表达式中的代码可以访问来自包含它的作用域的变量。

fun countClicks(window: JComponent) {
    var clickCount = 0
    var enterCount = 0

    window.addMouseListener(object : MouseAdapter() {
        override fun mouseClicked(e: MouseEvent) {
            clickCount++
        }

        override fun mouseEntered(e: MouseEvent) {
            enterCount++
        }
    })
    // ……
}

11.2 对象声明

Kotlin 使用 object 关键字来声明一个对象，其中变量与函数都是静态的。

可以通过对象声明来获得一个单例，且是线程安全的饿汉式单例。

object DataProviderManager {
    fun registerDataProvider(provider: DataProvider) {
        // ……
    }

    val allDataProviders: Collection
        get() = // ……
}

对象声明在另一个类的内部时，只能通过类名来访问，且该对象不能直接访问到外部类的方法和变量

class Site {
    var name = "Hello World"
    object DeskTop{
        var url = "www.runoob.com"
        fun showName(){
            print{"desk legs $name"} // 错误，不能访问到外部类的方法和变量
        }
    }
}

fun main(args: Array) {
    var site = Site()
    site.DeskTop.url // 错误，不能通过外部类的实例访问到该对象
    Site.DeskTop.url // 正确
}

伴生对象

类内部的对象声明可以用 companion关键字标记，可以直接通过外部类访问到对象的内部元素，类似于Java中的static静态功能

class MyClass {
    companion object Factory {
        fun create(): MyClass = MyClass()
    }
}

val instance = MyClass.create()   // 访问到对象的内部元素

可以省略伴生对象的名称，在这种情况下将使用名称 Companion

class MyClass {
    companion object { }
}

val x = MyClass.Companion

一个类里只能声明一个内部关联对象，即companion只能使用一次

Java中的静态变量和方法，在kotlin中都放在companion object中。因此Java中的静态初始化在kotlin中也放在companion object中，由init和一对大括号表示。

class Sample {
    companion object {
      init {
            ...
        }
    }
}

伴生对象是真实对象的实例成员，而且还可以实现接口

interface Factory {
    fun create(): T
}

class MyClass {
      companion object : Factory {
          override fun create(): MyClass = MyClass()
      }
      fun test() {
          println("test")
      }
  }

  fun main(args: Array) {
      val f: Factory = MyClass
      f.create().test()
  }

语义差异

  • 对象表达式是在使用他们的地方立即执行（及初始化）的；
  • 对象声明是在第一次被访问到时延迟初始化的；
  • 伴生对象的初始化是在相应的类被加载（解析）时，与 Java 静态初始化器的语义相匹配

你可能感兴趣的:(Kotlin语法进阶)

  • EcmaScript和JavaScript的区别 每天吃八顿 前端ecmascript
    ECMAScript和JavaScript是经常被混淆的两个术语，但实际上它们之间存在一些区别：ECMAScript：ECMAScript（通常缩写为ES，并且有版本号如ES5,ES6和ES7等）是由ECMA国际（EuropeanComputerManufacturersAssociation）制定的一种脚本语言的规范。这个规范定义了语法、命令、数据类型等基本元素。ECMAScript是一种规范，
  • 爱的进阶 懒方的羊
    热恋时，你侬我侬。每一刻都不嫌多，最怕时间突然消逝，很多的呢喃还未说道。那简简单单的对望，都显得情深义重。真真是应了那句，有情饮水饱！不满时，锱铢必较。哪怕没有及时的回应，都显得漠不关心，不禁质疑，爱还在么？还有多少？是否已经厌倦？那忙碌的回答，又是否是不在意的敷衍？争吵是，互相伤害。开始彼此埋怨，陈年往事不停地诉说。开始觉得彼此都不愿付出了，却没发现彼此都在不停地索取。这时，两个人是不是在彼此的
  • ros2中使用launch.xml启动时，怎么在命令行里设置参数，或者加载参数文件（params.yaml） code . Autoware自动驾驶ROS2xmlRos2自动驾驶机器人
    在ROS2中使用launch.xml启动时，可以通过命令行设置参数或加载参数文件（如params.yaml）。以下是具体的方法：1.在命令行中设置参数你可以在运行ros2launch命令时直接设置参数，使用key:=value的语法。例如：ros2launchparam_name:=param_value例如，如果你有一个参数background_r，你可以这样设置：ros2launchmy_pa
  • 《Android进阶之光》读书笔记 soleil雪寂 读书笔记#Android进阶之光
    文章目录第1章Android新特性1.1.Android5.0新特性1.2.RecyclerView1.1.4.3种Notification1.1.5.Toolbar与Palette1.1.6.Palette1.2.Android6.0新特性1.2.2.运行时权限机制1.3.Android7.0新特性第2章MaterialDesign2.2.DesignSupportLibrary常用控件详解第3
  • 《Android进阶之光》— Android 书籍 王睿丶 Android永无止境《Android进阶之光》Android书籍Androidphoenix移动开发
    文章目录第1章Android新特性1第2章MaterialDesign48第3章View体系与自定义View87第4章多线程编程165第5章网络编程与网络框架204第6章设计模式271第7章事件总线308第8章函数响应式编程333第9章注解与依赖注入框架382第10章应用架构设计422第11章系统架构与MediaPlayer框架460出版年:2017-7简介：《Android进阶之光》是一本And
  • 《android进阶之光》——多线程编程（上） TAING要一直努力 读书笔记
    今天了解了下多线程编程，知识点如下：进程与线程：进程是什么？线程是什么？进程可以看作是程序的实体，是线程的容器，是受操作系统管理的基本运行单元，例如exe文件就是一个进程。线程是进程运行的一些子任务，是操作系统调度的最小单元，各线程拥有自己的计数器，堆栈，局部变量等，也可以访问线程间共享的内存。线程的状态有哪些？新创建，可运行，等待，超时等待，阻塞，终止怎么创建一个线程？-三种方法第一种，MyTr
  • 什么是 PHP? 为什么用 PHP? 谁在用 PHP? m0_37438181 永远学习php开发语言
    一、什么是PHP？PHP（HypertextPreprocessor，超文本预处理器）是一种广泛应用于Web开发的通用开源脚本语言。PHP主要用于服务器端编程，可以嵌入HTML中，与数据库进行交互，生成动态网页内容。它具有以下特点：简单易学：语法相对简单，容易上手，对于初学者来说是一个不错的选择。跨平台性：可以在多种操作系统上运行，如Windows、Linux、Unix等。丰富的函数库：提供了大量
  • 继续探索通往桃花源的路-我为何参加进阶写作特训营 安晴兰
    记得一个月前写了一篇为何参加21天爱上写作训练营，我开始了这个写作的旅程。一个月后写了一篇参与课程的心得。我发现这段很短的时间，21天，回首一望，其实，自己才迈开了一步。老师给我们一些方法与技巧，告诉我们补给的重要，老师看着我们继续前行，因为这条写作路，是自己的选择。我相信老师一定希望我们勇往直前，笔从心的继续写下去，做个终生的写作者。这段时间我的写作产出量的确比不上其他多产的小伙伴，但我已达到老
  • android进阶之光！Android面试必备的集合源码详解，系列篇 程序员Sunbu 程序员Android
    前言面试：如果不准备充分的面试，完全是浪费时间，更是对自己的不负责。文末会给大家分享下我整理的Android面试专题及答案其中大部分都是大企业面试常问的面试题，可以对照这查漏补缺，当然了，这里所列的肯定不可能覆盖全部方式，不过对大家找工作肯定是有帮助！本月飞机到达上海，到今天第6天了，四家大公司华为，小米，映客，抖音，还有二家中小型公司。有几家已经面了几轮，下周还要面，挂了几家，不过目前已经选择了
  • js进阶第二天 LIT乐言
    一、水平滚动条和垂直滚动条Snip20161124_1.png1.1核心技术点1）求滚动条的长度？2）拖动滚动条，求内容要走多少？滚动条的长度取决于滚动内容（滚动内容越长，滚动条越短）；内容滚动的距离和滚动条走的距离是成倍数关系。1.2换算公式获取滚动条的长度：**滚动条的长度/盒子的长度=盒子的长度/内容的长度**滚动条长度=(盒子的宽度/内容的宽度)*盒子的宽度拖动滚动条，求内容走的长度：**
  • Jacoco的XML报告详解 CrissChan 自动化测试持续交付和持续测试jacoco测试
    使用jacococli完成jacoco测试报告生成后，会看到有一个.xml结尾的文件，这个就是xml格式的覆盖率报告。除了xml还有csv、html格式的报告，本文进介绍xml报告。DTD文件在介绍jacoco的xml报告之前，我们应该先看一下对应的DTD文件的内容。(DTD的全称为DocumentTypeDefinition，是一种文件定义格式，它规定了XML文件结构为XML文件提供了语法与规则
  • 学期复盘 高wen鑫
    1我的大学生活之大学英语学习1）在这个学期的大学英语学习中，我的GPS[Gains]在这个学期的英语学习中我的听力能力提高了；多于长句的理解翻译能力也增加了；对于英语的文化背景的了解也增加了[Problems]听力能力提升空间还很大；对于语法还有很多不懂；词汇量也比较少[Suggestions]多背单词；多联系听力并适应英英互译2）在这个学期的复盘日志中，我的收获是：对于短语、句式的积累变多；英语
  • nacos管理springboot配置时，发生的Could not resolve placeholder两种原因 生产队队长 SpringAllspringboot
    IllegalArgumentException:Couldnotresolveplaceholder'xxx.xxx.xxx'invalue"${xxx.xxx.xxx}"第一种：确实缺少配置，加上对应的配置即可。第二种：这个情况，可能会迷惑很多人报错某个配置无法引用，但是，检查配置时，确实存在，已经配置好了。而且，整个yml文件也没有语法格式错误。原因：我们在解决第一个问题的时候，可能导致这个
  • springboot整合MongoDB时碰到的问题 生产队队长 DatabaseSpringAllmongodbspring
    1.账号总是不对，导致查不出数据，报错Auth…权鉴错误这次，我也是第一次接触MongoDB，非常的生疏springboot整合MongoDB，要在properties文件中配置账号mongodb基本语法：useDATABASE_NAME;--创建数据库showdbs;--查看我们所有的库，注意，我们刚创建的库，如果没有数据，是不会被显示的showusers;--查看当前库所有拥有的账号db.cr
  • Java之抽象类和接口 不互关就取关 java开发语言
    一、抽象类1.抽象类概念如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类，比如动物类。没有实际工作的方法,我们可以把它设计成一个抽象方法，包含抽象方法的类我们称为抽象类。2.抽象类语法在Java中，一个类如果被abstract修饰称为抽象类，抽象类中被abstract修饰的方法称为抽象方法，抽象方法不用给出具体的实现体。//抽象类：被abstract修饰的类publicabs
  • PCIe进阶之Gen3 Physical Layer Transmit Logic（二） 芯芯之火，可以燎原 PCIe进阶硬件工程信息与通信
    1文章概述本文是接着上面一篇文章《Gen3PhysicalLayerTransmitLogic（一）》继续对Gen3PhysicalLayerTransmitLogic做进一步的解析，具体包含ByteStriping和Scrambling以及Serializer。1.1ByteStripingGen3x1OrderedSetConstruction如下所示：OrderedSetBlock由一个Sy
  • PCIe进阶之Gen3 Physical Layer Receive Logic（一） 芯芯之火，可以燎原 PCIe进阶硬件工程信息与通信
    1文章概述本篇文章是接着前面两篇文章进一步研究Gen3PhysicalLayerReceiveLogic的实现，具体包含DifferentialReceiver，CDR（ClockandDataRecovery）和ReceiverClockCompensationLogic三个部分的介绍和解析。1.1DifferentialReceiverGen3的DifferentialReceiver逻辑和之
  • 大数据新视界 --大数据大厂之揭秘大数据时代 Excel 魔法：大厂数据分析师进阶秘籍 青云交 大数据新视界Excel数据分析函数公式数据透视表图表功能规划求解数据分析工具库大数据新视界数据库
    亲爱的朋友们，热烈欢迎你们来到青云交的博客！能与你们在此邂逅，我满心欢喜，深感无比荣幸。在这个瞬息万变的时代，我们每个人都在苦苦追寻一处能让心灵安然栖息的港湾。而我的博客，正是这样一个温暖美好的所在。在这里，你们不仅能够收获既富有趣味又极为实用的内容知识，还可以毫无拘束地畅所欲言，尽情分享自己独特的见解。我真诚地期待着你们的到来，愿我们能在这片小小的天地里共同成长，共同进步。本博客的精华专栏：Ja
  • 一张图让你清晰认识Python（附基本语法总结） 进击的C语言 数据库服务器运维python
    一张图认识Python（附基本语法总结）一张图带你了解Python，更快入门，一张图认识Python（附基本语法总结）Python基础语法总结：1.Python标识符在Python里，标识符有字母、数字、下划线组成。在Python中，所有标识符可以包括英文、数字以及下划线(_)，但不能以数字开头。Python中的标识符是区分大小写的。以下划线开头的标识符是有特殊意义的。以单下划线开头_foo的代表
  • matlab上下标如何输入,在Matlab中怎样输入特殊符号或者上标、下标 李一舟DESIGN matlab上下标如何输入
    Matlab的text/title/xlabel/ylabel对象支持简单的TeX排版语法，如希腊字母，上下标等例如text(0.5,0.5,'\alpha^\beta_2');Matlab图形中允许用TEX文件格式来显示字符。使用\bf，\it，\rm表示黑体，斜体，正体字符，特别注意大括号{}的用法。实例：在存在的图形上写一段有黑体、有斜体、有整体的句子。1、画图x=0:0.01:8;y=si
  • Kotlin 代替Java接口回调，就这么简单 深海呐 Android#Kotlinjavakotlin开发语言
    假如你使用旧的接口回调：通常三步：1定义接口和方法；2使用接口中方法；3继承接口并实现方法；例：classXXXAdapter{publicvarmClickCollBack:clickCollBack?=null//1定义interfaceclickCollBack{//1定义funclick(int:Int)//1定义}itemView.setOnClickListener{mClickCol
  • Android 用线程池实现一个简单的任务队列(Kotlin) 深海呐 Android#Android进阶#Kotlinandroidkotlin线程池延时任务队列线程池延时任务
    关于线程池,Kotlin和java的使用方式一样在Android中,很多人喜欢用Handler的postDelayed()去实现延时任务.要使用postDelayed(),去实现延时任务队列,就不可避免要使用递归.但是这样做,代码的简洁性,和书写的简易,就远不如使用线程池.使用线程池的简单程度:privatevalmThreadPool=Executors.newSingleThreadSched
  • Python进阶之Openpyxl详解 夏天Aileft Pythonpython开发语言openpyxl
    ✨前言openpyxl是一个用于读取和编辑Excel文件（即.xlsx格式文件）的Python库。以下是openpyxl的详细介绍及常见操作示例✨安装在使用openpyxl之前，需要先安装它。可以通过以下命令安装：pipinstallopenpyxl✨加载工作簿#加载已经存在的工作簿wb=openpyxl.load_workbook('example.xlsx')#创建一个新的工作簿wb=open
  • 【Linux 从基础到进阶】Kubernetes 集群搭建与管理 爱技术的小伙子 Linux从基础到进阶linuxkubernetes运维
    Kubernetes集群搭建与管理Kubernetes（简称K8s）是一个用于自动化部署、扩展和管理容器化应用程序的开源平台。它提供了容器编排功能，能够管理大量的容器实例，并支持应用的自动扩展、高可用性和自愈能力。本文将详细介绍如何在CentOS和Ubuntu系统上安装和配置Kubernetes集群，并讲解Kubernetes的基本概念和管理操作。1.Kubernetes基础概念在了解如何搭建Ku
  • 【ADB】adb、shell的介绍 "啦啦啦" adbshelladbshell
    目录adb命令和shell命令的关系adb命令shell命令shell脚本shell脚本运行的环境是什么.sh脚本和.bat脚本有什么区别这两个脚本使用的命令和语法是一样的吗adb命令和shell命令的关系ADB（AndroidDebugBridge）命令和Shell命令都是用于与操作系统交互的命令行工具，但它们的使用环境和目标设备不同。ADB是一种调试工具，主要用于从计算机连接和操作Androi
  • Python中定义函数有哪些方法？ 老男孩IT教育 python开发语言
    在Python中，函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码块，它可以提高应用的模块性，和代码的重复利用率。那么Python如何定义一个函数?以下是具体内容介绍。在Python中定义函数有多种方法。最常见的方法是使用def关键字，后跟函数名称和一对圆括号。语法：def函数名称(参数1，参数2，...):函数体示例：定义一个名为greet的函数，它接受一个name参数并打印一条问
  • AJAX异步请求数据 铸键为犁 JavaWebajaxservletjavascript
    文章目录前言一、AJAX是什么？二、使用步骤1.语法格式2.示例2.注意事项总结前言本篇主要介绍怎么使用AJAX向服务器请求数据。一、AJAX是什么？异步请求技术,可以实现页面局部刷新,在不刷新页面的情况下发送请求到后台加载数据,并且展现在前端二、使用步骤1.语法格式代码如下：$.get(url,data,function(data){})发送get请求参数1:url是后台服务器地址参数2:dat
  • 【Linux 从基础到进阶】Puppet配置管理工具使用 爱技术的小伙子 Linux从基础到进阶linuxpuppet运维
    Puppet配置管理工具使用Puppet是一种开源的配置管理工具，广泛用于自动化管理和配置服务器。它通过声明式的语言定义系统状态，能够跨多台服务器实现一致性配置。Puppet对运维团队来说，是一种强大的工具，能够有效管理服务器配置并简化操作复杂性。本文将详细介绍Puppet的核心概念、安装步骤、以及如何在CentOS和Ubuntu系统上进行配置和管理。1.Puppet的核心概念在使用Puppet之
  • 2024Mysql And Redis基础与进阶操作系列（8）作者——LJS[含MySQL 创建、修改、跟新、重命名、删除视图等具体详步骤；注意点及常见报错问题所对应的解决方法] 肾透侧视攻城狮 MYSQLREDISAdvanceoperationredismysql数据库linuxsqlbashadb
    目录1MySQL视图1.概念2.作用3.特点4.具体如何操作实现MYSQL视图4.1创建视图语法示例查看表和视图查看视图的结构查看视图属性信息（比如：显示数据表的存储引擎、版本、数据行数和数据大小等）查看视图的详细定义信息4.2修改视图简介格式举例4.3更新视图简介下述结构中不可更新的视图补充说明举例更新视图视图包含聚合函数不可更新视图包含distinct不可更新视图包含goupby、having
  • 软件架构，一切尽在权衡 元闰子 架构
    荐语本文要介绍的是2021年O’Reilly出版的书籍SoftwareArchitecture:TheHardParts（后文简称SAHP），某种程度上，它是FundamentalsofSoftwareArchitecture（后文简称FSA）的延续，两本书的主要作者相同。FSA是基础篇，重点介绍了常见的8种架构模式；SAHP是进阶篇，重点介绍了如何从单体架构演进到分布式架构。软件架构，特别是分布
  • 辗转相处求最大公约数 沐刃青蛟 C++漏洞
    无言面对”江东父老“了，接触编程一年了，今天发现还不会辗转相除法求最大公约数。惭愧惭愧！   为此，总结一下以方便日后忘了好查找。   1.输入要比较的两个数a,b   忽略：2.比较大小（因为后面要的是大的数对小的数做%操作）   3.辗转相除（用循环不停的取余，如a%b,直至b=0）   4.最后的a为两数的最大公约数 &
  • F5负载均衡会话保持技术及原理技术白皮书 bijian1013 F5负载均衡
    一.什么是会话保持？        在大多数电子商务的应用系统或者需要进行用户身份认证的在线系统中，一个客户与服务器经常经过好几次的交互过程才能完成一笔交易或者是一个请求的完成。由于这几次交互过程是密切相关的，服务器在进行这些交互过程的某一个交互步骤时，往往需要了解上一次交互过程的处理结果，或者上几步的交互过程结果，服务器进行下
  • Object.equals方法：重载还是覆盖 Cwind javagenericsoverrideoverload
    本文译自StackOverflow上对此问题的讨论。 原问题链接   在阅读Joshua Bloch的《Effective Java（第二版）》第8条“覆盖equals时请遵守通用约定”时对如下论述有疑问： “不要将equals声明中的Object对象替换为其他的类型。程序员编写出下面这样的equals方法并不鲜见，这会使程序员花上数个小时都搞不清它为什么不能正常工作：” pu
  • 初始线程 15700786134
          暑假学习的第一课是讲线程，任务是是界面上的一条线运动起来。            既然是在界面上，那必定得先有一个界面，所以第一步就是，自己的类继承JAVA中的JFrame，在新建的类中写一个界面，代码如下： public class ShapeFr
  • Linux的tcpdump 被触发 tcpdump
    用简单的话来定义tcpdump，就是：dump the traffic on a network，根据使用者的定义对网络上的数据包进行截获的包分析工具。 tcpdump可以将网络中传送的数据包的“头”完全截获下来提供分析。它支 持针对网络层、协议、主机、网络或端口的过滤，并提供and、or、not等逻辑语句来帮助你去掉无用的信息。 实用命令实例 默认启动 tcpdump 普通情况下，直
  • 安卓程序listview优化后还是卡顿 肆无忌惮_ ListView
    最近用eclipse开发一个安卓app，listview使用baseadapter，里面有一个ImageView和两个TextView。使用了Holder内部类进行优化了还是很卡顿。后来发现是图片资源的问题。把一张分辨率高的图片放在了drawable-mdpi文件夹下，当我在每个item中显示，他都要进行缩放，导致很卡顿。解决办法是把这个高分辨率图片放到drawable-xxhdpi下。 &nb
  • 扩展easyUI tab控件，添加加载遮罩效果 知了ing jquery
    (function () { $.extend($.fn.tabs.methods, { //显示遮罩 loading: function (jq, msg) { return jq.each(function () { var panel = $(this).tabs(&
  • gradle上传jar到nexus 矮蛋蛋 gradle
    原文地址： https://docs.gradle.org/current/userguide/maven_plugin.html configurations {     deployerJars } dependencies {     deployerJars "org.apache.maven.wagon
  • 千万条数据外网导入数据库的解决方案。 alleni123 sqlmysql
    从某网上爬了数千万的数据，存在文本中。 然后要导入mysql数据库。 悲剧的是数据库和我存数据的服务器不在一个内网里面。。 ping了一下， 19ms的延迟。 于是下面的代码是没用的。 ps = con.prepareStatement(sql); ps.setString(1, info.getYear())............; ps.exec
  • JAVA IO InputStreamReader和OutputStreamReader 百合不是茶 JAVA.io操作 字符流
    这是第三篇关于java.io的文章了，从开始对io的不了解-->熟悉--->模糊，是这几天来对文件操作中最大的感受，本来自己认为的熟悉了的，刚刚在回想起前面学的好像又不是很清晰了，模糊对我现在或许是最好的鼓励 我会更加的去学 加油！： JAVA的API提供了另外一种数据保存途径，使用字符流来保存的，字符流只能保存字符形式的流   字节流和字符的难点：a,怎么将读到的数据
  • MO、MT解读 bijian1013 GSM
    MO= Mobile originate，上行，即用户上发给SP的信息。MT= Mobile Terminate，下行，即SP端下发给用户的信息； 上行:mo提交短信到短信中心下行:mt短信中心向特定的用户转发短信，你的短信是这样的，你所提交的短信，投递的地址是短信中心。短信中心收到你的短信后，存储转发，转发的时候就会根据你填写的接收方号码寻找路由，下发。在彩信领域是一样的道理。下行业务：由SP
  • 五个JavaScript基础问题 bijian1013 JavaScriptcallapplythisHoisting
    下面是五个关于前端相关的基础问题，但却很能体现JavaScript的基本功底。 问题1：Scope作用范围 考虑下面的代码：  (function() { var a = b = 5; })(); console.log(b); 什么会被打印在控制台上？  回答：         上面的代码会打印 5。 &nbs
  • 【Thrift二】Thrift Hello World bit1129 Hello world
    本篇，不考虑细节问题和为什么，先照葫芦画瓢写一个Thrift版本的Hello World，了解Thrift RPC服务开发的基本流程   1. 在Intellij中创建一个Maven模块，加入对Thrift的依赖，同时还要加上slf4j依赖，如果不加slf4j依赖，在后面启动Thrift Server时会报错 <dependency>
  • 【Avro一】Avro入门 bit1129 入门
    本文的目的主要是总结下基于Avro Schema代码生成，然后进行序列化和反序列化开发的基本流程。需要指出的是，Avro并不要求一定得根据Schema文件生成代码，这对于动态类型语言很有用。   1. 添加Maven依赖   <?xml version="1.0" encoding="UTF-8"?> <proj
  • 安装nginx+ngx_lua支持WAF防护功能 ronin47
    需要的软件:LuaJIT-2.0.0.tar.gz                   nginx-1.4.4.tar.gz          &nb
  • java-5.查找最小的K个元素-使用最大堆 bylijinnan java
    import java.util.Arrays; import java.util.Random; public class MinKElement { /** * 5.最小的K个元素 * I would like to use MaxHeap. * using QuickSort is also OK */ public static void
  • TCP的TIME-WAIT bylijinnan socket
    原文连接： http://vincent.bernat.im/en/blog/2014-tcp-time-wait-state-linux.html 以下为对原文的阅读笔记 说明： 主动关闭的一方称为local end，被动关闭的一方称为remote end 本地IP、本地端口、远端IP、远端端口这一“四元组”称为quadruplet，也称为socket 1、TIME_WA
  • jquery ajax 序列化表单 coder_xpf Jquery ajax 序列化
       checkbox 如果不设定值，默认选中值为on；设定值之后，选中则为设定的值   <input type="checkbox" name="favor" id="favor" checked="checked"/> $("#favor&quo
  • Apache集群乱码和最高并发控制 cuisuqiang apachetomcat并发集群乱码
    都知道如果使用Http访问，那么在Connector中增加URIEncoding即可，其实使用AJP时也一样，增加useBodyEncodingForURI和URIEncoding即可。 最大连接数也是一样的，增加maxThreads属性即可，如下，配置如下： <Connector maxThreads="300" port="8019" prot
  • websocket dalan_123 websocket
    一、低延迟的客户端-服务器 和 服务器-客户端的连接 很多时候所谓的http的请求、响应的模式，都是客户端加载一个网页，直到用户在进行下一次点击的时候，什么都不会发生。并且所有的http的通信都是客户端控制的，这时候就需要用户的互动或定期轮训的，以便从服务器端加载新的数据。   通常采用的技术比如推送和comet（使用http长连接、无需安装浏览器安装插件的两种方式：基于ajax的长
  • 菜鸟分析网络执法官 dcj3sjt126com 网络
      最近在论坛上看到很多贴子在讨论网络执法官的问题。菜鸟我正好知道这回事情.人道"人之患好为人师" 手里忍不住,就写点东西吧. 我也很忙.又没有MM,又没有MONEY....晕倒有点跑题. OK,闲话少说,切如正题. 要了解网络执法官的原理. 就要先了解局域网的通信的原理. 前面我们看到了.在以太网上传输的都是具有以太网头的数据包. 
  • Android相对布局属性全集 dcj3sjt126com android
    RelativeLayout布局android:layout_marginTop="25dip" //顶部距离android:gravity="left" //空间布局位置android:layout_marginLeft="15dip //距离左边距 // 相对于给定ID控件android:layout_above 将该控件的底部置于给定ID的
  • Tomcat内存设置详解 eksliang jvmtomcattomcat内存设置
    Java内存溢出详解   一、常见的Java内存溢出有以下三种：   1. java.lang.OutOfMemoryError: Java heap space ----JVM Heap（堆）溢出JVM在启动的时候会自动设置JVM Heap的值，其初始空间(即-Xms)是物理内存的1/64，最大空间(-Xmx)不可超过物理内存。 可以利用JVM提
  • Java6 JVM参数选项 greatwqs javaHotSpotjvmjvm参数JVM Options
    Java 6 JVM参数选项大全（中文版）   作者：Ken Wu Email: [email protected] 转载本文档请注明原文链接 http://kenwublog.com/docs/java6-jvm-options-chinese-edition.htm！   本文是基于最新的SUN官方文档Java SE 6 Hotspot VM Opt
  • weblogic创建JMC i5land weblogicjms
    进入 weblogic控制太 1.创建持久化存储 --Services--Persistant Stores--new--Create FileStores--name随便起--target默认--Directory写入在本机建立的文件夹的路径--ok 2.创建JMS服务器 --Services--Messaging--JMS Servers--new--name随便起--Pers
  • 基于 DHT 网络的磁力链接和BT种子的搜索引擎架构 justjavac DHT
    上周开发了一个磁力链接和 BT 种子的搜索引擎 {Magnet & Torrent}，本文简单介绍一下主要的系统功能和用到的技术。 系统包括几个独立的部分： 使用 Python 的 Scrapy 框架开发的网络爬虫，用来爬取磁力链接和种子； 使用 PHP CI 框架开发的简易网站； 搜索引擎目前直接使用的 MySQL，将来可以考虑使
  • sql添加、删除表中的列 macroli sql
    添加没有默认值：alter table Test add BazaarType char(1) 有默认值的添加列：alter table Test add BazaarType char(1) default(0) 删除没有默认值的列：alter table Test drop COLUMN BazaarType 删除有默认值的列：先删除约束（默认值）alter table Test DRO
  • PHP中二维数组的排序方法 abc123456789cba 排序二维数组PHP
    <?php/*** @package     BugFree* @version     $Id: FunctionsMain.inc.php,v 1.32 2005/09/24 11:38:37 wwccss Exp $*** Sort an two-dimension array by some level
  • hive优化之------控制hive任务中的map数和reduce数 superlxw1234 hivehive优化
    一、    控制hive任务中的map数: 1.    通常情况下，作业会通过input的目录产生一个或者多个map任务。 主要的决定因素有： input的文件总个数，input的文件大小，集群设置的文件块大小(目前为128M, 可在hive中通过set dfs.block.size;命令查看到，该参数不能自定义修改)；2. 
  • Spring Boot 1.2.4 发布 wiselyman spring boot
    Spring Boot 1.2.4已于6.4日发布，repo.spring.io and Maven Central可以下载(推荐使用maven或者gradle构建下载)。   这是一个维护版本，包含了一些修复small number of fixes,建议所有的用户升级。   Spring Boot 1.3的第一个里程碑版本将在几天后发布，包含许多
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他