大数据利器--Scala语言学习(基础)

//对 scala 的基本的程序结构说明
//1. object 是一个关键字，表示一个伴生对象
//2. 如果该文件只出现了一个 object HelloScala 就会在编译后两个.class 文件
//3. 第一个文件是 HelloScala.class 这个表示他的伴生类，但是空的.
//4. 第 2 个文件是 HelloScala$.class 对应的是 object HelloScala,但是本质是调用它对应的一个静态属性 MODULE$
//5. 这两个文件的关系和 main 函数的入口关系一会分析
object HelloScala {
  // 1. def 表示一个方法或者一个函数
  // 2. main 表示入口
  // 3. args: Array[String] 表示形参，args 是形参名 Array[String] 是形参类型表示一个 Array 数组
  // 4. :Unit 表示返回值类型为 Unit ，等价于 java 的 void
  // 5. = 表示 后面写的是函数体/方法体, 它还有返回值类型推导的作用
  def main(args: Array[String]):Unit = {
    // 表示是 输出， 类似 System.out.println("hello, scala 世界!")
    // 在 scala 语句后，不需要带; //体现简洁
    println("hello, scala 世界!")
  }
}

object Demo1 {

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

    lazy val res = sum(1, 2, 3, 4, 6)
    println(res) //使用res时，才会真正的开始计算

  }
  def sum(args: Int*): Int = {
    var res = 0
    for (n <- args) {
      res += n
    }
    res
  }
}

def main(args: Array[String]): Unit = {
    
    //scala 中去掉所谓的 checked（编译） 异常
    //设计者认为，如果程序员编程时，认为某段代码可疑，就直接 try 并处理
    //说明
    //1. 如果代码可疑，使用 try 进行处理
    //2. 在 catch 中，可以有多个 case ，对可能的异常进行匹配
    //3. case ex: Exception => println("异常信息=" + ex.getMessage)
    // (1) case 是一个关键字
    // (2) ex: Exception 异常的种类
    // (3) => 表明后的代码是对异常进行处理,如果处理的代码有多条语句可以{}扩起
    //4. 在 scala 中把范围小的异常放在后面，语法不会报错，但是不推荐
    //5. 如果捕获异常，代码即使出现异常，程序也不会崩溃。
    
  try{
    var n = 10 /0
  }catch {
    case ex:ArithmeticException=>{
      println("异常："+ex.getMessage)
    }
    case exception: Exception=>{
      println(exception.getMessage)
    }
  }finally {
    printf("完成")
  }
}

@throws (classOf[ArithmeticException])
def function1(): Unit ={
  var n = 10/0
}

class  类名( 形参列表) { //  主构造器
//  类体
def this( 形参列表) { //  辅助构造器
	}
def this( 形参列表) { // 辅助构造器可以有多个...
	}
}

class Cat {
    
  @BeanProperty var name: String = ""
  @BeanProperty var age: Int = 0
  @BeanProperty var color: String = ""

  def this(name: String) {
    this()
    this.name = name
  }

  override def toString = s"Cat($name, $age, $color)"
}

class Dog {
//import 可以放在任何的地方，同时他的作用范围就是{} 块中
//import 如果使用到 3 次及以上，则可以放在文件前面,否则可以使用就近引入.
import scala.beans.BeanProperty
@BeanProperty var name : String = ""
}

//Java 中如果想要导入包中所有的类，可以通过通配符*，Scala 中采用下 _
//如果不想要某个包中全部的类，而是其中的几个类，可以采用选取器,使用{} 括起来即可。

//如果有多个同名的类或者 trait 等，可以使用 scala 重命名的机制来解决.
import java.util.{ HashMap=>JavaHashMap, List}

//如果某个冲突的类根本就不会用到，那么这个类可以直接隐藏掉
import java.util.{ HashMap=>_, _} // 含义为 引入 java.util 包的所有类，但是忽略 HahsMap 类

def main(args: Array[String]): Unit = {
  var student = new student
  student.name = "michong"
  student.num = "123123"

  student.getInfo()
}

