带你快速掌握Scala操作———（4）

scala针对每一类集合都提供了一个迭代器（iterator）用来迭代访问集合

	使用iterator方法可以从集合获取一个迭代器
	迭代器的两个基本操作
	hasNext——查询容器中是否有下一个元素
	next——返回迭代器的下一个元素，如果没有，抛出NoSuchElementException
	每一个迭代器都是有状态的
	迭代完后保留在最后一个元素的位置
	再次使用则抛出NoSuchElementException
	可以使用while或者for来逐个返回元素

1.	定义一个列表，包含以下元素：1,2,3,4,5
2.	使用while循环和迭代器，遍历打印该列表

scala> val ite = a.iterator
ite: Iterator[Int] = non-empty iterator

scala> while(ite.hasNext) {
    | println(ite.next)
    | }

1.	定义一个列表，包含以下元素：1,2,3,4,5
2.	使用for 表达式和迭代器，遍历打印该列表

scala> val a = List(1,2,3,4,5)
a: List[Int] = List(1, 2, 3, 4, 5)

scala> for(i <- a) println(i)

scala是支持面向对象的，也有类和对象的概念。我们依然可以基于scala语言来开发面向对象的应用程序。

使用class来定义一个类 new来创建对象

object _01ClassDemo {
 // 创建类
 class Person{}

 def main(args: Array[String]): Unit = {
   // 创建对象
   val p = new Person()
   println(p)
}
}

object _02ClassDemo {

 // 创建类，省略花括号
 class Person

 def main(args: Array[String]): Unit = {
   // 创建对象，省略括号
   val person = new Person
}
}

一个类会有自己的属性，例如：人这样一个类，有自己的姓名和年龄。在类中定义、和访问成员变量

object _03ClassDemo {
 class Person {
   // 定义成员变量
   var name = ""
   var age = 0
}

 def main(args: Array[String]): Unit = {
   // 创建Person对象
   val person = new Person
   person.name = "zhangsan"
   person.age = 20

   // 获取变量值
   println(person.name)
   println(person.age)
}
}

scala中有一个更简洁的初始化成员变量的方式，可以让代码看起来更加简洁。

在定义var类型的成员变量时，可以使用_来初始化成员变量
	String => null
	Int => 0
	Boolean => false
	Double => 0.0
	...
val类型的成员变量，必须要自己手动初始化

object _04ClassDemo {

 class Person{
   // 使用下划线进行初始化
   var name:String = _
   var age:Int = _
}

 def main(args: Array[String]): Unit = {
   val person = new Person
   
   println(person.name)
   println(person.age)
}
}

类可以有自己的行为，scala中也可以通过定义成员方法来定义类的行为。
使用def来定义成员方法

1、创建一个Object，添加main方法
2、创建Customer类，添加成员变量、成员方法
3、在main方法中创建Customer类对象，设置成员变量值(张三、男)
4、调用成员方法

object _05ClassDemo {

 class Customer {
   var name:String = _
   var sex:String = _

   // 定义成员方法
   def sayHi(msg:String) = {
     println(msg)
  }
}

 def main(args: Array[String]): Unit = {
   val customer = new Customer
   customer.name = "张三"
   customer.sex = "男"
   customer.sayHi("你好")
}
}

和Java一样，scala也可以通过访问修饰符，来控制成员变量和成员方法是否可以被访问。

可以在成员前面添加private/protected关键字来控制成员的可见性。 
scala中，没有public关键字，任何没有被标为private或protected的成员都是公共的

在main方法中创建该类的对象，测试是否能够访问到私有成员

object _02AccessDemo {

 class Person {
   // 定义私有成员变量
   private var name:String = _
   private var age:Int = _

   def getName() = name
   def setName(name:String) = this.name = name
   def getAge() = age
   def setAge(age:Int) = this.age = age

   // 定义私有成员方法
   private def getNameAndAge = {
     name -> age
  }
}

 def main(args: Array[String]): Unit = {
   val person = new Person
   person.setName("张三")
   person.setAge(10)

   println(person.getName())
   println(person.getAge())
}
}

当创建类对象的时候，会自动调用类的构造器。之前使用的都是默认构造器， 

Java的构造器，有构造列表和构造代码块

class Person {
   // 成员变量
   private String name;
   private Integer age;

   // Java构造器
   public Person(String name, Integer age) {
       // 初始化成员变量
       this.name = name;
       this.age = age;
  }
}

在scala中， 可以使用更简洁的语法来实现。

