Scala 第三篇 OOP篇

Scala 第三篇 OOP篇

上接:Scala 第二篇 算子篇

  • 前序
  • 一、类
    • 1、修饰符
    • 2、创建类示例
    • 3、类的继承
  • 二、抽象类
  • 三、单例对象
  • 四、特质
    • 1、动态混入
    • 2、抽象类 VS 特质
  • 五、内部类
  • 六、样例类
  • 七、枚举
  • 八、泛型
  • 九、隐式类
  • 十、包与包对象
  • 练习

前序

1、Scala 为纯粹OOP
1.1、不支持基本类型:一切皆为对象 Byte, Int,…
1.2、不支持静态关键字:static
1.3、支持类型推断,和类型预定,动静结合

一、类

关键字:class
创建对象:new
内含:成员变量和方法
区别:
1、默认访问修饰符为 public,也支持 private 和 protected
2、没有构造方法,通过构造参数列表实现对象创建

1、修饰符

修饰符类(class)伴生对象(object)子类(subclass)同包(package)全局(world)
public(default)YYYYY
protectedYYYNN
privateYYNNN

2、创建类示例

  1. 创建类

    // 类自身:就是类的【主】构造器
    class Student(name:String, age:Int) {// 属性private var _name:String = nameprivate var _age:Int = age// 辅助构造器:基于主构造器的重载def this() = this("Unknown", 0)def this(name:String) = this(name, 18)// 方法def play(): Unit = {println("play computer game")}def getName:String = _namedef getAge:Int = _agedef setName(name: String):Unit = _name = namedef setAge(age: Int):Unit = _age = ageoverride def toString(): String = s"Student{name=${_name}, age=${_age}}"
    }
    
  2. 创建对象与方法调用

    val stu1 = new Student("张三", 20)
    val stu2 = new Student()
    val stu3 = new Student("leaf")stu1.play()				// play computer game
    stu2.setName("aaa")			
    stu2.setAge(19)	
    println(stu2)		 	// Student{name=aaa, age=19}
    println(stu3.getAge)	// 18
    

3、类的继承

  1. 类的继承

    // 继承关键字:extents,  继承Student类
    class EliteStudent(name: String, age: Int, score: Int) extends Student(name, age){// 增添属性private var _score: Int = score// 重载方法override def play(): Unit = {println("Do homework")}override def toString(): String = s"${super.toString()}, score: ${score}"
    }
    
  2. 调用

    val eliteStudent = new EliteStudent("李四", 12, 100)
    eliteStudent.play()			// 输出:Do homework
    println(eliteStudent)		// Student{name=李四,age=12}, score: 100
    

二、抽象类

关键字:abstract

  • 抽象类中可以有抽象方法(没有方法体的方法即抽象方法)
  • 无法实例化
  • 使用 abstract 关键字修饰
  • 子类重写父类【抽象】方法可以省略 override 关键字,但不推荐省略
  • 子类重写父类【非抽象】方法必须写 override 关键字

示例代码

// 抽象类
abstract class Animal {def eat(): Unit	// 抽象方法def play(): Unit	
}class Dog extends Animal {override def eat(): Unit = {println("大口吃肉")}override def play(): Unit = {println("抓蝴蝶")}
}class Cat extends Animal{override def eat(): Unit = {println("优雅的吃")}override def play(): Unit = {println("滚毛球")}
}

三、单例对象

代替 Java 中的 static 关键字
1、关键字:object
2、可以包含属性和方法,且可以通过单例对象名直接调用
3、采取惰性模式,第一次被访问时创建
4、无构造器,且不能 new
5、程序入口方法必须定义在单例对象中
6、同一个文件中同名的类和单例对象形成绑定关系,并称之为伴生类和伴生对象

  1. 伴生类,伴生对象(单例对象)的创建

    // 伴生类:与伴生对象具有相同名称的类被称为伴生类。
    class Student(name:String, age:Int) {private var _name:String = nameprivate var _age:Int = agedef this() = this("Unknown", 0)def this(name:String) = this(name,18)def getName:String = _namedef getAge:Int = _agedef setName(name: String):Unit = _name = namedef setAge(age: Int):Unit = _age = agedef play(): Unit = {println("play computer game")}override def toString(): String = s"Student{name=${_name},age=${_age}}"
    } 
    // 伴生对象:伴生对象是一个单例对象,它与一个类具有相同的名称。
    // 通常用于存放与该类相关的静态方法或字段。
    object Student{var products:Array[String] = Array("BigData","Cloud")// apply方法常用于作为创建类实例的工厂方法,省去了使用new关键字的麻烦def apply(name: String, age: Int): Student = new Student(name, age)def add(a:Int,b:Int) = a + b
    }
    
  2. 调用

    Student.products.foreach(e => print(e + " "))	// 输出静态属性:BigData Cloud
    val stu = Student("张三", 12)					   // 省略 new 
    print("\n" + Student.add(1, 5))					// 调用静态方法
    

