第一章.面向对象

1.Scala包

  1. package com.atguigu.chapter06
  3. object $01_Package {
  4.   /**
  5.    * 包的好处:1.便于区分同名类   2.便于管理
  6.    * java中对于包的用法:
  7.    * 1.导包:导包的位置必须在package声明之后,类名之前
  8.    * 2.导入包下某个类: import 包名.类名
  9.    * 3.导入包下所有类: import 包名.*
  10.    * 4.声明包: 语法 package 包名    声明包必须在源文件第一行
  11.    * scala中对于包的用法
  12.    * 1.导包:scala可以在任意位置导入包
  13.    * a.导入包下某个类: import 包名.类名
  14.    * b.导入包下所有类: import 包名._
  15.    * c.导入包下多个类: import 包名.{类名1,类名2,....}
  16.    * d.导入包下某个类,并起别名: import 包名.{类名=>别名}
  17.    * e.导入包下除开某个类的所有类: import 包名.{类名=>_ , _}
  18.    * 2.声明包
  19.    * a.语法: package 包名
  20.    * b.声明包必须在源文件第一行
  21.    * 3.创建包
  22.    * a.语法: package 包名{....}
  23.    * b.此种方式创建的包只能在classes目录才能看到
  24.    * 4.包对象
  25.    * a.语法: package object 包名{...}
  26.    * b.包对象定义的非private的属性和方法可以在包中任何位置使用
  27.    * 5.包与访问修饰符结合
  28.    * a.语法: private[包名] val 属性名:类型 = 值
  29.    * b.private[包名]修饰的成员只能在指定的包下使用,其他包不能使用
  30.    */
  31.   private[chapter06] val sex = "man" //包与访问修饰符结合
  33.   import java.util.{HashMap => JavaHashMap} //导入包下所有类
  35.   class Person
  37.   def main(args: Array[String]): Unit = {
  38.     val map = new JavaHashMap[String, Int]()
  39.     val p = new xx.Person
  40.   }
  44. }
  45. package xx{
  46.   class Person
  47. }

2.定义Class

  1. package com.atguigu.chapter06
  3. object $02_ClassDefined {
  4.   /**
  5.    * java创建类:[访问修饰符] class 类名{....}
  6.    * java创建对象: new 类名(....)
  7.    *
  8.    * scala创建类: class 类名{......}
  9.    * scala创建对象: new 类名(.......)
  10.    */
  11.   class Person{}
  13.   def main(args: Array[String]): Unit = {
  14.     val person = new Person
  15.     println(person)
  16.   }
  18. }

3.定义属性和方法

  1. package com.atguigu.chapter06
  3. object $03_ClassFieldAndMethod {
  4.   /**
  5.    * java中class定义属性:[访问修饰符] 类型 属性名 = 值
  6.    * java中class定义方法: [访问修饰符] 返回值类型 方法名(参数类型 参数名,...){...}
  7.    * scala中class定义属性: [访问修饰符] val/var 属性名:类型 = 值
  8.    *  scala中默认是public效果
  9.    *  scala在class中定义属性的时候var修饰的属性可以通过_赋予初始值
  10.    * scala中class定义方法: [访问修饰符] def 方法名(参数名:类型,...):返回值类型 = {....}
  11.    *
  12.    */
  13.   class Person{
  14.     //定义属性
  15.     val name:String = "zhangsan"
  16.     //scala在class中定义属性的时候var修饰的属性可以通过_赋予初始值
  17.     var age:String = _
  18.     val func = (x:Int,y:Int) => x + y
  19.     private val address = "shenzhen"
  20.     private def add(x:Int,y:Int) = x + y
  21.   }
  23.   def main(args: Array[String]): Unit = {
  24.     val person = new Person
  25.     println(person.name)
  26.     println(person.age)
  27.     println(person.func(10, 20))
  28.     //println(person.address)
  29.     //println(person.add(10, 20))
  30.   }
  32. }

