运算符方法语法结构
运算符
运算符主要有+ - * / 四则运算符，含义与数学中的相同。常量与常量，变量与变量，变量与常量之间均可以进行四则运算。特别注意整型除法运算，运算结果取整。比如10/3=3. 不会等3.333333… 要使结果为3.33333… 需让分子分母至少一项为float 或double型。即10.00/3=3.3333
代码实例如下：
public class Demo040perator {
public static void main(String[] args) {
//两个常量之间可以进行数学运算
System. out. println(20 + 30);//输出结果为50
//两个变量之间也可以进行数学运算
int a=20;
int b=30;
System.out.println(a - b); // 输出结果为-10
// 变量和常量之间可以混合使 用
System.out.println(a * 10); // 200
int x=10;
int y= 3;
int result1 = x / y;
System.out.println(result1); // 输出结果为3而不是3.3333...
int z=10.0;
System.out.println(z/y); //输出结果为3.33333333...
int result2 =x % y;
System.out.println(result2); //余数，模，1
// int + double --> double + dquble --> double
//不同精度的数进行四则运算时自动转化为精度最高的数据类型。输出结果类型保持
double result3 = x + 2.5;
System.out.println(result3); // 12.5
}
}加法运算的用法
常见三种用法：
- 数值运算中就为正常加法运算。
- 在char运算中，char类型会被自动转化为int型，再运算。char和int类型之间的对照关系遵从ASCII表和Unicode表。
- 对于字符串String类型来说，加号代表字符串连接操作。
代码实例如下：
public class Demo05Plus {
public static void main(String[] args) {
//字符串类型的变量基本使用
//数据类型 变量名称=数据值;
String str1 = "Hello";
System. out.println(str1); // Hello
System. out.println("Hello" + "World"); // 结果为：HelloWorld
String str2 = "Java";
// String + int --> String 同样为连接操作
System.out.println(str2 + 20); // Java20
//优先级问题
// String + int + int
// String + int
// String
System.out.println(str2 + 20 + 30); // 运算次序为从左到右，结果为Java2030
System.out.println(str2 + (20 + 30)); // 加入括号后运算的优先性被改变，先计算20+30，再将结果与str2连接。结果为Java50
}
}自增自减运算符
自增运算符: ++
自减运算符: –
基本含义:-一个变量增加一个数字1，或者让一个变量减小一个数字1
使用格式:写在变量名称之前，或者写在变量名称之后。例如: ++num， 也可以num++
使用方式:
1.单独使用:不和其他任何操作混合，自己独立成为一个步骤。
2.混合使用:和其他操作混合，例如与赋值混合，或者与打印操作混合，等。
使用区别:
1.在单独使用的时候，前++和后++没有任何区别。也就是: ++num;和num++;是完全一样的。
2.在混合的时候，有[重大区别]
A.如果是[前++]，那么变量[立刻马上+1]，然后拿着结果进行使用。 [先加后用]
B.如果是[后++]，那么首先使用变量本来的数值， [先用然后再让变量+1]。
[先用后加]
public class Demo060perator {
public static void main(String[] args) {
int num1 = 10;
System.out.println(num1); // 10
++num1; //单独使用，前++
System.out.println(num1); // 11
num1++; //单独使用，后++
System.out.println(num1); // 12
System.out.print1n-="==============");
//与打印操作混合的时候
int num2 = 20;
//混合使用， 先++，变量立刻马， 上变成21，然后打印结果21
System.out.println(++num2); // 21 20先加1变成21，再输出
System.out.println(num2); // 21 经过上一步操作后num2的值改变
System.out.println("===============");
int num3 = 30;
//混合使用，后++，首先使用变量本来的30，然后再让变量+1得到31
System.out.println(num3++); // 30 先输出，再对变量进行+1操作
System.out.println(num3); // 31 经过上一步操作后的值
System.out.println("===============");
int num4 = 40;
//和赋值操作混合
int result1 = --num4; // 混合使用，前--，变量立刻马上-1变成39，然后 将结果39交给result1变量
System.out.println(result1); // 39
System.out.println(num4); // 39 1
}
}赋值运算符
赋值运算符分为:
基本赋值运算符:就是一个等号“_”，代表将右侧的数据交给左侧的变量。
inta=30;
复合赋值运算符:
- += 例：a +=3 相当于 a=a+ 3
- -= 例：b-=4 相当于 b=b-4
- = 例： c= 5 相当于 c=c*5
-
/= 例：d/=6 相当于 d=d/6 - %= 例：e%=7 相当于 e=e%7
public class Demo07Operator {
public static void main(String[] args) {
int a=10;
=5;
System.out.println(a); // 15
int x=10;
%=3;
System.out.println(x); // 1
// 50 = 30; //常量不能进行赋值， 不能写在赋值运算符的左边。错误写法!
byte num = 30;
+=5;
System.out.println(num); // 35
比较运算符
逻辑运算符
与或非运算
- 与(并且) && 全都是true， 才是true;否则就是false。 a&&b a和b全为真时结果才为真
- 或(或者) || 至少一个是true，就是true; 全都是false, 才是false，a||b a和b中至少有一个为真时才为真
- 非(取反) ! 本来是true，变成false;本来是false，变成true !a a为真时 !a为假
三元运算符
三元运算符:需要三个数据才可以进行操作的运算符。
格式:
数据类型变量名称=条件判断?表达式A :表达式B;
流程:
首先判断条件是否成立:
如果成立为true，那么将表达式A的值赋值给左侧的变量;
如果不成立为false，那么将表达式B的值赋值给左侧的变量;
二者选其一。
注意事项:
1.必须同时保证表达式A和表达式B都符合左侧变量定义数据类型的要求。
2.三元运算符的结果必须被使用。
public class Demo100perator {
public static void main(String[] args) {
int a=10;
int b=20;
//数据类型变量名称=条件判断?表达式A :表达式B；
//判断a > b是否成立，如果成立将a的值赋值给max;如果不成立将b的值赋值给max。二者选其一
intmax=a>b?a:b;//最大值的变量
System.out.println("最大值: " + max); // 20
//int result=3>4?2.5:10;//错误写法! 2.5与int为不同的数据类型，需要强制转换，但不存在，故不行。
}
}方法
●方法:就是将一个功能抽取出来,把代码单独定义在一 个大括号内，形成一个单独的功能。
当我们需要这个功能的时候，就可以去调用。这样即实现了代码的复用性，也解决了代码冗余的现象。
定义格式：
注意事项:
1.方法定义的先后顺序无所谓。
2.方法的定义不能产生嵌套包含关系。
3.方法定义好了之后，不会执行的。如果要想执行，一定要进行方法的[调用]。
结构语句
选择结构
根据条件选择不同的执行操作
if语句
单if语句
标准if-else语句
扩展if-else语句：
代码示例：
public static void main(String[] args) {
int a=10;
//单if语句
if(a>1) {
System.out.println("a>1");
}
//标准if-else语句
if(a>2) {
System.out.println("a>2");
}else {
System.out.println("a<2");
}
//扩展if-else语句
if(a>100) {
System.out.println("a>100");
}else if(a>50) {
System.out.println("100>a>50");
}else if(a>10) {
System.out.println("50>a>10");
}else {
System.out.println("a<10");
}
}switch语句
语句格式：
先计算表达式的值，再和case后的常量值比较，执行相应的语句，在执行过程中遇到break则结束。
执行流程：
注意事项：
1.多个case后面的数值不可以重复。
2. switch后面小括号当中只能是下列数据类型:
基本数据类型: byte/ short/char/int
引用数据类型: String字符串、 enum枚举I
3. switch语句格式可以很灵活:前后顺序可以颠倒，而且break语句还可以省略。
“匹配哪-一个case就从哪一一个位置向下执行，直到遇到了break或者整体结束为止。
代码示例：
public static void main(String[] args) {
int num=3;
switch(num) {
case 1:
System.out.println("星期一");
break;
case 2:
System.out.println("星期二");
break;
case 3:
System.out.println("星期三");
break;
case 4:
System.out.println("星期四");
break;
case 5:
System.out.println("星期五");
break;
case 6:
System.out.println("星期六");
break;
case 7:
System.out.println("星期日");
break;
default:
System.out.println("输入错误");
break; //如果case都不满足，则执行default
}
}循环结构
循环结构的基本组成部分，一般可以分成四部分:
1.初始化语句:在循环开始之初执行的语句，只执行一次。
2.条件判断:如果成立，则执行循环体;如果不成立，则推出循环。
3.循环体:重复要做的事情内容，即要重复执行的语句。
4.步进语句:每次循环之后都要进行的扫尾工作，每次循环结束之后都要执行一次。
for循环
语法结构：
for (初始化表达式①;布尔表达式②;步进表达式④) {
循环体③
}
执行流程：
执行顺序:①②③④>②③④>②③④…②不满足为止。
①负责完成循环变量初始化
②负责判断是否满足循环条件，不满足则跳出循环
③具体执行的语句
④循环后,循环条件所涉及变量的变化情况
实例代码：
public static void main(String[] args) {
for(int i=0;i<10;i++) {
System.out.println("这是第"+i+"次循环");
}
}运行结果：
while循环和do…while循环
while循环格式：
初始化语句;
while (条件判断) {
循环体;
步进语句;
}
public static void main(String[] args) {
int num1=1; //初始化语句
while(num1<=10) { //条件判断
System.out.println("这是while循环第"+num1+"次"); //循环体
num1++; //步进语句
}
}运行结果：
do…while循环格式
循环格式：
初始化语句
do {
循环体
步进语句
} while (条件判断);
先执行循环体，再判断条件是否继续执行，与while循环的区别在于，do…while循环至少执行一次执行语句。而while循环需满足条件才执行循环体。
实例代码：
int a=0; //初始化条件语句
do {
System.out.println("这是do...while循环的第"+a+"次循环"); //循环体
a++; //步进语句
}while(a<=10); //条件判断步进语句是跳出循环的关键，否则可能出现死循环。
break和continue
break除了在switch中使用，在其他循环语法中用来终止整个循环，不再执行之后的所有循环体。
continue用于所有循环语法，用于跳过某一次循环。继续执行之后的循环体。
