《chang哥教你一天搞定Scala》

 /**
* 《chang哥教你一天搞定Scala》
* scala是一门多范式编程语言,集成了面向对象编程和函数式编程等多种特性。
* scala运行在虚拟机上,并兼容现有的Java程序。
* Scala源代码被编译成java字节码,所以运行在JVM上,并可以调用现有的Java类库。
*/ /**
* 第一个Scala程序
* Scala和Java最大的区别是:Scala语句末尾的分号(;)是可选的!
* 编译运行:
* 先编译:scalac HelloScala.scala 将会生成两个文件:HelloScala$.class和HelloScala.class
* 在运行:scala HelloScala
* 输出结果:hello scala!!!
*
* object HelloScala{
def main(args: Array[String]): Unit = {
println("hello scala!!!")
}
}
*/ /**
* Scala基本语法:
* 区分大小写
* 类名首字母大写(MyFirstScalaClass)
* 方法名称第一个字母小写(myMethodName())
* 程序文件名应该与对象名称完全匹配
* def main(args:Array[String]):scala程序从main方法开始处理,程序的入口。
*
* Scala注释:分为多行/**/和单行//
*
* 换行符:Scala是面向行的语言,语句可以用分号(;)结束或换行符(println())
*
* 定义包有两种方法:
* 1、package com.ahu
* class HelloScala
* 2、package com.ahu{
* class HelloScala
* }
*
* 引用:import java.awt.Color
* 如果想要引入包中的几个成员,可以用selector(选取器):
* import java.awt.{Color,Font}
* // 重命名成员
* import java.util.{HashMap => JavaHashMap}
* // 隐藏成员 默认情况下,Scala 总会引入 java.lang._ 、 scala._ 和 Predef._,所以在使用时都是省去scala.的
* import java.util.{HashMap => _, _} //引入了util包所有成员,但HashMap被隐藏了
*/ /**
* Scala数据类型:
* Scala与Java有着相同的数据类型,下面列出一些Scala有的数据类型。
* Unit:表示无值,和其他语言的void一样。
* Null:null或空引用。
* Nothing:是Scala的类层级的最低端,是任何其他类型的子类型。
* Any:是所有其他类的超类。
* AnyRef:是Scala所有引用类的基类。
*
* 多行字符串的表示方法:
val foo ="""第一行
第二行
第三行"""
*/ /**
* Scala变量:
* 在Scala中,使用关键字“var”声明变量,使用关键字“val”声明常量。
* var myVar1 : String = "foo"
* var myVar2 : Int
* val myVal = "Hello,Scala!"
* Scala多个变量声明:
* val xmax, ymax = 100 // xmax,ymax都声明为100
*/ /**
* Scala访问修饰符:
* Scala访问修饰符和Java基本一样,分别有private、protected、public。
* 默认情况下,Scala对象的访问级别是public。
*
* 私有成员:用private关键字修饰的成员仅在包含了成员定义的类或对象内部可见。
* class Outer{
* class Inner{
* private def f(){println("f")}
* class InnerMost{
* f() // 正确
* }
* (new Inner).f() // 错误
* }
* }
*
* 保护成员:Scala比Java中更严格。只允许保护成员在定义了该成员的类的子类中被访问。
* package p{
* class Super{
* protected def f() {println("f")}
* }
* class Sub extends Super{
* f()
* }
* class Other{
* (new Super).f() // 错误
* }
* }
*
* 公共成员:默认public,这样的成员在任何地方都可以被访问。
* class Outer{
* class Inner{
* def f(){println("f")}
* class InnerMost{
* f() // 正确
* }
* }
* (new Inner).f() // 正确
* }
*
* 作用域保护:Scala中,访问修饰符可以通过使用限定词强调。
* private[x] 或者 protected[x]
* private[x]:这个成员除了对[...]中的类或[...]中的包中的类及他们的伴生对象可见外,对其他的类都是private。
*/ /**
* Scala运算符:和Java一样,这里就不再浪费时间一一介绍了。
* 算术运算符、关系运算符、逻辑运算符、位运算符、赋值运算符。
*/ /**
* Scala if...else语句:和Java一样,简单列举一下四种情况。
* if(...){
*
* }
*
* if(...){
*
* }else{
*
* }
*
* if(...){
*
* }else if(...){
*
* }else{
*
* }
*
* if(...){
* if(...){
*
* }
* }
*/ /**
* Scala循环:和Java一样,这里不赘述,只介绍三种循环类型。
* while循环、do...while循环、for循环
*/ /**
* Scala函数:用一个例子来说明函数的定义和函数调用。
* object Test{
* def main(args: Array[String]){
* println(addInt(1,3)); // 函数调用
* }
* def addInt(a:Int, b:Int) : Int = { // 函数定义
* var sum:Int = 0
* sum = a + b
* return sum
* }
* }
*/ /**
* Scala闭包:
* 闭包是一个函数,返回值依赖于声明在函数外部的一个或多个变量。
* 例子:
* object Test{
* def main(args: Array[String]){
* println("muliplier(1) value = " + muliplier(1))
* println("muliplier(2) value = " + muliplier(2))
* }
* var factor = 3 // 定义在函数外的自由变量
* val muliplier = (i:Int) => i * factor // muliplier函数变量就是一个闭包
* }
* 输出结果:
* muliplier(1) value = 3
* muliplier(2) value = 6
*/ /**
* Scala字符串:
*
* Scala中可以创建两中字符串:一种是不可修改的,一种是可以修改的。
* // 创建不可修改的字符串
* val greeting:String = "Hello World!";
* // 创建可以修改的字符串
* object Test{
* def main(args: Array[String]){
* val buf = new StringBuilder;
* buf += 'a' // 添加一个字符
* buf ++= "bcdef" // 添加一个字符串
* println(buf.toString); // 输出:abcdef
* }
* }
*
* 字符串长度:xxx.length()
*
* 字符串连接:可以用concat()方法或者用加号
* object Test {
def main(args: Array[String]) {
var str1 = "字符串1:";
var str2 = "字符串2";
var str3 = "字符串3:";
var str4 = "字符串4";
println( str1 + str2 ); // 字符串1:字符串2
println( str3.concat(str4) ); // 字符串3:字符串4
}
}
*
* 创建格式化字符串:
* String类中可以使用printf()方法来格式化字符串并输出。
* object Test{
* def main(args:Array[String]){
* var floatVar = 12.456
* var intVar = 2000
* var stringVar = "字符串变量"
* var fs = printf("浮点型变量为 " +
* "%f,整形变量为 %d, 字符串为 " +
* "%s", floatVar, intVar, stringVar)
* println(fs) // 浮点型变量为 12.456000, 整型变量为 2000, 字符串为 字符串变量
* }
* }
*/ /**
* Scala数组:
* 1、声明数组
* var z:Array[String] = new Array[String](3) 或者 var z = new Array[String]()
* z(0) = "value1"; z(1) = "value2"; z(2) = "value3"
*
* var z = Array("value1", "value2", "value3")
*
* 2、处理数组
* object Test{
* def main(args: Array[String]){
* var myList = Array(1.1, 2.2, 3.3, 4.4)
*
* // 输出所有数组元素
* for(x <- myList){
* println(x)
* }
*
* // 计算数组所有元素的总和
* var total = 0.0
* for(i <- 0 to (myList.length - 1)){
* total += myList(i)
* }
* println("总和:" + total)
*
* // 查找数组中的最大元素
* var max = myList(0)
* for(i <- 1 to (myList.length - 1)){
* if(myList(i) > max)
* max = myList(i)
* }
* println("最大值:" + max)
* }
* }
*
* 3、多维数组
* import Array._
* object Test{
* def main(args: Array[String]){
* // 定义数组
* var myMatrix = ofDim[Int](3,3)
* // 创建矩阵
* for(i <- 0 to 2){
* for(j <- 0 to 2){
* myMatrix(i)(j) = j;
* }
* }
* // 打印矩阵
* for(i <- 0 to 2){
* for(j <- 0 to 2){
* print(" " + myMatrix(i)(j));
* }
* println();
* }
* }
* }
*
* 4、合并数组
* import Array._
* object Test{
* def main(args: Array[String]){
* var myList1 = Array(1.1, 2.2, 3.3, 4.4)
* var myList2 = Array(5.5, 6.6, 7.7, 8.8)
* // 使用concat()合并
* var myList3 = concat(myList1, myList2)
* // 输出所有数组元素
* for(x <- myList3){
* println(x)
* }
* }
* }
*
* 5、创建区间数组:使用range(x,y,z)创建区间数组,数值范围大于等于x,小于y。z表示步长,默认为1。
* object Test{
* def main(args: Array[String]){
* var myList1 = range(10, 20, 2)
* var myList2 = range(10, 20)
* for(x <- myList1){
* print(" " + x) //输出:10 12 14 16 18
* }
* println()
* for(x <- myList2){
* print(" " + x) // 输出:10 11 12 13 14 15 16 17 18 19
* }
* }
* }
*/ /**
* Scala集合:分为可变集合和不可变集合。
* 可变集合:可以在适当的地方被更新或扩展,也就是可以修改、添加、移除一个集合的元素。
* 不可变集合:永远不会改变。但可以模拟添加、移除、更新操作,但是这些操作将在每一种情况下都返回一个新的集合,
* 同时使原来的集合不发生改变。
* // 定义整形List
* val x = List(1,2,3,4)
* // 定义Set
* var x = Set(1,3,5,7)
* // 定义Map
* val x = Map("one" -> 1, "two" -> 2, "three" -> 3)
* // 创建两个不同类型的元组
* val x = (10, "Runoob")
* // 定义Option
* val x:Option[Int] = Some(5)
*/ /**
* Scala迭代器:
* 迭代器不是一个集合,而是一个用于访问集合的方法。
*
*/
/*object Test{
def main(args: Array[String]): Unit = {
val it = Iterator("one", "two", "three", "four")
while(it.hasNext){ // 检测集合中是否还有元素
println(it.next()) // 返回迭代器的下一个元素,并更新迭代器的状态
} val ita = Iterator(1, 2, 3, 4, 5)
val itb = Iterator(11, 22, 33, 44, 55)
//println(ita.max) // 查找最大元素
//println(itb.min) // 查找最小元素 println(ita.size) // 获取迭代器的长度
println(itb.length) // 获取迭代器的长度
}
}*/ /**
* Scala类和对象:
* 类是对象的抽象,对象是类的具体实例。
* 类是抽象的,不占用内存;对象是类的具体实例,占用存储空间。
*
*/
/*import java.io._
class Point(xc: Int, yc: Int){
var x: Int = xc
var y: Int = yc
def move(dx: Int, dy: Int): Unit ={
x = x + dx
y = y + dy
println("x点的坐标是:" + x)
println("y点的坐标是:" + y)
}
}
object Test{
def main(args: Array[String]): Unit = {
val pt = new Point(10, 20)
// 移到一个新的位置
pt.move(10, 10)
}
}*/
/**
* Scala继承:跟Java差不多。
* 1、重写一个非抽象方法必须使用override修饰符
* 2、只有主构造函数才可以往基类的构造函数里写参数
* 3、在子类中重写超类的抽象方法时,不需要使用override
*/
/*class Point(val xc: Int, val yc: Int){
var x: Int = xc
var y: Int = yc
def move(dx: Int, dy: Int): Unit ={
x = x + dx
y = y + dy
println("x点的坐标是:" + x)
println("y点的坐标是:" + y)
}
//-------------------------------------
var name = ""
override def toString = getClass.getName + "[name=" + name + "]"
}
class Location(override val xc: Int, override val yc: Int,
val zc: Int) extends Point(xc, yc){ // 继承 重写了父类的字段
var z: Int = zc
def move(dx: Int, dy: Int, dz: Int){
x = x + dx
y = y + dy
z = z + dz
println("x点的坐标是:" + x)
println("y点的坐标是:" + y)
println("z点的坐标是:" + z)
}
//---------------------------------------
var salary = 0.0
override def toString = super.toString + "[salary=" + salary + "]"
}
object Test{
def main(args: Array[String]): Unit = {
val loc = new Location(10, 20, 30)
loc.move(10, 10 ,5)
//------------------------------------
loc.name = "lc"
loc.salary = 35000.0
println(loc)
}
}*/ /**
* Scala单例对象:
* Scala中没有static,要使用object关键字实现单例模式。
* Scala中使用单例模式时,除了定义类,还要定义一个同名的object对象,它和类的区别是,object对象不能带参数。
* 当单例对象与某个类共享一个名称时,他被称作这个类的伴生对象。
* 必须在同一个源文件里定义类和它的伴生对象。
* 类和它的伴生对象可以互相访问其私有成员。
*/
/*// 私有构造方法
class Marker private(val color:String) {
println("创建" + this)
override def toString(): String = "颜色标记:"+ color //4:颜色标记:red
} // 伴生对象,与类共享名字,可以访问类的私有属性和方法
object Marker{
private val markers: Map[String, Marker] = Map(
"red" -> new Marker("red"), //1:创建颜色标记:red
"blue" -> new Marker("blue"), //2:创建颜色标记:blue
"green" -> new Marker("green") //3:创建颜色标记:green
) def apply(color:String) = {
if(markers.contains(color)) markers(color) else null
} def getMarker(color:String) = {
if(markers.contains(color)) markers(color) else null //5:颜色标记:blue
} def main(args: Array[String]) {
println(Marker("red"))
// 单例函数调用,省略了.(点)符号
println(Marker getMarker "blue")
}
}*/ /**
* Scala Trait(特征):
* 相当于Java的接口,但比接口功能强大,它还可以定义属性和方法的实现。
* 一般情况下Scala的类只能单继承,但特征可以实现多重继承。
*/
/*// 定义特征
trait Equal{
def isEqual(x: Any): Boolean // 未实现的方法
def isNotEqual(x: Any): Boolean = !isEqual(x) // 实现了的方法
} class Point(xc: Int, yc: Int) extends Equal{
var x: Int = xc
var y: Int = yc override def isEqual(obj: Any): Boolean =
obj.isInstanceOf[Point] &&
obj.asInstanceOf[Point].x == x
} object Test{
def main(args: Array[String]): Unit = {
val p1 = new Point(2, 3)
val p2 = new Point(2, 4)
val p3 = new Point(3, 3)
println(p1.isNotEqual(p2))
println(p1.isNotEqual(p3))
println(p1.isNotEqual(2))
}
}*/ /**
* 特征构造顺序:
* 构造器的执行顺序:
* 1、调用超类的构造器
* 2、特征构造器在超类构造器之后、类构造器之前执行
* 3、特征由左到右被构造
* 4、每个特征当中,父特征先被构造
* 5、如果多个特征共有一个父特征,父特征不会被重复构造
* 6、所有特征被构造完毕,子类被构造
*/ /**
* Scala模式匹配:
* 选择器 match {备选项}
*/
/*object Test{
def main(args: Array[String]): Unit = {
println(matchTest("two"))
println(matchTest("test"))
println(matchTest(1))
println(matchTest(6))
}
def matchTest(x: Any): Any = x match {
case 1 => "one"
case "two" => 2
case y: Int => "scala.Int" // 对应类型匹配
case _ => "many" // 默认全匹配选项
}
}*/
/**
* 使用样例类:
* 使用case关键字的类定义就是样例类,样例类是种特殊的类,经过优化以用于模式匹配。
*/
/*object Test{
def main(args: Array[String]): Unit = {
val alice = new Person("Alice", 25)
val bob = new Person("Bob", 32)
val charlie = new Person("Charlie", 27)
for(person <- List(alice, bob, charlie)){
person match{
case Person("Alice", 25) => println("Hi Alice!")
case Person("Bob", 32) => println("Hi Bob!")
case Person(name, age) => println("Age: " + age + " year,name: " + name +"?")
}
}
}
// 样例类
case class Person(name: String, age: Int)
}*/ /**
* Scala正则表达式:
* 和Java差不多,在用的时候查一下就行了。
*/ /**
* Scala异常处理:
* 和Java类似。在Scala中借用了模式匹配的方法来在catch语句块中来进行异常匹配。
*/
/*import java.io.{FileNotFoundException, FileReader, IOException}
object Test{
def main(args: Array[String]): Unit = {
try {
val f = new FileReader("input.txt")
}catch {
case ex: FileNotFoundException => {
println("Missing file exception")
}
case ex: IOException => {
println("IO Exception")
}
}finally {
println("Exiting finally...")
}
}
}*/ /**
* Scala提取器(Extractor):
* apply方法:无需new操作就可创建对象。
* unapply方法:是apply方法的反向操作,接受一个对象,然后从对象中提取值,提取的值通常是用来构造对象的值。
*/
/*object Test {
def main(args: Array[String]) { println ("Apply 方法 : " + apply("Zara", "gmail.com")); // 也可直接Test("Zara", "gmail.com")来创建Zara@gmail.com
println ("Unapply 方法 : " + unapply("Zara@gmail.com"));
println ("Unapply 方法 : " + unapply("Zara Ali")); }
// 注入方法 (可选)
def apply(user: String, domain: String) = {
user +"@"+ domain
} // 提取方法(必选)
def unapply(str: String): Option[(String, String)] = {
val parts = str split "@"
if (parts.length == 2){
Some(parts(0), parts(1))
}else{
None
}
}
}*/
/**
* 提取器使用模式匹配:
* 在我们实例化一个类的时,可以带上0个或者多个的参数,编译器在实例化的时会调用 apply 方法。
*/
/*object Test {
def main(args: Array[String]) { val x = Test(5)
println(x) x match
{
case Test(num) => println(x + " 是 " + num + " 的两倍!") //2:10是5的两倍!
//unapply 被调用
case _ => println("无法计算")
} }
def apply(x: Int) = x*2 //1:10
def unapply(z: Int): Option[Int] = if (z%2==0) Some(z/2) else None
}*/ /**
* Scala文件I/O:
*
*/
/*// 文件写操作
import java.io._
object Test {
def main(args: Array[String]) {
val writer = new PrintWriter(new File("test.txt" )) writer.write("Scala语言")
writer.close()
}
}*/
// 从屏幕上读取用户输入
/*object Test {
def main(args: Array[String]) {
print("请输入菜鸟教程官网 : " )
val line = Console.readLine // 在控制台手动输入 println("谢谢,你输入的是: " + line)
}
}*/
// 从文件上读取内容
/*import scala.io.Source
object Test {
def main(args: Array[String]) {
println("文件内容为:" ) Source.fromFile("test.txt" ).foreach{
print
}
}
}*/

