小结以便学习和使用

• 1 Java
• 1.1 八种基本类型
• 1.2 类型之间的转换
• 1.3 变量
• 1.4 常量
• 1.5 控制流程
• 1.5.1 if 条件语句
• 1.5.2 while 循环
• 1.5.3 for 循环
• 1.5.4 switch 多重选择
• 1.5.5 中断控制流程语句

1.6 类案例

2 Scala

• 2.1 声明值和变量
• 2.2 九种基本数据类型
• 2.3 基本类型操作
• 2.4 方法与函数
• 2.5 循环控制语句
• 2.5.1 if 条件表达式
• 2.5.2 while 循环
• 2.5.3 for 循环
• 2.5.4 中断

2.6 类案例

3 Python

• 3.1 基础语法
• 3.2 基本数据类型
• 3.2.1 Number
• 3.2.2 String
• 3.2.3 List
• 3.2.4 Tuple
• 3.2.5 Set
• 3.2.6 Dictionary

3.3 运算符

3.4 控制循环语句

• 3.4.1 if
• 3.4.2 while
• 3.4.3 for
• 3.4.4 中断

3.5 函数

3.6 面向对象

4 Shell 脚本

• 4.1 基础语法
• 4.2 变量
• 4.3 基本运算符
• 4.4 流程控制语句
• 4.4.1 if
• 4.4.2 for
• 4.4.3 while
• 4.4.4 until
• 4.4.5 case
• 4.4.6 跳出循环 break / continue

4.5 函数

参考引用

1 Java

1.1 八种基本类型

序号	类型名称	定义	应用举例	字节空间
1	byte	-128~127,默认0	byte bt=120;	1Byte
2	short	-32768~32767,默认0	short st=32700;	2Byte
3	int	最常用的整数类型-231~231-1,默认0	int i=100;	4Byte
4	long	-263~263-1,默认0L	long ll=32222L;	8Byte
5	float	默认0.0f	float=3.2f;	4Byte
6	double	默认0.0d,默认的浮点数类型	double=4.5;	8Byte
7	char	16位无符号整数，代表对应的unicode字符，默认为空	char=704;	2Byte
8	boolean	默认false，只允许true/false	Boolean bl=false;	1Byte

1.2 类型之间的转换

不同的基本类型直接可以相互转换。

1. 自动类型转换(隐式类型转换)
   从小类型到大类型可以自动完成。类型的大小关系如下：

byteshortintlongfloatdoublechar

1. 强制类型转换
   从大类型到小类型需要强制转换符，但这样转换有可能会造成精度损失或溢出。

2. 特殊转换

   多种基本类型参与的表达式运算中，运算结果会自动的向较大的类型进行转换；

   byte、char、short三种类型实际存储的数据都是整数，在实际使用中遵循如下规则：
   int直接量可以直接赋值给byte、char和short，只要不超过其表示范围;
   byte、char、short三种类型参与运算时，先一律转换成int类型再进行运算。

1.3 变量

Java是一种强类型语言，这就意味着必须为每一个变量声明一种类型。如：

double salary;
boolean done;

声明一个变量后，必须用赋值语句对变量进行显式初始化。如：

System.out.println(salary); //报错，变量没有初始化
int i = 100;

1.4 常量

利用关键字 final 指示常量，表示该变量只能被赋值一次，一旦被赋值之后，就不能再更改了。习惯上，常量名使用全大写。如：

public static final double CM=3.9;

1.5 控制流程

1.5.1 if 条件语句

if (yourSales >= 2*target){
bonus = 1000000;
}
else if (yourSales >= 1.5*target){
bonus = 1000;
}
else if  (yourSales >= target){
bonus = 100;
}
else{
System.out.print("You are fired!");
}

1.5.2 while 循环

int i = 1;
while ( i<10 ){
System.out.println(i);
i++;
}

也可以使用 do (statement) while (condition)

1.5.3 for 循环

int money = 1000;
for (int i=1; i<1000; i++){
money = i*money; //poor little one! sigh!
}

1.5.4 switch 多重选择

switch (choice){
case 1:
...
break;
case 2:
...
break;
default:
...
break;
}