4.构造器

  1. package com.atguigu.chapter06
  3. object $04_Contruct {
  4.   /**
  5.    * java中构造器的定义
  6.    *  1.定义位置: 定义在类内部
  7.    *  2.语法: 访问修饰符 类名(参数类型 参数名,...){...}
  8.    *
  9.    * scala中构造器分为两种
  10.    *  a.主构造器
  11.    *    1.定义位置: 定义在类名后面
  12.    *    2.语法: class 类名([访问修饰符] [val/var] 属性名:类型 [=默认值],....)
  13.    *      主构造器使用val/var修饰的属性与不使用val/var修饰的属性属性的区别
  14.    *        使用val/var修饰的非private属性可以在class内部/外部都可以使用
  15.    *        不使用val/var修饰的属性只能在class内部使用
  16.    *
  17.    *  b.辅助构造器
  18.    *    1.定义位置: 定义在class内部
  19.    *    2.语法: def this(参数名:类型){
  20.    *    //辅助构造器第一行必须调用其他的辅助构造器或者主构造器
  21.    *           this(...)
  22.    *    }
  23.    */
  24.   class Person(private val name:String = "zhangsan",var age:Int = 20,address:String){
  25.     var money:Double = _
  26.     var flag:Boolean = _
  27.     def this(flag:Boolean){
  28.       this(address="beijing")
  29.       this.flag = flag
  31.     }
  32.     def this(money:Double){
  33.       this(true)
  34.       this.money=money
  35.     }
  36.   }
  38.   def main(args: Array[String]): Unit = {
  39.     val person = new Person(address = "beijing")
  40.     //println(person.name)
  41.     println(person.age)
  42.     //println(person.address)
  43.     val person1 = new Person(10.0)
  44.     println(person1.flag)
  45.     println(person1.money)
  46.     val person2 = new Person(false)
  47.     println(person2.flag)
  48.   }
  50. }

5.封装

  1. package com.atguigu.chapter06
  3. import com.alibaba.fastjson.JSON
  4. import com.alibaba.fastjson.serializer.SerializeFilter
  7. import scala.beans.BeanProperty
  9. object $05_Private {
  11.   class Person{
  12.     @BeanProperty
  13.     var name:String = _
  14.     @BeanProperty
  15.     var age:Int = _
  17.     /*def setName(name:String) = this.name =name
  18.     def setAge(age:Int) = this.age =age
  19.     def getName()= this.name
  20.     def getAge()= this.age*/
  23.     /**
  24.      * java很多Api底层都需要set/get方法,scala为了兼容java的Api,提供了一个注解@BeanProperty,该注解能够自动生成set/get方法
  25.      *     @BeanProperty注解不能用于private修饰的属性上
  26.      *
  27.      */
  29.   }
  30.   def main(args: Array[String]): Unit = {
  31.     val person = new Person
  32.     /*person.name="lisi"
  33.     person.age=20
  34.     println(person.name)*/
  35.     person.setName("zhaoliu")
  36.     person.setAge(18)
  37.     println(person.getName())
  38.     //对象转json
  39.     val json = JSON.toJSONString(person, null.asInstanceOf[Array[SerializeFilter]])
  40.     println(json)
  41.   }
  43. }

6.继承

  1. package com.atguigu.chapter06
  3. import scala.util.Random
  5. object $06_Extends {
  6.   /**
  7.    * java通过extends关键字实现继承
  8.    * java通过@overwrite注解实现方法的重写
  9.    *
  10.    * scala通过extends关键字实现继承
  11.    * 哪些不能被继承
  12.    *    final修饰的class不能被继承
  13.    *    父类中private修饰的成员不能被继承
  14.    * scala子类可以通过override关键字实现方法实现方法与val属性的重写
  15.    * var修饰的属性不能被重写
  16.    * scala子类中可以通过super关键字调用父类的方法和属性
  17.    * scala中的属性和方法都能做到多态,java只能方法多态
  18.    */
  19.    class Person{
  20.     private val name = "lisi"
  21.     var age:Int = _
  22.     val address:String = "shenzhen"
  23.     def add(x:Int,y:Int) = x+y
  25.   }
  27.   class Student extends Person{
  28.     //override var age:Int =0
  29.     override val address:String="beijing"
  30.     override def add(x:Int,y:Int):Int={
  31.       x*y
  32.     }
  34.   }
  35.   class Student2 extends Person{
  36.     override val address:String="tianjin"
  38.     override def add(x: Int, y: Int): Int = x-y
  39.   }
  41.   def main(args: Array[String]): Unit = {
  42.     val student = new Student
  43.     println(student.age)
  44.     println(student.address)
  45.     println(student.add(10, 20))
  46.     val person = getPerson()
  47.     println(person.add(20, 10))
  48.     val p:Person = new Student
  49.     println(p.address)
  51.   }
  52.   def getPerson():Person={
  53.     val index = Random.nextInt(10)
  54.     if(index % 2 ==0) new Student
  55.     else new Student2
  56.   }
  57. }

