【Scala】——面向对象

1 Scala 包

1.1 包风格

  Scala 有两种包的管理风格。

  1. 第一种 Java 的包管理风格相同，每个源文件一个包（包 名和源文件所在路径不要求必须一致），包名用“.”进行分隔以表示包的层级关系，如 com.atguigu.scala。
  2. 另一种风格，通过嵌套的风格表示层级关系，一个源文件中可以声明多个 package，子包中的类可以直接访问父包中的内容，而无需导包
package com {
  package scala {
    package chapter06 {
      object TestPackage {
        def main(args: Array[String]): Unit = {
          println("package test!")
        }
      }
    }
  }
}

package com {

  import com.scala.chapter06.other.Inner.in //父包访问子包需要导包
  package scala {
    package chapter06 {
      object TestPackage {
        val out: String = "out"

        def main(args: Array[String]): Unit = {
          println("package test!")
          println(in)

        }
      }
      package other {
        object Inner {
          val in: String = "in"

          def main(args: Array[String]): Unit = {
            println(TestPackage.out) //子包访问父包无需导包
          }
        }
      }

    }

  }

}

1.2 包对象

  1. 在 Scala 中可以为每个包定义一个同名的包对象，定义在包对象中的成员，作为其对 应包下所有 class 和 object 的共享变量，可以被直接访问。
  2. 若使用 Java 的包管理风格，则包对象一般定义在其对应包下的 package.scala 文件中，包对象名与包名保持一致。
    在这里插入图片描述
package com.scala

package object chapter06 {

}
  1. 如采用嵌套方式管理包，则包对象可与包定义在同一文件中，但是要保证包对象 与包声明在同一作用域中。
package com {
  package scala {
    package chapter06 {
      object TestPackage {
        val out: String = "out"
        def main(args: Array[String]): Unit = {
          println("package test!")
          println(in)
        }
      }
    }
  }
}
package object com {
  val shareValue = "share"
  def shareMethod() = {}
}

1.3 导包

  1. 和 Java 一样，可以在顶部使用 import 导入，在这个文件中的所有类都可以使用。
  2. 局部导入：什么时候使用，什么时候导入。在其作用范围内都可以使用
  3. 通配符导入：import java.util._
  4. 给类起名：import java.util.{ArrayList=>JL}
  5. 导入相同包的多个类：import java.util.{HashSet, ArrayList}
  6. 屏蔽类：import java.util.{ArrayList =>,}
  7. 导入包的绝对路径：new root.java.util.HashMap
  8. Scala 中的三个默认导入的包
import java.lang._ 
import scala._ 
import scala.Predef._

1.4包访问权限

  1. Scala 中属性和方法的默认访问权限为 public，但 Scala 中无 public 关键字。
  2. private 为私有权限，只在类的内部和伴生对象中可用。
  3. protected 为受保护权限，Scala 中受保护权限比 Java 中更严格，同类、子类可以访问，同包无法访问。
  4. private[包名]增加包访问权限，包名下的其他类也可以使用
package com.scala
package chapter06

class Person {
  private var name: String = "bobo"
  protected var age: Int = 18
  private[chapter06] var sex: String = "男"

  def say(): Unit = {
    println(name)
  }
}

object Person {
  def main(args: Array[String]): Unit = {
    val person = new Person
    person.say()
    println(person.name)
    println(person.age)
  }
}

class Teacher extends Person {
  def test(): Unit = {
    this.age
    this.sex
  }
}

class Animal {
  def test: Unit = {
    new Person().sex
  }
}

2 类和对象

2.1 类

  1. 语法
[修饰符] class 类名 {
 类体
}
  1. Scala 语法中，类并不声明为 public，所有这些类都具有公有可见性（即默认就是public）
  2. 一个 Scala 源文件可以包含多个类

2.1 属性

  1. 语法
[修饰符] var|val 属性名称 [：类型] = 属性值
var name: String = "bobo"
  1. Bean 属性（@BeanPropetry），可以自动生成规范的 setXxx/getXxx 方法