class 类名(var/val 参数名:类型 = 默认值, var/val 参数名:类型 = 默认值){
   // 构造代码块
}

	主构造器的参数列表是直接定义在类名后面，添加了val/var表示直接通过主构造器定义成员变量
	构造器参数列表可以指定默认值
	创建实例，调用构造器可以指定字段进行初始化
	整个class中除了字段定义和方法定义的代码都是构造代码

1.	定义一个Person类，通过主构造器参数列表定义姓名和年龄字段，并且设置它们的默认值
2.	在主构造器中输出"调用主构造器"
3.	创建"张三"对象（姓名为张三，年龄为20），打印对象的姓名和年龄
4.	创建"空"对象，不给构造器传入任何的参数，打印对象的姓名和年龄
5.	创建"man40"对象，不传入姓名参数，指定年龄为40，打印对象的姓名和年龄

object _06ConstructorDemo {

  // 定义类的主构造器
  // 指定默认值
  class Person(var name:String = "", var age:Int = 0) {
    println("调用主构造器")
  }

  def main(args: Array[String]): Unit = {
    // 给构造器传入参数
    val zhangsan = new Person("张三", 20)
    println(zhangsan.name)
    println(zhangsan.age)

    println("---")

    // 不传入任何参数
    val empty = new Person
    println(empty.name)
    println(empty.age)

    println("---")

    // 指定字段进行初始化
    val man40 = new Person(age = 40)
    println(man40.name)
    println(man40.age)
  }
} 

除了主构造器之外的构造器称为辅助构造器。
例如：允许通过多种方式，来创建对象，这时候就可以定义其他更多的构造器。 

	定义辅助构造器与定义方法一样，也使用def关键字来定义
	这个方法的名字为this
def this(参数名:类型, 参数名:类型) {
    // 第一行需要调用主构造器或者其他构造器
    // 构造器代码
}

辅助构造器的第一行代码，必须要调用主构造器或者其他辅助构造器

示例说明
	定义一个Customer类，包含一个姓名和地址字段
	定义Customer类的主构造器（初始化姓名和地址）
	定义Customer类的辅助构造器，该辅助构造器接收一个数组参数，使用数组参数来初始化成员变量
	使用Person类的辅助构造器来创建一个"zhangsan"对象
	姓名为张三
	地址为北京
	打印对象的姓名、地址

object _07ConstructorDemo {
  class Customer(var name:String = "", var address:String = "") {
    // 定义辅助构造器
    def this(arr:Array[String]) = {
      // 辅助构造器必须要调用主构造器或者其他辅助构造器
      this(arr(0), arr(1))
    }
  }

  def main(args: Array[String]): Unit = {
    val zhangsan = new Customer(Array("张三", "北京"))

    println(zhangsan.name)
    println(zhangsan.address)
  }
}

scala中没有Java中的静态成员，若想要定义类似于Java的static变量、static方法，就要使用到scala中的单例对象——object.

单例对象表示全局仅有一个对象（类似于Java static概念）
	定义单例对象和定义类很像，就是把class换成object
	在object中定义的成员变量类似于Java的静态变量
	可以使用object直接引用成员变量

示例说明
	定义一个Dog单例对象，保存狗有几条腿
	在main方法中打印狗腿的数量

	object _08ObjectDemo {
	
	  // 定义一个单例对象
	  object Dog {
	    // 定义腿的数量
	    val LEG_NUM = 4
	  }
	
	  def main(args: Array[String]): Unit = {
	    println(Dog.LEG_NUM)
	  }
	}

在单例对象中定义成员方法
	在object中定义的成员方法类似于Java的静态方法

示例说明
	设计一个单例对象，定义一个能够打印分割线（15个减号）的方法
	在main方法调用该方法，打印分割线

object _09ObjectDemo {

  object PrintUtil {

    // 打印分割线
    def printSpliter() = {
      // 字符串乘法，表示返回多少个字符串
      println("-" * 10)
    }
  }

  def main(args: Array[String]): Unit = {
    PrintUtil.printSpliter()
  }
}

	编写一个DateUtil工具类专门用来格式化日期时间
	定义一个方法，用于将日期（Date）转换为年月日字符串，例如：2030-10-05

	定义一个DateUtil单例对象，定义日期格式化方法（format）
	使用SimpleDateFormat将日期转换为字符串

object _10ObjectDemo {

  object DateUtils {
    // 在object中定义的成员变量，相当于Java中定义一个静态变量
    // 定义一个SimpleDateFormat日期时间格式化对象
    val simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm")

    // 相当于Java中定义一个静态方法
    def format(date: Date) = simpleDateFormat.format(date)
  }

