java基本语法 下
目录
[TOC]
运算符
运算符是一种特殊的符号，用以表示数据的运算、赋值和比较等。
- 算术运算符
- 赋值运算符
- 比较运算符（关系运算符）
- 逻辑运算符
- 位运算符（了解）
- 三元运算符
运算符：算术运算符
术运算符的注意问题
- 如果对负数取模，可以把模数负号忽略不记，如：5%-2=1。 但被模数是负数则不可忽略。此外，取模运算的结果不一定总是整数。
- 对于除号“/”，它的整数除和小数除是有区别的：整数之间做除法时，只保留整数部分而舍弃小数部分。
- +”除字符串相加功能外，还能把非字符串转换成字符串
- 前++ ：先自增 后运算 后++ 先运算 后自增 :不会改变本身变量的数据类型，
注意点 取余运算% 结果的符号与被取余的符号相同，整型和整型做运算得到的是int类型
class AirrTest
/*
运算符之一 算数运算符
+ - + - / % 前++ 后++ 前-- 后--
除法运算取商数 取余运算取余数
*/
{
public static void main(String[] args)
{
//除号 /
int num1=12;
int num2=5;
//整型和整型做运算得到的是int类型 2
int result=num1 / num2;
//0.0是double类型，所以num2+0.0是double类型 2.4
double resul2=num1 /(num2+0.0);
double result3=num1/ (double)num2;
System.out.println(result3);
//取余运算% 结果的符号与被取余的符号相同
int m1=12;
int m2=-5;
System.out.println("res1"+ m1%m2);//2
int m3=-12;
int m4=5;
System.out.println("res2"+m3%m4);//-2
int m5=-12;
int m6=-5;
System.out.println("res3"+m5%m6);//-2、
//前++ ：先自增 后运算
//后++ 先运算 后自增
int a1=10;
int b1=++a1;
System.out.println("a1="+a1+",b1="+b1);//11 11
int a2=10;
int b2=a2++;
System.out.println("a2="+a2+",b2="+b2);//11 10
//注意点 :不会改变本身变量的数据类型
short s1=10;
//s1=s1+1;
//前-- ：先自增 后运算
//后-- 先运算 后自增
int a3=10;
int b3=--a3;
System.out.println("a3="+a3+",b3="+b3);//11 11
int a4=10;
int b4=a4--;
System.out.println("a4="+a4+",b4="+b4);//11 10
}
}
运算符：赋值运算符
- 符号：= 当“=”两侧数据类型不一致时，可以使用自动类型转换或使用强制
- 类型转换原则进行处理。支持连续赋值。
- 扩展赋值运算符：+=, -=, *=, /=, %=
class setValue
// 赋值 = += *= /= %=
{
public static void main(String[] args)
{
//赋值符号=
int j1=10;
int j2=20;
//连续赋值
int i1,i2;
i1=i2=10;
int i3=10,j3=20;
//********
int num=10;
num+=2;//mum=num+2
short s1=10;
// s1=s1+2;编译失败
s1+=2;// 不会改变 变量本身数据类
System.out.println("Hello World!");
}
}
运算符：比较运算符
比较运算符的结果都是boolean型，也就是要么是true，要么是false。
比较运算符“ ==” 不能误写成“ =” 。
/*
运算符之三 比较运算符
== != > < >= <= instanceof
比较运算符的结果是boolean类型
*/
class compare
{
public static void main(String[] args)
{
boolean i=true;
boolean j=false;
System.out.println(i==j);//false
System.out.println(j=i);//false
}
}
运算符：逻辑运算符
- &—逻辑与
- | —逻辑或
- ！—逻辑非
- && —短路与
- || —短路或
- ^ —逻辑异或
逻辑运算符用于连接布尔型表达式，在Java中不可以写成3<x<6，应该写成x>3 & x<6。
&”和“&&”的区别：
- 单&时，左边无论真假，右边都进行运算；
- 双&时，如果左边为真，右边参与运算，如果左边为假，那么右边不参与运算。
- “|”和“||”的区别同理，||表示：当左边为真，右边不参与运算。
异或( ^ )与或( | )的不同之处是：当左右都为true时，结果为false。理解：异或，追求的是“异”
/*
运算符之四：逻辑运算符
& && | || ！ ^
&& 与 & 运算结果是相同的，符号左边是true时 都会执行右边的运算
当符号左边是false时，&继续执行右边的运算，&&不在执行右边的运算
|| 与 | 运算结果是相同的，符号左边是false时 都会执行右边的运算
当符号左边是true时，|继续执行右边的运算，||不在执行右边的运算
逻辑运算符操作的都是Boolean类型
*/
class logic {
public static void main(String[] args){
//逻辑与
boolean b1=false;
int num1=10;
if(b1&(num1++>0)){
System.out.println("真的");
}else{
System.out.println("假的");
}
System.out.println("num1："+num1);
//短路与
boolean b2=false;
int num2=10;
if(b2&&(num2++>0)){
System.out.println("真的");
}else{
System.out.println("假的");
}
System.out.println("num2："+num2);
// 逻辑或
boolean b3=true;
int num3=10;
if(b3|(num3++>0)){
System.out.println("真的");
}else{
System.out.println("假的");
}
System.out.println("num3："+num3);
//短路或
boolean b4=true;
int num4=10;
if(b4 ||(num4++>0)){
System.out.println("真的");
}else{
System.out.println("假的");
}
System.out.println("num4："+num4);
}
}
运算符：三元运算符
表达式 1 和表达式 2 为 同种类型
三元运算符与 if-else 的联系与区别：
- 1）三元运算符可简化if-else语句
- 2）三元运算符要求必须返回一个结果。
- 3）if后的代码块可有多个语句
class sanYuan
/*
运算符之五：三元运算符
结构条件表达式？（表达式1：表达式2）
根据表达式真或假 决定执行表达式1或表达式2
表达式为true，则执行表达式1
表达式为false 则执行表达式2
表达式1与表达式2的类型要求是一致的
三元运算符可以嵌套使用
凡是可以使用三元运算符的地方都可以改写为if---else,反之不可以
*/
{
public static void main(String[] args) {
//获取两个整数的较大值
int m=12;
int n=12;
int max=(m>n)?m:n;
String maxstr=m>n?"m大":((m==n)?"m和n相等":"n大");
if(m>n){
System.out.println(m);
}else{
System.out.println(n);
}
System.out.println(maxstr);
}
}
运算符的优先级
- 运算符有不同的优先级，所谓优先级就是表达式运算中的运算顺序
- 只有单目运算符、三元运算符、 赋值运算符是从右向左运算的
程序流程控制
概念
流程控制语句是用来控制程序中各语句执行顺序的语句，可以把语句组 合成能完成一定功能的小逻辑模块。 其流程控制方式采用结构化程序设计中规定的三种基本流程结构，即：
- 顺序结构程序从上到下逐行地执行，中间没有任何判断和跳转。
- 分支结构根据条件，选择性地执行某段代码 有if…else和switch-case两种分支语句
- 循环结构根据循环条件，重复性的执行某段代码 有while、do…while、for三种循环语句。
注：JDK1.5提供了foreach循环，方便的遍历集合、数组元素。
顺序结构
顺序结构 Java中定义成员变量时采用合法的前向引用。如
Java中定义成员变量时采用合法的前向引用。如：
public class Test{
int num1 = 12;
int num2 = num1 + 2;
}
错误形式：
public class Test{
int num2 = num1 + 2；
int num1 = 12;
}
if-else结构
- 条件表达式必须是布尔表达式（关系表达式或逻辑表达式）、布尔变量
- 语句块只有一条执行语句时，一对{}可以省略，但建议保留
- if-else语句结构，根据需要可以嵌套使用
- 当if-else结构是“多选一”时，最后的else是可选的，根据需要可以省略
- 当多个条件是“互斥”关系时，条件判断语句及执行语句间顺序无所谓
- 当多个条件是“包含”关系时，“小上大下/子上父下”
/*
分支结构中的if--else
三种结构
第一种
if（条件表达式）{执行表达式}
第二种 二选一
if（条件表达式）{
执行表达式1
}else{
执行表达式2
}
第三种 多选一
if（条件表达式）{
执行表达式1
}else if（条件表达式）{
执行表达式2
}else{
执行表达式3
}
*/
class ifTest
{
public static void main(String[] args)
{
int n=10;
int m=5;
if(m>n){
System.out.println("m:"+m);
}else if(m==n){
System.out.println("相等");
}else{
System.out.println("n:"+n);
}
System.out.println("Hello World!");
}
}
switch-case结构
- switch(表达式)中表达式的值 必须 是下述几种类型之一： byte ， short ， char ， int ，枚举 (jdk 5.0) ， String (jdk 7.0) ；
- case子句中的值必须是 常量 ，不能是变量名或不确定的表达式值；
- 同一个switch语句，所有case子句中的常量值互不相同；
- break语句用来在执行完一个case分支后使程序跳出switch语句块；如 果没有break，程序会顺序执行到switch结尾
- default子句是 可任选的 。同时，位置也是灵活的。当没有匹配的case时， 执行default
/*
分支结构之二：switch-case
1.格式
switch(表达式){
case 常量1:
执行语句1;
//break;
case 常量2:
执行语句2;
//break;
...
default:
执行语句n;
//break;
}
2.说明：
① 根据switch表达式中的值，依次匹配各个case中的常量。一旦匹配成功，则进入相应case结构中，调用其执行语句。
当调用完执行语句以后，则仍然继续向下执行其他case结构中的执行语句，直到遇到break关键字或此switch-case结构
末尾结束为止。
② break,可以使用在switch-case结构中，表示一旦执行到此关键字，就跳出switch-case结构
③ switch结构中的表达式，只能是如下的6种数据类型之一：
byte 、short、char、int、枚举类型(JDK5.0新增)、String类型(JDK7.0新增)
④ case 之后只能声明常量。不能声明范围。
⑤ break关键字是可选的。
⑥ default:相当于if-else结构中的else.
default结构是可选的，而且位置是灵活的。
*/
class SwitchCaseTest {
public static void main(String[] args) {
int number = 5;
switch(number){
case 0:
System.out.println("zero");
break;
case 1:
System.out.println("one");
break;
case 2:
System.out.println("two");
break;
case 3:
System.out.println("three");
break;
default:
System.out.println("other");
//break;
}
String season = "summer";
switch (season) {
case "spring":
System.out.println("春暖花开");
break;
case "summer":
System.out.println("夏日炎炎");
break;
case "autumn":
System.out.println("秋高气爽");
break;
case "winter":
System.out.println("冬雪皑皑");
break;
default:
System.out.println("季节输入有误");
break;
}
//**************如下的两种情况都编译不通过*********************
//情况一
/*
boolean isHandsome = true;
switch(isHandsome){
case true:
System.out.println("我好帅啊~~~");
break;
case false:
System.out.println("我好丑啊~~~");
break;
default:
System.out.println("输入有误~~~");
}
*/
//情况二
/*
int age = 10;
switch(age){
case age > 18:
System.out.println("成年了");
break;
default:
System.out.println("未成年");
}
*/
}
}
f和switch语句很像，具体什么场景下，应用哪个语句呢？
- 如果判断的具体数值不多，而且符合byte、short、char、int、String、枚举等几种类型。虽然两个语句都可以使用，建议使用swtich语句。因为效率稍高。
- 其他情况：对区间判断，对结果为boolean类型判断，使用if，if的使用范围更广。
- 也就是说，使用switch-case的，都可以改写为if-else。反之不成立。
循环结构
循环结构 在某些条件满足的情况下，反复执行特定代码的功能
循环语句分类 for 循环 while 循环 do-while 循环
循环语句的四个组成部分
- 初始化部分(init_statement)
- 循环条件部分(test_exp)
- 循环体部分(body_statement)
- 迭代部分(alter_statement)
循环结构之for循环
语法格式
for ( ①初始化部分 ; ②循环条件部分 ; ④迭代部分 ) ｛
③循环体部分 ;
｝
执行过程： ①-②-③-④-②-③-④-②-③-④-.....-②
说明：
- ②循环条件部分为boolean类型表达式，当值为false时，退出循环
- ①初始化部分可以声明多个变量，但必须是同一个类型，用逗号分隔
- ④可以有多个变量更新，用逗号分隔
/*
For循环结构的使用
一、循环结构的4个要素
① 初始化条件
② 循环条件 --->是boolean类型
③ 循环体
④ 迭代条件
二、for循环的结构
for(①;②;④){
③
}
执行过程：① - ② - ③ - ④ - ② - ③ - ④ - ... - ②
*/
class ForTest {
public static void main(String[] args) {
/*
System.out.println("Hello World!");
System.out.println("Hello World!");
System.out.println("Hello World!");
System.out.println("Hello World!");
System.out.println("Hello World!");
*/
for(int i = 1;i <= 5;i++){//i:1,2,3,4,5
System.out.println("Hello World!");
}
//i:在for循环内有效。出了for循环就失效了。
//System.out.println(i);
//练习：
int num = 1;
for(System.out.print('a');num <= 3;System.out.print('c'),num++){
System.out.print('b');
}
//输出结果：abcbcbc
System.out.println();
//例题：遍历100以内的偶数,输出所有偶数的和,输出偶数的个数
int sum = 0;//记录所有偶数的和
int count = 0;//记录偶数的个数
for(int i = 1;i <= 100;i++){
if(i % 2 == 0){
System.out.println(i);
sum += i;
count++;
}
//System.out.println("总和为：" + sum);
}
System.out.println("总和为：" + sum);
System.out.println("个数为：" + count);
}
}
循环结构之while循环
语法格式
①初始化部分
while( ②循环条件部分 ) ｛
③循环体部分 ;
④迭代部分 ;
}
执行过程： ① - ② - ③ - ④ - ② - ③ - ④ - ② - ③ - ④ -...- ②
说明：
- 注意不要忘记声明④迭代部分。否则，循环将不能结束，变成死循环。
- for循环和while循环可以相互转换
/*
While 循环的使用
一、循环结构的4个要素
① 初始化条件
② 循环条件 --->是boolean类型
③ 循环体
④ 迭代条件
二、while循环的结构
①
while(②){
③;
④;
}
执行过程：① - ② - ③ - ④ - ② - ③ - ④ - ... - ②
说明：
1.写while循环千万小心不要丢了迭代条件。一旦丢了，就可能导致死循环！
2.我们写程序，要避免出现死循环。
3.for循环和while循环是可以相互转换的！
区别：for循环和while循环的初始化条件部分的作用范围不同。
算法：有限性。
*/
class WhileTest{
public static void main(String[] args) {
//遍历100以内的所有偶数
int i = 1;
while(i <= 100){
if(i % 2 == 0){
System.out.println(i);
}
i++;
}
//出了while循环以后，仍可以调用。
System.out.println(i);//101
}
}
循环结构之do-while循环
语法格式
①初始化部分 ;
do{
③循环体部分
④迭代部分
}while( ②循环条件部分 );
执行过程： ① - ③ - ④ - ② - ③ - ④ - ② - ③ - ④ -... ②
说明： do-while 循环至少执行一次循环体。
/*
do-while循环的使用
一、循环结构的4个要素
① 初始化条件
② 循环条件 --->是boolean类型
③ 循环体
④ 迭代条件
二、do-while循环结构：
①
do{
③;
④;
}while(②);
执行过程：① - ③ - ④ - ② - ③ - ④ - ... - ②
说明：
1.do-while循环至少会执行一次循环体！
2.开发中，使用for和while更多一些。较少使用do-while
*/
class DoWhileTest {
public static void main(String[] args) {
//遍历100以内的偶数,并计算所有偶数的和及偶数的个数
int num = 1;
int sum = 0;//记录总和
int count = 0;//记录个数
do{
if(num % 2 == 0){
System.out.println(num);
sum += num;
count++;
}
num++;
}while(num <= 100);
System.out.println("总和为：" + sum);
System.out.println("个数为：" + count);
//*************体会do-while至少执行一次循环体***************
int number1 = 10;
while(number1 > 10){
System.out.println("hello:while");
number1--;
}
int number2 = 10;
do{
System.out.println("hello:do-while");
number2--;
}while(number2 > 10);
}
}
嵌套循环结构
将一个循环放在另一个循环体内，就形成了嵌套循环。其中， for ,while ,do…while均可以作为外层循环或内层循环。
实质上，嵌套循环就是把内层循环当成外层循环的循环体。当只有内层循环的 循环条件为false时，才会完全跳出内层循环，才可结束外层的当次循环，开 始下一次的循环。
设外层循环次数为m次，内层为n次，则内层循环体实际上需要执行m*n次
/*
嵌套循环的使用
1.嵌套循环：将一个循环结构A声明在另一个循环结构B的循环体中,就构成了嵌套循环
2.
外层循环：循环结构B
内层循环：循环结构A
3. 说明
① 内层循环结构遍历一遍，只相当于外层循环循环体执行了一次
② 假设外层循环需要执行m次，内层循环需要执行n次。此时内层循环的循环体一共执行了m * n次
4. 技巧：
外层循环控制行数，内层循环控制列数
*/
class ForForTest {
public static void main(String[] args) {
//******
//System.out.println("******");
for(int i = 1;i <= 6;i++){
System.out.print('*');
}
System.out.println("\n");
/*
******
******
******
******
*/
for(int j = 1;j <= 4;j++ ){
for(int i = 1;i <= 6;i++){
System.out.print('*');
}
System.out.println();
}
/* i(行号) j(*的个数)
* 1 1
** 2 2
*** 3 3
**** 4 4
***** 5 5
*/
for(int i = 1;i <= 5;i++){//控制行数
for(int j = 1;j <= i;j++){//控制列数
System.out.print("*");
}
System.out.println();
}
/* i(行号) j(*的个数) 规律：i + j = 5 换句话说：j = 5 - i;
**** 1 4
*** 2 3
** 3 2
* 4 1
*/
for(int i = 1;i <= 4;i++){
for(int j = 1;j <= 5 - i;j++){
System.out.print("*");
}
System.out.println();
}
}
}
break、continue
break的使用 终止本次循环
break语句用于终止某个语句块的执行
{ …… break; …… }
break语句出现在多层嵌套的语句块中时，可以通过标签指明要终止的是 哪一层语句块
label1: { …… label2: { …… label3: { …… break label2; …… } } }
continue的使用 跳过本层循环
- continue只能使用在循环结构中
- continue语句用于跳过其所在循环语句块的 一次 执行，继续下一次循环
- continue语句出现在多层嵌套的循环语句体中时，可以通过标签指明要跳过的是哪一层循环
/*
break和continue关键字的使用
使用范围 循环中使用的作用(不同点) 相同点
break: switch-case
循环结构中 结束当前循环 关键字后面不能声明执行语句
continue: 循环结构中 结束当次循环 关键字后面不能声明执行语句
*/
class BreakContinueTest {
public static void main(String[] args) {
for(int i = 1;i <= 10;i++){
if(i % 4 == 0){
break;//123
//continue;//123567910
//System.out.println("今晚迪丽热巴要约我！！！");
}
System.out.print(i);
}
System.out.println("\n");
//******************************
label:for(int i = 1;i <= 4;i++){
for(int j = 1;j <= 10;j++){
if(j % 4 == 0){
//break;//默认跳出包裹此关键字最近的一层循环。
//continue;
//break label;//结束指定标识的一层循环结构
continue label;//结束指定标识的一层循环结构当次循环
}
System.out.print(j);
}
System.out.println();
}
}
}
break只能用于 switch 语句 和 循环语句 中。 continue只能用于 循环语句 中。
- 二者功能类似，但continue是终止 本次 循环，break是终止 本层 循环。
- break、continue之后不能有其他的语句，因为程序永远不会执行其后的语句。
- 标号语句必须紧接在循环的头部。标号语句不能用在非循环语句的前面。
