scala 面向对象

2019独角兽企业重金招聘Python工程师标准>>>

类class
class Hello{
  private val tt="Hello";
  private var tos="World";
  def add(){
    println(tt+tos);
  }
  def plus(m:Char)=tos+m;
}
类定义
类主要包括字段val和var方法和函数，但scala禁止使用同样的名称命名字段和方法
类成员可见性有两种 private跟public，private需要申明，pulic不用申明
类申明后用new申明对象
val one=new Hello();
对象操作
val a=one.value1
val b=one.value2
one.value2=one.plus(H)
one.add()
调用无参方法可以不带（）one。add
若类中无参方法不带() 实际调用也不带()
def add{println（value1+value2）}
one。add
getter方法
setter方法
sclala对每个类的字段默认都提供getter和setter方法
对于共有字段来说，getter和setter同样是公有的对于私有字段来说，则是私有的
var申明的字段带有getter和setter方法
val字段自带有getter方法只读
对于字段value1 期形式为value1,没有setter方法
对于字段value2  其getter和setter方法形式为value2和value2_=
实际使用时，在类定义外，getter和setter方法是使用一致的，形如one。value2
getter方法和setter方法意义在与控制类中的私有对象数据
在类中可以通过重定义getter和setter方法获取，有限制的修改私有字段
class HELLOWORLD {
  private var value1 = "HELLO"
  var value2 = "WORLD"
  def add() {println(value1+value2)  }
  def plus(m: Char) = value2 + m
  def value1 = value1

  def value1_=(newvalue1: String) {
    if (newvalue1.length > value1.length) value1 = newvalue1
  }

}
class H
构造器
每个类都有一个主构造器，且与类定义交织在一起
主构造器的参数直接放置在类名之后
class HELLOWORLD（val value1:String,var value2:String）
主构造器的参数被编译成一个字段，并在构造对象初始化时传入
一个类若没有显示定义朱构造器那么自动拥有一个无参主构造器
若类中有直接执行的语句，，每次函数构造时都会执行一次，不论怎么样的构造器
如 class HELLOWORLD（val value1:String,var value2:String）{
println（“HELLOWORLD IS CREATED ”
val value3=value1+value2）}

主构造器一般有四种
value：String
生成对象私有字段，对象中没有方法使用value，则没有该字段
private val/var value:String
私有字段 私有的gettter和setter方法
val、var value ：String
私有字段，共有的setter、getter方法
@BeanProperty val、var value ：String
class HelloWorld private (主构造器){类成员}
主构造器私有，只能通过辅助构造器构造对象
辅助构造器
scala 类有任意多的辅助构造器
辅助构造器的名称为this 在类中定义
辅助构造器必须以一个朱构造器或者其他已定义的辅助构造器调用开始
class HELLOWORLD {
  private var value1 = "HELLO"
  var value2 = "WORLD"
def this(m:String){
    this()//调用主构造器
    this.value1=m
  }
def this(m:String,n:String){
  this(m)
  this.value2=n
}
}
嵌套类
scala允许任何语法结构中镶嵌语法结构，因此能够在类中定义类
class HELLOWORLD{
CLASS HI{}}
对于容一个外部类ongoing实例下的内部类是不同的，
形如 val three=new HELLOWORLD与four =new HELLOWORLD
three.HI与four.HI是不同的类
内部类可以调用外部类成员，利用外部类.this或者指针实现
class HELLOWORLD{pointto=>
var value2=""
class HI{val value3=HELLOWORLD.this.value2
var value4=pointto.value2}}}}}


