Scala 语言入门：初学者的基础语法指南

object Main {  def main(args: Array[String]): Unit =    println("Hello, Scala developer!")}

object Main extends App {  println("Hello, Scala developer!")}

val x = 1// x = 2 // 这会报错，因为不能给 val 变量重新赋值

var y = 1y = 2 // 这是合法的，因为 y 是一个 var 变量

val x: Int = 1 + 1var x: Int = 1 + 1

object Main extends App {  trait Animal {    def speak: String  }
  class Dog extends Animal {    def speak = "Woof!"  }
  class Cat extends Animal {    def speak = "Meow!"  }
  class Parrot extends Animal {    def speak = "Squawk!"  }
  class AnimalShelter[A <: Animal] {    private var animals: List[A] = Nil
    def addAnimal(animal: A): Unit = {      animals = animal :: animals    }
    def getAnimal: A = {      val animal = animals.head      animals = animals.tail      animal    }  }
  val dogShelter = new AnimalShelter[Dog]  dogShelter.addAnimal(new Dog)  val dog: Dog = dogShelter.getAnimal  println(dog.speak)
  val catShelter = new AnimalShelter[Cat]  catShelter.addAnimal(new Cat)  val cat: Cat = catShelter.getAnimal  println(cat.speak)
  val parrotShelter = new AnimalShelter[Parrot]  parrotShelter.addAnimal(new Parrot)  val parrot: Parrot = parrotShelter.getAnimal  println(parrot.speak)}
输出：Woof!Meow!Squawk!

import users._  // 导入包 users 中的所有成员import users.User  // 导入类 Userimport users.{User, UserPreferences}  // 仅导入选择的成员import users.{UserPreferences => UPrefs}  // 导入类并且设置别名

def sqrtplus1(x: Int) = {  import scala.math.sqrt  sqrt(x) + 1.0}

package accounts
import _root_.users._

// File: com/example/myapp/package.scala
package com.example
package object myapp {  val appName: String = "MyApp"
  def printAppName(): Unit = {    println(appName)  }}