四、特质

类似 java 的接口 (interface)
关键字:trait
1、包含字段、方法,亦可包含字段和方法的实现
2、类、单例对象、普通对象都可以扩展特质
3、没有构造器,不能实例化
4、单根继承,借助 with 实现多混入

// 定义抽象类 Animal
abstract class Animal {var _name: String
}// 定义特质 ByFoot
trait ByFoot {def eat(): Unitdef play(): Unit
}// 定义类 Cat,实现了 ByFoot 特质
class Cat extends ByFoot {override def eat(): Unit = println("吃西瓜")override def play(): Unit = println("抓老鼠")
}// 定义类 Dog,继承了 Animal 抽象类并实现了 ByFoot 特质
class Dog(name: String) extends Animal with ByFoot {override var _name: String = nameoverride def eat(): Unit = println("大口吃肉")override def play(): Unit = println("抓蝴蝶")
}

1、动态混入

  1. 特质类的定义

    trait Animal {val name:Stringdef cry():Unit
    }trait ByFoot {def jog():Unitdef run():Unit
    }
    // 动态强制混入特质:只能定义一个强制混入特质,且必须位于类内首行
    // self 是 this 的别名
    class Penguin {self: Animal => // 强制混入特质语法val brand: String = "企鹅"
    }// 动态非强制混入特质 with,支持多混入
    class Bear(nickName: String) {val _name: String = nickName
    }
    
  2. 调用,动态混入

    // 复合类型 Penguin with Animal
    val penguin: Penguin with Animal = new Penguin() with Animal {override val name: String = "阿童木"override def cry(): Unit = println(s"$brand $name is crying")
    }
    penguin.cry()val bear: Bear = new Bear("熊大") with Animal with ByFoot {override val name: String = "狗熊"override def cry(): Unit = println(s"$name ${_name} is crying")override def jog(): Unit = println(s"$name ${_name} is jogging")override def run(): Unit = println(s"$name ${_name} is running")
    }
    

2、抽象类 VS 特质

一般【优先使用特质】:
1、抽象类在于多类公共属性和行为的抽象,重点在于封装思想,本质为类,单继承,不支持多混入
2、接口在于一类事物的属性和行为标准定义,重点在于多态思想,支持多混入,动态混入
若需要带参构造,只能使用抽象类

五、内部类

内部类是定义在另一个类内部的类。内部类可以访问外部类的成员,包括私有成员。
内部类的主要优点之一是它们可以更轻松地访问外部类的状态,而不需要显式地传递引用
Java中内部类是【外部类的成员】:
InClass ic = new OutClass.InClass()
Scala中内部类是【外部类对象的成员】:
val oc = new OutClass();
val ic = new oc.InClass();

  1. 创建

    class OutClass(name:String,age:Int,gender:String,school:String,major:String) {class InnerClass(age:Int,gender:String){private var _age:Int = ageprivate var _gender:String = genderdef getAge = _agedef getGender = _genderdef setAge(age:Int) = _age = agedef setGender(gender:String) = _gender = gender}private val _name:String = nameprivate var _in:InnerClass = new InnerClass(age, gender)var _in2:OutClass.Inner2Class = new OutClass.Inner2Class(school, major)def setAge(age:Int) = _in.setAge(age)def setGender(gender:String) = _in.setGender(gender)def setIn(in:InnerClass) = _in = indef setIn2(in2:OutClass.Inner2Class) = _in2 = in2override def toString: String = s"${_name},${_in.getAge},${_in.getGender},${_in2._school},${_in2._major}"
    }
    object OutClass{class Inner2Class(school:String,major:String){val _school:String = schoolval _major:String = major}
    }
    

    调用

    val oc = new OutClass("henry",22,"male","xx","通信")
    oc.setAge(33)
    oc.setGender("female")
    println(oc)val in = new oc.InnerClass(30, "female") // 外部类对象.内部类(...)
    oc.setIn(in)val in2 = new OutClass.Inner2Class("xxx","人工智能")
    oc.setIn2(in2)
    