package com.scala
package chapter06
import scala.beans.BeanProperty
class Person {
  //Bean 属性（@BeanProperty）
  @BeanProperty var sex: String = "男"
}
object Person {
  def main(args: Array[String]): Unit = {
    var person = new Person()
    person.setSex("女")
    println(person.getSex)
  }
}
  1. _表示给属性一个默认值
package com.scala
package chapter06
import scala.beans.BeanProperty
class Person {
  var age: Int = _ // _表示给属性一个默认值
}

object Person {
  def main(args: Array[String]): Unit = {
    var person = new Person()
    println(person.age)
  }
}
  1. val 修饰的属性不能赋默认值，必须显示指定
//val school: Int = _ // _表示给属性一个默认值

2.3 方法

def 方法名(参数列表) [：返回值类型] = {
    方法体
}

2.4 创建对象

  1. 语法
val | var 对象名 [：类型] = new 类型()
  1. val 修饰对象，不能改变对象的引用（即：内存地址），可以改变对象属性的值。
  2. var 修饰对象，可以修改对象的引用和修改对象的属性值
  3. 自动推导变量类型不能多态，所以多态需要显示声明
  4. 案例
class Person {
  var name: String = "canglaoshi"
}
object Person {
  def main(args: Array[String]): Unit = {
    //val 修饰对象，不能改变对象的引用（即：内存地址），可以改变对象属 性的值。
    val person = new Person()
    person.name = "bobo"
    // person = new Person()// 错误的
    println(person.name)
  }
}

2.5 构造器

  1. Scala 类的构造器包括：主构造器和辅助构造器
  2. 语法
class 类名(形参列表) { // 主构造器
 // 类体
 def this(形参列表) { // 辅助构造器
 }
 def this(形参列表) { //辅助构造器可以有多个...
 }
}
  1. 辅助构造器，函数的名称 this，可以有多个，编译器通过参数的个数及类型来区分。
  2. 辅助构造方法不能直接构建对象，必须直接或者间接调用主构造方法。
  3. 构造器调用其他另外的构造器，要求被调用构造器必须提前声明。
  4. 如果主构造器无参数，小括号可省略，构建对象时调用的构造方法的小括号也可 以省略。
  5. 案例
class Person {
  var name: String = _
  var age: Int = _

  def this(age: Int) {
    this()
    this.age = age
    println("辅助构造器")
  }

  def this(age: Int, name: String) {
    this(age)
    this.name = name
  }

  println("主构造器")
}

object Person {
  def main(args: Array[String]): Unit = {
    val person2 = new Person(18)
  }
}

2.6 构造器参数

  Scala 类的主构造器函数的形参包括三种类型：未用任何修饰、var 修饰、val 修饰

  1. 未用任何修饰符修饰，这个参数就是一个局部变量
  2. var 修饰参数，作为类的成员属性使用，可以修改
  3. val 修饰参数，作为类只读属性使用，不能修改
class Person(name: String, var age: Int, val sex: String) {
}
object Test {
  def main(args: Array[String]): Unit = {
    var person = new Person("bobo", 18, "男")
    // （1）未用任何修饰符修饰，这个参数就是一个局部变量
     //printf(person.name)
    // （2）var 修饰参数，作为类的成员属性使用，可以修改
    person.age = 19
    println(person.age)
    // （3）val 修饰参数，作为类的只读属性使用，不能修改
    // person.sex = "女"
    println(person.sex)
  }
}

3 封装

  封装就是把抽象出的数据和对数据的操作封装在一起，数据被保护在内部，程序的其它 部分只有通过被授权的操作（成员方法），才能对数据进行操作。
  Scala 中的 public 属性，底层实际为 private，并通过 get 方法（obj.field()）和 set 方法 （obj.field_=(value)）对其进行操作。所以 Scala 并不推荐将属性设为 private，再为其设置 public 的 get 和 set 方法的做法。但由于很多 Java 框架都利用反射调用 getXXX 和 setXXX 方 法，有时候为了和这些框架兼容，也会为 Scala 的属性设置 getXXX 和 setXXX 方法（通过 @BeanProperty 注解实现）。

4 继承&多态

  1. 语法
class 子类名 extends 父类名 { 类体 }
  1. 子类继承父类的属性和方法
  2. scala 是单继承
  3. 继承的调用顺序：父类构造器->子类构造器
