Java和Scala如何實現物件導向編程

Scala套件：

基本語法：

package 套件名稱.類別名稱

Scala套件的三大作用：

#區分相同名字的類別

當類別很多時，可以很好的管理類別

控制存取範圍

套件名稱的命名規格：

一般是小寫字母小圓點

com.公司名稱.專案名稱.業務模組名稱

寫入套件的好處：

在maven中可以將自己寫的套件透過maven導入到項目中

在Scala中獨有的包的寫法 和資料夾不對應 可以獨立存在

下圖是我在類別下邊建的包，和正常的包一樣使用 

套件是可以嵌套的

内层调用外层 不需要导包  atguigu包在techer下

外层调用内层 对象 需要导包

 如下程式碼：

package chapter04
object Test_01_package {
  def main(args: Array[String]): Unit = {
  }
}
//Scala独有的
package techer {
  import chapter04.techer.atguigu.Inner
  object test01t {
    def main(args: Array[String]): Unit = {
      println("hello  我是大哥 pack")
      //外层调用内层 对象 需要导包
          //Inner.main是下边那个包中的
      Inner.main(args)
    }
  }
  package atguigu {
    object Inner {
      def main(args: Array[String]): Unit = {
        println("Inner")
        //内层调用外层 不需要导包  atguigu包在techer下
        test01t.main(args)
      }
    }
  }
}

套件物件：

在Scala中套件也是面向物件的，只要在套件的內部（只要在內部都可以，內層的嵌套也可以），都可以直接呼叫套件物件的屬性和方法

如果套件有嵌套，會出現覆蓋的情況，則會調用距離最近的套件的屬性與方法（包距離最近則會後調用，會覆蓋先前調用的）

導包說明：

導包是不支援嵌套的（導包後只能用它下邊的類別和對象，不能再用它下邊的包，如果想使用它下邊包中的方法，就需要使用  .   但是當我們導包直接導入它下邊的包 就可以直接調用，不需要用 .     來使用）

Scala 中的三個預設導入分別是
import java.lang._
import scala._
import scala .Predef._

類別與物件：

類別：可以看成一個模板
物件：表示具體的事物
我們在使用物件的時候，會以類別為範本建立物件

定義類別：

在Java中一個檔案中只能有一個public    

在Scala中預設的是public 但是它在一個文件中可以建立多個伴生類別和伴生物件

封裝：

在Scala中屬性只有兩種 可變（var）與不可變（val）（分離了讀寫權限-- --類似與物件導向中的封裝（封裝get  set  方法 是為了分離讀取和寫入權限））

在Scala直接透過屬性的類型來分離

在Scala中屬性的類型已經封裝成   var----private       val----private final         

且get  set方法也已封裝（封裝成了註解，使用get  set方法的時候則需要先引入已引入（封裝---Bean----- -不過此註解的作用域只有一個屬性 意思是 一個屬性需要設定一個註解）

建構器：

物件導向的語言基本上都有建構器（建構方法），如果在類別中不寫構造方法 預設建構器為空參構造方法

在Scala中也有構造器，與Java不同，

Scala的構造器是在類別名稱上加個()是主構造器（主構造器無參的時候可以省略()  表示預設是可以無參構造的 類同Java）

有主構造器就一定有從構造器

在主建構器的內部可以定義輔助建構器定義的格式是固定的，在從建構器的內部第一行程式碼必須是直接或間接的呼叫主建構器

class Person03(name:String){
  var name1:String=name
def this()
  {
    this("唐不唐")
    println("hello world")
  }
}

主從建構器的載入機制：

在Scala中沒有類別載入機制，所以在程式碼直接呼叫輔助建構器的時候它是不知道類別中的內容的， 所以上邊要求（從建構器的內部第一行程式碼必須是直接或間接的呼叫主建構器），這就是原因所在，取得類別資訊（載入一遍），調用完後才會回傳從建構器繼續執行

根據main方法中你的參數決定你呼叫那個建構器

從建構器是有先後順序的，後邊的只能呼叫前面的（所呼叫的建構器必須在本建構器之前）

從建構器的名稱統一為this（根基底參數的個數來區分）

主建構器是可以傳參的參數可以當作屬性來使用（參數型別如果省略，預設val）

繼承：

繼承關鍵字：extends

基礎語法：

class 子類別名稱extends 父類別名稱{ 類別體}

#子類別繼承父類別的屬性和方法

scala 是單繼承

繼承的本質：其實與Java是完全不一樣的

在建立子類別的對象時，Scala會先建立父類別的物件讓後在外層建立子類別物件（同Java）

Scala繼承的本質就是繼承父類別的一個建構器（繼承那個建構器（參數個數來區別）就會呼叫那個）

抽象屬性：

就是不寫等號，寫抽象方法需要把類別改成抽象類別

抽象屬性在使用的時候需要繼承它  讓後需要重寫屬性和方法（在Java中是不需要重寫屬性的，因為Scala底層是對屬性進行封裝，自帶方法）

在重写抽象类中的非抽象方法的时候需要在重写的方法前面加上    override   关键字

子类调用父类的方法的时候使用关键字super  

子类对抽象属性进行实现，父类抽象属性可以用 var 修饰；

子类对非抽象属性重写，父类非抽象属性只支持 val 类型，而不支持 var。
因为 var 修饰的为可变变量，子类继承之后就可以直接使用(可以直接进行修改)，没有必要重写    

多态：

父类的引用指向子类的实例

Java中的多态测试

：在父子共有的属性和方法调用的是父类还是子类：

public class Polymorphic {
    public static void main(String[] args) {
        Person person=new Student();
        System.out.println(person.name);
        person.sayhi();
    }
    public static class Person{
     String   name="Person";
     public void sayhi()
     {
         System.out.println("person  sayhi");
     }
    }
public static class Student extends Person{
        String name="Student";
        public void sayhi()
        {
            System.out.println("student sayhi");
        }
}
 
}

属性是调用父类   方法是调用子类   

在进行多态的时候是先将整个内存先把父类写入里面，再把子类嵌套到外边

引用是使用栈 把地址值是先指向父类的   指向谁就调用谁的属性，但是调用方法是一层一层的调用，是不断的被重写的，所以方法是调用子类

而Scala与Java不同 都是调用的子类的

Scala测试如下：

package chapter04
 
object Test07_Polymorphic {
  def main(args: Array[String]): Unit = {
       val  per:Person07=new Student07
       per.sayhi();
    println(per.name)
  }
}
class Person07()
{
  val name:String="dsdsd"
def sayhi():Unit={
  println("hi person")
}
}
class Student07 extends Person07{
  override val name: String = "Student"
override def sayhi(): Unit =
  {
    println("Student say hi")
  }
}

匿名子类：

可以使用匿名子类直接调用抽象类

也可以直接new这个抽象子类

匿名子类是自动使用多态的

多态无法调用子类独有的属性和方法，外部无法使用匿名子类中特有的（它自己的）方法和属性

以上是Java和Scala如何實現物件導向編程的詳細內容。更多資訊請關注PHP中文網其他相關文章！