语言基础...

1. 运算符：

int a ; int b , c , d , e ;

int a = 250 ; int a ; a = 250 ;

int b = a + 10 ; System . out . println ( b );

a = a + 10 ; // 在 a 本身基础之上增 10

short s1 = 5 ;

short s2 = 6 ;

short s3 = ( short )( s1 + s2 ); 算术： + 、 - 、 * 、 / 、 % 、 ++ 、 --

%: 取模 / 取余，余数为 0 即为整除

System . out . println ( 5 % 2 ); //1 ，商 2 余 1

System . out . println ( 8 % 2 ); //0 ，商 4 余 0---- 整除

System . out . println ( 2 % 8 ); //2 ，商 0 余 2

++/--: 自增 1/ 自减 1 ，可在变量前也可在变量后

单独使用时，在前在后都一样

被使用时，在前在后不一样

a++ 的值为 a----------(a-- 的值为 a)

++a 的值为 a+1--------(--a 的值为 a-1)

// 演示 ++ 单独使用

int a = 5 , b = 5 ;

a ++ ; // 相当于 a=a+1

++ b ; // 相当于 b=b+1

System . out . println ( a ); //6

System . out . println ( b ); //6

// 演示 ++ 被使用

int a = 5 , b = 5 ;

int c = a ++ ; //1) 将 a++ 的值 5 赋值给 c 2)a 自增 1 变为 6

//----a++ 的值为 a(5) ，所以 c 的值就是 5

int d = ++ b ; //1) 将 ++b 的值 6 赋值给 d 2)b 自增 1 变为 6

//++b 的值为 b+1(6) ，所以 d 的值就是 6

System . out . println ( a ); //6

System . out . println ( b ); //6

System . out . println ( c ); //5

System . out . println ( d ); //6

// 演示 -- 单独使用 :

int a = 5 , b = 5 ;

a -- ;

-- b ;

System . out . println ( a ); //4

System . out . println ( b ); //4

// 演示 -- 被使用 :

int a = 5 , b = 5 ;

int c = a -- ; //1) 将 a-- 的值 5 赋值给 c 2)a 自减 1 变为 4

int d = -- b ; //1) 将 --b 的值 4 赋值给 d 2)b 自减 1 变为 4

System . out . println ( a ); //4

System . out . println ( b ); //4

System . out . println ( c ); //5

System . out . println ( d ); //4

关系： > 、 < 、 >= 、 <= 、 == 、 != 1 ) > ( 大于 ) 、 < ( 小于 )

>= ( 大于或等于 ) 、 <= ( 小于或等于 )

== ( 等于 ) 、 != ( 不等于 )

2 ) 关系运算的结果为 boolean 型，

关系成立则为 true ，关系不成立则为 false

int a = 5 , b = 10 , c = 5 ;

boolean b1 = a > b ;

System . out . println ( b1 ); //false

System . out . println ( c < b ); //true

System . out . println ( a >= c ); //true

System . out . println ( a <= b ); //true

System . out . println ( a == c ); //true

System . out . println ( a != c ); //false

System . out . println ( a + c > 10 ); //false

System . out . println ( a % 2 == 0 ); //false

System . out . println ( a ++> 5 ); //false--------a 自增 1 变为 6

System . out . println ( a ++> 5 ); //true---------a 自增 1 变为 7

逻辑： && 、 || 、 !

逻辑运算是建立在关系运算的基础之上的

逻辑运算的结果也是 boolean 型

&&: 短路与 ( 并且 ) ，两边都为真则为真，见 false 则 false

int a = 5 , b = 10 , c = 5 ;

boolean b1 = b >= a && b < c ;

System . out . println ( b1 ); //true&&false=false

System . out . println ( b <= c && b > a ); //false&&true=false

System . out . println ( a == b && c > b ); //false&&false=false

System . out . println ( b != c && a < b ); //true&&true=true

// 演示短路

boolean b1 = a > b && c ++> 2 ;

System . out . println ( b1 ); //false

System . out . println ( c ); //5 ，发生短路了

||: 短路或 ( 或者 ) ，有真则为真，见 true 则 true

int a = 5 , b = 10 , c = 5 ;

System . out . println ( b >= a || b < c ); //true||false=true

System . out . println ( b <= c || b > a ); //false||true=true

System . out . println ( b != c || a < b ); //true||true=true

System . out . println ( a == b || c > b ); //false||false=false

// 演示短路

boolean b2 = a < b || c ++> 2 ;

System . out . println ( b2 ); //true