六、样例类

描述【不可变值】的对象
样例类构造参数默认声明为 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 需要显式声明
// val obj: Any = Student("张三", 18)
val obj: Any = Point(10, 20)
val info = obj match {case Student(_, 22) => "年龄22"case Student(name, _) if name.startsWith("张") => "姓张"case Point(a, _) => s"$a"
}
println(info)
// 追加伴生对象并实现 apply & unapply 
object Point{def apply(x: Int, y: Int): Point = new Point(x, y)def unapply(arg: Point): Option[(Int, Int)] = Some((arg._x,arg._y))
}

七、枚举

单例对象通过继承 Enumeration 实现枚举创建,简单易用,但不可扩展
通常用于定义一个有限取值范围的常量

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 wd = WeekDay.WEN
val info = wd match {case WeekDay.MON => "星期一"case WeekDay.TUE => "星期二"case WeekDay.WEN => "星期三"case _ => "不需要"
}

八、泛型

类型参数化,主要用于集合
不同于 Java 泛型被定义在 [] 中

  1. 测试类

    class GrandFather(name:String) {val _name:String = nameoverride def toString: String = _name
    }
    object GrandFather{def apply(name: String): GrandFather = new GrandFather(name)
    }class Father(name:String) extends GrandFather(name:String) {}
    object Father{def apply(name: String): Father = new Father(name)
    }class Son(name:String) extends Father(name:String) {}
    object Son{def apply(name: String): Son = new Son(name)
    }class GrandSon(name:String) extends Son(name:String){}
    object GrandSon{def apply(name: String): GrandSon = new GrandSon(name)
    }
    
  2. 泛型边界定义

    //	上边界:T<:A	泛型为某个类型的子类
    //	下边界:T>:A	泛型为某个类型的父类
    class MyArray[T <: Father](items:T*) {def join(sep:String) = items.mkString(sep)
    }
    // Type GrandFather does not conform to 【 upper bound 】 Father of type parameter T
    val arr:MyArray[GrandFather] = ...class MyArray[T >: Son](items:T*) {def join(sep:String) = items.mkString(sep)
    }
    // Type GrandSon does not conform to 【 lower bound 】 Son of type parameter T
    val arr:MyArray[GrandSon] = ...
    
  3. 型变:多态

    协变:[+T] 若A是B的子类,则 C[A]为C[B]的子类
    逆变:[-T] 若A是B的子类,则 C[B]为C[A]的子类
    不变:[T] 默认

    class MyArray[+T](items:T*) {def join(sep:String) = items.mkString(sep)
    }
    // Father 是 Son 的父类,则 MyArray[Father] 就是 MyArray[Son] 的父类
    val arr:MyArray[Father] = new MyArray[Son](Son("henry"),Son("ariel"))class MyArray[-T](items:T*) {def join(sep:String) = items.mkString(sep)
    }
    // Father 是 Son 的子类,则 MyArray[Son] 就是 MyArray[Father] 的子类
    val arr:MyArray[Son] = new MyArray[Father](Son("henry"),Son("ariel"))class MyArray[T](items:T*) {def join(sep:String) = items.mkString(sep)
    }
    // 所有泛型都必须为 Son
    val arr:MyArray[Son] = new MyArray[Son](Son("henry"),Son("ariel"))
    

九、隐式类

