Scala 02——Scala OOP

在这里插入图片描述
在这里插入图片描述

文章目录

  • Scala 02——Scala OOP
      • 前序
      • 类
          • 1. 类的基本结构
          • 2. 普通类和数据类的区别
      • 继承
          • 1. extends
          • 2. override
      • 抽象类
          • 抽象类的特点
      • 单例对象
          • 1. 定义
          • 2. 场景
          • 3. 方法
            • 3.1 方法定义
            • 3.2 方法调用
      • 特质
          • 1. 抽象类和特质的区别
          • 2. 强制混入语法
          • 3. 静态混入和动态混入
      • 内部类
          • Java和Scala内部类的区别
          • 当类与对象存在伴生关系时，类的写法
            • 内部类定义在实例中（①）:
            • 内部类定义在伴生对象中（②）:
      • 样例类
      • 枚举
          • 定义
      • 泛型
          • 1. 定义
          • 2. 泛型边界
          • 3. 协变、逆变、不变
      • 包与包对象
          • 1. 命名规则：
          • 2. 包的作用
          • 3. 导包的不同方式
          • 4. 多级包的导包
          • 5. 包对象
            • 5.1 定义
            • 5.2 包对象的意义

Scala 02——Scala OOP

前序

为什么说Scala是纯粹的OOP？

  • 不支持基本类型，一切皆为对象：Byte,Int…

    • Scala会将基本类型视为对象，还是在JVM上运行，自动与Java的基本数据类型完成拆装箱的操作。

  • 不支持静态关键字：static

    • Java和Scala的静态概念的区别

      • Java
        • Java的静态成员：在Java中，静态成员(属性或方法)是指属于类本身而非类的实例的成员，静态成员可以在没有创建类的实例的情况下被访问。
      • Scala
        • Scala的静态类型系统：Scala被称为静态语言，与其属性和方法是否属于对象无关，是因为在Scala中，所有的类型检查都是在编译时完成的，而非运行时。
        • Scala的单例对象：为了提供类似于Java中静态成员的功能，Scala引入了单例对象。

    • 编译时检查和运行时检查的区别

      • 编译时检查：在程序运行之前发现错误【Java Mysql Scala…】
        • 类型检查
        • 语法检查
        • 结构检查
        • 访问规则检查
      • 运行时检查：在运行时检查，通常由执行环境执行(如虚拟机或解释器)【解释型语言 或 脚本…】

    • 静态和动态的区别

      • 静态是编译时检查，动态是运行时检查

      • expression = "3 * 7 + 2"
result = eval(expression)
print(result)  # 输出 23

        对于静态语言来说，expression的结果是一个内容是表达式的字符串。

        而对于动态语言来说(以Python的eval()函数为例)，eval() 函数允许执行一个字符串形式的表达式，并返回表达式的结果。是因为在运行前没有进行类型检查，编译器视其为表达式而非文本。

  • 支持类型推断，类型预定，动静结合

    • 动静结合

    • 类型预定

      • 在运行时保留类型信息

    • 类型推断

      • 泛型编程中的不变、协变、逆变

        • 泛型类型

          • 定义

            1. 容器类

              • 列表，如List[T]
              • 集合，如Set[T]
              • 映射，如Map<K,V>

            2. 函数和方法

              def func[T](x:T):t = x

        • 不变

          • 定义

            泛型类型 G[A] 和泛型类型 G[B] 的关系与类型 A 和类型 B的关系无关。

        • 协变

          • 定义

            如果类型 A 是类型 B 的子类型，泛型类型 G[A] 是泛型类型 G[B] 的子类型。

            假设我们有一个泛型类Container[+A]，其中A是一个协变类型参数。如果Dog是Animal的子类，那么Container[Dog]也应该被看作是Container[Animal]的子类型。这意味着你可以用Container[Dog]的实例去替换Container[Animal]的实例。

          class Animal
class Dog extends Animal

class Container[+A]

