Scala包

1. 基本语法：
   package 包名
2. Scala包的三大作用（和Java一样）
   1.区分相同名字的类
   2.当类很多时，可以很好的管理类
   3.控制访问范围

包的命名

1. 命名规则
   只能包含数字、字母、下划线、小圆点.，但不能用数字开头，也不要使用关键字。
2. 案例实操
   demo.class.exec1 //错误，因为 class 关键字
   demo.12a //错误，数字开头
3. 命名规范
   一般是小写字母+小圆点
   com.公司名.项目名.业务模块名
4. 案例实操
   com.admin.oa.model
   com.admin.oa.controller
   com.sohu.bank.order

包的好处

1. 便于管理
2. 便于区分同名包

java中包的用法

1. 导包
   语法：

import 包.*/ import 包.类名

位置：

必须处于java源文件中，声明包(package)之后，类(class) 之前

2. 声明包

scala中包的用法

1. 导包
   位置：可以导入到任何位置中
   声明包下:

import  java.util._
object Demo07 {}

object中：

object Demo07 {
  import  java.util._
}

class 中

class Student{
  import  java.util._
}

函数中

  def sayHello():Unit={
    import  java.util._
  }

导包的几种方式：

1. 导入包总所有的类

import 包名._

import  java.util._

2. 导入包下有一个类

import 包名.类名

import  java.util.ArrayList

3. 同时导入包中多个指定的类

import 包名.{类名,...}

import  java.util.{ArrayList,HashMap,LinkedList}

4. 取别名

import 包名.{类名=>别名,...}

  def sayHello():Unit={
    import  java.util.{ArrayList=>myList,HashMap=>myHash}
    
    val list=new myList[String]()
    list.add("张三")
    list.add("李四")
    list.add("王五")
  }

5. 导入包下除开某个类的所有类（鸡肋，基本不用）

import 包名.{类名=>,}

import  java.util.{ArrayList=>_,_}

2. 声明包
   语法： package 报名
   声明包必须在源文件的第一行。

3. 创建包
   语法：

package 包名{}

package my_package{}

注意：这里不像创建类那样，若未定义内容{} 可以省略。在这里不行。

使用：

package my_package{

  object ddd{

    def main(args: Array[String]): Unit = {
      println("my_package.....") // my_package.....
    }
  }

}

此种方式创建的包，只能在classes目录下才能看到。

4. 包对象
   语法：

package object 包名{}

package com.admin

package object xxx {

}

xxx 是怎么来的？当然不是我输入的，包名就是 xxx；

注意：不要去改包对象名称，必须要与包名保持一致。

包对象的作用：

1. 可以用于存放一些该包下公共的属性和方法。
2. 包对象中，定义的非private属性与方法在当前包下，任何位置都可以访问。

5. 包与权限
   语法：

private [包名]

代表修饰的属性或方法，只能在指定包中使用。

  class  Person{
    private[xxx] var name:String=_
    
    private[xxx] def sayHello():Unit={}
  }

类和对象

定义类与对象

1. 语法：
   java 定义类

[修饰符] class 类名{类体}

scala 定义类，不用指定修饰符

class 类名[(参数列表)]{类体}

2. 说明：
   1.Scala语法中，类并不声明为public，所有这些类都具有公有可见性（即默认就是public）
   2.一个Scala源文件可以包含多个类

案例：

class Person{}
class Student{}

若 类中什么都没做，{} 是可以省略的。

class Person
class Student

3. 创建对象
   java ：采用 new 关键字

类型 名称=new 类(...)

scala : 也是采用 new 关键字

var/val 名称:类型=new 类(...)

案例：

  def main(args: Array[String]): Unit = {
    val student:Student=new Student()
  }

若未指定构造器(默认的构造器)，() 可以省略

  def main(args: Array[String]): Unit = {
    val student:Student=new Student
  }

---

属性

属性是类的一个组成部分
基本语法：
java:

[修饰符] 类型 属性名=[属性值]

scala

[修饰符] var/val 属性名 [:类型]=[属性值]

案例：

class Person{
  var name:String=""
  var age:Int=0
  var sex:Char='M'
}

当然也可以成修饰符private
Scala语法中，类并不声明为public，所有这些类都具有公有可见性（即默认就是public）

 private var name:String=""

在 class 中定义属性的时候使用 var 修饰的属性可以使用_赋予初始值

class Person{
  private var name:String=_
  var age:Int=_
  var sex:Char=_
}

引用类型：null
整数类型：0
浮点类型：0.0
布尔类型：false

使用_的时候必须指定类型
使用_ 不能定义于 val 修饰的属性上。

class Person{
  private var name="" // 可以自动推断，name 类型
  var age=_ // 报错；不能指定类型，_无法分配默认值。
}

类型自定推断；当对属性名设置了默认值时，可以不用指定属性对应的类型，可以自动推断出该属性的类型

class Person{

  private var name="张三"
  val age=18
  var sex='男'
  private  val bobby="打篮球"
}

方法

方法定义：
java:

[修饰符] 返回值类型 方法名(参数类型，参数名称,...){方法体}

scala

[修饰符] def 方法名(参数名称:参数类型,...):返回值类型={方法体}

案例：
定义

class Person{

  private var name="张三"
  val age=18
  var sex='男'
  private  val bobby="打篮球"
  
  /**
   * 输出用户信息
   * @return
   */
  def getInfo():String={
    s"姓名：$name，年纪：$age 性别：$sex 爱好：$bobby"
  }

}