class person {

  var name: String = _

  def getInfo(): Unit = {
    println("姓名：" + name)
  }
}

class student extends person {

  var num: String = _

  override def getInfo(): Unit = {
    super.getInfo()
    println("学号：" + num)
  }
}

var student:person = new student
student.name = "michong"
student.asInstanceOf[student].num = "123123"

abstract class person {
  var name:String
}

class student extends person {
  var name:String=""
}

def main(args: Array[String]): Unit = {
  //抽象类，他不能实例化，我们可以通过匿名子类的方式创建一个实例
  val p = new person {
    override var name: String = "123"
    override def info(): Unit = {
      println("test")
    }
  }
  p.info()
}

abstract class person {
  var name:String
  def info()
	}
}

package cn.buildworld.scala.day2

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

    val p1 = new Person("michong")
    val p2 = new Person("qjzxzxd")
    val p3 = new Person("米虫")

    Person.joinGroup(p1)
    Person.joinGroup(p2)
    Person.joinGroup(p3)

    Person.showInfo()
  }

  class Person(pname: String) {
    var name: String = pname
  }

  object Person {

    var num: Int = 0

    def joinGroup(person: Person): Unit = {
      num += 1
      println(person.name + "--加入组织")
    }

     def showInfo(): Unit ={
       println("当前"+num+"人")
     }

    def say(): Unit = {
      println("Say Hi")
    }
  }
}

trait 名 特质名 {
trait 体 体
}

1) trait 命名 一般首字母大写.
2) 在 scala 中，java 中的接口可以当做特质使用

#没有父类
class 类名 extends 质 特质 1 with 质 特质 2 with 质 特质 3 ..
#有父类
class 类名 extends 父类 with 质 特质 1 with 质 特质 2 with

package cn.buildworld.scala.day2

object demo2 {

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

    val c = new C
    c.getConnect("root","123456")

    // 带有特质的对象，动态混入
    val b = new B with Trait1{
      override def getConnect(user: String, pwd: String): Unit = {
        println("用户登录信息：user: "+user+" pwd: "+pwd)
      }
    }

    b.getConnect("root","123456")
  }

  trait Trait1{
    def getConnect(user:String,pwd:String): Unit
  }

  class A{}

  class B extends A{}

  class C extends A with Trait1{
    override def getConnect(user: String, pwd: String): Unit = {
      println("用户登录信息：user: "+user+" pwd: "+pwd)
    }
  }

  class D{}

  class E extends D with Trait1{
    override def getConnect(user: String, pwd: String): Unit = {}
  }
}

#在Logger中已经可以使用Exception中的相关的方法了
trait Logger{
  this:Exception=>

  def log()={
    println(getMessage)
  }
}

#使用MyLogger时先继承Exception类
class MyLogger extends Exception with Logger {}

class AAA{

  myOuter=>
  class InnerAAA{

    //使用别名的方式来访问外部类的属性和方法，相当于 myouter 是一个外部类的实例 AAA.this
    //这时需要将外部类的属性和方法的定义/声明放在别名后
    def test(innerAAA: InnerAAA): Unit ={
      println(innerAAA)

      println(myOuter.name)
      println(myOuter.sal)
    }
  }

  var name:String=_
  private var sal:Double=_
}

package cn.buildworld.scala.day2

object demo5 {

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

    //隐式值
    implicit val str1:String = "michong"

    def hello(implicit name:String): Unit ={
      println(name)
    }
    hello

  }

}

package cn.buildworld.scala.day2

object demo5 {

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

    val db = new MySql
    db.add()
  }

    
  //隐式类
  implicit class DB(val m :MySql){
    def add(): Unit ={
      println("添加")
    }
  }
  class MySql{}

}

package cn.buildworld.scala.day2

object demo4 {

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

    //隐式函数
    implicit def addDelete(mySql: MySql):DB={
       new DB
    }
 
    var db = new MySql
    db.delete()

  }

  class MySql{}

  class DB {
    def delete(): Unit ={
      println("删除数据！！！")
    }
  }
}