val dogs: Container[Dog] = new Container[Dog]
val animals: Container[Animal] = dogs // 正确，因为Container是协变的

          • 适用场景

            作为输出，可以安全地从Container[Animal]中读取Animal类型的对象，不管容器实际包含的是Dog还是哪种Animal的子类型。

        • 逆变

          • 定义

            如果类型 A 是类型 B 的子类型，泛型类型 G[B] 是泛型类型 G[A] 的子类型。

            假设我们有一个泛型类Container[-A]，其中A是一个逆变类型参数。如果Dog是Animal的子类，那么Container[Animal]应该被看作是Container[Dog]的子类型。这意味着你可以用Container[Animal]的实例去替换Container[Dog]的实例。

            class Animal
class Dog extends Animal

class Printer[-A] {
  def print(value: A): Unit = println(value)
}

val animalPrinter: Printer[Animal] = new Printer[Animal]
val dogPrinter: Printer[Dog] = animalPrinter // 正确，因为Printer是逆变的

          • 适用场景

            方法是通用的，面向各种不同类型，可以用更宽泛的类型实例替代更具体的类型实例。

在这里插入图片描述

类

1. 类的基本结构

类的本质就是模板，我们根据以下代码模板学习Scala类的基本结构：

  • 主构造器(构造参数)
  • 属性
  • 方法
  • 辅助构造器
  • 重写方法
    • toString的重写接近于JSON的表达方式
// 主构造器：类自身
class Point(x:Int,y:Int){ // 没有构造方法，通过构造参数列表实现对象创建
  // 属性：必须赋初值，且赋的是主构造器的参数
  private var _x:Int = x // 私有属性的命名方式通常为`{_参数}`
  private var _y:Int = y
  
  // 方法
  def updatePoint(x:Int,y:Int): Unit = {
    _x = x
    _y = y
   }
  
  // 辅助构造器
  // 辅助构造器必须调用主构造器
  // 辅助构造器中有两个this，第一个this是辅助构造器的名称，第二个this是调用主构造器。
  def this() = this(-1,-1)
  
  // getter 和 setter 方法
  def getX=_x
  def getY=_y

  def setX(x:Int)={
    _x=x
   }
  def setY(y:Int)={
    _y=y
   }  
  
  // 重写方法
  override def toString: String = {
    s"(X:${_x},Y:${_y})"
   }
}
修饰符类(class)伴生对象(object)子类(subclass)同包(package)全局(world)
default(public)YYYYY
protectedYYYNN
privateYYNNN
2. 普通类和数据类的区别

  • 普通类：可以有主构造器，也可以有辅助构造器，可以有属性，可以有方法，可以有重写方法，可以有get、set方法

  • 数据类：只能有主构造器，不能有辅助构造器，只能有属性，不能有方法，不能有重写方法，不能有get、set方法

继承

1. extends
class ColorPoint(x:Int,y:Int,color:Boolean) extends Point(x:Int,y:Int) {
  var _color:Boolean = color

  private def getColor = if(_color) "red" else "black"

  override def move(offsetX: Int, offsetY: Int): Unit = {
    _x += offsetX*2
    _y += offsetY*2
    println(s"$getColor point moved to {${_x},${_y}}")
  }

  override def toString: String = s"$getColor point ${super.toString}"
}

val cp = new ColorPoint(0,0,true)
println(cp)
cp.move(12,25)
2. override

在重写方法时：

  • 子类重写父类抽象方法推荐添加override关键字
  • 子类重写父类非抽象方法必须添加override关键字

抽象类

abstract class Shape {
  // 抽象方法
  def draw()

  // 普通方法
  def show:Unit = println("this is Shape")
}
抽象类的特点
  • 可以有抽象方法(Scala中没有方法体即为没有=号及=号后面的部分)
  • 无法被实例化
  • 使用abstract关键字修饰

单例对象

1. 定义

  • 关键字：object

  • 单例对象用于管理共享资源或共通逻辑，封装静态工具方法，提供了便携创建其他实例的工厂方法

  • 可以直接通过单例对象名.属性或方法来访问，类同于Java的静态属性和方法

  • 采取惰性模式，第一次被访问时被创建

  • main方法必须定义在单例对象中，才能被JVM识别

  • 同名的类和单例对象形成绑定关系，并称之为伴生类和伴生对象

    • 伴生类和其伴生对象可以相互访问对方的私有成员(包括私有方法或私有变量)
