Java對比Scala之面向對象

構造方法

前面的內容中,我已將java和scala基本語法的部分做了對比。接下來，我會談談關於面向對象的部分。面向對象是使得程序功能更加強大，更加豐富的基礎。得益於面向對象,我們纔可以完成更加複雜的人機交互程序。

類的定義

JAVA中如何定義一個對象類型呢？其實，主要包括：類名，屬性（數據域），方法，這三個部分。

public class People {//生成一個類
    String name;
    int age;
    String sex;

    public People() {
        //無參構造
    }

    public People(String name, int age, String sex) {//含參數構造
        this.name = name;
        this.age = age;
        this.sex = sex;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    @Override
    public String toString() {
        return "People{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", sex='" + sex + '\'' +
                '}';
    }
    public void JavaPeopleEat(String name){
        System.out.println(name +" can eat food .");
    }

    public static void main(String[] args) {
        People p1=new People();
        p1.name="skj";
        p1.JavaPeopleEat(p1.name);
    }
}

java的已經看過了,scala的其實也是類似,只不過是有些關鍵字不同而已.

package HomeWork

object ScalaPeople {
  class People{
    var name:String=null
    var age :Int = _ //_是給age初始化用的
    val school :String ="zut" //用val修飾的屬性不能修改
    def ScalaPeopleEat(): Unit ={//自定義方法
      println(this.name + " can eat food too.")
    }
    override def toString = s"People($name, $age, $school)"
  }

  def main(args: Array[String]): Unit = {
    val peo1=new People
    println(peo1)//打印的是默認值
    peo1.name="skj"
    peo1.age=20
    println(peo1)//傳入參數之後打印的是相關參數
    peo1.ScalaPeopleEat()//調用方法
  }
}

對比一下,不難看出.scala的代碼要比java精簡很多.爲什麼呢?

其實,Scala 的類中底層會自動生成類似 Java 中的公共的 getter 和 setter 方法。所以我們不用再寫get和set方法了.

修飾符

訪問修飾符

Java中，可以使用訪問控制符來保護對類、變量、方法和構造方法的訪問。Java 支持 4 種不同的訪問權限。

default (即默認，什麼也不寫）: 在同一包內可見，不使用任何修飾符。使用對象：類、接口、變量、方法。

private : 在同一類內可見。使用對象：變量、方法。注意：不能修飾類（外部類）

public : 對所有類可見。使用對象：類、接口、變量、方法

protected : 對同一包內的類和所有子類可見。使用對象：變量、方法。注意：不能修飾類（外部類）。

scala中也有四種訪問權限修飾符：公共的， protected (只能子類訪問)， private[] 包訪問權限， private(私有訪問權限)

但是區別是:公共的是默認的訪問權限，scala沒有這個關鍵public

非訪問修飾符

爲了實現一些其他的功能，Java 也提供了許多非訪問修飾符。

static 修飾符，用來修飾類方法和類變量。
final 修飾符，用來修飾類、方法和變量，final 修飾的類不能夠被繼承，修飾的方法不能被繼承類重新定義，修飾的變量爲常量，是不可修改的。
abstract 修飾符，用來創建抽象類和抽象方法。
synchronized 和 volatile 修飾符，主要用於線程的編程。
其他

來展示一下java的修飾符

public class JavaModifier {
    private int IDcard=2020001;//私有屬性
    public String name = "skj";//公共屬性
    protected void fun(){//java的protected 可以修飾數據成員，構造方法，方法成員，不能修飾類（內部類除外）
        System.out.println("this is a protected function");
    }
    /*static 修飾符*/
    private static int numInstances = 0;//靜態變量
    protected static int getCount() {//靜態方法,可以用類名直接調用
        return numInstances;
    }
    /*final 修飾符*/
    //final 修飾符通常和 static 修飾符一起使用來創建類常量。
    static final String FINE = "I am fine";//和C語言類似,變量名通常大寫
    /*abstract 修飾符*/
    //abstract 修飾符用來定義抽象類和抽象方法
    /*synchronized 關鍵字*/
    //synchronized 聲明的方法同一時間只能被一個線程訪問。synchronized 修飾符可以應用於四個訪問修飾符。
    public static void main(String[] args) {
        System.out.println(JavaModifier.getCount());
        System.out.println(FINE);
    }
}

接下來,對比一下scala的:

在 Scala 語法中沒有 static 修飾的方法和字段，那麼就可以創建一個和類名一樣的 object 作爲伴生對象，以此達到靜態內容的實現。同名的 class 創建的類稱爲伴生類。

package HomeWork

object ScalaAssociated {
  val stu="skj"
  def fun1: Unit ={
    println("object ScalaAssociated 相當於伴生對象")
  }

  def main(args: Array[String]): Unit = {
    //調用伴生對象的方法
    fun1
    val sa=new ScalaAssociated
    sa.fun2
  }
  /*伴生類*/
  class ScalaAssociated{
      def fun2: Unit ={
        println("class ScalaAssociated 是伴生對象的伴生類")
      }
  }
}

scala得apply方法

package HomeWork

object ScalaEmail {

  object Email {
    def apply(user: String, domain: String): String = {
      println("apply  method")
      user + "@" + domain
    }
    def apply(user:String):String={
      user
    }
    def fun(user:String):String={
      user
    }
  }

  def main(args: Array[String]): Unit = {
    val email = Email //單例對象
    println(email.apply("skj", ".com"))//帶apply方法
    println(email.apply("skj"))
    println(email.fun("com"))
    val email2= Email("skj")//假如我們把中間的apply方法註釋掉,該句就會報錯,why?
    println(email2)
  }
}

構造方法

java得構造已經在類的定義裏面寫過了,現在我們直接寫scala得構造函數

object demo01{
  def main(args: Array[String]): Unit = {
    val stu1=new student("skj",20)
    println(stu1.name+" "+stu1.age+" "+stu1.classroom)
    val stu2=new student("arimakose",14,"child")
    println(stu2.name+" "+stu2.age+" "+stu2.sex)
    val monitor1=new Monitor("tenglinxing",18,"girl","boss")
    println(monitor1.position)
  }
}
//主構造器:student(var name:String,var age:Int)
class student(var name:String,var age:Int){
  println("student in ....")
  var classroom:Int = 182
  var sex:String= _
  //附屬構造器,附屬構造器必須先調用主構造器
  def this(name:String,age:Int,sex:String){
    this(name,age)
    this.sex=sex
  }
  println("student out ....")
}
//繼承的話,如果之類有特有的屬性,必須加上var
class Monitor(name:String,age:Int,sex:String,var position:String) extends student(name:String,age:Int,sex:String){
  println("Monitor in ....")
  println("繼承的類如果運行,必須會先調用他的父類")
  println("Monitor out ....")
}

Java對比Scala之面向對象