sxt第三天学习总结-3月29日

时间:2022-05-24 14:05:07
知识回顾:
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条件分支




循环结构