object Util{
  var PI:Float = 3.14f
  var count:Int = 0

  def resume:Unit = println("this is my resume.")
}

// 调用
Util.resume

class Commodity(sku:String,price:Float) {
  private val _sku:String = sku
  private val _price:Float = price

  def getSKU:String={
    _sku
  }
  def getPrice:Float={
    discount(_price)
  }
  // 伴生类自由访问伴生对象中的所有变量
  def getSalePrice=discount(_price)

  override def toString:String={
    s"SKU:${_sku},PRICE:${_price}"
  }
}
object Commodity{
  // 商品折扣
  private var _discount:Float = 1.0f
  // 包裹
  def apply(sku:String,price:Float):Commodity = new Commodity(sku,price)
  // 拆解：伴生对象中可以自由访问伴生类中所有资源
  def unapply(arg:Commodity):(String,Float) = (arg.getSKU,arg.getPrice)
  // 自定义方法
  def setDiscount(discount:Float)=_discount=discount
  def discount(price:Float)=price*_discount
}
2. 场景

工具类

3. 方法
3.1 方法定义

apply 方法

def apply(sku:String,price:Float):Commodity = new Commodity(sku,price)

unapply 方法

def unapply(arg:Commodity):(String,Float) = (arg.getSKU,arg.getPrice)
3.2 方法调用
object Person {
  // apply方法允许不使用new关键字就能创建Person实例
  def apply(name: String, age: Int): Person = new Person(name, age)

  // unapply方法支持模式匹配，提取Person对象的属性
  def unapply(p: Person): Option[(String, Int)] = {
    if (p != null)
      Some((p.name, p.age))
    else
      None
  }
}

// 使用apply方法隐式创建Person对象
val alice = Person("Alice", 25)  // 实际调用 Person.apply("Alice", 25)

// 使用模式匹配，其中unapply方法被隐式调用
alice match {
  case Person(n, a) if a >= 18 => println(s"$n is an adult, aged $a.")
  case Person(n, _) => println(s"$n is a minor.")
}

特质

1. 抽象类和特质的区别

  • 抽象类可以传构造参数，而特质不能传构造参数;抽象类可以有构造代码(抽象属性结合参数的构造)，而特质没有构造代码。

  • 一个类可以继承多个特质但只能继承一个抽象类。

  • 抽象类针对的是高复用性的功能，而特质更多是针对定制化的功能。

  • 抽象类可以提供方法的默认实现，减少了子类重复相同代码的需要。

2. 强制混入语法

定义：要求其子类必须重写这个特质的方法，并允许在基类中使用特质的方法

abstract class Animal(brand:String){
  var name:String
  val _type:String = brand
  def roar:Unit
  def me = s"${_type}:$name"
}
trait ByFoot {
  def walk()
  def run()
}
trait ByFly{
  def fly()
}
trait BySwim{
  def swim()
}
class Cat(nickname:String) extends Animal("猫") with ByFoot {
  override var name: String = nickname
  override def roar: Unit = println(me+"喵喵喵")
  override def walk: Unit = println(me+"悠闲地漫步")
  override def run: Unit = println(me+"正在快速跑")
}

class Bird(nickname:String) extends Animal("鸟") with ByFly with ByFoot {
  override var name: String = nickname
  override def roar: Unit = println(me+"叽叽叽")
  override def fly(): Unit = println(me+"正在飞")
  override def walk(): Unit = println(me+"正在闲逛")
  override def run(): Unit = println(me+"正在快速跑")
}

class Fish() extends Animal("鱼"){
  self:BySwim=> // 等同于 this:BySwim=>
  override var name: String = _
  override def roar: Unit = ???
}
3. 静态混入和动态混入

静态混入和动态混入的核心区别：

  • 静态混入：在创建对象之前，就混入特质(该类事物的通用特征)
  • 动态混入：在创建对象之后，再混入特质(特殊事物的特殊特征)
// 静态混入
val bird = new Bird("小雀")
bird.run()
bird.fly()
bird.walk()
bird.roar

// 动态混入
val fish3 = new Fish() with BySwim with ByFoot {
	override def swim(): Unit = ...
	override def walk(): Unit = ...
	override def run(): Unit = ...
}