class Person(nameParam: String) {
  var name = nameParam
  var age: Int = _

  def this(nameParam: String, ageParam: Int) {
    this(nameParam)
    this.age = ageParam
    println("父类辅助构造器")
  }

  println("父类主构造器")
}

class Emp(nameParam: String, ageParam: Int) extends
  Person(nameParam, ageParam) {
  var empNo: Int = _

  def this(nameParam: String, ageParam: Int, empNoParam: Int) {
    this(nameParam, ageParam)
    this.empNo = empNoParam
    println("子类的辅助构造器")
  }

  println("子类主构造器")
}

object Person{
  def main(args: Array[String]): Unit = {
    new Emp("z3", 11, 1001)
  }
}

在这里插入图片描述
5. 动态绑定：Scala 中属性和方法都是动态绑定，而 Java 中只有方法为动态绑定。

class Person {
  val name: String = "person"
  def hello(): Unit = {
    println("hello person")
  }
}
class Teacher extends Person {
  override val name: String = "teacher"
  override def hello(): Unit = {
    println("hello teacher")
  }
}
object Test {
  def main(args: Array[String]): Unit = {
    val teacher: Teacher = new Teacher()
    println(teacher.name)
    teacher.hello()
    println("----------------------------------------")
    val teacher1:Person = new Teacher
    println(teacher1.name)
    teacher1.hello()
  }
}

在这里插入图片描述

5 抽象类

5.1 语法

  1. 定义抽象类
abstract class Person{} //通过 abstract 关键字标记抽象类
  1. 定义抽象属性
val|var name:String //一个属性没有初始化，就是抽象属性
  1. 定义抽象方法
def hello():String //只声明而没有实现的方法，就是抽象方法

abstract class Person {
  val name: String
  def hello(): Unit
}
class Teacher extends Person {
  val name: String = "teacher"
  def hello(): Unit = {
    println("hello teacher")
  }
}

5.2 继承&重写

  1. 如果父类为抽象类，那么子类需要将抽象的属性和方法实现，否则子类也需声明为抽象类
  2. 重写非抽象方法需要用 override 修饰，重写抽象方法则可以不加 override。
  3. 子类中调用父类的方法使用 super 关键字
  4. 子类对抽象属性进行实现，父类抽象属性可以用 var 修饰；子类对非抽象属性重写，父类非抽象属性只支持 val 类型，而不支持 var。因为 var 修饰的为可变变量，子类继承之后就可以直接使用，没有必要重写

5.3 匿名子类

  和 Java 一样，可以通过包含带有定义或重写的代码块的方式创建一个匿名的子类。

abstract class Person {
  val name: String
  def hello(): Unit
}
object Test {
  def main(args: Array[String]): Unit = {
    val person = new Person {
      override val name: String = "teacher"
      override def hello(): Unit = println("hello teacher")
    }
  }
}

6 单例对象（伴生对象）

6.1 概述

  Scala语言是完全面向对象的语言，所以并没有静态的操作（即在Scala中没有静态的概 念）。但是为了能够和Java语言交互（因为Java中有静态概念），就产生了一种特殊的对象 来模拟类对象，该对象为单例对象。若单例对象名与类名一致，则称该单例对象这个类的伴生对象，这个类的所有“静态”内容都可以放置在它的伴生对象中声明

6.2 语法

object Person{ val country:String="China" }
  1. 单例对象采用 object 关键字声明
  2. 单例对象对应的类称之为伴生类，伴生对象的名称应该和伴生类名一致。
  3. 单例对象中的属性和方法都可以通过伴生对象名（类名）直接调用访问。
//（1）伴生对象采用 object 关键字声明
object Person {
  var country: String = "China"
}
//（2）伴生对象对应的类称之为伴生类，伴生对象的名称应该和伴生类名一致。
class Person {
  var name: String = "bobo"
}
object Test {
  def main(args: Array[String]): Unit = {
    //（3）伴生对象中的属性和方法都可以通过伴生对象名（类名）直接调用访 问。
    println(Person.country)
  }
}

