[SCALA] 발과 스칼라 클래스 내부 객체?

발과 스칼라 클래스 내부 객체?

다음 코드에서와 같이 스칼라 클래스 내부 발, 게으른 발 및 객체로 필드를 선언의 차이점은 무엇입니까 :

class A

class B {
  val a1 = new A      { def foo = 1 }
  object a2 extends A { def foo = 1 }
  lazy val a3 = new A { def foo = 1 }
}

해결법

1. ==============================

   1.클래스 B가 생성 될 때 이전에 포함 된 모든 코드는 곧로 실행됩니다. 실제로 객체를 사용할 때까지 후자 그러나, 그것은 인스턴스화되지 않습니다.

   클래스 B가 생성 될 때 이전에 포함 된 모든 코드는 곧로 실행됩니다. 실제로 객체를 사용할 때까지 후자 그러나, 그것은 인스턴스화되지 않습니다.

   당신은 차이를 여기에서 볼 수 있습니다 :

   class A { println("Creating a new A") }
   class B {
     val a1 = new A { println("a1"); def foo = 1 }
     object a2 extends A { println("a2"); def foo = 1 }
   }
   
   scala> val b = new B
   Creating a new A
   a1
   b: B = B@1176e8a
   
   scala> b.a2.foo
   Creating a new A
   a2
   res0: Int = 1
   

   생성 된 .class 파일은 이름과 같은 무엇에 숨겨진 차이가있다; 물론 두 사람은 서로 다른 유형이있다.

2. ==============================

   2.나는 aioobe는 그의 대답의 중요성을 인식하고 있지 않다 있는지,하지만 다른 유형은 실제로 발스와 객체 사이의 중요한 차이를 나타냅니다. 개체는 싱글 타입을 갖는다 : 특히, 발 및 지연 브로 구조적 형태 (예를 들어, {지능 DEF foo는})이있다. 개체에 foo는 메서드에 호출하지 않는 동안 그 결과, 애송이들이다에 foo는 메소드 호출, 반사를 포함한다 :

   나는 aioobe는 그의 대답의 중요성을 인식하고 있지 않다 있는지,하지만 다른 유형은 실제로 발스와 객체 사이의 중요한 차이를 나타냅니다. 개체는 싱글 타입을 갖는다 : 특히, 발 및 지연 브로 구조적 형태 (예를 들어, {지능 DEF foo는})이있다. 개체에 foo는 메서드에 호출하지 않는 동안 그 결과, 애송이들이다에 foo는 메소드 호출, 반사를 포함한다 :

   class A
   
   class B {
     val a1 = new A      { def foo = printStack }
     object a2 extends A { def foo = printStack }
     lazy val a3 = new A { def foo = printStack }
   
     def printStack() = 
        new Exception().getStackTrace take 3 foreach println
   }
   
   scala> val b = new B
   b: B = B@5c750
   
   scala> b.a1.foo   // the val
   line124$object$$iw$$iw$B.printStack(<console>:12)
   line124$object$$iw$$iw$B$$anon$1.foo(<console>:7)
   sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
   
   scala> b.a2.foo   // the object
   line124$object$$iw$$iw$B.printStack(<console>:12)
   line124$object$$iw$$iw$B$a2$.foo(<console>:8)
   line128$object$$iw$$iw$.<init>(<console>:9)
   
   scala> b.a3.foo   // the lazy val
   line124$object$$iw$$iw$B.printStack(<console>:12)
   line124$object$$iw$$iw$B$$anon$2.foo(<console>:9)
   sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
   

3. ==============================

   3.하나의 주요 차이점은 개체 수는 없지만 발의가 오버라이드 (override) 할 수 있다는 것입니다.

   하나의 주요 차이점은 개체 수는 없지만 발의가 오버라이드 (override) 할 수 있다는 것입니다.

   class C extends B {                           
     override val a1 = new A { def foo = 2 }     
     override object a2 extends A { def foo = 2 }
   }
   

   으로 이끌다:

   <console>:9: error: overriding object a2 in class B of type object C.this.a2;
   object a2 cannot be used here - classes and objects cannot be overridden
   override object a2 extends A { def foo = 2 }
   

4. ==============================

   4.나는 한 가지 차이점은 A2 즉 a2.type (A)의 또 다른 하위 유형이 될 것입니다 동안 그 A1은 한 하위 유형이 될 것입니다 가정합니다.

   나는 한 가지 차이점은 A2 즉 a2.type (A)의 또 다른 하위 유형이 될 것입니다 동안 그 A1은 한 하위 유형이 될 것입니다 가정합니다.

   scala> class A
   defined class A
   
   scala> val a1 = new A {def foo = 1}
   a1: A{def foo: Int} = $anon$1@a9db0e2
   
   scala> object a2 extends A {def foo = 1}
   defined module a2
   
   scala> a1
   res0: A{def foo: Int} = $anon$1@a9db0e2
   
   scala> a2
   res1: a2.type = a2$@5b25d568
   
   scala> 
   