7.抽象类

  1. package com.atguigu.chapter06
  3. object $07_Abstract {
  4.   abstract class Animal{
  5.     //具体属性
  6.     val name:String ="lisi"
  7.     //抽象属性
  8.     val age:Int
  9.     //具体方法
  10.     def add(x:Int,y:Int):Int=x+y
  11.     //抽象方法
  12.     def m1(x:Int,y:Int):Int
  13.   }
  15.   class Dog extends Animal{
  16.     override val age:Int = 20
  17.     override def m1(x:Int,y:Int):Int = x-y
  18.   }
  20.   /**
  21.    * java中抽象类的定义: abstract class 类名{...}
  22.    *
  23.    * scala中抽象类的定义: abstract class 类名{....}
  24.    *  抽象方法: 没有方法体的方法称之为抽象方法
  25.    *  抽象属性: 没有初始化的属性称之为抽象属性
  26.    *
  27.    * scala抽象类中既可以定义抽象属性也可以定义具体属性,既可以定义抽象方法也可以定义具体方法
  28.    *
  29.    */
  32.   def main(args: Array[String]): Unit = {
  33.     val dog = new Dog
  34.     println(dog.age)
  35.     println(dog.m1(10, 20))
  36.     //匿名子类
  37.     val animal = new Animal {
  38.       override val age: Int = 100
  40.       override def m1(x: Int, y: Int): Int = x+y
  41.     }
  42.     println(animal.age)
  43.   }
  45. }

8.单例对象(伴生对象)

Scala语言是完全面向对象的语言，所以并没有静态的操作（即在Scala中没有静态的概念）。但是为了能够和Java语言交互（因为Java中有静态概念），就产生了一种特殊的对象来模拟类对象，该对象为单例对象。若单例对象名与类名一致，则称该单例对象这个类的伴生对象，这个类的所有“静态”内容都可以放置在它的伴生对象中声明。

  1. package com.atguigu.chapter06
  3. object $08_Object {
  4.   /**
  5.    * 单例对象: object object名称{....}
  6.    *    object中定义的所有属性和方法都是类似java static修饰的,可以通过 object名称.属性名/方法名 调用
  7.    *    class中定义的所有属性和方法都是类似java 非static修饰的
  8.    *
  9.    * 伴生类[class]和伴生对象[object]
  10.    *    必须满足两个条件
  11.    *      a.class与object的名称必须一致
  12.    *      b.class与object必须在同一个.scala源文件中
  13.    * 伴生类和伴生对象的特性:可以互相访问对方private修饰的成员
  14.    * apply方法[主要是为了简化伴生类对象的创建]
  15.    *      定义位置: 必须定义在伴生对象中
  16.    * 定义apply方法之后,就可以通过 object名称.apply(...)/object名称(...) 获取伴生类的对象
  17.    */
  18.   def main(args: Array[String]): Unit = {
  20.     println($08_Object)
  21.     Person.xx()
  22.     new Person().yy()
  23.     println(Person.getAge())
  24.     val person = Person.apply("beijing")
  25.     person.yy()
  26.     val person2 = Person("tianjin")
  27.     println(person2.getName())
  29.   }
  31. }
  32. class Person(val address:String){
  33.   def this(){
  34.     this("")
  35.   }
  36.   private val age =20
  37.   def yy()=println("++++++++++++++++++")
  38.   def getName()= Person.name
  40. }
  41. object Person{
  42.   private val name ="lisi"
  43.   def xx()= println(".............")
  44.   def getAge()= new Person().age
  45.   def apply(address:String):Person = new Person(address)
  46.   def apply():Person = new Person()
  47. }