用implicit关键字修饰的类,扩展其主构造器唯一参数类型的功能
只能在类、Trait、对象(单例对象、包对象)内部定义
构造器只能携带一个非隐式参数
隐式类不能是 case class
在同一作用域内,不能有任何方法、成员或对象与隐式类同名
隐式类必须有主构造器且只有一个参数

  1. 隐式参数:隐式传入

    场景:多个函数共享同一个参数,选择柯里化,将最后一个列表设计为该共享参数的唯一参数,并将该参数设置为 implicit

    implicit order:Ordering[Int] = Ordering.Int.reverse
    val sorted = Array(8,1,3,2,5).sorted(implicit order:Ording[Int])
    
  2. 隐式函数:隐式类型转换

    implicit def strToInt(str:String) = str.toInt
    val a:Int = "12"
    
  3. 隐式类:扩展

    // 字符串的方法扩展,而在 Java 中 String 是final的,无法扩展
    implicit class StrExt(str:String){def incr() = str.map(c=>(c+1).toChar)def isEmail = str.matches("\\w+@[a-z0-9]{2,10}\\.(com(.cn)?|cn|edu|org)")
    }
    
    val a:String = "12665473@qq.com"
    val incr: String = a.incr
    val isEmail: Boolean = a.isEmail
    

十、包与包对象

包命名规则:字母、数字、下划线、点,不能以数字开头,在【一个类文件中可以定义多个并列的包】
导包的不同方式

import com.org.Person				// 方便使用类 Person
import com.org._					// 方便使用 com.kgc 包中的所有类
import com.org.Person._				// 方便使用类 Person 中的所有属性和方法
import com.org.{Person=>PS,Book}	// 只导入包中 Person和Book,并将Person重命名为PS

不同于Java:import 导包语句可以出现在任意地方
可以导入包、类、类成员

单个文件多包结构:资源按包名语义分类存放,方便管理和使用

测试样例,import 导包语句可以出现在任意地方

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-1breakable({while (j>=0){if(array(j)>t){array(j+1) = array(j)}else{break()}j-=1}})array(j+1) = t}}}
}

包对象

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

package test {// 导包(包在下面定义)import test.util.Constants._ // 导入 test.util.Constants 包对象中的所有成员,包括 PI 和 getQuarter 方法import test.util.Constants.{DataFormat => DF} // 导入 test.util.Constants 包对象中的 DataFormat 类,并将其重命名为 DFobject PackageTest {def main(args: Array[String]): Unit = {println(PI * 2 * 2)println(getQuarter(5))val format: DF = DF(2024, 3, 29)println(format.stdYMD())println(format.stdFull())println(format.timestamp())}}
}package test.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 = yearprivate var _month: Int = monthprivate var _day: Int = dayprivate var _hour: Int = hourprivate var _minute: Int = minuteprivate var _second: Int = secondprivate var _millis: Int = millisdef 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)}}
}

练习

【 练习一 】需求说明假设类Book有属性title和author(多个),books是Book的列表实现Book类,同时使用主构造器与辅助构造器实现Book的伴生对象,使用伴生对象创建Book实例创建books,使用List[Book]初始化5个以上Book实例找出books中书名包含“xxx”的书,并打印书名找出books中作者名以“xxx”打头的书,并打印书名
val list = List(Book("武侠:最强小保安",Array("张三","李四","王五")),Book("都市:上门赘婿",Array("阿强","洞冥福","花花")),Book("武侠:翔龙会",Array("阿庆嫂","黄世仁")),Book("都市:缘起",Array("徐世明","张丘月")),Book("武侠:小李飞刀",Array("王栋","李宏","张明")),
)
【 练习二 】需求说明现在Book拥有电子版本,可以在多终端上播放属性:作者author:String,书名bookName:String,类型bookType:String内容chapters:Array[String]方法:简介resume():Unit定义Ebook特质方法:play()使Book动态混入Ebook特质,实现play()方法
val chapters = Array("“春游浩荡,是年年寒食,梨花时节。白锦无纹香烂漫,玉树琼苞堆雪。静夜沉沉,浮光霭霭,冷浸溶溶月。人间天上,烂银霞照通彻。浑似姑射真人,天姿灵秀,意气殊高洁。万蕊参差谁信道,不与群芳同列。浩气清英,仙才卓荦,下土难分别。瑶台归去,洞天方看清绝。”\n\n  作这一首《无俗念》词的,乃南宋末年一位武学名家,有道之士。此人姓丘,名处机,道号长春子,名列全真七子之一,是全真教中出类拔萃的人物。《词品》评论此词道:“长春,世之所谓仙人也,而词之清拔如此”。这首词诵的似是梨花,其实词中真意却是赞誉一位身穿白衣的美貌少女,"
)
val book = Book("张三","倚天屠龙记","武侠小说")

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

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

