第2单元 编程基础
2.1 Java基本语法
2.1.1 Java程序基本格式
修饰符 class 类名{
程序代码;
}
程序代码：结构定义语句
功能执行语句
Java严格区分大小写
有排版要求：两个词或符号之间插入空格
字符串不能分成两行书写
长字符串：两个短字符串通过“+”链接：字符串1+字符串2
2.1.2 Java注释
1、单行注释 //
2、多行注释 /* */
3、文本注释 /** /
2,1.3 Java中的标识符
标识符：
定义：按一定规则制定的符号，表示一些名称：包名，类名，方法名，参数名，变量名等
构成：字母、数字、下划线或美元符号，且首位不能是数字，不能是关键字
（关键字：Java语言保留的有特定意义的标识符：if,else, while。break，continue，class，)
包名：字母小写 chapter01
类名和接口名：每个单词首字母大写 HelloWorld，Student
常量名：每个字母都大写： PI=3.14 3.1415926
变量名和方法名：第一个单词首字母小写，第二个单词开始首字母大写
变量名：一般名词 name ,userName
方法名：动宾结构（动词+名词） getName,setName
使用有意义的单词定义标识符
区分变量名和方法名：变量名:没有括号；方法(参数)：有括号
2.1.4 关键字（保留字）
关键字：Java语言保留的有特定意义的标识符：if,else,classwhile
关键字字母小写
关键字不能作为标识符
2.1.5 Java常量
1、整型常量：
2、浮点常量：
3、字符常量： 'a' 或 '\u0000' 转义字符
4、字符串常量： ""，"a","agegaegreg544654658**-*/*/*-奏国歌如果"
5、布尔常量：true ,false
6、null常量:引用类型的对象为空（不指向任何对象）
2.2 Java中的变量
1、变量：能随时改变的量，用变量标识符定义
2、变量的类型：2类：基本数据类型，引用数据类
基本数据类型：数值类型：整数类型：byte,short, int,long
浮点类型：float,double
字符类型：char
布尔类型：true, false
引用数据类型：类（class）
接口（interface）
数组 {1,2,3,4,5}
枚举（enumerate）
注解（annotation）
基本数据类型：使用的是值。
引用数据而类型：使用的是（内存）地址。
基本数据类型使用：声明（定义）、赋值
引用数据类型使用：声明（定义）、创建（new关键字创建）和赋值
3、基本数据类型变量的使用：声明（定义）与赋值
声明（定义）：数据类型 变量名;
赋值： 变量=值;
<=>
声明+赋值; 数据类型 变量名=值;
例子：
1、
int x; //声明（定义一个int型变量x）
x=10; // 给int变量x赋初值10 <=> int x=10;
2、
int x=0,y; //2个int变量x,y x=0,y int x=0; int y
y=x+3; //y=x=3
声明：int x;
赋值：
声明与赋值：以10为底的幂次
2^10*2^5=1024*32=300000
整型数据类型：4种类型，不同类型占用内存大小不同
0 1 -2 123456 123456789987654321
-128~127
4种不同类型： byte 8位(8个二进制位) （1个字节） 8个二进制位（bit）=1个字节(byte) (-2^7~2^7-1)
short 16位（2个字节） 00000000 00000000 ~2^15-1
int 32位（4个字节） 00000000 00000000 00000000 00000000 2^31-1
long 64位（8个字节）：
计算机底层二级制：0或1
0 或 1： 1个二进制位： 2个：2^1
00 01 10 11 ： 2个二进制位：4个: 2^2
000 001 010 011 100 101 110 111 ：3 个二进制位数： 8个： 2^3
n个二进制位数： n个 2^n
如果是long类型变量，后面要加字母l（或L），说明是long类型；
若赋的值未超过int类型取值范围，可省略字母l（或L）
long num=220000000L;
long num=198l;
long num=198;
int x=0;
198(4); 198l(8)
浮点类型数据：2种类型，不同类型占用内存大小不同
2种类型：float 32位（4个字节）
double 64位（8个字节）（默认）
E(e)=10^
3.14E2=3.14*10^2=314.0
314e-2=3.14*10^-2=3.14
10^-1=1/10=0.1
10^-2=1/100=0.01
浮点类型，默认是double类型， 如果是doule类型变量，字母d（或D）可加可不加
如果是float类型变量，后面必须加字母f（或F）
double d1=100.1;
double d2=199.3d;(建议)
float f=123.4f;（必须加f）
给浮点型赋整型值：可行（自动类型转换）
float f=100;
double d=100;
3、字符类型变量(char)：一个字符2个字节，单引号''
Java字符，Unicode编码，每个字符对应唯一的数值 'a':97
字符变量赋值时，可以赋字符，也可以赋数值（计算机自动将数值转换对应字符）
char c='a'; <=> char c=97;
4、布尔数据类型：boolean关键字声明，只有true和false两个值
boolean flag=false;
flag=true;
2.2.3 变量的类型转换
目的：解决数据类型不一致
类型：自动数据类型转换： 小--->大
强制数据类型转换： 大---->小，数据类型不同
1、自动数据类型转换：3种
原值 目标值
（1）整型类型间： byte-->short,int,long short s=15b iint i =15b; long l=15b
short、char--->int ,long
int--->long long l =198;
（2）整数类型、字符类型转化为floa型：byte、short、int、char---->float float f =15;
（3）整数类型、字符类型和单精度float型转化为double型：byte、short、int、char、float---->double
强制数据类型转换：两种数据类型不兼容或目标类型取值范围小于原类型 int x=(int) 195l;
2、强制数据类型语法：
目标类型 变量=（目标值）值
注意：对变量进行强制数据类型转换时，可能会造成数据丢失。
2.2.4 变量的作用域（作用范围）：
变量先声明（定义）再赋值，最后使用
变量一定被定义在一对大扩号内，大括号所包含的区域就是该变量的作用域。(找变量最近的左括号)
public static void main(String[] args){
int x=4;
{
int y=9;
}
}
2.3 Java中的运算符
在Java中，运算符种类：算术、赋值、比较和逻辑 ，4类运算符
2.3.1 算术运算符
类型：+，-，++，--，*，/，%
作用：进行算数运算
1、+
（1）+特殊用法：字符串与不同基本数据类型的链接： 字符串类型+基本数据类型： : 结果是字符串类型。 “1”+2：“12”
（2）自加、自减操作： 1）++（或--）在操作数前（++a）： 先自加（或自减），再进行其他运算
2）++（或--）在操作数后(a++)： 先进行其他运算，再自加（或自减）
例子：
int a=1;
int b=2;
int x=a+b++; b++: a+b x:3 b:3
System.out.println("b="+b); b=3
System.out.println("x="+x); x=3
2、/： 分子 （被除数）/ 分母（除数） 6/3
（1）被除数和除数，都是整数：结果为整数，小数舍去： 2510/1000: 2
（2）被除数或除数有浮点数：结果为浮点数。
例子：
25/10.0 : 2.5
25.0 /10: 2.5
25.0/10.0: 2.5
3、%：求余数（求模）
（1）余数的正负，取决于%左边的数（先不管符号，算完再处理）
例子：
（-5）%3 = -2
5%（-3）= 2
2.3.2 赋值运算符：
类型： =，+=，-=，*=，/=，%=
作用：将右边常量、变量或表达式的值赋给左边的变量
a+=1 <=> a=a
变量 = 表达式 （常量、变量或表达式） （ 变量 <---- 表达式）
1、=：
（1）=：赋值号（或赋值运算符）
（2）作用：将右边常量、变量或表达式的值赋给左边的变量
（3）赋值方向：从右往左赋值（右边表达式的结果，赋值给左边变量）
变量 = 表达式 （常量、变量或表达式） （ 变量 <---- 表达式）
（4）单个变量赋值：先声明，再赋值。
例子：
int x;
x=5; < => int x=5;
（5）多个变量赋值：先声明，再赋值。
例子：
int x=5;
int y=5; （√）
int z=5;
------------------------
int x,y,z;
x=1;
y=2;
z=3; （√）
------------------
int x=y=z=5; （×）
2、自运算符： +=，-=，*=，/=，%=
（1）会算：
例子
a=3,b=2;
a+=b;
a-=b;
a*=b;
a/=b;
（2）自运算符，强制类型转换会自动完成，不需要处理。
short s=3;
int i = 5;
s+=i ; // 自运算，强制类型转换自动完成
2.3.3 比较运算符
类型： ==，!=，<，>, <=,>=
作用：比较两个量的大小，其结果为布尔值（true、false二选一）
注意：
（1）“abc”=="Abc"： false (Java区分大小写)
（2）<=(小于或等于)，>=(大于或等于)
例子：
3<=4: true
3>=4: false
5>=4: true
5<=4：false
2.3.4 逻辑运算符：
类型： &（与），|（或），^（异或），！（非），&&（短路与），||（短路或）
作用：对布尔类型数据进行判定，结果为布尔值
1、&和&&：
（1）相同点：全真为真，一假为假
（2）区别： &：符号两边表达式都要运算
&&：符号左边为false时，右边不算。
例子：2.6
int x = 0;
int y = 0;
int z = 0;
boolean a, b;
a = x > 0 & y++ > 1; // x=0; y=1 a:false
System.out.println(a);
System.out.println("y = " + y); //y=1
b = x > 0 && z++ > 1; //x=0 ,z=0
System.out.println(b);
System.out.println("z = " + z); z=0
2、|和||：
（1）相同点：一真为真，全假为假
（2）区别： |：符号两边表达式都要运算
||：符号左边为true时，右边不算。
例子：
int x=0;
int y=0;
boolean b= x==0 || y++>0
3、^：异或
口诀：布尔值相同，结果为false
布尔值不同，结果为true
例子：
true ^ true: false
false ^ false: false
true ^ false: true
false ^ true： true
2.3.5 运算符优先级
1、不同类型，优先级不同：括号>算术运算符>比较运算符>逻辑运算符（&>^>|）>赋值运算符
2、同级别，从左往右处理。
3、分不清，加括号（括号优先级最高）
例子：
int a=2;
int b= a+3*a;
----------------
int a=2;
int b=(a+3)*a;
2.4 选择结构语句
选择语句：if条件语句： if单分支，if双分支，if多分支
switch语句
2.4.1 if条件语句
1、if语句：if 单分支语句
语法：
if (条件语句){ // 条件语句为true，执行{}中的代码块；否则，不执行{}中的代码块
代码块；
}
2、if......else语句：if 双分支语句
语法：
if (条件语句){ // 条件语句为true，执行{}中的代码块1；否则，执行{}中的代码块2
代码块1；
}
else{
代码块2；
}
3、if......else if.....else语句：if 多分支语句（只选择一个分支）
语法：
if (条件语句1){ //条件语句1为true，执行{}中的代码块1；否则，执行条件语句2，以此类推满足
代码块1； //当所有条件都不满足，执行else后面的代码块n+1。
}
else if (条件语句2){
{
代码块2；
}
......
else if (条件语句n){
{
代码块n；
}
else{
代码块n+1；
}
2.4.2 三元运算符：
1、if...else 双分支结构的简化码
2、三元运算符语法：
判定条件 ？ 表达式1：表达式2
注释：当判定条件为true，执行表达式1，且该值作为整个表达式的结果；否则执行表达式2，且该值作为整个表达式的结果
注意：
（1）三元运算符，?与：不能分开
（2）优先级：赋值运算符<三元运算符<算术或关系运算符
（3）条件运算符嵌套：自右向左结合
a > b ? a : c > d ? c ：d <=> a > b ? a : （c >d ? c : d）
例子：比较两个数的大小
if.....else 结构
int x=0;
int y=1;
int max;
if (x>y){
max=x;
}
else{
max=y;
}
System.out.println(max);
--------------
三元运算符：
int x=0;
int y=1;
int max= x>y ? x : y;
System.out.println(max);
--------------
2.4.3 switch条件语句：对表达式进行匹配，且只匹配一次。
1、基本语法：
switch(表达式值){
case 目标值1:
执行语句1;
break;
case 目标值2:
执行语句2;
break;
......
case 目标值n:
执行语句n;
break;
[ default:
执行语句n; //这段代码块可缺省
break;
]
}
解释：
（1）表达式的值与case语句的目标值进行匹配，匹配成功，执行对应case后面的语句；如果没有匹配的case语句，执行default后的语句。
（2）break关键字作用：结束并跳出switch结构。
2、执行语句存在重复，只需写一次即可
例子2-11
switch(表达式值){
case 目标值1:
case 目标值2:
case 目标值3:
执行语句1;
break;
......
case 目标值4:
case 目标值5:
执行语句2;
break;
[default:
执行语句n;
break;]
}
2.5 循环结构语句
循环语句：while循环语句： while循环 ，do......while循环
for循环语句：
2.5.1 while循环语句：先判定，再循环
语法：
while (循环条件){
执行语句; //循环体，有缩进
......
}
解释：当循环条件为true，执行大括号内的执行语句
否则，当循环条件为false，结束整个while循环，跳出while循环结构（while关键字+循环条件+循环体）
例子2-12：
2.5.2 do......while循环语句：先循环，再判定（至少循环一次）
语法：
do{
执行语句; //循环体，有缩进
......
}while (循环条件);
解释：先循环，再判定
当循环条件为true，再次执行大括号内的执行语句
否则，当循环条件为false，结束整个do.....while循环，跳出循环结构
例子2-13：
2.5.3 for循环语句
语法：
for (初始表达式; 循环条件; 操作表达式){
执行语句； //循环体，有缩进
.....
}
解释：for关键字后面的三个内容：1、初始表达式 2、循环条件 3、操作表达式
4、执行语句（循环体）
for(int i=1;i<=10;i++){
Systm.out.println("i="+i);
Systm.out.println("*****")
}
for( 1 ; 2 ; 3 ) {
4；
}
for循环流程：
第一步：执行1（初始表达式）
第二步：判定2（循环条件），如果为true，则执行第三步；如果为false，执行第五步
第三步：执行4（循环体）
第四步：执行3（操作表达式），然后重复第二步
第五步：退出循环
例子2-14
2.5.4 循环嵌套
1、定义：在一个循环语句中再定义一个循环语句。while、do.....while和for语句，这3种循环语句间相互嵌套
典型：双层for循环
for (初始表达式; 循环条件; 操作表达式){
执行语句； //循环体，有缩进
.....
for (初始表达式; 循环条件; 操作表达式){
执行语句； //循环体，有缩进
......
}
......
}
注意：
1、外层循环、内层循环变量尽量不同（原因：变量作用域）
2、循环变量的声明（定义）与赋值，放在for循环内。
3、外层循环：行数
内层循环：列数
例子2-15
2.5.5 跳转语句：break关键词，continue关键词
1、break关键词作用： break之后的循环体不执行
跳出整个循环结构（本循环结构）
执行循环结构外（后）的语句
2、continue关键词作用：continue之后的循环体不执行
终止本次循环，并执行下一次循环
2.6 方法
2.6.1 方法（函数）
1、定义：可重复调用的程序。通过调用方法名，实现方法对应的功能。
2、方法语法格式：
修饰符 返回值类型 方法名(参数类型 参数名1,参数类型 参数名2,....,参数类型 参数名n){
执行语句;
........
[ return 返回值; ] //[]:缺省 无返回值，返回值类型void(空)
}
修饰符：对访问权限进行限定：private、protected、default、public
static、final
返回值类型：限定方法返回值的数据类型；（若没有返回值，该类型为void）
参数类型：限定调用方法时传入参数的数据类型
参数名：是一个变量，用于接受调用方法时传入的数据
return关键字：返回方法指定类型的值，并结束方法。
返回值：return语句返回的值，该值返回给调用者。
注意：参数列表：可以为空，即 方法名()
方法的返回值类型必须是方法声明类型返回值类型，若方法没有返回值，return语句可以不写，且方法的返回值类型声明为void
例子2-19：无return语句的方法
例子2-20：有return语句的方法
2.6.2 方法的重载：
1、定义：在同一个作用域内，方法名相同，但参数个数或参数类型不同（3种情况）的方法。
方法的重载：与方法名和参数有关，与方法的返回值类型无关。
2.7 数组
定义：是指一组类型相同的数据的集合。
注意：1、数组中的每个数据称为元素
2、数组元素类型可以任意，但同一个数组，元素类型必须一致
3、数组分为：一维数组 和 多维数组
2.7.1 数组的定义
数组：1、定义（声明）
2、创建
3、赋值
1、一维数组声明（定义）、创建
（1）第1种（仅声明）：
数据类型[] 数组名;
（2）第2种（声明、创建、自动赋初值）：
数据类型[] 数组名；
数组名 = new 数据类型[长度];
例子
int[] x; //声明一个int[]类型数组
x=new int[100]; //为数组分配100个int元素空间
解释：
1、第一行代码 int[] x ，声明了一个变量x,该变量的类型是int[]，即int类型数组。变量x占用一块内存空间，声明时没有分配初始值
2、第二行代码 x=new int[100]；（1）（在内存中）创建了一个长度为100个int元素的数组：第一个元素的名称为x[0]，第二个元素名称为x[1],.....第100个元素的名称为x[99]
（2）将创建的数组的首地址，赋值给变量x（即数组变量，保存数组对象首地址）
2、访问一维数组中的元素：
语法：
变量名[索引（或下标）]
例子：x[0],x[1],......x[99]
注：
1、数组索引最小值：0，最大值：length-1
2、length：数组属性，获取该数组长度
用法： 数组名.length
例子2-22
3、数组创建成功后，没有赋初值：系统自动赋予一个默认值。（引用数据类型，创建成功后未赋值，系统自动赋初值）
整型：byte、short、int、long 0
浮点型：float、double 0.0
字符型：char 空字符，即'\u0000'
布尔型：boolean false
引用数据类型 null，变量没有引用对象
（3）声明、创建、自动赋初值
数据类型[] 数组名 = new 数据类型[长度];
例子
int[] x; <=> int[] x=new int[100];
x=new int[100];
2、一维数组赋值：
（1）动态初始化：声明、创建数组后未赋值，系统自动赋值（可通过赋值语句修改默认值）
（2）静态初始化赋值：声明、创建数组的同时给数组的每个元素赋值。
静态初始化语法：
1）数组类型[] 数组名=new 数组类型[]{元素1,元素2,....,元素n} ([]内不能填写具体数值)
2）数组类型[] 数组名={元素1,元素2,....,元素n} （推荐√）
例子 2-24
2.7.2 数组的常见操作
1、数组遍历：
例子2-27 数组遍历
2、最值获取：
例子2-28 数组最值
3、数组排序（冒泡排序）
例子2-29 数组排序
2.7.3 二维数组：
多维数组：即数组的元素是一个数组
1、二维数组定义（声明）、创建
（1）第1种：行数和列数确定
数组类型[][] 数组名=new 数据类型[行数][列数]；
例子
int[][] xx=new int[3][4]；
----->xx[0]---------->xx[0][0] xx[0][1] xx[0][2] xx[0][3]
xx ----->xx[1]---------->xx[1][0] xx[1][1] xx[1][2] xx[1][3]
----->xx[2]---------->xx[2][0] xx[2][1] xx[2][2] xx[2][3]
解释：
（2）第2种：行数确定，列数不确定
数组类型[][] 数组名=new 数据类型[行数][]；
（3）第3种：静态初始化
数组类型[][] 数组名={{第0行初始值},{第1行初始值},......,{第n-1行初始值}}；
例子
int[][] x={{1,2},{3,4,5,6},{7,8,9}};
----->xx[0]----------> 1 2
xx ----->xx[1]----------> 3 4 5 6
----->xx[2]----------> 7 8 9
二维数组元素的访问：索引访问
数组名[行索引][列索引]
例子2-30
菜单
本页目录