6.3 apply 方法

  1. 通过伴生对象的 apply 方法，实现不使用 new 方法创建对象。
  2. 如果想让主构造器变成私有的，可以在()之前加上 private。
  3. apply 方法可以重载。
  4. Scala 中 obj(arg)的语句实际是在调用该对象的 apply 方法，即 obj.apply(arg)。用以统一面向对象编程和函数式编程的风格。
  5. 当使用 new 关键字构建对象时，调用的其实是类的构造方法，当直接使用类名构建对象时，调用的其实时伴生对象的 apply 方法
object Test {
  def main(args: Array[String]): Unit = {
    //（1）通过伴生对象的 apply 方法，实现不使用 new 关键字创建对象。
    val p1 = Person()
    println("p1.name=" + p1.name)
    val p2 = Person("bobo")
    println("p2.name=" + p2.name)
  }
}
//（2）如果想让主构造器变成私有的，可以在()之前加上 private
class Person private(cName: String) {
  var name: String = cName
}
object Person {
  def apply(): Person = {
    println("apply 空参被调用")
    new Person("xx")
  }
  def apply(name: String): Person = {
    println("apply 有参被调用")
    new Person(name)
  }
}

7 特质

7.1 概述

   Scala 语言中，采用特质 trait（特征）来代替接口的概念，也就是说，多个类具有相同的特质（特征）时，就可以将这个特质（特征）独立出来，采用关键字 trait 声明。
  Scala 中的 trait 中即可以有抽象属性和方法，也可以有具体的属性和方法，一个类可以混入（mixin）多个特质。这种感觉类似于 Java 中的抽象类。
  Scala 引入 trait 特征，第一可以替代 Java 的接口，第二个也是对单继承机制的一种补充。

7.2 语法&说明

  1. 声明
trait 特质名 { 
    trait 主体 
} 

trait PersonTrait {
  // 声明属性
  var name:String = _
  // 声明方法
  def eat():Unit={
  }
  // 抽象属性
  var age:Int

  // 抽象方法
  def say():Unit
}
  1. 一个类具有某种特质（特征），就意味着这个类满足了这个特质（特征）的所有要素， 所以在使用时，也采用了 extends 关键字，如果有多个特质或存在父类，那么需要采用 with 关键字连接。
  2. 类和特质的关系：使用继承的关系。
  3. 当一个类去继承特质时，第一个连接词是 extends，后面是 with。
  4. 如果一个类在同时继承特质和父类时，应当把父类写在 extends 后。
没有父类：class 类名 extends 特质 1 with 特质 2 with 特质 3 …
有父类：class 类名 extends 父类 with 特质 1 with 特质 2 with 特质 3…
  1. 特质可以同时拥有抽象方法和具体方法
  2. 一个类可以混入（mixin）多个特质
  3. 所有的 Java 接口都可以当做 Scala 特质使用
  4. 动态混入：可灵活的扩展类的功能
    动态混入：创建对象时混入 trait，而无需使类混入该 trait
    如果混入的 trait 中有未实现的方法，则需要实现
package com.scala
package chapter07

trait PersonTrait {

  //（1）特质可以同时拥有抽象方法和具体方法
  // 声明属性
  var name: String = _
  // 抽象属性
  var age: Int

  // 声明方法
  def eat(): Unit = {
    println("eat")
  }
  // 抽象方法
  def say(): Unit
}
trait SexTrait {
  var sex: String
}

//（2）一个类可以实现/继承多个特质
//（3）所有的 Java 接口都可以当做 Scala 特质使用
class Teacher extends PersonTrait with java.io.Serializable {
  override def say(): Unit = {
    println("say")
  }
  override var age: Int = _
}
object TestTrait {
  def main(args: Array[String]): Unit = {
    val teacher = new Teacher
    teacher.say()
    teacher.eat()
    //（4）动态混入：可灵活的扩展类的功能
    val t2 = new Teacher with SexTrait {
      override var sex: String = "男"
    }
    //调用混入 trait 的属性
    println(t2.sex)
  }
}