内部类

Java和Scala内部类的区别
  • Java中内部类是【外部类的成员】
InClass ic = new OutClass.InClass()
  • Scala中内部类是【外部类对象的成员】
val oc = new OutClass();
val ic = new oc.InClass();
当类与对象存在伴生关系时，类的写法
class OutClass {
  // ①
  /*class InClass{
    override def toString: String = "InClass"
  }*/
  private val in:InClass = new InClass
  override def toString: String = s"OutClass{${in}}"
}
object OutClass{
  // ②
  /*class InClass{
    override def toString: String = "InClass"
  }*/
}
内部类定义在实例中（①）:

这意味着InClass与OutClass的一个具体实例关联。

val oc = new OutClass
println(oc)
val ic: oc.InClass = new oc.InClass()
内部类定义在伴生对象中（②）:

这里的OutClass.InClass是一个整体，伴生对象能够通过伴生对象名称直接获取内部的属性或方法。

val oi: OutClass.InClass = new OutClass.InClass

样例类

/*
	描述【不可变值】的对象
	样例类构造参数默认声明为 val，自动生成 getter
	样例类的构造参数若声明为 var，自动生成 getter & setter
	样例类自动生成伴生对象
	样例类自动实现的其他方法：toString,copy,equals,hashCode
	样例类伴生对象实现的方法：apply, unapply(用于模式匹配)
*/
// 普通类的模式匹配案例
case class Student(name:String, age:Int)	// 构造参数默认 val
case class Point(var x:Int,var y:Int)		// var 需要显式声明

枚举

定义

单例对象通过继承Enumeration实现枚举创建，通常用于定义一个有限取值范围的常量。

class EnumTest {
  object WeekDay extends Enumeration {
    val MON = Value(0)
    val TUE = Value(1)
    val WEN = Value(2)
    val THU = Value(3)
    val FRI = Value(4)
    val SAT = Value(5)
    val SUN = Value(6)
  }
  
  val d = WeekDay.THU
  val info: String = d match {
    case WeekDay.MON => "Monday"
    case WeekDay.TUE => "Tuesday"
    case WeekDay.WEN => "Wednesday"
    case WeekDay.THU => "Thursday"
    case WeekDay.FRI => "Friday"
    case WeekDay.SAT => "Saturday"
    case WeekDay.SUN => "Sunday"
  }
}

泛型

1. 定义

类型参数化，主要用于集合。

不同于 Java 泛型被定义在 [] 中，Scala泛型更为自由

// 也可以定义在可变参数中
class MyArray[T](items:T*) {
  def join(sep:String) = items.mkString(sep)
}
2. 泛型边界

  • [T<:F] 表示 T 必须是F的子类

  • [T>:F] 表示 T 必须是F的父类

class F
class S extends F


class Many[T<:F] (t:T){
  ...
}
3. 协变、逆变、不变
  • 协变：[+T] 若A是B的子类，则 C[A]为C[B]的子类
  • 逆变：[-T] 若A是B的子类，则 C[B]为C[A]的子类
  • 不变：[T] 默认

包与包对象

1. 命名规则：

可以以字母数字下划线点开头，不能以数字开头

2. 包的作用
  • 命名空间管理：每个包提供了一个独立的命名空间
  • 作用域控制：包允许细粒度的访问控制
  • 逻辑分隔：将功能相似的类和对象放在同一个包中，使代码结构更清晰
3. 导包的不同方式
  • import导包语句可以出现在任何地方
  • import可以导入包、类、类成员
import com.kgc.Person				// 方便使用类 Person
import com.kgc._					 // 方便使用 com.kgc 包中的所有类
import com.kgc.Person._			// 方便使用类 Person 中的所有属性和方法
import com.kgc.{Person=>PS,Book}	// 只导入包中 Person和Book，并将Person重命名为PS
4. 多级包的导包
package cha03{
  import cha03.util.Sorts
  object PackageTest {
    def main(args: Array[String]): Unit = {
      val array: Array[Int] = Array(3, 1, 5, 4, 2)
      Sorts.insertSort(array)
      array.foreach(println)
    }
  }
}