信息技术内涵及意义

一、信息技术及其演进趋势 &#xff08;一&#xff09;信息技术概况概念 信息技术&#xff08;Information Technology&#xff0c;IT&#xff09;指“应用在信息加工和处理中的科学、技术与工程的训练方法与管理技巧&#xff1b;上述方法和技巧的应用&#xff1b;计算机及其…

C#面试题目含参考答案(二)

前言 面试是应聘一个工作岗位的环节&#xff0c;来考察一个人的工作能力与综合素质。在应聘C#程序员或与C#相关岗位时&#xff0c;我们都会被问到一些与.NET、C#、数据库、业务知识或编程思想等问题。 题目 31、值类型和引用类型的区别 参考答案&#xff1a; 1、值类型的数…

JavaScript+B/S版云LIS系统源码ASP.NET CORE 3.1 MVC云LIS系统如何实现样本追踪的预警功能?医院云LIS检验系统源码

JavaScriptB/S版云LIS系统源码ASP.NET CORE 3.1 MVC云LIS系统如何实现样本追踪的预警功能&#xff1f;医院云LIS检验系统源码 实验室信息管理系统&#xff08;Trasen Laboratory Information Management System&#xff09;是一套专业的医疗实验室信息管理软件&#xff0c;包含…

【C++庖丁解牛】C++11---新的类的功能 | 可变参数模板

&#x1f341;你好&#xff0c;我是 RO-BERRY &#x1f4d7; 致力于C、C、数据结构、TCP/IP、数据库等等一系列知识 &#x1f384;感谢你的陪伴与支持 &#xff0c;故事既有了开头&#xff0c;就要画上一个完美的句号&#xff0c;让我们一起加油 目录 1.新的类功能1.1 默认成员…

pyqt标签常用qss格式设置

pyqt标签常用qss格式设置 QSS介绍标签常用的QSS设置效果代码 QSS介绍 Qt Style Sheets (QSS) 是 Qt 框架中用于定制应用程序界面样式的一种语言。它类似于网页开发中的 CSS&#xff08;Cascading Style Sheets&#xff09;&#xff0c;但专门为 Qt 应用程序设计。使用 QSS&…

24.4.28(板刷dp,拓扑判环,区间dp+容斥算回文串总数)

星期一&#xff1a; 昨晚cf又掉分&#xff0c;小掉不算掉 补ABC350 D atc传送门 思路&#xff1a;对每个连通块&#xff0c;使其成为一个完全图&#xff0c;完全图的边数为 n*(n-1)/2 , 答案加上每个连通块成为完全图后的…

第十五届蓝桥杯Java软件开发大学B组自我经验小结

自我介绍 23届大一 双非 计院科班 软件工程 江苏人在吉林上大学 Java蒟蒻 在学校的宣传下 有幸参加了第十五届蓝桥杯Java大学b组省赛 蓝桥杯说明 就是一个算法比赛吧 考试时间9.00到1.00 四小时 带准考证和身份证和笔 草稿纸会发 赛制是IOC就是不会给任何反馈 就是你…

富唯智能案例|双3D相机引导衔架抓取铝型材

随着制造业的快速发展和自动化水平的不断提升&#xff0c;铝型材的自动化抓取和加工成为行业内的一大技术难题。铝型材因其轻便、耐腐蚀、易加工等特点&#xff0c;广泛应用于建筑、汽车、电子等领域。然而&#xff0c;铝型材的形状多样、尺寸不一&#xff0c;以及生产线上的高…

MTK Android.mk 预置应用out下生成,但桌面不加载显示

预置第三方APK&#xff1a; prebuilts xxx.apk android.mk lib文件 # android.mk具体配置如下&#xff1a; include $(CLEAR_VARS) //必须先定义LOCAL_PATH 变量&#xff0c;此变量表示源文件的位置。编译系统提供的宏函数 my-dir 将返回当前目录&#xff08;Android.mk…

Ruby递归目录文件的又一种方法