switch 将从匹配的 case 处执行直到遇到 break，或者执行到switch 语句的结束处为止。警告：有可能触发多个分支，如果在 case分支语句结尾没有 break语句，那么就会接着执行下一个 case 分支语句。

case 标签常量可以是：

• 类型为 char / byte / short / int 的常量表达式；
• 枚举常量；
• 字符串字面量。

1.5.5 中断控制流程语句

break 跳出整个循环；
continue 跳出当前循环。

1.6 类案例

class Employee{
private String number,name;
private int salary,salarygrow,salarysum;
public Employee(String number,String name,int salary){
this.number=number;
this.name=name;
this.salary=salary;
}
public void salaryGrow(){
salarygrow=salary*2+1000;
}
public void salarySum(){
salarysum=salary+salarygrow;
}
public void printsalary(){
System.out.println("编号："+number+"  姓名："+name+"  基本薪水："+salary+"  薪水增长额："+salarygrow+"  工资总额："+salarysum);
}
}

public class EmployeeTest{
public static void main(String args[]){
Employee e=new Employee("11412241","陈菲菲",3000);
e.salaryGrow();
e.salarySum();
e.printsalary();
}
}
---------------------
作者：神之子2
来源：CSDN
原文：https://blog.csdn.net/weixin_42895133/article/details/81807437
版权声明：本文为博主原创文章，转载请附上博文链接！

2 Scala

2.1 声明值和变量

• var 可变变量：变量被赋值后，变量值可以随着程序的运行而改变；
• val 不可变变量：常量，无法被改变；
• 类型推断：定义时候可以不给出 var / val 的类型，scala 内部有类型推断机制，可以自动推断出变量的类型。

scala> 24+"H"
res1: String = 24H

• 初始化：不管是val 还是var，在声明的时候都要进行初始化，否则报错；
• var 使用占位符“___”初始化：String 类型使用“___”初始化为 null, Int / Float /Double 等被“___”初始化为 0，Char 则为 ？；
• lazy 关键字：可以用来修饰 val 声明的变量，表示只有这个变量真正被使用的时候才去赋值。
• 格式注意：在Scala 中，变量或函数的类型总是写在变量或函数名称的后面，每条语句后面不使用分号，仅当同一行代码中存在多条语句时才需要用分号隔开。

scala> var s:String=_ //类型写在变量名称的后面
s: String = null

scala> var i:Int=_
i: Int = 0

scala> var c:Char=_
c: Char = ?

scala> lazy val s = "test"
s: String = <lazy>

scala> s
res2: String = test

2.2 九种基本数据类型

• Scala中所有数据类型的根类型是 AnyVal, 类似于java 中 Object类；
• 与java不同，这些类型都是类，首字母必须大写。

序号	类型	定义	说明	示例
1	Byte	字节类型	8位有符号整数
2	Short	短整型	16位有符号整数
3	Int	整型	32位有符号整数
4	Long	长整型	64位有符号整数
5	Float	浮点型	32位浮点数	val floatnum=0.34f
6	Double	默认浮点型	64位双精度浮点数
7	Char	字符型	16位无符号字符
8	Boolean	布尔类型
9	Unit	空类型

2.3 基本类型操作

Scala语言是纯面向对象、编译型编程语言，在Scala中一切皆对象，所有的操作都是方法的调用。或者说 Scala 并不刻意区分基本类型和引用类。你可以对数字执行方法，如：

scala> 1.toString()
res4: String = 1

1. 算术运算操作

在Scala中，可以使用加(+)、减(-) 、乘(*) 、除(/) 、余数（%）等操作符，而且，与java不同的是这些操作符都是方法。例如，5 + 3和(5).+(3)是等价的，也就是说：

a 方法 b

a.方法(b)

需要注意的是，和Java不同，在Scala中并没有提供++和- -操作符，当需要递增和递减时，可以采用 += / -=。

1. 关系运算操作 / 逻辑运算操作 / 位运算操作
   与java 相同

2. 对象比较运算操作
   与java不同：Scala是基于内容进行比较的，而java是比较的对象的引用，即：比较的是物理内存地址是否一样。