package cha03.util{
  object Sorts{
    def insertSort(array: Array[Int]): Unit ={
      import scala.util.control.Breaks._
      for(i<- 1 until array.length){
        val t = array(i)
        var j = i-1
        breakable({
          while (j>=0){
            if(array(j)>t){
              array(j+1) = array(j)
            }else{
              break()
            }
            j-=1
          }
        })
        array(j+1) = t
      }
    }
  }
}
5. 包对象
5.1 定义

包中可以包含：类、对象、特质…

包对象中可以包含：除了类、对象、特质外，还可以包含变量和方法

5.2 包对象的意义

常用的函数、常量和类型可以在包对象中定义，这允许在相同包的任何地方访问这些共享资源。

package cha03.util{
  import java.util.Calendar
  // 包对象
  package object Constants{
    // 变量
    val PI:Float = 3.14f
	// 方法
    def getQuarter(month:Int)=(month-1)/3+1
	// 类
    class DataFormat(
        year:Int,month:Int,day:Int,
        hour:Int,minute:Int,second:Int,
        millis:Int){
      private var _year:Int = year
      private var _month:Int = month
      private var _day:Int = day
      private var _hour:Int = hour
      private var _minute:Int = minute
      private var _second:Int = second
      private var _millis:Int = millis

      def this(year:Int,month:Int,day:Int){
        this(year,month,day,0,0,0,0)
      }

      def stdYMD():String = s"${_year}-${_month}-${_day}"
      def stdFull():String = s"${_year}-${_month}-${_day} ${_hour}:${_minute}:${_second}.${_millis}"
      def timestamp():Long = {
        val cld = Calendar.getInstance()
        cld.set(_year,_month,_day,_hour,_minute,_second)
        cld.set(Calendar.MILLISECOND,555)
        cld.getTimeInMillis
      }
    }
  }
  object DataFormat{
      def apply(year: Int, month: Int, day: Int, 
                hour: Int, minute: Int, second: Int, millis: Int): DataFormat 
      	= new DataFormat(year, month, day, hour, minute, second, millis)
      def apply(year: Int, month: Int, day: Int): DataFormat 
      	= new DataFormat(year, month, day)
  }
}

在这里插入图片描述

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

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

相关文章

EelasticSearch是什么？及EelasticSearch的安装

EelasticSearch是什么？及EelasticSearch的安装

一、概述 Elasticsearch 是一个基于 Apache Lucene 构建的开源分布式搜索引擎和分析引擎。它专为云计算环境设计&#xff0c;提供了一个分布式的、高可用的实时分析和搜索平台。Elasticsearch 可以处理大量数据&#xff0c;并且具备横向扩展能力&#xff0c;能够通过增加更多的…
阅读更多...
HarmonyOS Next 视频弹幕功能

HarmonyOS Next 视频弹幕功能

视频弹幕功能 介绍 本示例介绍如何使用ohos.danmakuflamemaster和ohos.gsyvideoplayer开发支持视频弹幕的播放器。可以自定义弹幕样式、占据屏幕宽度&#xff0c;发送弹幕&#xff0c;开关弹幕视图。 效果图预览 使用说明 点击播放按钮&#xff0c;进行视频播放&#xff0c…
阅读更多...
Windows版Apache 2.4.59解压直用（免安装-绿色-项目打包直接使用）

Windows版Apache 2.4.59解压直用（免安装-绿色-项目打包直接使用）

windows下Apache分类 Apache分为 安装版和解压版 安装版: 安装方便&#xff0c;下一步------下一步就OK了&#xff0c;但重装系统更换环境又要重新来一遍&#xff0c;会特别麻烦 解压版&#xff08;推荐&#xff09;&#xff1a; 这种方式&#xff08;项目打包特别方便&#x…
阅读更多...
TLS v1.3 导致JetBrains IDE jdk.internal.net.http.common CPU占用高

TLS v1.3 导致JetBrains IDE jdk.internal.net.http.common CPU占用高

