Scala Basics (II): variables and data types

One 、 Variables and constants

How to define ？

 var  Variable name  [:  Variable type ] =  Initial value  
 val  Constant names  [:  constant type ] =  Initial value  


Take a chestnut ：

 var a: Int = 10;
 val b: Int = 22;
 //  Variable types can be omitted
 var a = 10;
 val b = 22;


because Scala It's a functional programming language , So you don't need variables where you can use constants .

Important conclusions ：

• When variables are declared , Type can be omitted , Compiler automatically infers , That is type derivation .

• Static type , A type cannot be modified after it has been given or derived .

• When variables and constants are declared , There must be an initial value .

• var The modified variable is variable ,val Modifier constants are immutable .

• Reference type constant , Cannot change the object pointed to by a constant , You can change the fields of an object .

• Don't to ; At the end of the sentence ,scala The compiler automatically recognizes the end of a statement .

Specification for identifier naming

• Start with a letter or underscore , Followed by a letter 、 Numbers 、 Underline , and Java The grammar is the same

• Scala You can start with an operator , And contains only the operator （+ - * / # ! etc. ）

• What's special ：scala Any string enclosed in backquotes , Even if it's  Scala  keyword （39  individual ） It's fine too .

Take a chestnut ：

 val hello = ""
 var Helo = ""
 var _abc=123
 var -+/% = "hello"
 var `if` = 123


Scala Keyword set in ：• 

package, import, class, object, trait, extends, with, type, for

• 

private, protected, abstract, sealed, final, implicit, lazy, override

• 

try, catch, finally, throw

• 

if, else, match, case, do, while, for, return, yield

• 

def, val, var

• 

this, super

• 

new

• 

true, false, null

And Java Here's the difference ：

object trait with implicit match yield def val var

character string

Basic grammar

• Keyword is  
  String

• adopt  
  +
    Connection No

• *
  Used to copy a string multiple times

• printf
  Output string , adopt % Pass value

• Interpolation string ：
  s"${ Variable name }“
  , The prefix for  
  s
    Format template string ,
  f
    Floating point number for formatting template ,
  %
  The following is the formatted content

• Raw output ：
  raw" Output content ${ Variable name }"
  , The output result is output as is

• Output statement ： 
  print( Output content )
  、
  println()
  、 
  printf()

• Three quotation marks indicate a string , Keep the original format output of multiline string .
  """......."""

Take a chestnut ：

 val name: String = "lisi" + " ";
 val age: Int = 12
 
 println(name * 3)
 printf("%d Year old %s be at table ", age, name)
 //  Format template string
 println(s"${age} Year old ${name} be at table ")
 
 val num: Double = 2.26054
 println(s"this number is ${num}")
 println(f"this num is ${num}%2.2f")
 println(raw"this num is ${num}%2.2f")
 
 val sql =
 s"""
 |select *
 | from student
 | where name = ${name}
 | and
 | age > ${age}
 |""".stripMargin
 
 println(sql)


Keyboard entry

Basic grammar

• import scala.io.StdIn
  ,StdIn stay  IO  It's a bag

• StdIn.readLine()
    Read string

• StdIn.readShort()

• StdIn.readDouble()

• .....................

Take a chestnut ：

object Test04_StdInt {
 def main(args: Array[String]): Unit = {
 println(" Please enter your name ：")
 val name = StdIn.readLine()
 println(" Please enter your age ：")
 val age = StdIn.readInt()

 println(s" welcome ${age} Of ${name}, Light copy system ！！！")
 }
}


File input and output ：

import scala.io.Source
import java.io.PrintWriter
import java.io.File

object Test05_FileIO {
 def main(args: Array[String]): Unit = {
 // 1. Reading data from a file
 Source.fromFile("src/main/resources/test.txt").foreach(print)

 // 2. Write data to file
 val writer = new PrintWriter(new File("src/main/resources/put.txt"))
 writer.write("hello scala from java")
 writer.close()
 }
}


Two 、 data type

Java Data types in

• Basic types ：
  char、byte、short、int、long、float、double、boolean

• The corresponding packaging class ：
  Character、Byte、Short、Integer、Long、Float、Double、Boolean

• because Java There are basic types , And the basic type is not a real object ,Java Not purely object-oriented .

Scala Data types in

• Scala All data in a database are objects ,
  Any
  Is the parent of all data .