7.3 特质叠加

  由于一个类可以混入（mixin）多个 trait，且 trait 中可以有具体的属性和方法，若混入的特质中具有相同的方法（方法名，参数列表，返回值均相同），必然会出现继承冲突问题。冲突分为以下两种

  1. 一个类（Sub）混入的两个 trait（TraitA，TraitB）中具有相同的具体方法，且两个 trait 之间没有任何关系，解决这类冲突问题，直接在类（Sub）中重写冲突方法。
    在这里插入图片描述

  2. 一个类（Sub）混入的两个 trait（TraitA，TraitB）中具有相同的具体方法，且两个 trait 继承自相同的 trait（TraitC），及所谓的“钻石问题”，解决这类冲突问题，Scala采用了特质叠加的策略。
    在这里插入图片描述
    所谓的特质叠加，就是将混入的多个 trait 中的冲突方法叠加起来

7.4 特质叠加执行顺序

package com.scala
package chapter07

trait Ball {
  def describe(): String = {
    "ball"
  }
}

trait Color extends Ball {
  override def describe(): String = {
    "blue-" + super.describe()
  }
}

trait Category extends Ball {
  override def describe(): String = {
    "foot-" + super.describe()
  }
}

class MyBall extends Category with Color {
  override def describe(): String = {
    "my ball is a " + super.describe()
  }
}

object TestTrait1 {
  def main(args: Array[String]): Unit = {
    println(new MyBall().describe())
  }
}
  1. 当一个类混入多个特质的时候，scala 会对所有的特质及其父特质按照一定的顺序进行 排序，而此案例中的 super.describe()调用的实际上是排好序后的下一个特质中的 describe() 方法。
  2. 叠加规则：
    在这里插入图片描述
  3. 案例中的 super，不是表示其父特质对象，而是表示上述叠加顺序中的下一个特质， 即，MyClass 中的 super 指代 Color，Color 中的 super 指代 Category，Category 中的 super 指代 Ball。
  4. ）如果想要调用某个指定的混入特质中的方法，可以增加约束：super[]，例如super[Category].describe()。

7.5 特质喝抽象类的区别

  1. 优先使用特质。一个类扩展多个特质是很方便的，但却只能扩展一个抽象类。
  2. 如果你需要构造函数参数，使用抽象类。因为抽象类可以定义带参数的构造函数， 而特质不行（有无参构造）。

8 扩展

8.1 类型检查和转换

  1. obj.isInstanceOf[T]：判断 obj 是不是 T 类型。
  2. obj.asInstanceOf[T]：将 obj 强转成 T 类型。
  3. classOf 获取对象的类名。
package com.scala
package chapter07

class Person {
}

object Person {
  def main(args: Array[String]): Unit = {
    val person = new Person
    //（1）判断对象是否为某个类型的实例
    val bool: Boolean = person.isInstanceOf[Person]
    if (bool) {
      //（2）将对象转换为某个类型的实例
      val p1: Person = person.asInstanceOf[Person]
      println(p1)
    }
    //（3）获取类的信息
    val pClass: Class[Person] = classOf[Person]
    println(pClass)
  }
}

8.2 枚举类和应用类

  1. 枚举类：需要继承 Enumeration
  2. 应用类：需要继承 App
package com.scala
package chapter07


object Test {
  def main(args: Array[String]): Unit = {
    println(Color1.YELLOW)
  }
}

// 枚举类
object Color1 extends Enumeration {
  val RED = Value(1, "red")
  val YELLOW = Value(2, "yellow")
  val BLUE = Value(3, "blue")
}
// 应用类
object Test20 extends App {
  println("xxxxxxxxxxx");
}

8.3 Type 定义新类型

  使用 type 关键字可以定义新的数据数据类型名称，本质上就是类型的一个别名