Scala入门教程---《chang哥教你一天搞定Scala》的更多相关文章

  1. 教你怎么半天搞定Docker

    首先,不要把docker想的那么高大,它不就是先做个镜像,然后通过docker像虚拟机一样跑起来嘛...docker其实在真实业务场景中还是非常有局限性的.Dockerfile脚本也没那么好写,有些应 ...

  2. scala入门教程:scala中的面向对象定义类,构造函数,继承

    我们知道scala中一切皆为对象,函数也是对象,数字也是对象,它是一个比java还要面向对象的语言. 定义scala的简单类 class Point (val x:Int, val y:Int) 上面 ...

  3. Python系列教程-详细版 | 图文+代码,快速搞定Python编程(附全套速查表)

    作者:韩信子@ShowMeAI 教程地址:http://showmeai.tech/article-detail/python-tutorial 声明:版权所有,转载请联系平台与作者并注明出处 引言 ...

  4. 数据可视化地图制作教程,这个免费BI软件轻松搞定

    ​数据可视化地图制作教程 现在做数据分析基本上离不开数据可视化,在大量的数据中,有很大一部分数据都与地理信息相关,因此,在数据可视化中,可视化地图是非常重要的一部分.无论是新闻报道,还是商业分析报告, ...

  5. 还在繁琐的敲MVP接口和实现类吗,教你一秒搞定。

    只有程序员懒起来,才能提高开发效率 233333 在MVP的使用过程中,我们需要反复的去写各种MVP的接口和实现类, 实在是 太麻烦了!!所以抽时间撸了一款插件(只可用于Intellj IDEA 和 ...

  6. Scala入门到精通

    原文出自于: http://my.csdn.net/lovehuangjiaju 感谢! 也感谢,http://m.blog.csdn.net/article/details?id=52233484 ...

  7. 【军哥谈CI框架】之入门教程之第二讲:分析CI结构和CI是怎么工作的

    [军哥谈CI框架]之入门教程之第二讲:分析CI结构和CI是怎么工作的   之入门教程之第二讲:分析CI结构和CI是如何工作的大家好!上一节,我们共同部署了一个CI网站,做到这一点非常简单,但是,亲们, ...

  8. 《Visual C++ 2010入门教程》系列四:VC2010中初学者常见错误、警告和问题

    <Visual C++ 2010入门教程>系列四:VC2010中初学者常见错误.警告和问题   这一章将帮助大家解释一些常见的错误.警告和问题,帮助大家去理解和解决一些常见问题,并了解它的 ...

  9. 《Visual C++ 2010入门教程》系列三:关于C++的一些问题

    <Visual C++ 2010入门教程>系列三:关于C++的一些问题   这一回我自己都不知道应该写点什么好,或许今天的篇幅会比往常短很多.我说过,这不是C++的教程,因为我还没有那个能 ...

随机推荐

  1. Linux 4.10.8 根文件系统制作(一)---环境搭建

    一.工具 制作工具为busybox 下载地址:https://busybox.net/ 解压: 二.制作文件系统 进入目录,执行make menuconfig: 2.1 busybox setting ...

  2. Seafile 网络磁盘

    Seafile 个人 网盘 1.安装 Seafile 1.安装依赖环境 使用 yum 安装 Python 及 MySQL: yum install python python-setuptools p ...

  3. 列表视图QlistView

    列表视图QlistView要配合setModel模型一起使用 例子一 QStringListModel()  字符串列表模型 import sys from PyQt5.QtWidgets impor ...

  4. 字体选择框QFontComboBox

    self.combobox_2 = QFontComboBox(self)  # 实例化字体列表框 combobox.currentFont()  返回字体选择框中当前的字体 self.combobo ...

  5. [JLOI2015]装备购买 (高斯消元)

    [JLOI2015]装备购买 \(solution:\) 首先这道题的题面已经非常清晰的告诉我们这就是线性空间高斯消元的一道题(可以用某些装备来表示另一件装备,这已经不能再明显了),只是这道题要求我们 ...

  6. solr学习

    入门文档 http://www.cnblogs.com/edwinchen/p/3972904.html 中文分词 https://github.com/EugenePig/ik-analyzer-s ...

  7. ubuntu 上下左右键变成ABCD

    1.在ubuntu终端环境出现: 这表示你正在insert mode.... 按esc,回到command mode,上下左右就回复到正常的方向键功能了 2.可能写的程序是在insert mode(r ...

  8. Java将list数据导出到Excel——(八)

    Java实体类 package bean; public class Question { private String timu; //题干 private String leixing; //类型 ...

  9. Qt5.7 无法输入中文问题

    把libfcitxplatforminputcontextplugin.so复制到安装的Qt目录下的两个文件夹中 sudo apt install fcitx-frontend-qt5 sudo cp ...

  10. 【Python】【辅助程序】练手小程序:记录外网动态IP地址

    练手小程序 程序作用:对IP实时记录: 1.定时获取外网IP,存储在本地文件中: 编写思路: 1)收集获取外网的API接口       http://bbs.125.la/thread-1383897 ...