9.特质

  1. Scala语言中，采用特质trait（特征）来代替接口的概念，也就是说，多个类具有相同的特征（特征）时，就可以将这个特质（特征）独立出来，采用关键字trait声明。
  2. Scala中的trait中即可以有抽象属性和方法，也可以有具体的属性和方法，一个类可以混入（mixin）多个特质。
  3. Scala引入trait特征，第一可以替代Java的接口，第二个也是对单继承机制的一种补充。
  1. package com.atguigu.chapter06
  3. object $09_TraitDefined {
  5.   /**
  6.    * scala是单继承多实现
  7.    * 特质的语法:trait 特质名{....}
  8.    * scala中子类实现特质:
  9.    *    1.子类不需要继承父Class,此时子类实现第一个trait使用extends关键字,其他trait的实现使用with关键字
  10.    *    2.子类需要继承父class,此时子类实现trait使用with关键字
  11.    * 特质中既可以定义具体方法也可以定义抽象方法,既可以定义抽象属性也可以定义具体属性
  12.    *
  13.    *
  14.    */
  15.   trait Log1{
  16.     //抽象属性
  17.     val name:String
  18.     //具体属性
  19.     val age = 20
  20.     //抽象方法
  21.     def m1(x:Int,y:Int):Int
  22.     //具体方法
  23.     def m2(x:Int) = x*x
  24.   }
  25.   trait Log2
  26.   trait Log3
  27.   //子类不需要继承父class,此时子类实现第一个trait使用extends关键字,其他trait的实现使用with关键字
  28.   class Errorlog extends Log1 with Log2 with Log3{
  29.     override  val name:String ="lisi"
  31.     override def m1(x: Int, y: Int): Int = x + y
  32.   }
  33.   class ParentLog
  34.   //子类需要继承父class,此时子类实现trait使用with关键字
  35.   class WarnLog extends ParentLog with Log1 with Log2 with Log3{
  36.     override val name: String = "zhangsan"
  38.     override def m1(x: Int, y: Int): Int = x - y
  39.   }
  41.   def main(args: Array[String]): Unit = {
  42.     val log = new Errorlog
  43.     println(log.name)
  44.     println(log.m1(10, 20))
  45.   }
  47. }

10.特质混入

  1. package com.atguigu.chapter06
  2. object $10_ObjectMix {
  3.   /**
  4.    * 对象混入:让某个对象拥有指定特质的属性和方法
  5.    *    语法: new 类名(...) with 特质名
  6.    */
  7.     trait Log{
  8.       val name = "lisi2"
  9.     }
  10.   class ErrorLog
  11.   def main(args: Array[String]): Unit = {
  12.     val log = new ErrorLog
  13.     //println(log.name)
  14.     val log2 = new ErrorLog with Log
  15.     println(log2.name)
  16.   }
  17. }

11.特质的叠加

  1. package com.atguigu.chapter06
  3. object $11_TriatAdd {
  4.   /**
  5.    * 子类可以实现多个父特质,如果这多个父特质都有一个同名方法并且参数列表也一样的时候,此时子类默认调用该同名方法会报错
  6.    * 子类可以通过重写该同名方法来解决报错问题
  7.    *     子类中如果想要调用父类的同名方法可以使用super.方法名的方式调用,此时默认情况下调用的是继承顺序最后一个特质的同名方法
  8.    *     如果子类想要调用指定父特质的同名方法可以使用super[特质名].方法名的方式调用
  9.    * 子类可以实现多个父特质,如果这多个父特质中都有一个同名方法并且参数列表也一样的时候,并且这多个特质都继承同一个父特质的时候,此时可以通过super调用
  10.    * 同名方法的时候是按照继承顺序从右向左开始调用
  11.    */
  12.   trait ParentLog{
  13.     def log(msg:String)={
  14.       println(s"ParentLog:${msg}")
  15.     }
  16.   }
  17.   trait Log1 extends ParentLog{
  18.     override def log(msg: String): Unit = {
  19.       println(s"Log1:${msg}")
  20.       super.log(msg)
  21.     }
  22.   }
  23.   trait Log2 extends ParentLog{
  24.     override def log(msg: String): Unit = {
  25.       println(s"Log2:${msg}")
  26.       super.log(msg)
  27.     }
  28.   }
  29.   trait Log3 extends ParentLog{
  30.     override def log(msg: String): Unit = {
  31.       println(s"Log3:${msg}")
  32.       super.log(msg)
  33.     }
  34.   }
  35.   class ErrorLog extends Log1 with Log2 with Log3{
  36.     override def log(msg: String): Unit = {
  37.       println(s"ErrogLog:${msg}")
  38.       super.log(msg)
  39.     }
  41.   }
  43.   def main(args: Array[String]): Unit = {
  44.     var obj = new ErrorLog
  45.     obj.log("hello")
  46.   }
  48. }