System . out . println ( c ); //5 ，发生短路了

!: 逻辑非 ( 取反 ) ，非真则假，非假则真 int a = 5 , b = 10 , c = 5 ;

boolean b2 = ! ( a < b );

System . out . println ( b2 ); //!true=false

System . out . println ( ! ( a > b )); //!false=true

赋值： = 、 += 、 -= 、 *= 、 /= 、 %=

简单赋值运算符： =

扩展赋值运算符： += 、 -= 、 *= 、 /= 、 %=

--- 注意 : 扩展赋值运算符自带强转功能

int a = 5 ;

a += 10 ; // 相当于 a=(int)(a+10)

System . out . println ( a ); //15

a *= 2 ; // 相当于 a=(int)(a*2)

System . out . println ( a ); //30

a /= 6 ; // 相当于 a=(int)(a/6)

System . out . println ( a ); //5

// 小面试题 :

short s = 5 ;

//s = s+10; // 编译错误，需强转 : s=(short)(s+10);

s += 10 ; // 相当于 : s=(short)(s+10);

字符串连接： +

若两边为数字，则做加法运算

若两边出现了字符串，则做字符串连接

任意类型的数据只要和字符串连，结果都会变为字符串类型 --- 同化作用

int age = 38 ;

System . out . println ( "age=" ); //age=

System . out . println ( age ); //38

System . out . println ( "age=" + age ); //age=38

System . out . println ( " 我的年龄是 " + age ); // 我的年龄是 38

System . out . println ( " 我今年 " + age + " 岁了 " ); // 我今年 38 岁了

String name = "WKJ" ;

System . out . println ( "name=" + name ); //name=WKJ

System . out . println ( " 大家好，我叫 " + name ); // 大家好，我叫 WKJ

System . out . println ( " 大家好，我叫 " + name + " ，今年 " + age + " 岁了 " ); // 大家好，我

叫 WKJ ，今年 38 岁了

System . out . println ( 10 + 20 + "" + 30 ); //3030--------String

System . out . println ( "" + 10 + 20 + 30 ); //102030------String

System . out . println ( 10 + 20 + 30 + "" ); //60----------String

条件 / 三目：

语法：

boolean? 数 1: 数 2

执行过程：

整个表达式是有值的，它的值要么是问号后的数 1 ，要么是冒号后的数 2

判断 boolean 的值 : 若为 true ，则整个表达式的结果为 ? 号后的数 1

若为 false ，则整个表达式的结果为 : 号后的数 2

int num = 0 ;

int flag = num > 0 ? 1 : - 1 ;

System . out . println ( flag ); //-1

int a = 8 , b = 55 ;

int max = a > b ? a : b ;

System . out . println ( "max=" + max );

2. 分支结构：基于条件执行的语句

if 结构： 1 条路

1 ) 语法 :

if ( boolean ){

语句块 ------------- 基于条件执行的语句

}

2 ) 执行过程 :

判断 boolean 的值 :

若为 true ，则执行语句块 ( 整个结束 )

若为 false ，则直接结束

//1) 偶数的判断 :

int num = 6 ;

if ( num % 2 == 0 ){ // 带数 (6,5)

System . out . println ( num + " 是偶数 " );

}

System . out . println ( " 继续执行 ..." );

//1) 满 500 打 8 折

double price = 300.0 ; // 消费金额

if ( price >= 500 ){ // 满 500 带数 (600.0,300.0)

price = price * 0.8 ; // 打 8 折

}

System . out . println ( " 最终结算金额为 :" + price );

if...else 结构： 2 条路

1 ) 语法 :

if ( boolean ){

语句块 1

} else {

语句块 2

}

2 ) 执行过程 :

判断 boolean 的值 :

若为 true ，则执行语句块 1 ( 整个结束 )

若为 false ，则执行语句块 2 ( 整个结束 )

3 ) 说明 :

语句块 1 和语句块 2 ，必走其中之一 ---------- 2 选 1

//1) 偶数、奇数的判断 :

int num = 5 ; // 带数 (6,5)

补充：

1. 任何复杂的程序逻辑都可以通过三种结构来实现：

顺序结构：从上往下逐行执行，每句必走

分支结构：有条件的执行某语句，并非每句必走

1. Scanner 接收用户输入的数据：共 3 步 ----------- 不需要理解，先记住它，面向对象第五天才能理解

package day04 ;

import java . util . Scanner ; //1. 导入扫描仪

//Scanner 的演示