调用：

  def main(args: Array[String]): Unit = {
    val p:Person=new Person
    println(p.getInfo()) // 姓名：张三，年纪：18 性别：男 爱好：打篮球
  }

在javabean规范中，应该对属性定义 get/set 方法，在scala中也有默认 get/set 方法。

默认的set 方法就是：属性名=新值

 def main(args: Array[String]): Unit = {
    val p:Person=new Person
    p.sex='女'

    println(p.getInfo()) // 姓名：张三，年纪：18 性别：女 爱好：打篮球
  }

默认的get方法就是属性名。

  def main(args: Array[String]): Unit = {
    val p:Person=new Person
    println(s"年纪：${p.age}") // 18
  }

构造器

scala构造器方法分为两种：主构造器、辅助构造器

主构造器

定义位置：

定义在类名后面以()的形式表示

语法：

class 类名([修饰符] val/var 属性名:类型[=默认值],...)

案例

class Person(private val id:Int=1,val name:String,val sex:Char='男',var age:Int){}

在主构造器中使用 var/val 的区别与不使用 var/val 的区别？

使用 var/val 非 private 修饰的，在class内部与外部都可以访问

不使用 var/val 修饰的属性，只能在class内部使用

辅助构造器

定义位置

定义在class内部

语法：

def this(参数列表){
// 辅助构造器第一行必须调用其他构造器（主构造器或辅助构造器）。
this(参数列表)
}

定义辅助构造器

class Person(private val id:Int=1,val name:String="王五",val sex:Char='男',var age:Int=19){
  // 定义辅助构造器
  def this(id:Int,name:String){
    // 调用主构造器
    this(id,name,sex='男',age=24)
  }

  def getInfo(): String ={
    s"ID：$id，姓名：$name，性别：$sex ,年龄：$age"
  }
}

使用辅助构造器

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

    val p =new Person(100,"王富贵") // ID：100，姓名：王富贵，性别：男 ,年龄：24

    println(p.getInfo())

  }

主构造器只能有一个，但是辅助构造器可以有多个。

class Person(private val id:Int=1,val name:String="王五",val sex:Char='男',var age:Int=19){

  // 定义辅助构造器
  def this(id:Int,name:String){
    // 调用主构造器
    this(id,name,sex='男',age=24)
  }
  
  // 定义第二个辅助构造器
  def this(name:String){
    // 调用另一个辅助构造器
    this(id=20,name)
  }

  def getInfo(): String ={
    s"ID：$id，姓名：$name，性别：$sex ,年龄：$age"
  }
  
}

使用

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

    val p =new Person("汪峰") // ID：20，姓名：汪峰，性别：男 ,年龄：24

    println(p.getInfo())
  }

在class中编写代码：（不知道怎么描述，看案例应该就能明白了）

java：

public class Person{
   System.out.println("hello world...")
}

scala：

class Person{
    println("hello world...")
}

结果是什么？
毋庸置疑；java的肯定会报错。那scala 呢？

  class Person2{
    println("hello world...")
  }

  def main(args: Array[String]): Unit = {
    // println正常输出
    val p2 =new Person2 // hello world...
  }

也许你可能想到，这有点类似于java中代码块

public class Person{
   {
     System.out.println("hello world...")
   }
}

或者静态代码块

public class Person{
   static{
     System.out.println("hello world...")
   }
}

在 scala中，在class中的代码不是属性或函数， 它会统一放到主构造器中执行。
于是在对类进行初始化的时候就被执行了，这点很重要。

---

案例一：对构造器设值

class Person(private val id:Int=1,val name:String,val sex:Char='男',var age:Int){
  def getInfo(): String ={
    s"ID：$id，姓名：$name，性别：$sex ,年龄：$age"
  }
}

  def main(args: Array[String]): Unit = {
    val p =new Person(name = "张三",age = 18,id = 10)
    println(p.getInfo()) // ID：10，姓名：张三，性别：男 ,年龄：18
  }

案例二：对构造器中未定义默认值的属性赋值

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

    val p =new Person(name = "李四",age = 20)

    println(p.getInfo()) // ID：1，姓名：李四，性别：男 ,年龄：20

  }

案例三：构造器中都设有默认值，可以带括号

class Person(private val id:Int=1,val name:String="王五",val sex:Char='男',var age:Int=19){}

省略了重复的代码

 def main(args: Array[String]): Unit = {
    val p =new Person()
    println(p.getInfo()) // ID：1，姓名：王五，性别：男 ,年龄：19
  }

或者

 def main(args: Array[String]): Unit = {
    val p =new Person
    println(p.getInfo()) // ID：1，姓名：王五，性别：男 ,年龄：19
  }

总结

类：
类并不用声明成public ，默认就是public ，对所有都是可见的。
定义：class 类名[(参数列表)]{类体}
若类中没有任何声明，可以不加{}
类中有一个主构造器，多个辅助构造器，声明辅助构造器必须调用主构造器或其他辅助构造器。
声明辅助构造器使用 def this(){} 进行声明。
对象：
创建对象，使用 new 关键字。
若创建对象时无需传参，可以不用加()
属性：
语法：[修饰符] var/val 属性名 [:类型]=[属性值]
若该属性为 var 修饰，可以使用_ 初始默认值
使用 _ 必须指定参数类型
当手动为属性初始化默认值时，可以不用指定参数类型，可以自动推断。
方法：
在class 定义方法和之前的没有任何差别。可以使用 def 关键字