5. ==============================

   5.또 다른 주요 차이점은 객체가 자신의 이름을 알고와 val의이 없다는 것입니다.

   또 다른 주요 차이점은 객체가 자신의 이름을 알고와 val의이 없다는 것입니다.

6. ==============================

   6.제 실질적인 차이 발스 열망 반면 지연 발스 물체가 지연 때문이다.

   제 실질적인 차이 발스 열망 반면 지연 발스 물체가 지연 때문이다.

   목적 및 지연 발스의 주요 차이점은 목적은 JVM의 관점에서 일반적으로 고정 부재로서 간주되는 "단일"로 간주 언어의 관점에서, 점이다. 인스턴스에 연결하지 않고, 가상 함수 조회를 할 수있는 더 생각할 수있는 방법은 없습니다 : 다른 사람이 보여준대로 주어진 예에서 객체 정의는 같은 이유로 정적 회원 오버라이드 (override) 할 수 없다, 오버라이드 (override) 할 수 없습니다.

   object Foo { object Bar extends A; }
   

   다음 자바 코드처럼 느슨하게입니다 :

   class Foo { 
     private static class Bar extends A{}
     public static Bar Bar = new Bar;
   }
   

   위의 예에서 경우 서브 클래스 C는 푸 정의 된 확장하는 경우, 바의 정의를 오버라이드 (override) 할 수 없습니다. 자바의 정적 인스턴스 바 Foo.Bar로 액세스 할 것입니다. C.Bar는 (새로운 C) .bar 인과 같은 것을 의미하지 않는다. 나는이 정적 멤버 같은 개체의 일반적인 개념을 설명하기 위해 예에 불과 드 - 컴파일 스칼라 코드를 여기에 조금 떨어져, 나는 실제로 시도하지 않은 수 있습니다.

   게으른 놈들은 조금 덜 효율적이 될 수 있습니다. 지난번에 내가는, 그들은 게으른 놈들이 초기화 되었었던 추적을 유지 클래스에서 숨겨진 필드를 유지하여 구현되었습니다. 이 필드를 유지하는 것은 성능 문제가 발생할 수있는 잠금이 필요합니다.

   게으른 발과 물체 사이의 하나 개의 주요 실질적인 차이는 장애의 치료 :

   만약 내가 가지고 있다면:

   class Foo() { throw new Exception("blah!"); }
   object Stuff { object Bar extends Foo { val x = "hi" } }
   Stuff.Bar
   //exception "blah!" thrown.
   Stuff.Bar.x
   //NoClassDefFoundError: Could not initialize Stuff$Bar$
   

   내가 할 경우 반면 :

   object Stuff2 { lazy val Bar = new Foo() { val x = "hi" } }
   Stuff2.Bar
   // "blah!"
   Stuff2.Bar.x
   // "blah!"
   

   은 "NoClassDefFoundError를은"정말 혼란 스러울 수 있습니다, 그것은 오류이기 때문에 예외는 (적절하게) 캐치 / 로그 "예외"하지만 오류가 전파 할 수 있다는 오류 처리 코드를 깰 수 없습니다. 난이 사용 사례는 사실 않기 때문에 예외 조건이 아니라 진정으로 JVM 오류를 나타냅니다, 스칼라 언어의 버그 이런 종류의를 고려할 수 있습니다. 외부 리소스 (디스크에 예를 들어, 데이터베이스 연결 또는 파일)에 의존한다는 개체에 액세스 할 때 나는 NoClassDefFoundErrors을 보았다. 이러한 문제의 적절한 디버깅 일반적으로 응용 프로그램 서버를 다시 시작해야하므로 첫 번째 접근은 근본 원인을 기록합니다.

7. ==============================

   7.이 구조 타입이다 : 브로 A ​​= {않는 새 DEF foo는 = 1}

   이 구조 타입이다 : 브로 A ​​= {않는 새 DEF foo는 = 1}

   그것은 고유 한 익명의 서브 클래스를 생성; a.foo가 호출하는 해당 클래스에 foo는.

   DEF 바 : 여기서 X 구조 타입 (X {DEF베이스 : 지능})

   x.bass 이름 '베이스'로 방법을 찾기 위해 X (알 수없는 유형의) 성찰합니다. 그것은 생선이나 악기와 함께 작동합니다. ;)

   게으른 발과 물체 사이의 한 가지 차이점이 있습니다 :

   var someA = (new B).a3
   someA = (new B).a3 // ok
   
   var anotherA = (new B).a2
   anotherA =  = (new B).a2 // compile error
   

from https://stackoverflow.com/questions/3448691/val-and-object-inside-a-scala-class by cc-by-sa and MIT license