Java와 Scala가 객체 지향 프로그래밍을 구현하는 방법

Scala 패키지:

기본 구문:

패키지 패키지 이름. 클래스 이름

스칼라 패키지의 세 가지 주요 기능:

같은 이름의 클래스를 구별합니다.

클래스가 많을 때 클래스를 잘 관리할 수 있습니다

액세스 범위 제어

패키지 이름 명명 규칙:

일반적으로 소문자 + 작은 점

com.회사 이름.프로젝트 이름.비즈니스 모듈 이름

패키지 작성의 이점:

Maven Import에서 자신만의 패키지를 작성할 수 있습니다. maven을 통해 프로젝트에 추가

스칼라의 독특한 패키지 작성 방식은 폴더에 대응하지 않고 독립적으로 존재할 수 있습니다

아래 사진은 제가 클래스 아래에 구축한 패키지로, 일반 패키지처럼 사용됩니다

패키지는 중첩될 수 있습니다.

内层调用外层 不需要导包  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)
      }
    }
  }
}

패키지 객체:

스칼라에서는 패키지도 패키지 내부에 있는 한 객체 지향적입니다. 중첩된 패키지 객체의 속성과 메서드를 직접 호출할 수 있습니다

중첩된 패키지가 있으면 덮어쓰기가 발생하며 가장 가까운 패키지의 속성과 메서드가 호출됩니다. 나중에 이전에 호출한 항목을 덮어쓰게 됩니다.)

안내 패키지 지침:

안내 패키지는 중첩을 지원하지 않습니다. (패키지를 가져온 후에는 그 아래 클래스와 개체만 사용할 수 있으며 아래 패키지는 사용할 수 없습니다. 아래 패키지의 메소드를 사용하려면 를 사용해야 합니다. 하지만 패키지를 직접 가져오고 아래 패키지를 가져올 때는 .)을 사용하지 않고 직접 호출할 수 있습니다.

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

클래스 및 객체:

클래스: 템플릿으로 간주할 수 있음

객체: 특정 사물을 나타냄

객체를 사용할 때, 클래스를 템플릿으로 사용하여 객체를 생성합니다

정의 클래스:

Java에서는 파일에 공용이 하나만 있을 수 있습니다.

스칼라에서는 기본값이 공용이지만 여러 개의 동반 클래스와 동반 객체를 만들 수 있습니다.

캡슐화:

스칼라에는 변수(var)와 불변(val)이라는 두 가지 유형의 속성만 있습니다(읽기 및 쓰기 권한 분리 - 객체 지향의 캡슐화와 유사함(get set 메서드를 캡슐화하는 것은 분리하는 것임). 읽기 및 쓰기 권한))

Scala에서는 속성 유형으로 직접 구분됩니다.

Scala에서는 속성 유형이 var---private val----private final

그리고 get set 메소드도 캡슐화되었습니다(주석으로 캡슐화되었습니다. get set 메소드를 사용할 때 주석을 먼저 도입해야 합니다 @BeanProperty----그러나 이 주석의 범위에는 속성이 하나만 있으므로 하나의 속성이 필요합니다. 주석으로 설정)

생성자:

객체 지향 언어에는 기본적으로 생성자(생성 메서드)가 있습니다. 클래스에 생성자가 없는 경우 생성자 메서드를 빈 매개 변수 생성자로 작성합니다.

스칼라에도 생성자가 있습니다. 자바와는 달리

스칼라의 생성자는 클래스 이름에 ()를 붙여서 메인 생성자가 됩니다. (메인 생성자는 매개변수가 없습니다.) ()는 가능하다는 의미로 생략 가능합니다. 기본적으로 매개변수 없이 생성됨(Java와 유사)

주 생성자가 있으면 슬레이브 생성자가 있어야 합니다

주 생성자 내부에 보조 생성자를 정의할 수 있습니다. 정의의 첫 번째 줄은 고정되어 있습니다. 생성자 내부의 코드는 주 생성자를 직접 또는 간접적으로 호출해야 합니다

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

마스터-슬레이브 생성자의 로딩 메커니즘:

스칼라에는 클래스 로딩 메커니즘이 없으므로 코드가 보조 생성자를 직접 호출할 때 알 수 없습니다. 따라서 위의 요구 사항(생성자의 첫 번째 코드 줄은 기본 생성자를 직접 또는 간접적으로 호출해야 함)이 이유입니다. 클래스 정보를 가져오고(한 번 로드) 호출한 후 Then 호출하는 생성자는 기본 메서드의 매개 변수에 따라 다르며 이후 생성자는 이전 생성자만 호출할 수 있습니다(호출된 생성자는 이 생성자 앞에 있어야 합니다).

생성자 이름을 이것으로 통일(기본 매개변수 개수로 구분)

주 생성자는 매개변수를 전달하여 속성으로 사용할 수 있음(매개변수 유형이 생략되면 기본값은 val임)

상속:

상속 키워드: 확장

기본 구문:

클래스 하위 클래스 이름 확장 상위 클래스 이름 {클래스 본문}

하위 클래스는 상위 클래스의 속성과 메서드를 상속합니다.

scala는 단일 상속입니다 상속의 본질: 사실 자바와는 전혀 다릅니다

스칼라는 하위 클래스의 객체를 생성할 때 먼저 상위 클래스의 객체를 생성한 후 외부 계층에 하위 클래스 객체를 생성합니다(Java와 동일)

상속의 본질 Scala에서는 상위 클래스의 생성자를 상속합니다(상속하는 생성자(매개변수 수로 구분)가 호출됩니다)

Abstract 속성:

추상 메서드를 작성하려면 등호를 쓰지 마세요. 클래스를 추상 클래스로 변경해야 합니다

Abstract 속성을 사용할 때 속성을 상속한 다음 속성과 메서드를 다시 작성해야 합니다(스칼라의 최하위 계층은 속성을 캡슐화하고 해당 속성을 갖기 때문에 Java에서는 속성을 다시 작성할 필요가 없습니다). 자신만의 방법)

在重写抽象类中的非抽象方法的时候需要在重写的方法前面加上    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 중국어 웹사이트의 기타 관련 기사를 참조하세요!