scala> var s1 = new String("hello")
s1: String = hello

scala> var s2 = new String("hello")
s2: String = hello

scala> s1.equals(s2)
res8: Boolean = true

scala> s1 == s2
res9: Boolean = true

scala> s1.eq(s2) //和java一样比较内存的话，使用 eq
res10: Boolean = false

1. 字符串运算操作
   Scala中的String类型实际上就是java中的String的类型，因此可以调用java 中String类型的所有方法。

2.4 方法与函数

Scala 有方法与函数，二者在语义上的区别很小。Scala 方法是类的一部分，而函数是一个对象可以赋值给一个变量。换句话来说在类中定义的函数即是方法。
Scala 中的方法跟 Java 的类似，方法是组成类的一部分。
Scala 中的函数则是一个完整的对象，Scala 中的函数其实就是继承了 Trait 的类的对象。
Scala 中使用 val 语句可以定义函数，def 语句定义方法。

class Test{
def m(x: Int) = x + 3 //方法
val f = (x: Int) => x + 3 //函数
}

2.5 循环控制语句

2.5.1 if 条件表达式

object func {
def main(args:Array[String]){
var v = 30

if (v<20)
println("the number is less than 20")
else
println("the number is greater than 20")

}
}

2.5.2 while 循环

object Test {
def main(args: Array[String]) {
// 局部变量
var a = 10

// while 循环执行
while( a < 20 ){
println( "Value of a: " + a )
a = a + 1
}
}
}

do…while…循环同样。

2.5.3 for 循环

不同于java, Scala 中没有与 for(初始化变量；检查变量是否满足某条件；更新变量)直接对应的结构。

• 基本语法结构

for( var x <- Range ){
statement(s)
}

// i to j 语法：[1,10]
for( a <- 1 to 10){
println( "Value of a: " + a )
}

// i until j 语法：[1,10)
for( a <- 1 until 10){
println( "Value of a: " + a )
}

// 使用分号 (;) 来设置多个区间，它将迭代给定区间所有的可能值。
for( a <- 1 to 3; b <- 1 to 3){
println( "Value of a: " + a )
println( "Value of b: " + b )
}

// 循环集合
for( a <- numList ){
println( "Value of a: " + a )
}

// 循环过滤
for( a <- numList
if a != 3; if a < 8 ){
println( "Value of a: " + a )
}

// 使用 yield, 将 for 循环的返回值作为一个变量存储。
var retVal = for{ a <- numList
if a != 3; if a < 8
}yield a
// 输出返回值
for( a <- retVal){
println( "Value of a: " + a );
}

2.5.4 中断

Scala 不支持 break 或 continue 语句，但从 2.8 版本后提供了一种中断循环的方式：使用breaks 对象的 break方法。

2.6 类案例

import java.io._

class Point(xc: Int, yc: Int) { //类可以有参数
var x: Int = xc
var y: Int = yc

def move(dx: Int, dy: Int) {
x = x + dx
y = y + dy
println ("x 的坐标点: " + x);
println ("y 的坐标点: " + y);
}
}

object Test {
def main(args: Array[String]) {
val pt = new Point(10, 20);
// 移到一个新的位置
pt.move(10, 10);
}
}

3 Python

3.1 基础语法

1. 标识符

• 第一个字符必须是字母表中字母或下划线 _ ;
• 标识符的其他的部分由字母、数字和下划线组成;
• 标识符对大小写敏感。

1. 注释

• Python中单行注释以 # 开头;
• 多行注释可以用多个 # 号，还有 ‘’’ 和 “”"：

#!/usr/bin/python3

# 第一个注释
# 第二个注释

'''
第三注释
第四注释
'''

"""
第五注释
第六注释
"""
print ("Hello, Python!")

1. 行与缩进

• 使用缩进来表示代码块，不需要使用大括号 {} ；
• 缩进的空格数是可变的，但是同一个代码块的语句必须包含相同的缩进空格数，否则会错。

if True:
print ("Answer")
print ("True")
else:
print ("Answer")
print ("False")    # 缩进不一致，会导致运行错误