12.特质自身类型

  1. package com.atguigu.chapter06
  3. import java.io.{FileInputStream, FileOutputStream, ObjectInputStream, ObjectOutputStream}
  4. import scala.beans.BeanProperty
  6. object $12_Self {
  7.   /**
  8.    * 特质自身类型:提醒子类实现该特质的时候必须提前实现/继承某个特质/class
  9.    *    语法:this:类型=>
  10.    */
  11.   trait ObjectReadAndWrite{
  12.     //this:Serializable=>
  13.     _:Serializable=>
  14.     def read() ={
  15.       val ois = new ObjectInputStream(new FileInputStream("d:/obj.txt"))
  16.       val ref = ois.readObject()
  17.       ois.close()
  18.       ref
  19.     }
  20.     def write()={
  21.       val oos = new ObjectOutputStream(new FileOutputStream("d:/obj.txt"))
  22.       oos.writeObject(this)
  23.       oos.flush()
  24.       oos.close()
  25.     }
  26.   }
  27.   class Student extends ObjectReadAndWrite with Serializable {
  28.     @BeanProperty
  29.     var name:String = _
  30.     @BeanProperty
  31.     var age:Int = _
  33.   }
  35.   def main(args: Array[String]): Unit = {
  36.     val student = new Student
  37.     student.setName("lisi")
  38.     student.setAge(20)
  39.     student.write()
  41.     val s1 = new Student
  42.     val ref = s1.read()
  43.     val stu = ref.asInstanceOf[Student]
  44.     println(stu.getAge)
  45.     println(stu.getName)
  46.   }
  48. }

13.类型检查和判断

  1. package com.atguigu.chapter06
  3. import scala.util.Random
  5. object $13_TypeCheck {
  6.   /**
  7.    * java判断对象是否属于某个类型:对象 instanceof 类型
  8.    * java中强转: (类型)对象
  9.    * java中获取对象的class形式: 对象.getClass
  10.    * java中获取类的class形式: 类名.class
  11.    *
  12.    * scala中判断对象是否属于某个类型: 对象.isInstanceOf[类型]
  13.    * scala中强转: 对象.asInstanceOf[类型]
  14.    * scala中获取对象的class形式: 对象.getClass<常用>
  15.    * scala中获取类的class形式:classOf[类名]<常用>
  16.    *
  17.    * 新类型:给类起别名
  18.    *    语法: type 别名 = 类名
  19.    */
  20.   val RED = "red"  //枚举
  21.   class Animal
  22.   class Dog extends Animal{
  23.     val name = "haha"
  24.   }
  25.   class Pig extends Animal{
  26.     val age = 20
  27.   }
  29.   def main(args: Array[String]): Unit = {
  30.     val animal = getAnimal()
  31.     println(animal.getClass)
  32.     if(animal.isInstanceOf[Pig]){
  33.       val pig = animal.asInstanceOf[Pig]
  34.       println(pig.age)
  35.     }else{
  36.       val dog = animal.asInstanceOf[Dog]
  37.       println(dog.name)
  38.     }
  39.     type MyString = String
  40.     val name = new MyString("hello")
  41.     println(name)
  42.   }
  43.   def getAnimal()={
  44.     val num = Random.nextInt(10)
  45.     if(num%2==0) new Dog
  46.     else new Pig
  47.   }
  49. }