Una lista de cosas de Java que ahora nos despediremos felizmente después de Scala

Question

Me gustaría obtener una lista de las cosas molestas de Java que son historia y por qué característica de Scala ha sido reemplazada.

Debo admitir que soy nuevo en Scala, así que no puedo aportar mucho. Pero creo que esta lista será útil para mí y para otros para apreciar plenamente Scala

Por ej. usamos la palabra clave "val" y esto hace que el valor sea inmutable después de la inicialización. En Java, tuvimos que escribir el tipo del objeto y también la palabra clave final. Scala nos libera de este dolor.

El soporte de simultaneidad es obviamente mejor en Scala, pero no estoy buscando eso. Esa es una característica demasiado grande para ser ignorado. Estoy buscando los detalles más finos que aunque minúsculos tendrán un buen efecto.

Algunas áreas son: sistemas de tipo, manejo de excepciones, expresiones regulares, OOPS características, azúcar sintáctica etc.

Answer 1

me gusta el hecho de que las funciones son ahora objetos, y que los primitivos son envueltos por defecto. La capacidad del compilador para inferir de manera inteligente el tipo también es agradable.

Answer 2

No estoy de acuerdo con algunas suposiciones de la pregunta.

Scala se ejecuta en el JVM, por lo que el soporte de concurrencia (en el nivel de VM) no puede ser mejor que Java. Eso sí, actors puede ser un modelo mejor que Java threads, pero me sorprendería si los actores no pudieran implementarse en Java.

Además, Java tiene Regular Expressions.

Answer 3

• Null se ha ido (en su mayoría) en Scala
• Para expresiones
• covariante y genéricos del lado definición contravariantes
• operadores infijos/métodos (a + b, list map f)
• coincidencia de patrones
• implícita conversiones de tipo
• estática se ha ido (con el objeto)
• poderoso apoyo de paquetes (paquetes anidados)

Pero como todas las características que tienen sus implicaciones es parte del diseño de cuándo usar:

• para la expresión vs mapa/flatMap/filtro/...
• coincidencia de patrones vs polimorfismo
• infija vs sintaxis llamada de método

Cuando usar implícita tipo de conversiones y genéricos en absoluto.

Nada es gratis. Scala es una herramienta poderosa para que puedas lastimarte.

Answer 4

Una cosa que me gusta es ser capaz de escribir algo como:

case class Person(name: String, age: Int) 

En lugar de:

class Person { 

    private String name; 
    private int age; 

    public Person(String name, int age) { 
    this.name=name; 
    this.age=age; 
    } 

    public String getName() { 
     return name; 
    } 

    public int getAge{ 
     return age; 
    } 

    public String toString() { 
     return String.format("Person(%s, %d)", name, age); 
    } 

    public boolean equals(Object other) { 
     if (other == this) 
      return true; 
     if (other.getClass() != getClass()) 
      return false; 
     Person p = (Person) other; 
     return getName().equals(p.getName()) && getAge().equals(p.getAge()); 
    } 

    public int hashCode() { 
     int h = getName().hashCode(); 
     h = 37 * h + getAge(); //or whatever it is! 
     return h; 
    } 
} 

Answer 5

Creo que dos de las principales características de Scala son:

• Inferencia de tipo estático: esta característica de lenguaje genial realmente te permite hacer que tu código sea más corto pero necesariamente más rápido.
• Anotaciones de varianza, es decir, no de varianza (predeterminado en scala & java), co-varianza & contra-varianza: otra característica que le permite asociar tipos en su aplicación sin escribir demasiado código.

Sin embargo, una cosa que no se sienta demasiado bien conmigo es la existencia de las conversiones implícitas (que son similares a C++ 's conversión implícita) que suena como un ejemplo truco rápida conducto-taping

Para su consideración

Answer 6

Scala tiene un poderoso concepto de herencia múltiple: traits! Eso lleva un largo camino para acercarse al Eiffel's implementation inheritance. También tiene cierta similitud con Ruby's mixin modules.

Answer 7

Espero con optimismo los parámetros nombrados en 2.8. Facilitarán el código de auto-documentación en objetos inmutables ya que puede usar los nombres de los parámetros al invocar el constructor.

Además, las capacidades de copia en las clases de casos en 2.8 facilitarán la implementación de objetos de "copia en modificación", al igual que las colecciones inmutables que ya están en Scala.

Answer 8

Trabajando en Scala 2.8 aquí, así que algo de esto aún no se libera totalmente ...

Scala ayuda especialmente con la eliminación de repetitivo:

• inferencia de tipos
• Rasgos/Mixins
• Principio de acceso uniforme: no más getters y setters
• Sobrecarga del operador

y añadiendo construcciones funcionales para reducir aún más el tamaño de su programa:

• Funciones de primera clase - Sí, eso significa cierres :)
• Para-de comprensión. Estos NO son bucles, sino una bestia mucho más poderosa.
• bloques partido/de caso - Pattern Matching, mucho más potente que el switch/case

También funciona muy bien en torno a algunos de los defectos de diseño en Java

• clase Manifiesto de recuperar la información perdida por el borrado
• Singleton - Mucho más orientado a objetos que los métodos estáticos en una clase
• Declaración-Site varianza - No más <? se extiende T >
• No más excepciones

Y unos buenos extras comprobado

• con nombre y parámetros por defecto
• conversiones implícitas y parámetros
• literales XML
• Wiki scaladoc sintaxis

También vea http://www.artima.com/weblogs/viewpost.jsp?thread=275983 para una descripción general de algunos de los conceptos de programación funcional