1. 多行语句

• 如果语句很长，我们可以使用反斜杠()来实现多行语句，例如：

total = item_one + \
item_two + \
item_three

• 在 [], {}, 或 () 中的多行语句，不需要使用反斜杠()，例如：

total = ['item_one', 'item_two', 'item_three',
'item_four', 'item_five']

1. import 与 from … import …

• 将整个模块(somemodule)导入，格式为： import somemodule
• 从某个模块中导入某个函数,格式为： from somemodule import somefunction
• 从某个模块中导入多个函数,格式为： from somemodule import firstfunc, secondfunc, thirdfunc
• 将某个模块中的全部函数导入，格式为： from somemodule import *

3.2 基本数据类型

• Python 中的变量不需要声明。每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。
• Python 中，变量就是变量，它没有类型，我们所说的"类型"是变量所指的内存中对象的类型。
• 允许多变量赋值。

#!/usr/bin/python3

counter = 100          # 整型变量
miles   = 1000.0       # 浮点型变量
name    = "runoob"     # 字符串

print (counter)
print (miles)
print (name)

a = b = c = 1
a, b, c = 1, 2, "runoob"

• 六个标准数据类型

类型	名称	是否可变
Number	数字	不可变
String	字符串	不可变
List	列表	可变
Tuple	元组	不可变
Set	集合	可变
Dictionary	字典	可变

• 注意：Python3 中，True 和 False 定义成关键字了，但它们的值还是 1 和 0，它们可以和数字相加。

>>> i = 1+ True
>>> print(i)
2
>>> bb = True
>>> print(bb)
True
>>> bb +=1
>>> print(bb)
2
>>> print(type(bb))
<class 'int'>

3.2.1 Number

Python3 支持 int、float、bool、complex（复数）。

>>> a, b, c, d = 20, 5.5, True, 4+3j
>>> print(type(a), type(b), type(c), type(d))
<class 'int'> <class 'float'> <class 'bool'> <class 'complex'>

3.2.2 String

• Python中的字符串用单引号 ’ 或双引号 " 括起来，同时使用反斜杠 \ 转义特殊字符。
• 索引值以 0 为开始值，-1 为从末尾的开始位置。
• 加号 + 是字符串的连接符， 星号 * 表示复制当前字符串，紧跟的数字为复制的次数。
• Python 使用反斜杠()转义特殊字符，如果你不想让反斜杠发生转义，可以在字符串前面添加一个 r，表示原始字符串

>>> print('Ru\noob')
Ru
oob
>>> print(r'Ru\noob')
Ru\noob
>>> str = 'test'
>>> print(str[1:-1])
es

3.2.3 List

• List中的元素是可以改变的。
• Python 列表截取可以接收第三个参数，参数作用是截取的步长，

>>>a = [1, 2, 3, 4, 5, 6]
>>> a[0] = 9
>>> a[2:5] = [13, 14, 15]
>>> a
[9, 2, 13, 14, 15, 6]
>>> a[2:5] = []   # 将对应的元素值设置为 []
>>> a
[9, 2, 6]
>>> list = [1,2,3,4,5,6]
>>> print(list[1:4:2])
[2, 4]

3.2.4 Tuple

• 元组（tuple）与列表类似，不同之处在于元组的元素不能修改。
• 元组写在小括号 () 里，元素之间用逗号隔开。
• 元组中的元素类型也可以不相同。

#!/usr/bin/python3

tuple = ( 'abcd', 786 , 2.23, 'runoob', 70.2  )
tinytuple = (123, 'runoob')

print (tuple)             # 输出完整元组
print (tuple[0])          # 输出元组的第一个元素
print (tuple[1:3])        # 输出从第二个元素开始到第三个元素

• 构造包含 0 个或 1 个元素的元组比较特殊，所以有一些额外的语法规则：

tup1 = ()    # 空元组
tup2 = (20,) # 一个元素，需要在元素后添加逗号

3.2.5 Set

• 可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。
• 元素不能重复。

#!/usr/bin/python3

student = {'Tom', 'Jim', 'Mary', 'Tom', 'Jack', 'Rose'}