object Test {
  def main(args: Array[String]): Unit = {

    type S=String
    var v:S="abc"
    def test():S="xyz"
  }
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/321840.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

【极光系列】springBoot集成xxl-job调度器

【极光系列】springBoot集成xxl-job调度器

【springboot集成xxl-job】 一.gitee地址 直接下载可用 https://gitee.com/shawsongyue/aurora.git 模块：aurora_xxl_job 二.mysql安装教程 参考我的另一篇文章：https://blog.csdn.net/weixin_40736233/article/details/135582926?spm1001.2014.30…
阅读更多...
手写netty通信框架以及常见问题

手写netty通信框架以及常见问题

目录 通信框架设计 实现功能点 通信模型 消息定义 可靠性设计 代码 服务端代码 常见netty问题 如何让netty支持百万长连接? 1. 操作系统层面优化 2. netty层面优化 2.1 设置合理线程 2.2 心跳优化 2.3 合理使用内存池 2.4 IO线程与业务线程剥离 3. JVM层面优化 …
阅读更多...
WinSCP传文件到Ubuntu提示Permission denied

WinSCP传文件到Ubuntu提示Permission denied

使用WinSCP传文件到一台Ubuntu服务器时，提示Permission denied。 客户端：Windows 10 服务器：hyper-V虚拟机 Ubuntu 20.04 WinSCP版本：WinSCP 6.1 文章目录 WinSCP工具介绍WinSCP开源免费WinSCP优点 Permission denied 解决方法scp…
阅读更多...
QA Office and Security Room

QA Office and Security Room

QA办公室和安全室是一个完全模块化的套件，有450多个对象，可以让你用任意数量的楼层构建自己的办公楼内部。 支持内置URP。 这个包的演示场景包含许多不同的房间，如接待大厅、办公室、主任室和秘书室、会议厅、卫生间、储藏室、保安室、地下停车场的出口。此外，这个包还包括…
阅读更多...
Prepar3D多屏合成失败全屏显示失败

Prepar3D多屏合成失败全屏显示失败

P3D需要设置全屏显示，详细设置参考P3D全屏设置中的方法。 一、排查硬件问题 包括屏幕数据链接线等。 二、没有启用Surround （1）查看是否启用了Surround方法 打开 NVIDIA 控制面板,通常可以在桌面上右键单击并选择相应的选项。在显卡控制…
阅读更多...
MySQL——性能优化与关系型数据库

MySQL——性能优化与关系型数据库

文章目录 什么是性能？什么是关系型数据库？数据库设计范式 常见的数据库SQL语言结构化查询语言的六个部分版本 MySQL数据库故事历史版本5.6/5.7差异5.7/8.0差异 什么是性能？ 吞吐与延迟：有些结论是反直觉的，指导我们关…
阅读更多...
Hive基础知识（十五）：Hive中SQL排序方式全解

Hive基础知识（十五）：Hive中SQL排序方式全解

1. 全局排序（Order By） Order By：全局排序，只有一个 Reducer 1）使用 ORDER BY 子句排序 ASC（ascend）: 升序（默认） DESC（descend）: 降序 2&#…
阅读更多...
【题解】—— 每日一道题目栏

【题解】—— 每日一道题目栏

2024.1 【题解】—— LeetCode一周小结1 1. 1599. 经营摩天轮的最大利润 2. 466. 统计重复个数 3. 2487. 从链表中移除节点 4. 2397. 被列覆盖的最多行数 5. 1944. 队列中可以看到的人数 6. 2807. 在链表中插入最大公约数 7. 383. 赎金信 【题解】—— LeetCode一周小…
阅读更多...
爬虫入门学习（二）——response对象

爬虫入门学习（二）——response对象

大家好！我是码银，代码的码，银子的银🥰 欢迎关注🥰： CSDN：码银 公众号：码银学编程 前言 在本篇文章，我们继续讨论request模块。从上一节（爬虫学习(1)--reque…
阅读更多...
CTF伪随机数爆破

CTF伪随机数爆破

要了解伪随机数的爆破首先你的先知道什么是PHP种子， 借用在rand()函数中，我们可以通过设置随机数种子来影响随机数的生成。例如，在rand()函数中加入了随机数种子编码后，每次运行程序将会生成同样的随机整数序列。这个就是伪随机数…
阅读更多...
Vue报错 Cannot find module ‘../../modules/es6.symbol‘解决办法

Vue报错 Cannot find module ‘../../modules/es6.symbol‘解决办法

在进行webpack打包的时候，会出现Cannot find module XXX’的错误，找不到某个模块的错误，今天给出解决方法： 直接进行npm install重新打包；如果npm install重新打包之后，仍然出现这个问题，可以进…
阅读更多...
网站建设网络设计营销类网站eyouCMS模板(PC+WAP)

网站建设网络设计营销类网站eyouCMS模板(PC+WAP)

模板介绍： 本模板自带eyoucms内核，无需再下载eyou系统，原创设计、手工书写DIVCSS，完美兼容IE7、Firefox、Chrome、360浏览器等；主流浏览器；结构容易优化；多终端均可正常预览。
阅读更多...
我为什么要写RocketMQ消息中间件实战派上下册这本书？

我为什么要写RocketMQ消息中间件实战派上下册这本书？

我与RocketMQ结识于2018年，那个时候RocketMQ还不是Apache的顶级项目，并且我还在自己的公司做过RocketMQ的技术分享，并且它的布道和推广，还是在之前的首席架构师的带领下去做的，并且之前有一个技术神经质的人&#xff0…
阅读更多...
Softmax回归（多类分类模型）

Softmax回归（多类分类模型）

目录 1.对真实值类别编码：2.预测值：3.目标函数要求：4.使用Softmax模型将输出置信度Oi计算转换为输出匹配概率y^i：5.使用交叉熵作为损失函数：6.代码实现： 1.对真实值类别编码： y为真实值&#xf…
阅读更多...
实战指南：如何在Spring Boot中无缝整合Dubbo【四】

实战指南：如何在Spring Boot中无缝整合Dubbo【四】

欢迎来到我的博客，代码的世界里，每一行都是一个故事 实战指南：如何在Spring Boot中无缝整合Dubbo【四】 前言项目结构主项目(作为主pom)接口服务提供者properties文件实现类 服务消费者properties接口层 实现效果图 前言 微服务架构已经成为…
阅读更多...
前端开发必备：掌握正则表达式，轻松应对复杂的表单验证

前端开发必备：掌握正则表达式，轻松应对复杂的表单验证

前言 在前端开发中，经常需要处理 URL 地址、校验手机号合法性、提取域名等。正则表达式是一种常用的工具。通过使用正则表达式，我们可以对用户输入进行有效的验证，确保数据的合法性和完整性。本文将介绍一些常见的正则表达式，帮助…
阅读更多...
Meproc：简单高效的跨平台进程/任务管理工具

Meproc：简单高效的跨平台进程/任务管理工具

最近使用 Melang 语言写了一个 supervisor 相似服务Meproc来管理进程。 Meproc 有如下特性： 使用 HTTP API 管理控制 Meproc 来管理进程跨平台，支持 UNIX/Linux 、Mac 、Windows 等平台支持 cron 类定时调度任务支持简单的任务间依赖关系支持原生的协…
阅读更多...
如何打赢稳定性之战?

如何打赢稳定性之战?

文章目录 前言为什么总会出现问题呢？如何证明你的稳定性做的有效果？既是持久战，也是防御战1. 提前建筑好防御工事2. 以攻为守3. 找外部支援和配合 前言 随着23年年末期间，各大厂争先恐后的出现的各种线上故障，一时间“…
阅读更多...
highlight.js 实现搜索关键词高亮效果 ,显示匹配数量及切换显示功能

highlight.js 实现搜索关键词高亮效果 ,显示匹配数量及切换显示功能

先看效果&#xff1a; 更新&#xff1a;增加切换显示 折腾了老半天&#xff0c;记录一下 注意事项都写注释了 代码&#xff1a; <template><div class"absolute-lt wh-full overflow-hidden p-10"><div style"width: 200px"><el-…
阅读更多...
学网络必懂的华为CSS堆叠技术

学网络必懂的华为CSS堆叠技术

知识改变命运&#xff0c;技术就是要分享&#xff0c;有问题随时联系&#xff0c;免费答疑&#xff0c;欢迎联系&#xff01; 厦门微思网络​​​​​​https://www.xmws.cn 华为认证\华为HCIA-Datacom\华为HCIP-Datacom\华为HCIE-Datacom Linux\RHCE\RHCE 9.0\RHCA\ Oracle OC…
阅读更多...
最新文章

Copyright @ 2022~2023