public class ScannerDemo {

public static void main ( String [] args ) {

Scanner scan = new Scanner ( System . in ); //2. 新建一个扫描仪叫 scan

System . out . println ( " 请输入年龄 :" );

int age = scan . nextInt (); //3. 用扫描仪扫描一个整数赋值给 age

System . out . println ( " 请输入商品价格 :" );

double price = scan . nextDouble (); //3. 用扫描仪扫描一个小数赋值给 price

System . out . println ( " 年龄为 :" + age + " ，商品价格为 :" + price );

}

}

2. 分支结构：

if...else if 结构：多条路

1 ) 语法 :

if ( boolean - 1 ){

语句块 1

} else if ( boolean - 2 ){

语句块 2

} else if ( boolean - 3 ){

语句块 3

} else {

语句块 4

}

2 ) 执行过程 :

判断 boolean - 1 ，若为 true 则执行语句块 1 ( 结束 ) ，若为 false 则

再判断 boolean - 2 ，若为 true 则执行语句块 2 ( 结束 ) ，若为 false 则

再判断 boolean - 3 ，若为 true 则执行语句块 3 ( 结束 ) ，若为 false 则执行语句块 4 ( 结束 )

3 ) 说明 :

语句块 1 / 2 / 3 / 4 ，必走其中之一 ------- 多选 1

package day04 ;

import java . util . Scanner ;

// 成绩等级判断

public class ScoreLevel {

public static void main ( String [] args ) {

Scanner scan = new Scanner ( System . in );

System . out . println ( " 请输入成绩 :" );

double score = scan . nextDouble ();

// 带数 (888,-45,95,85,65,40)

if ( score < 0 || score > 100 ){

System . out . println ( " 成绩不合法 " );

} else if ( score >= 90 ){ // 成绩合法

System . out . println ( "A- 优秀 " );

} else if ( score >= 80 ){

System . out . println ( "B- 良好 " );

} else if ( score >= 60 ){

System . out . println ( "C- 中等 " );

} else {

System . out . println ( "D- 不及格 " ); }

}

}

switch...case 结构：

优点：效率高、结构清晰

缺点：只能对整数判断相等

break ：跳出 switch

面试题： switch 后数据的类型可以为： byte,short,char,int,String, 枚举类型

package day04 ;

import java . util . Scanner ;

// 命令解析程序

public class CommandBySwitch {

public static void main ( String [] args ) {

Scanner scan = new Scanner ( System . in );

System . out . println ( " 请选择功能 : 1. 存款 2. 取款 3. 查询余额 4. 退卡 " );

int command = scan . nextInt ();

switch ( command ){

case 1 :

System . out . println ( " 存款操作 ..." );

break ;

case 2 :

System . out . println ( " 取款操作 ..." );

break ;

case 3 :

System . out . println ( " 查询余额操作 ..." );

break ;

case 4 :

System . out . println ( " 退卡操作 ..." );

break ;

default :

System . out . println ( " 输入错误 " );

}

}

}

3. 循环：反复多次执行一段相同或相似的代码

4. 循环三要素：

循环变量的初始化

循环的条件 ( 以循环变量为基础 )

循环变量的改变 ( 向着循环的结束变 )

循环变量：在整个循环过程中所反复改变的那个数

案例一：

输出 5 次 " 行动是成功的阶梯 "

行动是成功的阶梯

行动是成功的阶梯

行动是成功的阶梯

行动是成功的阶梯 行动是成功的阶梯

循环变量 : 次数 times

1 ) int times = 0 ;

2 ) times < 5

3 ) times ++ ;

times = 0 / 1 / 2 / 3 / 4 / 5 时结束

案例二：

输出 9 的乘法表 :

1 * 9 = 9

2 * 9 = 18

3 * 9 = 27

4 * 9 = 36

5 * 9 = 45

6 * 9 = 54

7 * 9 = 63

8 * 9 = 72

9 * 9 = 81

循环变量 : 因数 num

1 ) int num = 1 ;

2 ) num <= 9

3 ) num ++ ;

num = 1 / 2 / 3 / 4 / 5 / 6 / 7 / 8 / 9 / 10 时结束

1 * 9 = 9

3 * 9 = 27

5 * 9 = 45

7 * 9 = 63

9 * 9 = 81

循环变量 : 因数 num

1 ) int num = 1 ;

2 ) num <= 9

3 ) num += 2 ;

num = 1 / 3 / 5 / 7 / 9 / 11 时结束

5. 循环结构：

while 结构：先判断后执行，有可能一次都不执行

1 ) 语法 :