开发环境 GoLand版本&#xff1a;2022.3.4 问题原因 JDK 中的 TLS v1.3 实现引起 解决办法 使用 SOCKS 代理代替HTTP代理 禁用 Space 和 Code With Me 插件 禁用 TLS v1.3&#xff0c;参考&#xff1a;https://stackoverflow.com/questions/54485755/java-11-httpclient-…
阅读更多...
深度解析Java JDK 1.8中Stream流的源码实现：带你探寻数据流的奥秘

深度解析Java JDK 1.8中Stream流的源码实现：带你探寻数据流的奥秘

文章目录 一、 Stream流概述1.1 什么是Stream流&#xff0c;以及它的主要特点和优势1.2 Stream流的基本操作&#xff1a;过滤、映射、排序等 二、 Stream流源码解析2.1 接口和基本概念2.2 创建流2.3 源码分析2.3.1 流的起始2.3.2 流的初始2.3.3 认识BaseStream2.3.4 Stream接口…
阅读更多...
【C++程序员的自我修炼】初始化列表

【C++程序员的自我修炼】初始化列表

一半烟火以谋生 一半诗意以谋爱 契子✨ 我们之前已经讲过了构造函数的初始化&#xff1a;前期回顾-构造函数 但是难免会遇到连构造函数都不好解决的问题 比如&#xff1a; 错误示范 class A { public:A(int n){this->_a n;this->_b n;} private:const int _a;int…
阅读更多...
JS-43-Node.js02-安装Node.js和npm

JS-43-Node.js02-安装Node.js和npm

Node.js是一个基于Chrome V8引擎的JavaScript运行时环境&#xff0c;可以让JavaScript实现后端开发&#xff0c;所以&#xff0c;首先在本机安装Node.js环境。 一、安装Node.js 官网&#xff1a;下载 Node.js 默认两个版本的下载&#xff1a; 64位windows系统的LTS(Long Tim…
阅读更多...
记录一下我102连不上MySQL的问题 NotBefore

记录一下我102连不上MySQL的问题 NotBefore

【背景描述】我在102上是能登录上MySQL的&#xff0c;但是用客户端&#xff08;DataGrip、SQLyog就连不上&#xff09; 【解决方案】 加个这个?useSSLfalse&serverTimezoneUTC 【另外的小问题】如果直接输mysql 上面这个不是报错&#xff0c;不用管 再输mysql -uroot -p…
阅读更多...
Ubuntu系统安装APITable多维表格平台结合内网穿透实现公网访问

Ubuntu系统安装APITable多维表格平台结合内网穿透实现公网访问

文章目录 前言1. 部署APITable2. cpolar的安装和注册3. 配置APITable公网访问地址4. 固定APITable公网地址 前言 vika维格表作为新一代数据生产力平台&#xff0c;是一款面向 API 的智能多维表格。它将复杂的可视化数据库、电子表格、实时在线协同、低代码开发技术四合为一&am…
阅读更多...
mybatis-puls 条件分析插件

mybatis-puls 条件分析插件

一&#xff0c;能做什么 我们在平时的开发中,会遇到一些慢sql. MP也提供了性能分析插件,如果超过这个时间就停止运行! 二&#xff0c;如何实现 2.1引入条件分析插件 //性能分析BeanProfile({"dev","test"}) //设置dev 和 test环境开启public Performanc…
阅读更多...
【数据结构与算法】：关于时间复杂度与空间复杂度的计算（C/C++篇）——含Leetcode刷题

【数据结构与算法】：关于时间复杂度与空间复杂度的计算（C/C++篇）——含Leetcode刷题

文章目录 一、什么是时间复杂度和空间复杂度&#xff1f;1.1 算法效率1.2 时间复杂度的概念1.3 空间复杂度的概念1.4 复杂度计算在算法中的意义 二、时间复杂度的计算2.1 大O渐进表示法2.2 常见时间复杂度计算举例 三、空间复杂度的计算四、Leetcode刷题1. 消失的数2. 旋转数组…
阅读更多...
探索设计模式的魅力：融合AI大模型与函数式编程、开启智能编程新纪元

探索设计模式的魅力：融合AI大模型与函数式编程、开启智能编程新纪元

