Bagaimana Java dan Scala melaksanakan pengaturcaraan berorientasikan objek

Pakej Scala:

Sintaks asas:

nama pakej pakej. nama kelas

Tiga fungsi utama pakej Scala:

Bezakan antara yang dengan nama yang sama Kelas

Apabila terdapat banyak kelas, kelas boleh diurus dengan baik

Kawal skop akses

Konvensyen penamaan untuk nama pakej:

biasanya huruf kecil + titik kecil

com.Nama syarikat.Nama projek.Nama modul perniagaan

Faedah menulis pakej:

Dalam maven, anda boleh mengimport pakej anda menulis ke dalam Dalam projek

Cara unik menulis pakej dalam Scala tidak sepadan dengan folder dan boleh wujud secara bebas

Gambar di bawah ialah pakej yang saya bina di bawah kelas, yang boleh digunakan seperti pakej biasa

Pakej boleh bersarang

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

rrree

Kod berikut:

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

Objek pakej:

Begitu juga untuk pakej dalam Scala Object-oriented, anda boleh terus memanggil sifat dan kaedah objek pakej selagi ia berada di dalam pakej (selagi ia berada di dalam, sarang dalaman juga okay)

Jika pakej bersarang, penggantian akan muncul Dalam kes , sifat dan kaedah pakej terdekat akan dipanggil (pakej yang paling hampir akan dipanggil kemudian dan akan menimpa yang dipanggil sebelum ini)

Perihalan pakej pengenalan:

Pakej pengenalan tidak disokong Nested (selepas mengimport pakej, anda hanya boleh menggunakan kelas dan objek di bawahnya dan anda tidak boleh menggunakan pakej di bawahnya. Jika anda mahu gunakan kaedah dalam pakej di bawahnya, anda perlu menggunakan . Tetapi apabila kami mengimport pakej, kami terus mengimport pakej di bawahnya. Anda boleh memanggilnya secara langsung tanpa menggunakan scala >Kelas dan objek:

Kelas: boleh dianggap sebagai templat
Objek: mewakili perkara tertentuApabila kita menggunakan objek, Objek akan dibuat menggunakan kelas sebagai templat

Tentukan kelas:

Di Java hanya boleh ada satu orang awam dalam fail

Lalainya ialah awam dalam Scala tetapi ia berada dalam kelas berbilang pasangan dan objek pengiring boleh dibuat dalam fail

Enkapsulasi:

Terdapat hanya dua jenis sifat dalam Scala, boleh ubah (var) dan tidak boleh ubah (val) (kebenaran baca dan tulis yang dipisahkan - ---Serupa dengan enkapsulasi dalam berorientasikan objek (the kaedah get set dirangkumkan untuk memisahkan kebenaran baca dan tulis))

Dalam Scala, ia dipisahkan terus oleh jenis atribut

Jenis atribut dalam Scala Ia telah dikapsulkan ke dalam var----private val----private final

dan kaedah get set juga telah dikapsulkan (dirangkumkan ke dalam anotasi. Apabila menggunakan kaedah get set, anda perlu memperkenalkan anotasi @BeanProperty-- --Walau bagaimanapun, skop anotasi ini hanya mempunyai satu atribut, yang bermaksud bahawa satu atribut perlu ditetapkan dengan anotasi)

Pembina:

Bahasa berorientasikan objek pada asasnya mempunyai pembina (kaedah pembinaan), jika Jangan tulis pembina dalam kelas Pembina lalai ialah pembina parameter kosong

Terdapat juga pembina dalam Scala,

Pembina Scala ialah tambah a ( pada nama kelas ) ialah pembina utama (() boleh ditinggalkan apabila pembina utama tidak mempunyai parameter, yang bermaksud ia boleh dibina tanpa parameter secara lalai, serupa dengan Java)

Jika ada ialah pembina utama, mesti ada pembina hamba

Format definisi pembina tambahan yang boleh ditakrifkan di dalam pembina utama adalah tetap Baris pertama kod di dalam pembina hamba mesti secara langsung atau tidak langsung memanggil utama pembina

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)
      }
    }
  }
}

Pembina tuan-hamba Mekanisme pemuatan:

Tiada mekanisme pemuatan kelas dalam Scala, jadi apabila kod itu memanggil pembina tambahan secara langsung, ia tidak mengetahui kandungan kelas, jadi keperluan di atas (dari baris pertama di dalam pembina Kod mesti memanggil pembina utama secara langsung atau tidak langsung), inilah sebabnya, dapatkan maklumat kelas (muat sekali), dan kemudian kembali ke pembina untuk meneruskan pelaksanaan selepas panggilan selesai

Mengikut parameter anda dalam kaedah utama Tentukan pembina yang anda panggil

Pembina hamba adalah teratur, yang kemudian hanya boleh memanggil yang sebelumnya (pembina yang dipanggil mesti sebelum pembina ini)

Pembina hamba Nama-nama disatukan seperti ini (dibezakan dengan bilangan parameter asas)

Pembina utama boleh melepasi parameter dan menggunakannya sebagai atribut (jika jenis parameter ditinggalkan, lalainya ialah val)

Warisan:

Warisi kata kunci: memanjang

Sintaks asas:

nama subkelas kelas melanjutkan kelas induk name {class body}

Subclass mewarisi atribut dan kaedah kelas induk

Scala is single inheritance

Intipati warisan: Sebenarnya, ia sepenuhnya berbeza daripada Java

Apabila mencipta objek subkelas, Scala akan mula-mula mencipta objek kelas induk dan kemudian mencipta objek subkelas di lapisan luar (sama seperti Java)

Intipati warisan Scala adalah untuk mewarisi pembina kelas induk (warisi pembina itu (bilangan parameter) Untuk membezakan) yang akan dipanggil)

Atribut abstrak:

Hanya jangan tulis tanda sama kepada tulis kaedah abstrak, anda perlu menukar kelas kepada kelas abstrak

Atribut abstrak digunakan Kadangkala anda perlu mewarisinya dan kemudian anda perlu menulis semula sifat dan kaedah (tidak perlu menulis semula sifat dalam Java , kerana lapisan bawah Scala merangkum sifat dan mempunyai kaedah tersendiri)

在重写抽象类中的非抽象方法的时候需要在重写的方法前面加上    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这个抽象子类

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

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

Atas ialah kandungan terperinci Bagaimana Java dan Scala melaksanakan pengaturcaraan berorientasikan objek. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!