while ( boolean ){

语句块 / 循环体 ---------- 反复执行的代码

}

2 ) 执行过程 :

判断 boolean 的值，若为 true 则执行语句块，

再判断 boolean 的值，若为 true 则再执行语句块，

再判断 boolean 的值，若为 true 则再执行语句块，

如此反复，直到 boolean 的值为 false 时， while 循环结束

//2) 输出 9 的乘法表 : //3*9=27

int num = 1 ;

while ( num <= 9 ){

System . out . println ( num + "*9=" + num * 9 );

num += 2 ; //num++;

}

System . out . println ( " 继续执行 ..." ); //1) 输出 5 次 " 行动是成功的阶梯 ":

int times = 0 ; //1) 循环变量的初始化

while ( times < 5 ){ //2) 循环的条件

System . out . println ( " 行动是成功的阶梯 " );

times ++ ; //3) 循环变量的改变

}

System . out . println ( " 继续执行 ..." );

*/

/*

执行过程 :

times=0

true 输出 times=1

true 输出 times=2

true 输出 times=3

true 输出 times=4

true 输出 times=5

false while 循环结束

输出继续执行 ...

*/

package day04 ;

import java . util . Scanner ;

// 猜数字小游戏

public class Guessing {

public static void main ( String [] args ) {

Scanner scan = new Scanner ( System . in );

int num = ( int )( Math . random () * 1000 + 1 ); //1 到 1000 之内的随机数

System . out . println ( num ); // 作弊

//300( 大 ),200( 小 ),250( 对 )

System . out . println ( " 猜吧 !" );

int guess = scan . nextInt (); //1.

while ( guess != num ){ //2.

if ( guess > num ){

System . out . println ( " 太大了 " );

} else {

System . out . println ( " 太小了 " );

}

System . out . println ( " 猜吧 !" );

guess = scan . nextInt (); //3.

}

System . out . println ( " 恭喜你猜对了 !" );

}

}

do...while 结构：先执行后判断，至少执行一次

当第 1 要素与第 3 要素的代码相同时，首选 do...while

package day04 ;

import java . util . Scanner ;

// 猜数字小游戏

public class Guessing {

public static void main ( String [] args ) {

补充：

1. 任何复杂的程序逻辑都可以通过三种结构来实现：

顺序结构：从上往下逐行执行，每句必走

分支结构：有条件的执行某语句一次，并非每句必走

循环结构：有条件的执行某语句多次，并非每句必走

2. 生成随机数： 1 到 1000

3. 变量的作用域 / 范围：

从变量的声明开始，到包含它最近的大括号结束

1. 循环结构：

for 结构：应用率高、与次数相关的循环

1 ) 语法 :

// 1 2 3

for ( 要素 1 ; 要素 2 ; 要素 3 ){

语句块 / 循环体 --------------- 反复执行的语句 4

}

2 ) 执行过程 :

1243243243243243. .. 2

for ( int times = 0 ; times < 5 ; times ++ ){

System . out . println ( " 行动是成功的阶梯 " );

}

// 特殊的 : for 中的循环变量 num 的作用域 --- 仅在当前 for 中

for ( int num = 1 ; num <= 9 ; num ++ ){

System . out . println ( num + "*9=" + num * 9 );

}

for ( int num = 1 ; num <= 9 ; num += 2 ){

System . out . println ( num + "*9=" + num * 9 );

}

/*

执行过程 :

num=1 true 1*9=9

num=3 true 3*9=27

num=5 true 5*9=45

num=7 true 7*9=63

num=9 true 9*9=81 num=11 false for 循环结束

*/

// 演示 for 的特殊语法格式 :

int num = 1 ;

for (; num <= 9 ; num ++ ){

System . out . println ( num + "*9=" + num * 9 );

}

for ( int num = 1 ; num <= 9 ;){

System . out . println ( num + "*9=" + num * 9 );

num ++ ;

}

for (;;){ // 没有条件的循环就是一个死循环

System . out . println ( " 我爱 Java" );

}

for ( int i = 1 , j = 5 ; i <= 5 ; i += 2 , j -= 2 ){

}

/*

i=1,j=5

i=3,j=3

i=5,j=1

i=7,j=-1

*/

// 随机加法运算器

package day05 ;

import java . util . Scanner ;

// 随机加法运算器