经常派得上用场&#xff0c;记录一下。 递归文件做一些操作 #encoding:utf-8require pathnamedef recursive_enum_files(from_path)from_path Pathname.new(from_path)raise ArgumentError,must start at a directory. unless from_path.directory?from_path.enum_for(:fin…

【算法系列】哈希表

目录 哈希表总结 leetcode题目 一、两数之和 二、判定是否互为字符重排 三、存在重复元素 四、存在重复元素 II 五、字母异位词分组 六、在长度2N的数组中找出重复N次的元素 七、两个数组的交集 八、两个数组的交集 II 九、两句话中的不常见单词 哈希表总结 1.存储数…

C语言/数据结构——每日一题(链表的中间节点)

一.前言 今天我在LeetCode刷到了一道单链表题&#xff0c;想着和大家分享一下这道题&#xff1a;https://leetcode.cn/problems/middle-of-the-linked-list。废话不多说让我们开始今天的知识分享吧。 二.正文 1.1题目描述 1.2题目分析 这道题有一个非常简便的方法——快慢指…

Kafka如何将消息发送到指定分区

背景 面试一个时&#xff0c;面试官问了一个问题&#xff0c;Kafka如何做到顺序消息。我回答只给Kafka的Topic创建一个分区&#xff0c;发送到该Topic的消息在Kafka中就是有序的。 面试官又问&#xff0c;如果Topic有多个分区呢&#xff1f;我回答消息发送者在发送消息的时候…

袁庭新ES系列17节|Spring Data Elasticsearch基础

前言 为了简化对Elasticsearch的操作Spring Data提供了Spring Data Elasticsearch。Spring Data Elasticsearch是Spring Data技术对Elasticsearch原生API封装之后的产物&#xff0c;它通过对原生API的封装&#xff0c;使得程序员可以简单的对Elasticsearch进行各种操作。接下来…

信融算网,创启未来 | 移动云一体化算网调度平台发布

4月29日上午&#xff0c;中国移动算力网络大会“自主可控算力网络应用”分论坛在苏州召开&#xff0c;中国移动云能力中心副总经理吴世俊、中国移动信息技术中心副总经理陈国出席论坛并发表致辞。论坛发布全国首个实现通算、智算、超算、量子计算&#xff0c;以及网络、安全一站…

全栈开发之路——前端篇(2)文件、组件与setup引入

全栈开发一条龙——前端篇 第一篇&#xff1a;框架确定、ide设置与项目创建 本文系该系列第二篇&#xff0c;主要将介绍各个文件的意义、组件结构与导入以及setup的引入。 目录 一、src外文件介绍.gitignore为git忽略文件env.d.ts用于识别其他文件index.htmljson文件vite.confi…

【JAVASE】带你了解的方法魅力

✅作者简介&#xff1a;大家好&#xff0c;我是橘橙黄又青&#xff0c;一个想要与大家共同进步的男人&#x1f609;&#x1f609; &#x1f34e;个人主页&#xff1a;橘橙黄又青-CSDN博客 目标&#xff1a; 1. 掌握方法的定义以及使用 2. 掌握方法传参 3. 掌握方法重载 …

java 基础面试-- hashCode 方法重要性及使用

引言 在Java编程的世界里&#xff0c;hashCode方法扮演着至关重要的角色&#xff0c;尤其在涉及到集合类&#xff08;如HashMap、HashSet&#xff09;和对象比较的场景中。本文将深入探讨hashCode方法的工作原理、重要性以及如何正确地重写它&#xff0c;以确保你的程序在性能…

[C++][算法基础]四种基本背包问题(动态规划)

1. 01背包问题 有 &#x1d441; 件物品和一个容量是 &#x1d449; 的背包。每件物品只能使用一次。 第 &#x1d456; 件物品的体积是 &#x1d463;&#x1d456;&#xff0c;价值是 &#x1d464;&#x1d456;。 求解将哪些物品装入背包&#xff0c;可使这些物品的总体…

10.JAVAEE之网络编程

1.网络编程 通过网络,让两个主机之间能够进行通信 >基于这样的通信来完成一定的功能进行网络编程的时候,需要操作系统给咱们提供一组 AP1, 通过这些 API才能完成编程&#xff08;API 可以认为是 应用层 和 传输层 之间交互的路径&#xff09;&#xff08;API:Socket API相当…