知识回顾:
1.关键字:
2.数据类型
2类:
基本数据类型:
byte --> short --> char --> int --> long --> float --> double
boolean
引用型数据类型:
类
接口
数组
3.数据类型转换
小转大
小类型转化为大类型 --> 隐式转换
大类型 变量名称 = 小类型;
大转小
大类型转化小类型 --> 显式转换
小类型 变量名称 = (小类型)大类型值;
what 是什么? 如何使用?
how 如何使用? 为什么要这么用
why 为什么要这么用? 这是个什么?
4.变量:
什么是变量?
变量语法格式?
变量定义? 如何使用它
变量分类:
按位置分:
成员变量
局部变量
就近原则
作用域范围,也是变量的生命周期
5.常量
什么是常量?
魔鬼数字?
订单
新建 0
支付中
1
支付完成 2
支付失败 3 ---->-1
配送中 4
配送完成 5
订单完成 6
setOrderState(3);//魔鬼数字
1.将设置订单的值为3的代码值都需要改成-1,如果这个数字代表状态再次发生改变,那么又都需要修改
2.直接设置具体的数字,代码比较晦涩难以理解,可读性差
如果某一个地方忘记修改,那么引起程序的问题是不可估量的.
6.
运算符
算术运算符:
+ - * /
% 求整除的余数
++
++在前
先做自身的加1运算
++在后
先参与其他运算,然后再做自身的加1运算
--
--在前
先做自身的减1运算
--在后
先参与其他运算,再做自身的减1运算
新知识:
拼接运算符: +
当字符串与数字拼接在一起时,最终会产生一个新的字符串,注意:类型是字符串 String
如果字符串后面有多个数字拼接运算,希望数字优先运算,需要使用()提高运算的优先级
===>System.out.println("我爱"+7+2) //我爱72,从左至右,"我爱"+7为字符串,字符串再+2
System.out.println("我爱"+(7+2)) //我爱9,()提高运算优先级,先运算7+2
逻辑运算符:
逻辑运算符用于对boolean类型的数据进行运算,且最终产生的运算结果也为boolean类型
逻辑运算运算规则:
& 与
&& 短路与
只有所有表达式的值都为true时,最终运算结果则为true,否则为false
(自己要有一个false,则结果必为false)
| 或
|| 短路或
只有所有表达式的值都为false,最终运算结果为false,否则为true
(只要有一个true,结果必为true)
! 非
取反, !true --> false !false --> true
^ 异或
两个值相同则为false,不同则为true
===>true^true-->false
比较&和&&的,|和||的区别:
1.运算的优先级不同
& 高于 &&
| 高于 ||
2.&&的运算效率高于&,||运算高于|
&和|会运算每一个表达式,但是&&遇到第一个false时,就会停止后面表达式的运算,直接返回false
||遇到第一个true时,就会停止后面表达式的运算直接返回true
====>
public class Demo_逻辑运算符的比较{
public static void main(String[] args){
System.out.println(test01());
System.out.println("=======================");
System.out.println(test01()&test02());//false
/*
通过对比,发现使用|时,test02,test01都执行了,而使用||时,test02执行了,但是test01没有执行
|与||或运算结果虽然相同,但是||比|少运算3个表达式,运算的效率高一些.
因为当||遇到第一个true时就会停止运算,后面的表达式将不会运算,直接返回结果为true,但是|会运算每一个表达式.
&和&&,&&遇到一个false时,就会停止运算,后面表达式就不会运算,直接返回结果false,但是&会运算每一个表达式
*/
System.out.println("=========比较| 与 ||==============");
System.out.println(test02()|test01()|test03()|test04()); //true,先跳转到test02(),打印test02,返回true,或运算,结果定为true,但后面也会运算
System.out.println(test02()||test01()||test03()||test04()); //true,跳转到test02(),打印test02,返回true,短路或运算,结果定为true,后面不在运算
System.out.println("=========比较& 与 &&==============");
System.out.println(test01()&test02()); //false,打印test01,返回false,短路与,结果false,运算结果注定,但运算不结束
System.out.println(test01()&&test02()); //false,打印test01,返回false,短路与,结果false,运算结果出来,运算结束
}
//test01 ---> false
public static boolean test01(){
System.out.println("test01");
return false;
}
//test02 ---> true
public static boolean test02(){
System.out.println("test02");
//很耗时间的操作
return true;
}
//test03 ---> false
public static boolean test03(){
System.out.println("test03");
return false;
}
//test04 ---> true
public static boolean test04(){
System.out.println("test04");
return true;
}
}
关系运算符:
注意:关系运算符,最终运算结果是一个boolean值
== 判断2个值是否相等
!= 不等于
> 大于
<
小于
>= 大于或等于
<= 小于或等于
赋值运算符: =
语法格式:
数据类型 变量名称 = 值;
语法解释:
将=号右边的值赋给等号左边.
例如:
int m = 2; ===> 将值2赋给m
组合写法:
+= , *= ,/=, %= //m +=3--->m = m+3
int m = 2;
m += 3; System.out.println(m); //m = m+3 = 2+3=5
m *= 2; System.out.println(m); //m = m*2 = 5*2=10
int m = 10;
m%=3;
m = m % 3;
三目运算符(三元运算符):
语法:
x = 表达式?m:n;
语法解释:
当表达式的最终运算结果为true,则将值m赋给x,否则将值n赋给x.
====>
public class Demo_三元运算符{
public static void main(String[] args){
int m = true?1:2;
System.out.println(m);
int n = false?1:2;
System.out.println(n);
int x = ((2>1)||(10-9)<8&&(100%3 == 0))?1:2; //&&优先级高于||,true&&flase为false,true||false为true,结果为1
System.out.println(x);
}
}
特殊符号:
\t 制表
\n 换行符
\r\n 换行
\ 转义符
public class Demo_特殊符号{
public static void main(String[] args){
System.out.print("张三"); //System.out.println打印结果会自动换行,会影响下面测试,print打印结果不会换行
System.out.print("\t"); //System.out.print("\n");
System.out.print("\r\n");
System.out.print("李四"); //打印李四
System.out.print("\\"); //打印\
// 因为在Java中,\具有特殊的意义,将符号进行转化为普通符号,第一个\将第二个\转化为了一个普通字符\.
System.out.print("\"我喜欢读书\""); //打印: "我喜欢读书"(有双引号)
System.out.print("我喜欢读书"); //打印 : 我喜欢读书
System.out.print(""我喜欢读书""); //报错,英文符号无所谓的正引号,反引号,前后分别组成两对
}
}
流程控制语句:
程序的执行顺序
3种:
顺序结构
是指程序默认的执行顺序,而默认执行顺序是自上而下.
注意:main方法是java程序的入口 javaweb项目的程序入口 --->web.xml
条件分支结构
满足条件,则执行,不满足条件就不执行.
条件分支:
if条件分支
3种语法格式:
语法格式1:
if(表达式){
代码块;
}
语法解释:
如果表达式的最终运算结果为true,则执行代码块.
语法格式二:
if(表达式){
代码块1;
}else{
代码块2;
}
语法解释:
如果表达式的最终运算结果为true,则执行代码块1,否则执行代码块2.
语法格式3:
if(表达式1){
代码块1;
}else if(表达式2){
代码块2;
}.....
else if(表达式n){
代码块n;
}else{
代码块n+1;
}
语法解释:
自上而下执行表达式,若表达式的运算结果为true,则执行相应的代码块,
且后面的表达式不会进行运算.若表达式的运算结果为false,则执行下一个表达式,
若所有的表达式运算结果都为false,则执行else中代码块.如果没有else,则结束if分支语句
比较if 与 if else if
如果商品价格大于5000,那么打印,这是奢侈品
如果商品价格大于4000 小于 5000,打印这是高端消费品
如果商品价格大于3000 小于 4000,打印中端消费品
如果商品价格大于2000 小于 3000,打印大众消费品
通过 if实现与if else if实现的对比:
if分支语句,简单,灵活,直观
if else if分支语句相对于语法复杂,但是运行的效率高于if分支语句,
而if分支语句因为每一个判断表达式都会执行,可以使用return进行优化.
return 关键字:
return关键字,可以用于返回值.return也可以用于结束所在的方法.
public class Demo_if与ifelseif比较{
public static void main(String[] args){
/*
如果商品价格大于5000,那么打印,这是奢侈品
如果商品价格大于4000 小于 5000,打印这是高端消费品
如果商品价格大于3000 小于 4000,打印中端消费品
如果商品价格大于2000 小于 3000,打印大众消费品
1.首先定义一个变量,表示是商品的价格
2.根据这个变量与具体数值的关系,打印对应的信息
*/
int price = 6000; //每个if都会检测运行,效率低,可加return关键字提高效率
if(price > 5000){
System.out.println("这是奢侈品");
// return;
}
if(price>4000 && price < 5000){
System.out.println("这是高端消费品");
}
if(price > 3000 && price < 4000){
System.out.println("这是中端消费品");
}
if(price > 2000 && price < 3000){
System.out.println("这是大众消费品");
}
System.out.println("=====================================");
if(price > 5000){ /*效率高,但是不直接,没有if一目了然,
符合人的常规,而且不适合多层嵌套,譬如什么东西?什么牌子的东西?
根据它们再看价格判断是否是奢侈品等,需要多层判断嵌套
*/
System.out.println("这是奢侈品");
}else if(price > 4000 ){
System.out.println("高端消费品");
}else if(price > 3000){
System.out.println("这是中端消费品");
}else if(price > 2000){
System.out.println("这是大众消费品");
}
/*
在这个题目中,if分支语句与if else if分支语句都实现了想要的效果.
但是 if分支语句,会每一个判断表达式都会运算,
但是if else if不会,遇到true后,后面表达式将不会运算.
多层嵌套
if(){
if(){
if(){}
}
}
一般在编程中,嵌套最多只允许嵌套3层
return关键字
*/
}
}
switch条件分支
循环结构