print(student)   # 输出集合，重复的元素被自动去掉

# 成员测试
if 'Rose' in student :
print('Rose 在集合中')
else :
print('Rose 不在集合中')

# set可以进行集合运算
a = set('abracadabra')
b = set('alacazam')

print(a)

print(a - b)     # a 和 b 的差集

print(a | b)     # a 和 b 的并集

print(a & b)     # a 和 b 的交集

print(a ^ b)     # a 和 b 中不同时存在的元素

3.2.6 Dictionary

• 字典是一种映射类型，字典用 { } 标识，它是一个无序的 键(key) : 值(value) 的集合。
• 键(key)必须使用不可变类型。
• 在同一个字典中，键(key)必须是唯一的。

#!/usr/bin/python3

dict = {}
dict['one'] = "1 - 菜鸟教程"
dict[2]     = "2 - 菜鸟工具"

tinydict = {'name': 'runoob','code':1, 'site': 'www.runoob.com'}

print (dict['one'])       # 输出键为 'one' 的值
print (dict[2])           # 输出键为 2 的值
print (tinydict)          # 输出完整的字典
print (tinydict.keys())   # 输出所有键
print (tinydict.values()) # 输出所有值

3.3 运算符

1. 算术运算符

• 数值的除法包含两个运算符：/ 返回一个浮点数，// 返回一个整数。
• 在混合计算时，Python会把整型转换成为浮点数。

>>> 2 / 4  # 除法，得到一个浮点数
0.5
>>> 2 // 4 # 除法，得到一个整数
0

1. 比较运算符
2. 赋值运算符
3. 位运算符
4. 逻辑运算符

and	x and y
or	x or y
not	not x

1. 成员运算符

in	x 在 y 序列中 , 如果 x 在 y 序列中返回 True。
not in	x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True

1. 身份运算符

运算符	描述	实例
is	is 是判断两个标识符是不是引用自一个对象	x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True，否则返回 False
is not	is not 是判断两个标识符是不是引用自不同对象	x is not y ， 类似 id(a) != id(b)。如果引用的不是同一个对象则返回结果 True，否则返回 False。

3.4 控制循环语句

3.4.1 if

if condition_1:
statement_block_1
elif condition_2:
statement_block_2
else:
statement_block_3

3.4.2 while

while 判断条件：
语句

while…else…

#!/usr/bin/python3

count = 0
while count < 5:
print (count, " 小于 5")
count = count + 1
else:
print (count, " 大于或等于 5")

3.4.3 for

#!/usr/bin/python3

sites = ["Baidu", "Google","Runoob","Taobao"]
for site in sites:
if site == "Runoob":
print("菜鸟教程!")
break
print("循环数据 " + site)
else:
print("没有循环数据!")
print("完成循环!")

>>>for i in range(0, 10, 3) :
print(i)

0
3
6
9

3.4.4 中断

break 跳出全部循环
continue 跳出当前循环

3.5 函数

def 函数名（参数列表）:
函数体

>>>def hello() :
print("Hello World!")
>>> hello()
Hello World!
>>>

3.6 面向对象

#!/usr/bin/python3

#类定义
class people:
#定义基本属性
name = ''
age = 0
#定义私有属性,私有属性在类外部无法直接进行访问
__weight = 0
#定义构造方法
def __init__(self,n,a,w):
self.name = n
self.age = a
self.__weight = w
def speak(self):
print("%s 说: 我 %d 岁。" %(self.name,self.age))

# 实例化类
p = people('runoob',10,30)
p.speak()

4 Shell 脚本

4.1 基础语法

• 单行注释与多行注释

#--------------------------------------------
# 这是一个注释
# author：菜鸟教程
# site：www.runoob.com

:<<EOF
注释内容...
注释内容...
注释内容...
EOF

:<<'
注释内容...
注释内容...
注释内容...
'

:<<!
注释内容...
注释内容...
注释内容...
!

4.2 变量

• 定义变量：变量名和等号之间不能有空格，这可能和你熟悉的所有编程语言都不一样。

your_name="runoob.com"