package com.example.myapp
object Main {  def main(args: Array[String]): Unit = {    println(myapp.appName)  // 直接访问包对象中的常量    myapp.printAppName()    // 直接调用包对象中的方法  }}

trait A {  def printA() = println("A")}
trait B {  def printB() = println("B")}
class C extends A with B
object Main extends App {  val c = new C  c.printA()  c.printB()}
输出：AB

trait Greeter {  def greet(name: String): Unit =    println("Hello, " + name + "!")}

class DefaultGreeter extends Greeter
class CustomizableGreeter(prefix: String, postfix: String) extends Greeter {  override def greet(name: String): Unit = {    println(prefix + name + postfix)  }}
val greeter = new DefaultGreeter()greeter.greet("Scala developer") // Hello, Scala developer!
val customGreeter = new CustomizableGreeter("How are you, ", "?")customGreeter.greet("Scala developer") // How are you, Scala developer?

import scala.collection.mutable.ArrayBuffer
trait Pet {  val name: String}
class Cat(val name: String) extends Petclass Dog(val name: String) extends Pet
val dog = new Dog("Harry")val cat = new Cat("Sally")
val animals = ArrayBuffer.empty[Pet]animals.append(dog)animals.append(cat)animals.foreach(pet => println(pet.name))  // Prints Harry Sally

class Vector2D(val x: Double, val y: Double) {  def +(other: Vector2D): Vector2D = {    new Vector2D(x + other.x, y + other.y)  }}
val v1 = new Vector2D(1.0, 2.0)val v2 = new Vector2D(3.0, 4.0)val sum = v1 + v2
println(sum.x) // 输出：4.0println(sum.y) // 输出：6.0

val num1 = 10val num2 = 5
val sum = num1 + num2val difference = num1 - num2val product = num1 * num2
println(sum)        // 输出：15println(difference)  // 输出：5println(product)     // 输出：50

def callByName(param: => Int): Unit = {  println("Inside callByName")  println("Param 1: " + param)  println("Param 2: " + param)}
def randomNumber(): Int = {  println("Generating random number")  scala.util.Random.nextInt(100)}
callByName(randomNumber())
输出：Inside callByNameGenerating random numberParam 1: 53Generating random numberParam 2: 87

implicit def intToString(x: Int): String = x.toString
val x: String = 1println(x) // 输出 "1"

implicit val x: Int = 1
def foo(implicit x: Int): Unit = println(x)
foo // 输出 1

class MyClass(x: Int) {  def printX(): Unit = println(x)}
val a = new MyClass(1)val b = new MyClass(2)a.printX() // 输出 1b.printX() // 输出 2

class Point(var x: Int = 0, var y: Int = 0)
val origin = new Point  // x and y are both set to 0val point1 = new Point(1)println(point1.x)  // prints 1

class Point(var x: Int = 0, var y: Int = 0)val point2 = new Point(y=2)println(point2.y)  // prints 2

object MyObject {  val x = 1  def printX(): Unit = println(x)}
MyObject.printX() // 输出 1

class MyClass(x: Int) {  private val secret = 42  def printCompanionSecret(): Unit = println(MyClass.companionSecret)}
object MyClass {  private val companionSecret = 24  def printSecret(c: MyClass): Unit = println(c.secret)}
val a = new MyClass(1)a.printCompanionSecret() // 输出 24MyClass.printSecret(a) // 输出 42

case class Person(var name: String, var age: Int)

object Test01 {  case class Person(var name: String, var age: Int)
  def main(args: Array[String]): Unit = {    val z = Person("张三", 20)    z.age = 23    println(s"z = $z")  }}

x match {  case 1 => "one"  case 2 => "two"  case _ => "other"}

val (x, _, z) = (1, 2, 3)

val list = List(1, 2, 3)list.map(_ * 2)

def add(x: Int, y: Int) = x + yval f = add _

println("Hello, world!")

val x = 1println(x)

val x = 1val y = 2println(x + y)

val name = "Alice"val age = 18println(s"My name is $name and I am $age years old.")

object Main {  def main(args: Array[String]): Unit = {    // 定义一个空的字符串列表    var emptyList: List[String] = List()    // 定义一个具有数据的列表    var intList = List(1, 2, 3, 4, 5, 6)    // 定义空列表    var emptyList2 = Nil    // 使用::运算符连接元素    var numList = 1 :: (2 :: (3 :: Nil))    println(emptyList)    println(intList)    println(emptyList2)    println(numList)  }}
输出：List()List(1, 2, 3, 4, 5, 6)List()List(1, 2, 3)

val list = List(1, 2, 3, 4)
// 获取列表的长度val length = list.length
// 获取列表的第一个元素val first = list.head
// 获取列表的最后一个元素val last = list.last
// 获取列表除第一个元素外剩余的元素val tail = list.tail
// 获取列表除最后一个元素外剩余的元素val init = list.init
// 反转列表val reversed = list.reverse
// 在列表头部添加元素val newList1 = 0 +: list
// 在列表尾部添加元素val newList2 = list :+ 5
// 连接两个列表val list1 = List(1, 2)val list2 = List(3, 4)val concatenatedList = list1 ++ list2
// 检查列表是否为空val isEmpty = list.isEmpty
// 检查列表是否包含某个元素val containsElement = list.contains(1)
// 过滤列表中的元素val filteredList = list.filter(_ > 2)
// 映射列表中的元素val mappedList = list.map(_ * 2)
// 折叠列表中的元素（从左到右）val sum1 = list.foldLeft(0)(_ + _)
// 折叠列表中的元素（从右到左）val sum2 = list.foldRight(0)(_ + _)
// 拉链操作val names = List("Alice", "Bob", "Charlie")val ages = List(25, 32, 29)val zipped = names.zip(ages) // List(("Alice", 25), ("Bob", 32), ("Charlie", 29))
// 拉链操作后解压缩val (unzippedNames, unzippedAges) = zipped.unzip // (List("Alice", "Bob", "Charlie"), List(25, 32, 29))

object Main {  def main(args: Array[String]): Unit = {    // 定义一个空的映射    val emptyMap = Map()    // 定义一个具有数据的映射    val intMap = Map("key1" -> 1, "key2" -> 2)    // 使用元组定义一个映射    val tupleMap = Map(("key1", 1), ("key2", 2))    println(emptyMap)    println(intMap)    println(tupleMap)  }}
输出：Map()Map(key1 -> 1, key2 -> 2)Map(key1 -> 1, key2 -> 2)

val map = Map("key1" -> 1, "key2" -> 2)
// 获取映射的大小val size = map.size
// 获取映射中的所有键val keys = map.keys
// 获取映射中的所有值val values = map.values
// 检查映射是否为空val isEmpty = map.isEmpty
// 检查映射是否包含某个键val containsKey = map.contains("key1")
// 获取映射中某个键对应的值val value = map("key1")
// 获取映射中某个键对应的值，如果不存在则返回默认值val valueOrDefault = map.getOrElse("key3", 0)
// 过滤映射中的元素val filteredMap = map.filter { case (k, v) => v > 1 }
// 映射映射中的元素val mappedMap = map.map { case (k, v) => (k, v * 2) }
// 遍历映射中的元素map.foreach { case (k, v) => println(s"key: $k, value: $v") }

// 定义一个从1到5的整数序列，包括1和5val range1 = 1 to 5
// 定义一个从1到5的整数序列，包括1但不包括5val range2 = 1 until 5
// 定义一个从1到10的整数序列，步长为2val range3 = 1 to 10 by 2
// 定义一个从10到1的整数序列，步长为-1val range4 = 10 to 1 by -1

val range = 1 to 5val list = range.toList

val range = 1 to 10 by 2
// 获取序列的起始值val start = range.start
// 获取序列的结束值val end = range.end
// 获取序列的步长val step = range.step
// 获取一个包括结束值的新序列val inclusiveRange = range.inclusive

object Main {  def main(args: Array[String]): Unit = {
    val list = List(1, 2, 3)    val iterator = list.iterator
    // 1. 使用 hasNext 方法来检查迭代器中是否还有元素    val hasMoreElements = iterator.hasNext    println(s"Has more elements: $hasMoreElements")
    // 2. 使用 next 方法来获取迭代器中的下一个元素    val nextElement = iterator.next()    println(s"Next element: $nextElement")
    // 注意：上面的代码已经将迭代器移动到了第二个元素，因此下面的代码将从第二个元素开始执行
    // 3. 使用 size 方法来获取迭代器中元素的个数    val size = iterator.size    println(s"Size: $size")
    val size1 = iterator.size    println(s"Size1: $size1")
    // 注意：上面的代码已经将迭代器移动到了末尾，因此下面的代码将不再有效
    // 4. 使用 contains 方法来检查迭代器中是否包含某个元素    val containsElement = iterator.contains(2)    println(s"Contains element: $containsElement")  }}
输出：Has more elements: trueNext element: 1Size: 2Size1: 0Contains element: false

object Main {  def main(args: Array[String]): Unit = {    // 定义一个包含两个元素的Tuple    val tuple1 = (1, "hello")    println(tuple1)
    // 定义一个包含三个元素的Tuple    val tuple2 = (1, "hello", true)    println(tuple2)
    // 定义一个包含多个不同类型元素的Tuple    val tuple3 = (1, "hello", true, 3.14)    println(tuple3)
    // 访问Tuple中的元素    val firstElement = tuple3._1    val secondElement = tuple3._2    println(s"first element: $firstElement, second element: $secondElement")  }}
输出：(1,hello)(1,hello,true)(1,hello,true,3.14)first element: 1, second element: hello

object Main {  def main(args: Array[String]): Unit = {    val tuple = (1, "hello")    // 交换二元组的元素    // 输出：(hello,1)    val swapped = tuple.swap
    // 使用 copy 方法来创建一个新的 Tuple，其中某些元素被替换为新值    //输出：(1,world)    val newTuple = tuple.copy(_2 = "world")
    // 遍历元素    // 输出： 1 hello    tuple.productIterator.foreach(println)
    // 转换为字符串    // 输出： (1,hello)    val stringRepresentation = tuple.toString
    // 使用 Tuple.productArity 方法来获取 Tuple 中元素的个数    // 输出： 2    val arity = tuple.productArity
    // 使用 Tuple.productElement 方法来访问 Tuple 中的元素    // 输出： 1    val firstElement = tuple.productElement(0)  }}

object Email {  def apply(user: String, domain: String): String = s"$user@$domain"    def unapply(email: String): Option[(String, String)] = {    val parts = email.split("@")    if (parts.length == 2) Some(parts(0), parts(1))    else None  }}
// 测试val address = "john.doe@example.com"address match {  case Email(user, domain) => println(s"User: $user, Domain: $domain")  case _ => println("Invalid email address")}

object Main {  def main(args: Array[String]): Unit = {    println("----while----")    var i = 0    while (i < 5) {      println(i)      i += 1    }
    println("----if----")    val x = 3    if (x > 0) {      println("x大于0")    } else {      println("x小于0")    }  }}
输出：----while----01234----if----x大于0

object Main {  def main(args: Array[String]): Unit = {  println("----for循环----")    for (i <- 1 to 5) {      println(i)    }  }}
输出：----for循环----12345

public class Main {  public static void main(String[] args) {    // 多重for循环    for (int i = 0; i < 3; i++) {      for (int j = 0; j < 3; j++) {        System.out.println(i + " " + j);      }    }  }}

object Main {  def main(args: Array[String]): Unit = {    // 多重for循环    for (i <- 0 until 3; j <- 0 until 3) {      println(i + " " + j)    }  }}
输出：0 00 10 21 01 11 22 02 12 2

object Main {  def main(args: Array[String]): Unit = {    val numbers = for (i <- 1 to 5) yield i * 2    println(numbers)  }}
输出：Vector(2, 4, 6, 8, 10)

object Main {  def main(args: Array[String]): Unit = {    def matchTest(x: Any): String = x match {      case 1 => "one"      case "two" => "two"      case y: Int => "scala.Int"      case _ => "many"    }
    println(matchTest(1))    println(matchTest("two"))    println(matchTest(3))    println(matchTest("test"))  }}
输出：onetwoscala.Intmany

abstract class Notification
case class Email(sender: String, title: String, body: String) extends Notification
case class SMS(caller: String, message: String) extends Notification
def showNotification(notification: Notification): String = {  notification match {    case Email(sender, title, _) =>      s"You got an email from $sender with title: $title"    case SMS(number, message) =>      s"You got an SMS from $number! Message: $message"  }}
val someSms = SMS("12345", "Are you there?")val someEmail = Email("John Doe", "Meeting", "Are we still meeting tomorrow?")
println(showNotification(someSms))println(showNotification(someEmail))

def checkNumberType(number: Int): String = number match {  case n if n > 0 && n % 2 == 0 => "Positive even number"  case n if n > 0 && n % 2 != 0 => "Positive odd number"  case n if n < 0 && n % 2 == 0 => "Negative even number"  case n if n < 0 && n % 2 != 0 => "Negative odd number"  case _ => "Zero"}
// 测试println(checkNumberType(10))    // 输出: Positive even numberprintln(checkNumberType(15))    // 输出: Positive odd numberprintln(checkNumberType(-4))    // 输出: Negative even numberprintln(checkNumberType(-9))    // 输出: Negative odd numberprintln(checkNumberType(0))     // 输出: Zero

def processValue(value: Any): String = value match {  case str: String => s"Received a String: $str"  case num: Int => s"Received an Int: $num"  case lst: List[_] => s"Received a List: $lst"  case _: Double => "Received a Double"  case _ => "Unknown value"}
// 测试println(processValue("Hello"))                // 输出: Received a String: Helloprintln(processValue(10))                     // 输出: Received an Int: 10println(processValue(List(1, 2, 3)))           // 输出: Received a List: List(1, 2, 3)println(processValue(3.14))                    // 输出: Received a Doubleprintln(processValue(true))                    // 输出: Unknown value

sealed abstract class Shape
case class Circle(radius: Double) extends Shapecase class Rectangle(width: Double, height: Double) extends Shapecase class Square(side: Double) extends Shape
def calculateArea(shape: Shape): Double = shape match {  case Circle(radius) => math.Pi * radius * radius  case Rectangle(width, height) => width * height  case Square(side) => side * side}
// 测试val circle = Circle(5.0)val rectangle = Rectangle(3.0, 4.0)val square = Square(2.5)
println(s"Area of circle: ${calculateArea(circle)}")         // 输出: Area of circle: 78.53981633974483println(s"Area of rectangle: ${calculateArea(rectangle)}")   // 输出: Area of rectangle: 12.0println(s"Area of square: ${calculateArea(square)}")         // 输出: Area of square: 6.25

def calculateDiscountedPrice(originalPrice: Double, discountPercentage: Double): Double = {  def applyDiscount(price: Double, discount: Double): Double = {    val discountedPrice = price - (price * discount)    discountedPrice  }
  def validateDiscount(discount: Double): Double = {    val maxDiscount = 0.8 // 最大折扣为80%    if (discount > maxDiscount) {      maxDiscount    } else {      discount    }  }
  val validatedDiscount = validateDiscount(discountPercentage)  val finalPrice = applyDiscount(originalPrice, validatedDiscount)  finalPrice}
// 调用外部方法val price = calculateDiscountedPrice(100.0, 0.9)println(s"The final price is: $price")

object Main extends App {  val emailPattern = "([a-zA-Z0-9_.+-]+)@([a-zA-Z0-9-]+)\\.([a-zA-Z0-9-.]+)".r
  def validateEmail(email: String): Boolean = email match {    case emailPattern(username, domain, extension) =>      println(s"Valid email address: $email")      true    case _ =>      println(s"Invalid email address: $email")      false  }
  // 测试  validateEmail("john.doe@example.com")        // 输出: Valid email address: john.doe@example.com  validateEmail("jane.doe@invalid")            // 输出: Invalid email address: jane.doe@invalid}

class Animalclass Dog extends Animal
class Cage[+A]
val dogCage: Cage[Dog] = new Cage[Dog]val animalCage: Cage[Animal] = dogCage

class Animalclass Dog extends Animal
class Cage[-A]
val animalCage: Cage[Animal] = new Cage[Animal]val dogCage: Cage[Dog] = animalCage

abstract class Animal {  def name: String}
class Dog(val name: String) extends Animal {  def bark(): Unit = println("Woof!")}
class Cat(val name: String) extends Animal {  def meow(): Unit = println("Meow!")}
class Cage[+A](val animal: A) {  def showAnimal(): Unit = println(animal.name)}
def printAnimalNames(cage: Cage[Animal]): Unit = {  cage.showAnimal()}
val dog: Dog = new Dog("Fido")val cat: Cat = new Cat("Whiskers")
val dogCage: Cage[Dog] = new Cage[Dog](dog)val catCage: Cage[Cat] = new Cage[Cat](cat)
printAnimalNames(dogCage) // 输出：FidoprintAnimalNames(catCage) // 输出：Whiskers

abstract class Animal {  def name: String}
class Dog(val name: String) extends Animal {  def bark(): Unit = println("Woof!")}
class Cage[A <: Animal](val animal: A) {  def showAnimal(): Unit = println(animal.name)}
val dog: Dog = new Dog("Fido")val cage: Cage[Animal] = new Cage[Dog](dog)
cage.showAnimal() // 输出：Fido

class Animal {  def sound(): Unit = println("Animal sound")}
class Dog extends Animal {  override def sound(): Unit = println("Dog barking")}
class Cat extends Animal {  override def sound(): Unit = println("Cat meowing")}
def makeSound[A >: Dog](animal: A): Unit = {  animal.sound()}
val dog: Dog = new Dogval cat: Cat = new Cat
makeSound(dog) // 输出：Dog barkingmakeSound(cat) // 输出：Animal sound

class Outer {  private val outerField: Int = 10
  class Inner {    def printOuterField(): Unit = {      println(s"Outer field value: $outerField")    }  }}
val outer: Outer = new Outerval inner: outer.Inner = new outer.Innerinner.printOuterField() // 输出：Outer field value: 10

def outerMethod(): Unit = {  val outerField: Int = 10
  class Inner {    def printOuterField(): Unit = {      println(s"Outer field value: $outerField")    }  }
  val inner: Inner = new Inner  inner.printOuterField() // 输出：Outer field value: 10}
outerMethod()

trait Flyable {  def fly(): Unit}
trait Swimmable {  def swim(): Unit}
class Bird extends Flyable {  override def fly(): Unit = println("Flying...")}
class Fish extends Swimmable {  override def swim(): Unit = println("Swimming...")}
def action(obj: Flyable with Swimmable): Unit = {  obj.fly()  obj.swim()}
val bird: Bird = new Birdval fish: Fish = new Fish
action(bird) // 输出：Flying...action(fish) // 输出：Swimming...

def printType[T](value: T): Unit = {  value match {    case s: String => println("String: " + s)    case i: Int => println("Int: " + i)    case d: Double => println("Double: " + d)    case _ => println("Unknown type")  }}
printType("Hello") // 输出：String: HelloprintType(123) // 输出：Int: 123printType(3.14) // 输出：Double: 3.14printType(true) // 输出：Unknown type

import java.util.Dateobject Main {  def main(args: Array[String]): Unit = {    printCurrentDate() // 输出当前日期和时间  }  def printCurrentDate(): Unit = {    val currentDate = new Date()    println(currentDate.toString)  }}

object Main {  def main(args: Array[String]): Unit = {    greet() // 输出 "Hello, World!"    greet("Alice") // 输出 "Hello, Alice!"  }
  def greet(name: String = "World"): Unit = {    println(s"Hello, $name!")  }}

def applyFuncToList(list: List[Int], f: Int => Int): List[Int] = {  list.map(f)}
val numbers = List(1, 2, 3, 4)val double = (x: Int) => x * 2val doubledNumbers = applyFuncToList(numbers, double) // List(2, 4, 6, 8)

object Main {  def main(args: Array[String]): Unit = {    val add = (x: Int, y: Int) => x + y    println(add(1, 2))  //输出： 3  }}

object Main {  def main(args: Array[String]): Unit = {
    println(divide.isDefinedAt(0)) // false    println(divideSafe.isDefinedAt(0)) // true
    println(divide(1)) // 42    println(divideSafe(1)) // Some(42)
    // println(divide(0)) // 抛出异常    println(divideSafe(0)) // None  }
  val divide: PartialFunction[Int, Int] = {    case d: Int if d != 0 => 42 / d  }
  val divideSafe: PartialFunction[Int, Option[Int]] = {    case d: Int if d != 0 => Some(42 / d)    case _ => None  }
}

def add(a: Int)(b: Int): Int = a + b

val result = add(1)(2) // 3

val addOne = add(1) _val result = addOne(2) // 3

def sum(x: Int, y: Int): Int = {  println("sum函数被执行了...")  x + y}
lazy val res: Int = sum(1, 2)
println("-----")println(res)