Scala第一行代码

<dependencies>
        <dependency>
            <groupId>org.scala-lang</groupId>
            <artifactId>scala-library</artifactId>
            <version>2.11.12</version>
        </dependency>

        <dependency>
            <groupId>org.scala-lang</groupId>
            <artifactId>scala-compiler</artifactId>
            <version>2.11.12</version>
        </dependency>

        <dependency>
            <groupId>org.scala-lang</groupId>
            <artifactId>scala-reflect</artifactId>
            <version>2.11.12</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <!-- Scala Compiler -->
            <plugin>
                <groupId>org.scala-tools</groupId>
                <artifactId>maven-scala-plugin</artifactId>
                <version>2.15.2</version>
                <executions>
                    <execution>
                        <goals>
                            <goal>compile</goal>
                            <goal>testCompile</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

/**
 * Demo01HelloWorldJava.java会经过编译生成.class的字节码文件，然后会被加载到JVM中运行
 * 为了区分不同的字节码文件，一般会给每个字节码文件取一个名字（以类名进行命名）
 * 代码需要变成对象才能运行，那我们把加载到JVM中的字节码文件称之为“类对象”
 * 如果要将代码运行，那么可以通过”类对象“。main方法进行调用
 */
public class Demo01HelloWorldJava {
   static int i=10;

   //定义一个静态方法
   public static void printS(){
       System.out.println("这是一个静态方法，可以直接通过“类对象”调用");
   }

   //定义一个普通的方法
    public void printN(){
        System.out.println("这是一个普通的方法，需要通过“类的对象”进行调用");
    }

    //程序的入口
    public static void main(String[] args) {
        System.out.println("HelloWorld Java");
        //自己调用自己，实际上是一个递归的过程
//        Demo01HelloWorldJava.main(args);
        System.out.println(Demo01HelloWorldJava.i);
        Demo01HelloWorldJava.printS();
        //创建一个"类的对象“进行调用
        new Demo01HelloWorldJava().printN();
    }
}

 HelloWorld Java
10
这是一个静态方法，可以直接通过“类对象”调用
这是一个普通的方法，需要通过“类的对象”进行调用

class Demo01HelloWorld {
  //定义一个main方法
  /**
   * main方法是scala程序的入口，只能定义在”类对象“中即Object中，因为scala中没有static关键字
   * 在class中定义的变量、方法都需要通过“类的对象”进行调用
   */
  //  def main(args: Array[String]): Unit = {
//    //打印HelloWorld
//    System.out.println("HelloWorld! Class");
//  }
  def printN():Unit={
    println("这是Scala类当中的普通方法，需要通过“类的对象”进行调用")
  }
}

/**
 * 由object修饰的即是”类对象“
 * 并且在Object中定义的变量、方法都是静态的（类似Java中由static修饰）
 */
object Demo01HelloWorld{
  //在Object中变量是静态的，可以直接通过“类对象”调用
  val i = 10

  def printS():Unit={
    println("这是定义在object中的方法，可以直接通过”类对象“调用")
  }

  //定义一个main方法

  /**
   * def 表示定义一个函数
   * main 方法名(main这个方法名比较特殊 它是程序的入口)
   * args 参数名
   * Array[String] 参数类型
   * Unit 相当于Java中的void 表示该函数没有返回值
   */
  def main(args: Array[String]): Unit = {
    //打印HelloWorld
    System.out.println("HelloWorld! Object")
    println(Demo01HelloWorld.i)

    new Demo01HelloWorld().printN()

    Demo01HelloWorld.printS()
  }
}

HelloWorld! Object
10
这是Scala类当中的普通方法，需要通过“类的对象”进行调用
这是定义在object中的方法，可以直接通过”类对象“调用