​&#x1f308; 个人主页&#xff1a;danci_ &#x1f525; 系列专栏&#xff1a;《设计模式》 &#x1f4aa;&#x1f3fb; 制定明确可量化的目标&#xff0c;坚持默默的做事。 ✨欢迎加入探索AI大模型与函数式编程模式融合之旅✨ 在编程世界的广阔疆域里&#xff0c;两大…
阅读更多...
组织机构代码是哪几位?营业执照怎么看组织机构代码?

组织机构代码是哪几位?营业执照怎么看组织机构代码?

组织机构代码是哪几位? 组织机构代码通常指的是组织机构代码证上的一组特定数字&#xff0c;它用于唯一标识一个组织或机构。在中国&#xff0c;组织机构代码由9位数字组成&#xff0c;前8位是本体代码&#xff0c;最后1位是校验码。这组代码是按照国家有关标准编制的&#x…
阅读更多...
第一部分-基础入门-学习导航

第一部分-基础入门-学习导航

专题地址：MacOS一站式程序开发系列专题 第一部分：基础入门学习导航 OSX-01-Mac OS应用开发概述：简单介绍下MacOS生态、Xcode使用以及使用Xcode创建app的方法OSX-02-Mac OS应用开发系列课程大纲和章节内容设计：介绍下此系列专题的文章内容组织形式以及此系列专题的覆盖内容…
阅读更多...
帮助中心最核心的内容，你都知道吗？

帮助中心最核心的内容，你都知道吗？

帮助中心&#xff0c;其实就是个解决问题的“百事通”。当你在使用某产品时&#xff0c;遇到了一些问题&#xff0c;就可以到帮助中心去查询相关的信息以解决问题。很多公司都会搭建帮助中心&#xff0c;那么&#xff0c;帮助中心的核心内容都有哪些呢&#xff1f;这就是今天我…
阅读更多...
K8s拉取habor镜像

K8s拉取habor镜像

目录 在daemon.json中添加仓库地址 重新加载daemon.json并重启docker 在目标node节点添加域名 验证目标node是否能正常登录镜像仓库 创建pod资源 加载yml文件 验证 查看pod的ip与端口号 在daemon.json中添加仓库地址 此处需要在创建资源对象所在的节点进行添加 路径&a…
阅读更多...
c++的学习之路：24、 二叉搜索树概念

c++的学习之路：24、 二叉搜索树概念

摘要 本章主要是讲一下二叉搜索树的实现 目录 摘要 一、二叉搜索树概念 二、 二叉搜索树操作 1、二叉搜索树的查找 2、二叉搜索树的插入 3、二叉搜索树的删除 三、二叉搜索树的实现 1、插入 2、中序遍历 3、删除 4、查找 四、二叉搜索树的递归实现 1、插入 2、删…
阅读更多...
Web前端-Vue组件库Element

Web前端-Vue组件库Element

黑马程序员JavaWeb开发教程 文章目录 一、快速入门&#xff08;1&#xff09;什么是Element&#xff08;2&#xff09;快速入门 二、常见组件1、表格2、分页&#xff08;Pagination&#xff09;3、表单 三、案例&#xff08;1&#xff09;根据页面原型完成员工管理页面开发&…
阅读更多...
vue实现文字转语音的组件，class类封装，实现项目介绍文字播放，不需安装任何包和插件（2024-04-17）

vue实现文字转语音的组件，class类封装，实现项目介绍文字播放，不需安装任何包和插件（2024-04-17）

1、项目界面截图 2、封装class类方法&#xff08;实例化调用&#xff09; // 语音播报的函数 export default class SpeakVoice {constructor(vm, config) {let that thisthat._vm vmthat.config {text: 春江潮水连海平&#xff0c;海上明月共潮生。滟滟随波千万里&#xf…
阅读更多...
MySQL高级（性能分析-查看执行频次、慢查询日志）

MySQL高级（性能分析-查看执行频次、慢查询日志）

目录 1、SQL性能分析 1.1、SQL执行频率 1.2、慢查询日志 1、SQL性能分析 1.1、SQL执行频率 MySQL 客户端连接成功后&#xff0c;通过 show [ session | global ] status 命令可以提供服务器状态信息。通过如下指令&#xff0c;可以查看当前数据库的 insert、update、delete、…
阅读更多...
最新文章

Copyright @ 2022~2023