scala面向對象怎么實現

本篇內容主要講解“scala面向對象怎么實現”，感興趣的朋友不妨來看看。本文介紹的方法操作簡單快捷，實用性強。下面就讓小編來帶大家學習“scala面向對象怎么實現”吧!

類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 班去掉重復且右側勝出

到此，相信大家對“scala面向對象怎么實現”有了更深的了解，不妨來實際操作一番吧！這里是億速云網站，更多相關內容可以進入相關頻道進行查詢，關注我們，繼續學習！