  // main是一个静态方法，所以必须要写在object中
  def main(args: Array[String]): Unit = {
    println(DateUtils.format(new Date()))
  }
}

scala和Java一样，如果要运行一个程序，必须有一个main方法。在Java中main方法是静态的，而在scala中没有静态方法。在scala中，这个main方法必须放在一个单例对象中。

main方法
def main(args:Array[String]):Unit = {
    // 方法体
}

示例说明
	创建一个单例对象，在该单例对象中打印"hello, scala"

object Main5 {
  def main(args:Array[String]) = {
    println("hello, scala")
  }
}

实现App Trait来定义入口
创建一个object，继承自App Trait（特质），然后将需要编写在main方法中的代码，写在object的构造方法体内。
object 单例对象名 extends App {
    // 方法体
}

示例说明
	继承App特质，来实现一个入口。同样输出"hello, scala"

object Main5 extends App {
  println("hello, scala")
}

在Java中，经常会有一些类，同时有实例成员又有静态成员。例如：

public class CustomerService {

private static String SERVICE_NAME = "CustomerService";

public void save() {
    // 保存客户
    System.out.println(SERVICE_NAME + ":保存客户");
}

public static void main(String[] args) {
    new CustomerService().save();
}
}

在scala中，要实现类似的效果，可以使用伴生对象来实现。

一个class和object具有同样的名字。这个object称为伴生对象，这个class称为伴生类
	伴生对象必须要和伴生类一样的名字
	伴生对象和伴生类在同一个scala源文件中
	伴生对象和伴生类可以互相访问private属性

示例说明
	编写一个CustomerService类，有一个save方法，打印
	服务类名称:保存客户
	编写一个CustomerService伴生对象，定义一个私有变量，用于保存服务类名称
	创建CustomerService对象，调用save方法

object _11ObjectDemo {

  class CustomerService {
    def save() = {
      println(s"${CustomerService.SERVICE_NAME}:保存客户")
    }
  }

  // CustomerService的伴生对象
  object CustomerService {
    private val SERVICE_NAME = "CustomerService"
  }

  def main(args: Array[String]): Unit = {
    val customerService = new CustomerService()
    customerService.save()
  }
}

如果某个成员的权限设置为private[this]，表示只能在当前类中访问。伴生对象也不可以访问

示例说明
	定义一个Person类，包含一个name字段
	定义Person类的伴生对象，定义printPerson方法
	测试伴生对象是否能访问private[this]权限的成员

  class Person(private[this] var name:String)
  
  object Person {
    def printPerson(person:Person): Unit = {
      println(person.name)
    }
  }
  
  def main(args: Array[String]): Unit = {
    val person = new Person("张三")
    Person.printPerson(person)
  }

scala语言是支持面向对象编程的， 可以使用scala来实现继承，通过继承来减少重复代码。

	使用extends关键字来实现继承
	可以在子类中定义父类中没有的字段和方法，或者重写父类的方法
	类和单例对象都可以从某个父类继承

class/object 子类 extends 父类 {
    ..
}

	定义一个Person类，再定义一个Student类，继承自Person类

	创建一个Student类对象实例，并设置name为“张三”
	打印姓名

class Person {
  var name = "super"

  def getName = this.name
}
class Student extends Person

object Main13 {
  def main(args: Array[String]): Unit = {
val p1 = new Person()
val p2 = new Student()

p2.name = "张三"

println(p2.getName)

	创建一个Student单例对象，让单例对象继承示例1中的Person类
	设置单例对象的名字为"张三"，调用Student单例对象的getName方法

class Person {
  var name = "super"

  def getName = this.name
}

object Student extends Person

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

    println(Student.getName)
  }
}

类似于Java语言， 在子类中使用override需要来重写父类的成员，可以使用super来引用父类

	子类要覆盖父类中的一个方法，必须要使用override关键字
	使用override来重写一个val字段
	使用super关键字来访问父类的成员方法

示例说明
	定义一个Person类，包含
	姓名字段（不可重新赋值）
	获取姓名方法
	定义一个Student类
	重写姓名字段
	重写获取姓名方法，返回"hello, " + 姓名
	创建Student对象示例，调用它的getName方法

class Person {
  val name = "super"

  def getName = name
}

class Student extends Person {
  // 重写val字段
  override val name: String = "child"

  // 重写getName方法
  override def getName: String = "hello, " + super.getName
}

object Main13 {
  def main(args: Array[String]): Unit = {
    println(new Student().getName)
  }
}