• Any
  There are two corresponding subclasses , One is the numeric type （
  AnyVal
  ）, The other is the reference type （
  AnyRef
  ）

• StringOps
  It's right Java Medium
  String
  enhance .

• Unit
  by Scala A data type in , Corresponding Java Medium
  void
  , Indicates that the method does not return a value , There is only one singleton , Output as string
  ()
  , and
  void
  It's a keyword

• Scala The default is to convert the low precision data type to the high precision data type （ Automatic conversion  \  Implicit conversion ）

• Null
  Is a type , only   There is one right   Elephant   yes
  null
  . It's all reference types （
  AnyRef
  ） Subclasses of .

• Nothing
  , Is a subclass of all data types , Use when a function has no explicit return value , Because in this way we can throw the return value , Return to any variable or function .<center> Data type chart （ Source network ~）</center>

Integer types

• Byte
   [1 Bytes ] 
  8  Bit signed complement integer
  . The value range is  
  -128
    To  
  127

• Short
   [2 Bytes ] 
  16  Bit signed complement integer
  . The value range is  
  -32768
    To  
  32767

• Int
   [4 Bytes ] 
  32  Bit signed complement integer
  . The value range is  
  -2147483648
    To  
  2147483647

• Long
   [8 Bytes  ] 
  64  Bit signed complement integer
  . The value range is  
  -9223372036854775808
    To
  9223372036854775807
  = 2  Of (64-1) Power -1

• Each integer type has a fixed representation range and field length

• Scala The default data type is
  Int
  , Long integers need to be added  
  l
    perhaps  
  L

• Converting a high-precision number to a low-precision number requires a cast ： 
  val b3: Byte = (1 + 10).toByte

Take a chestnut ：

 val al: Byte = 127
 val a2: Byte = -128

 val a3 = 12

 val b1: Byte = 10
 val b2: Byte = (10 + 20)
 println(b2)

 val b3: Byte = (b1 + 10).toByte


Floating point type

• Float
   [4] 32  position , IEEE 754  Standard single precision floating point numbers

• Double
   [8] 64  position  IEEE 754  Standard double precision floating point numbers

• The default is
  Double
  type

Take a chestnut ：

 val f1: Float = 1.232f
 val d2 = 12.987


Character type

• The character type is  
  Char
  , Represents a single character

• Character constants are in single quotes  ' '  A single character enclosed .

• Escape character ：
  \t 、\n、\\、\”

Boolean type

• Booolean  Only values of type data are allowed  
  true
    and  
  false

• Take up a byte

Take a chestnut ：

 val isTrue = true
 val isFalse: Boolean = false
 println(isTrue)


Empty type

• Unit
   ： It means no value   There is only one instance value , It's written in
  ()

• Null
   ： Null  Type has only one instance value  
  null

• Nothing
   ：  Confirm that there is no normal return value , It can be used  Nothing  To specify the return type

Take a chestnut ：

 def m2(n: Int): Int = {
 if (n == 0)
 throw new NullPointerException
 else
 return n
 }


Type conversion

• Principle of automatic promotion ： There are many types of data mixed operations , Firstly, the system automatically converts all data into the data type with high precision , And then calculate .

• Error will be reported when high-precision data is transferred to the precision .

• Byte
  ,
  Short
    and  
  Char
    They don't automatically switch to each other .

• Byte
  ,
  Short
  ,
  Char
    The three of them can calculate , In calculation, it is first converted to  
  Int
    type .

Take a chestnut ：

 val a1: Byte = 10;
 val b1: Long = 20L;
 val result1: Long = a1 + b1
 println(result1)


Cast

• Cast ：
  toByte
  、
  toInt
  、......

• 'aaa'.toInt 2.2.toInt

• There is a loss of precision

• Sum of values String Conversion between ：
  Basic type of value +" "
  、
  s1.toInt、s1.toFloat、s1.toDouble、s1.toByte

Take a chestnut ：

 val n1: Int = 2.5.toInt
 println(n1)

 val n2: Int = (2.6 + 3.7).toInt
 println(n2)

 //  Change the value to String
 val a: Int = 27
 val s: String = a + " "
 println(s)

 //String Convert to numeric
 val m: Int = "12".toInt
 val f: Float = "12.4".toFloat
 val f2: Int = "12.6".toFloat.toInt
 println(f2)


This article ends here , I hope it helped you ！！！