scala对象
单例对象
object语法定义了某个类的单个实例
对象的构造器在该对象第一次被使用时调用
object语法结构与class大致相同，除了object不能提供构造器参数
通常使用单列对象的环境
作为存放工具函数或者常量的地方
共享单个不可变的是咧
利用单个实例协调某个服务
伴生对象
当一个单列对象存在同名类的时候，称为伴生对象
class HELLOWORLD{}
object HELLOWORLD{}
类和其伴生对象可以互相访问私有属性，但必须存在同一源文件中
类的伴生对象可以被访问，但并不在作用于中
class HELLOWORLD{}
object HELLOWORLD{def }
HELLOWORLD必须通过HELLOWORLD.NOW调用伴生对象中的NOW 方法，而不能直接用NOW来调用
扩展类对象
构造一个扩展了指定类和特质的类作为类的对象，同时拥有对象定义给出的所有特性
apply方法
需要构造有参数需求的伴生对象时，可定义并使用appl方法
class HELLOWORLD（var m:String,n:Char）{}
object HELLOWORLD{
def apply(n:Char)=new HELLOWORLD("",n)
}
val hi=HELLOWORLD('j')
  扩展
  extens是scala 中实现继承的保留字
  class week extends month{}
  week 类继承了month类所有的非私有成员
  week类是month类的子类，month类是week类的超类
  子类能重写超类成员（具有相同名称和参数）
  class week（val num：int） extends month(var no:int){}
  object day extends week{}
  单例对象同样能从类中继承，与类的继承语法相同
  重写
  scala中使用override保留字方法进行方法重写
  class week (override val lastday:string)extends month{}
  override 保留字实际使用类似private 申明这个保留字后的定义申明是对超类的重写，因此，其也可能写在类定义的参数中
  class week extends month(override val lastday:string){}
  子类重写或者修改sclala会检查其超类，但是超类的修改并不会检查子类
  class month{def secondday(m:String)={}}
  class week extends month{def secondday={}}
  重写规则
  重写def
  用val 利用val能重写超类用没有参数的方法
  用def子类的方法与超类方法重名
  用var同时重写getter和setter方法。只重写getter方法报错
  重写val
  用val 子类一个私有字段与超类字段重名，getter方法重写超类的getter方法
  重写var
  用var 且当超类的var是抽象的才能被重写，否者超类的var会被集成
  class month{
  val one=25//可在子类用val重写
  var two=15//不可在子类中用var重写，因为不是抽象的
  var three:int
  def firstday= 、、可在子类中用val重写
  def now=  //可在子类中用var重写
  def now_=可在子类中用def重写
  def lastday（m:char）={}
  }
  子类中def 只能重写超类的def， val能重写超类的val或不带参数的def，var只能重写超类中
  抽象的var或者超类的getter和setter
 
 
 
  }
  抽象
  不能被实例的类叫做抽象类
  抽象类的某个或者某几个成员没有被完整的定义，这些没有被完整定义的成员称为抽象方法或者抽象字段
  用abstract保留字段标记抽象类
  abstract year{
  val name：Array[string]//抽象的val带有一个抽象的getter方法
  var num:Int//抽象的var 带有抽象的getter和setter方法
  def sign   //没有方法体函数体，是一个抽象方法
 
  }
  只要类中有一个抽象成员，必须使用abstract标记
  重写抽象方法，抽象字段不许愿使用override保留字
  保护
  当一个类不希望被继承，拓展时，可在类申明前加上final保留字
  final class year{}
  当一个类某些成员不希望被重写时，可在成员申明前加上final保留字
  class year{final def sign{}}
当超类中某些成员需要被子类继承，又不想对子类以外可见时，在成员变量时加上protect保留字
protect【this】将访问权限定于当前对象，类似于private[this]
类中protected的成员对其子类可见，对其超类不可见
class year{protect def sign{}}
  构造
  子类构造器的运行在超类构造器运行之后
  在超类的构造器其中调用的成员被子类重写之后，返回值可能不正确
  class month{
  val num=31
  val days=new Array[Int](num)}
  class week extends month{
  override val num=7}
  构造week对象前先执行month构造器 num被初始化为31 month为初始化数组
  调用num 但num被子类week重写了，但因为week构造器还没有被调用num的值未被初始化因而返回
  0 day 被设置长度为0的数组，month构造器运行完毕，执行week构造器，num被初始化为7
  解决方法
  将超类的val 申明为final
  将超类的val申明为lazy
  在子类中使用提前定义的语法
  提前定义在超类的构造器运行之前初始化子类的字段
  把需要提前定义的语句块放在extends与超类之间，并后接with保留字
  class week extends {overide val num=7} with month{}
  提前定义中若需要调用b成员时，除非b成员在已经调用前提定义
  class week extends{
  override val num=7
  override val num2=num+1//允许 num已经被提前定义
  overide val num4=num2+num3 //不允许，num3没有在之前提前定义
 
  }with month{}
  scala特质
  多重继承
  scala不支持多重继承，取而代之的是特质
  一个子类只能拥有一个超类，一个超类能拥有多个子类
  冀class week extends month，year不合法
  为什么
  若一个子类继承自不同的超类 不同的超类中同名成员子类不知如何处理
  多重继承产生菱形继承问题
  解决多重继承可能导致的问题消耗的资源远比多重继承产生的价值高
  sclala使用特质达到类似多重继承的效果
  一个类可以扩展多个特质，一个特质可以被多个类扩展
  特质使用
  特质是scala里代码复用的基础单元，封装了方法和字段定义
  特质使用保留字trait 具体语法与类定义相似，除了不能拥有构造器
  trait reset{
  def reset （m:Int,n:Int）=if(m>n)1}
  一旦特质被定义了，就可以混入类种
  class week extends reset wiTH B WITH C{}
  特质中成员能是抽象的吗
  所有java接口都能当做是特质使用在scala中
  特质成员可以是抽象的，而且，不需要使用abstract申明
  同样的，重写特质的抽象方法无需给出override
  但是，多个特质重写一个特质的抽象方法需要override
  除了在类中定义混入特质外还可以
  trait reseting extends reset{}
  在构造时混入特质
  val five=new month with reseting
  特质构造
  特质构造是有顺序的，从左至右被构造
  构造器如下顺序构造
  object hi {
  def main(args:Array[String]):Unit={}
  trait one{//抽象特质
  def a()}
 trait two extends one{
 override  def a(){println("my")}
 a
 }
 trait tree extends one {
  override  def a(){println("Name")}
  a
 }
  class Name(){val m=1}
 
 
  val one=new Name() with two with three //NAME NAME
   println()
   val two=new Name() with three with two//MY MY
 
 
  }
    如果class A extends B1 with B2 with B3
  那么传戒B1，B2 班去掉重复且右侧胜出

转载于:https://my.oschina.net/goudingcheng/blog/661412