• 使用一个定义过的变量：只要在变量名前面加美元符号即可，如：

your_name="qinjx"
echo $your_name
echo ${your_name}

• 传递参数：执行 Shell 脚本时，向脚本传递参数，脚本内获取参数的格式为：$n。n 代表一个数字，1 为执行脚本的第一个参数，2 为执行脚本的第二个参数，以此类推……$0 为执行的文件名：

#!/bin/bash
# author:菜鸟教程
# url:www.runoob.com

echo "Shell 传递参数实例！";
echo "执行的文件名：$0";
echo "第一个参数为：$1";
echo "第二个参数为：$2";
echo "第三个参数为：$3";

$ chmod +x test.sh
$ ./test.sh 1 2 3
Shell 传递参数实例！
执行的文件名：./test.sh
第一个参数为：1
第二个参数为：2
第三个参数为：3

4.3 基本运算符

• 原生bash不支持简单的数学运算，但以通过其他命令来实现，例如 awk 和 expr，expr 最常用。
• 表达式和运算符之间要有空格，例如 2+2 是不对的，必须写成 2 + 2，这与我们熟悉的大多数编程语言不一样。
• 完整的表达式要被``包含，注意这个字符不是常用的单引号，在 Esc 键下边。

#!/bin/bash

val=`expr 2 + 2`
echo "两数之和为 : $val"

算术运算符	关系运算符	布尔运算符	逻辑运算符	字符串运算符
+	-eq	!	&&	=
-	-ne	-o	||	!=
\*	-lt	-a		-z
/	-gt			-n
%	-le			$
=	-ge
==
!=

#!/bin/bash
# author:菜鸟教程
# url:www.runoob.com

a=10
b=20

if [[ $a -lt 100 && $b -gt 100 ]]
then
echo "返回 true"
else
echo "返回 false"
fi

if [[ $a -lt 100 || $b -gt 100 ]]
then
echo "返回 true"
else
echo "返回 false"
fi

num1="ru1noob"
num2="runoob"
if test $num1 = $num2
then
echo '两个字符串相等!'
else
echo '两个字符串不相等!'
fi

4.4 流程控制语句

4.4.1 if

if condition1
then
command1
elif condition2
then
command2
else
commandN
fi

4.4.2 for

for var in item1 item2 ... itemN
do
command1
command2
...
commandN
done

4.4.3 while

while condition
do
command
done

4.4.4 until

until condition
do
command
done

4.4.5 case

case 值 in
模式1)
command1
command2
...
commandN
;;
模式2）
command1
command2
...
commandN
;;
esac

4.4.6 跳出循环 break / continue

#!/bin/bash
while :
do
echo -n "输入 1 到 5 之间的数字:"
read aNum
case $aNum in
1|2|3|4|5) echo "你输入的数字为 $aNum!"
;;
*) echo "你输入的数字不是 1 到 5 之间的! 游戏结束"
break
;;
esac
done

#!/bin/bash
while :
do
echo -n "输入 1 到 5 之间的数字: "
read aNum
case $aNum in
1|2|3|4|5) echo "你输入的数字为 $aNum!"
;;
*) echo "你输入的数字不是 1 到 5 之间的!"
continue
echo "游戏结束"
;;
esac
done

4.5 函数

#!/bin/bash
# author:菜鸟教程
# url:www.runoob.com

funWithParam(){
echo "第一个参数为 $1 !"
echo "第二个参数为 $2 !"
echo "第十个参数为 $10 !"
echo "第十个参数为 ${10} !"
echo "第十一个参数为 ${11} !"
echo "参数总数有 $# 个!"
echo "作为一个字符串输出所有参数 $* !"
}
funWithParam 1 2 3 4 5 6 7 8 9 34 73

参考引用

传说中一网打尽各类编程语言的语法：http://www.runoob.com
Java八种基本类型（byte、short、int、long、浮点数、char、boolean、基本类型转换）
Java 定义并测试一个代表员工的Employee类
scala开发快速入门 | 第二篇 变量及基本数据类型
Scala学习之——变量、函数、方法及两者联系
Scala 教程