Comment Java et Scala implémentent la programmation orientée objet

Package Scala :

Syntaxe de base :

Nom du package package. Nom de la classe

Trois fonctions principales du package Scala :

Distinguer les classes portant le même nom

Lorsqu'il y a plusieurs classes, vous pouvez bien gérer les classes

Portée du contrôle d'accès

Convention de dénomination pour les noms de packages :

Lettres généralement minuscules + petits points

com.Nom de l'entreprise.Nom du projet.Nom du module métier

Avantages de l'écriture de packages :

Vous pouvez écrire vos propres packages dans Maven Import dans le projet via maven

La manière unique d'écrire des packages dans Scala ne correspond pas au dossier et peut exister indépendamment

L'image ci-dessous est le package que j'ai construit sous la classe, qui est utilisé comme un package normal

Package Il peut être imbriqué

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

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

Le code suivant :

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

Objet Package :

Dans Scala, les packages sont également orientés objet tant qu'ils sont à l'intérieur du package (tant qu'ils sont à l'intérieur, ils peuvent l'être. imbriqué dans la couche interne). Vous pouvez appeler directement les propriétés et les méthodes de l'objet package

S'il y a des packages imbriqués, un écrasement se produira et les propriétés et méthodes du package le plus proche seront appelées (le package le plus proche sera appelé). plus tard, et celui précédemment appelé sera écrasé)

Instructions pour les packages guidés :

Les packages guidés ne prennent pas en charge l'imbrication (après avoir guidé un package, vous ne pouvez utiliser que les classes et les objets en dessous, et vous ne pouvez pas utiliser les packages ci-dessous it. Si vous souhaitez utiliser les méthodes du package en dessous, vous devez utiliser . Mais lorsque nous importons le package directement et importons le package en dessous, nous pouvons l'appeler directement sans utiliser .) Les trois importations par défaut dans Scala. sont

import java.lang._
import scala._import scala.Predef._

Classes et objets :

Classe : peut être considérée comme un modèle

Objet : représente des choses spécifiques

Lorsque nous utilisons des objets, nous allons créer des objets en utilisant des classes comme modèles

Classes de définition :

En Java, il ne peut y avoir qu'un seul public dans un fichier

Dans Scala, la valeur par défaut est publique, mais il peut créer plusieurs classes compagnon et objets compagnon dans un. file.

Encapsulation :

Il n'y a que deux types d'attributs dans Scala : variable (var) et immuable (val) (séparant les autorisations de lecture et d'écriture - similaire à l'encapsulation en mode orienté objet (encapsuler la méthode get set consiste à séparer autorisations de lecture et d'écriture))

Dans Scala, ils sont séparés directement par le type de l'attribut

Dans Scala, le type des attributs a été encapsulé comme var----private val----private final

Et la méthode get set a également été encapsulée (encapsulée dans des annotations. Lors de l'utilisation de la méthode get set, les annotations doivent d'abord être introduites @BeanProperty----Cependant, la portée de cette annotation n'a qu'un seul attribut, ce qui signifie qu'un attribut a besoin à définir avec une annotation)

Constructeur :

Les langages orientés objet ont essentiellement des constructeurs (méthodes de construction). S'il n'y a pas de constructeur dans la classe, écrivez la méthode constructeur par défaut.

Il existe également un constructeur dans Scala. Contrairement à Java,

Le constructeur de Scala est le constructeur principal en ajoutant un () au nom de la classe (le constructeur principal n'a pas de paramètres). Lorsque vous pouvez omettre (), cela signifie qu'il peut être construit sans paramètres par défaut (similaire à Java)

S'il y a un constructeur principal, il doit y avoir un constructeur esclave

Vous pouvez définir le constructeur auxiliaire à l'intérieur du constructeur principal. Le format de la définition est fixe. du code depuis l'intérieur du constructeur doit appeler directement ou indirectement le constructeur principal

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

Mécanisme de chargement du constructeur maître-esclave :

Il n'y a pas de mécanisme de chargement de classe dans Scala, donc lorsque le code appelle directement le constructeur auxiliaire, il ne connaît pas le contenu de la classe, donc l'exigence ci-dessus (la première ligne de code du constructeur doit être d'appeler le constructeur principal directement ou indirectement), c'est la raison, obtenez les informations de classe (chargez-les une fois), et après avoir appelé Ensuite, reviendra au constructeur et continuera l'exécution.

Déterminez quel constructeur vous appelez en fonction de vos paramètres dans la méthode principale

Les constructeurs sont en ordre, et les derniers ne peuvent appeler que les précédents (le constructeur appelé doit être dans. Avant ce constructeur)

Unifiez le nom du constructeur avec celui-ci (distingué par le nombre de paramètres de base)

Le constructeur principal peut transmettre des paramètres et les utiliser comme attributs (si le type de paramètre est omis, la valeur par défaut est val)

Héritage :

Mot-clé Inherit : extends

Syntaxe de base :

le nom de la sous-classe de classe étend le nom de la classe parent {corps de la classe}

La sous-classe hérite des attributs et des méthodes de la classe parent

scala est un héritage unique

Le essence de l'héritage : En fait, c'est complètement différent de Java

Lors de la création d'un objet d'une sous-classe, Scala créera d'abord l'objet de la classe parent puis créera l'objet de sous-classe dans la couche externe (identique à Java)

L'essence de l'héritage dans Scala est d'hériter d'un constructeur de la classe parent (le constructeur dont vous héritez (distingué par le nombre de paramètres) sera appelé)

Attribut abstrait :

N'écrivez simplement pas le signe égal pour écrire un. méthode abstraite, vous devez changer la classe en classe abstraite

Résumé Lorsque vous utilisez des attributs, vous devez en hériter, puis réécrire les attributs et les méthodes (il n'est pas nécessaire de réécrire les attributs en Java, car la couche inférieure de Scala encapsule attributs et a ses propres méthodes)

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

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

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

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!