public class Addition {

public static void main ( String [] args ) {

Scanner scan = new Scanner ( System . in );

int score = 0 ; // 总分

for ( int i = 1 ; i <= 10 ; i ++ ){ //10 次 (1)25+65=?

int a = ( int )( Math . random () * 100 ); // 加数 a--0 到 99 的随机数

int b = ( int )( Math . random () * 100 ); // 加数 b--0 到 99 的随机数

int result = a + b ; // 存正确答案

System . out . println ( "(" + i + ")" + a + "+" + b + "=?" ); //1) 出题

System . out . println ( " 算吧 !" );

int answer = scan . nextInt (); //2) 答题

if ( answer ==- 1 ){ //3) 判题

break ;

}

if ( answer == result ){

System . out . println ( " 答对了 " );

score += 10 ; // 答对 1 题，加 10 分

} else {

System . out . println ( " 答错了 " );

}

}

System . out . println ( " 总分为 :" + score );

}

} 2. 三种循环结构如何选择：

先看循环是否与次数相关：

若相关 ------------------------------------- 直接上 for

若无关，再看第 1 要素与第 3 相互的代码是否相同：

若相同 -------------------------------- 直接上 do...while

若不同 -------------------------------- 直接上 while

3. break ：跳出循环

for ( int num = 1 ; num <= 9 ; num ++ ){

if ( num == 4 ){ // 在某种特定条件下，提前结束循环

break ; // 跳出循环

}

System . out . println ( num + "*9=" + num * 9 );

}

/*

执行过程 :

num=1 1*9=9

num=2 2*9=18

num=3 3*9=27

num=4

*/

continue ：跳过循环体中剩余语句而进入下一次循环

// 输出 9 的乘法表，只要不能被 3 整除

for ( int num = 1 ; num <= 9 ; num ++ ){

if ( num % 3 != 0 ){

System . out . println ( num + "*9=" + num * 9 );

}

}

// 输出 9 的乘法表，跳过能被 3 整除的

for ( int num = 1 ; num <= 9 ; num ++ ){

if ( num % 3 == 0 ){

continue ; // 跳过循环体中剩余语句而进入下一次循环

}

System . out . println ( num + "*9=" + num * 9 );

}

/*

num=1 1*9=9

num=2 2*9=18

num=3

num=4 4*9=36

num=5 5*9=45

num=6

num=7 7*9=63

num=8 8*9=72

num=9

num=10 false

*/

4. 嵌套循环：

循环中套循环，常常多行多列时使用，一般外层控制行，内层控制列 执行规则：外层循环走一次，内层循环走所有次

建议：嵌套层数越少越好，能用一层就不用两层，能用两层就不用三层

break 只能跳出当前一层循环

// 九九乘法表

public class MultiTable {

public static void main ( String [] args ) {

for ( int num = 1 ; num <= 9 ; num ++ ){ // 控制行

for ( int i = 1 ; i <= num ; i ++ ){ // 控制列

System . out . print ( i + "*" + num + "=" + i * num + "\t" );

}

System . out . println (); // 换行

}

/*

执行过程 :

num=3

i=1 1*3=3

i=2 2*3=6

i=3 3*3=9

i=4 false

换行

num=2

i=1 1*2=2

i=2 2*2=4

i=3 false

换行

num=1

i=1 1*1=1

i=2 false

换行

*/

}

}

5. 数组：

是一种数据类型 ( 引用类型 )

相同数据类型元素的集合

定义：

// 声明整型数组 arr ，包含 10 个元素，每个元素都是 int 型，默认值为 0

int [] arr = new int [ 10 ];

初始化： ------------------ 初始化的是数组中的元素

int [] arr1 = new int [ 3 ]; //0,0,0

int [] arr2 = { 2 , 5 , 8 }; //2,5,8

int [] arr3 = new int []{ 2 , 5 , 8 }; //2,5,8

int [] arr4 ;

//arr4 = {2,5,8}; // 编译错误，此方式只能声明同时初始化

arr4 = new int []{ 2 , 5 , 8 }; // 正确

访问： -------------- 访问的是数组中的元素

通过 ( 数组名 .length) 可以获取数组的长度 ( 元素个数 ) 通过下标 / 索引来访问数组中的元素，下标从 0 开始，最大到 ( 数组的长度 -1)

遍历 / 迭代：从头到尾挨个走一遍

补充：

1. 变量的重名问题：

作用域重叠时，变量不能同名

2. \t ：水平制表位，固定占 8 位

3. 数组元素的默认值：

4. 异常：

ArrayIndexOutOfBoundsException ：数组下标越界异常

数组下标为 0 到 ( 数组长度 -1) ，若超出这个范围则发生数组下标越界异常