语言基础第3天：

回顾：

变量：存数的

int a;  int b,c,d;
int a = 5;  int b; b = 5;
int c = a+b;  System.out.println(c); //10
a = a+10; //在a本身基础之上增10

八种基本数据类型：byte、short、int、long、float、double、boolean、char
- int：整型，4个字节，25,250,1000000......
- long：长整型，8个字节，25,10000000000000000L......
- double：浮点型，8个字节，3.14,56.0,25.678......
- boolean：布尔型，1个字节，true,false
- char：字符型，2个字节，'你','y','5','*'......
类型间的转换：
- 两种方式：
  - 自动类型转换：小到大
  - 强制类型转换：大到小 (要转换成为的数据类型)变量
- 两点规则：
```
short s1 = 5;
short s2 = 6;
short s3 = (short)(s1+s2);
```

精华笔记：

运算符：
- 算术：+、-、*、/、%、++、--
- 关系：>、<、>=、<=、==、!= boolean
- 逻辑：&&、||、! boolean
- 赋值：=、+=、-=、*=、/=、%=
- 字符串连接：+
- 条件/三目：boolean?数1:数2
分支结构(上)：基于条件执行某语句
- if结构：1条路
- if...else结构：2条路

笔记：

运算符：

算术：+、-、*、/、%、++、--

%:取模/取余，余数为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++; //简便记法:a++的值为5，所以c就为5
int d = ++b; //简便记法:++b的值为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--; //相当于a=a-1
--b; //相当于b=b-1
System.out.println(a); //4
System.out.println(b); //4

//演示--被使用:
int a=5,b=5;
int c = a--; //a--的值为5，所以c为5
int d = --b; //--b的值为4，所以d为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>b);  //false
System.out.println(a%2==0); //false
System.out.println(c++>5); //false----c自增1变为6
System.out.println(c++>5); //true-----c自增1变为7

逻辑：&&、||、!

逻辑运算是建立在关系运算的基础之上的逻辑运算的结果也是boolean型

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

第1个条件为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 b3 = a>b && c++>2;
System.out.println(b3); //false
System.out.println(c);  //5，发生短路了

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

第1个条件为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 b4 = a<b || c++>2;
System.out.println(b4); //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 = 5;
int flag = num>0?1:-1;
System.out.println(flag); //1

int a=8,b=5;
int max = a>b?a:b;
System.out.println("max="+max); //max=8
```

分支结构(上)：基于条件执行的语句

if结构：1条路

1)语法:
   if(boolean){
      语句块--------------基于条件执行的语句
   }
2)执行过程:
    判断boolean的值:
       若为true，则执行语句块(整个结束)
       若为false，则直接结束

//1)偶数的判断:
int num = 5;  //带数(6,5)
if(num%2==0){
    System.out.println(num+"是偶数");
}
System.out.println("继续执行...");

//2)满500打8折:
double price = 600.0; //消费金额   带数(600.0,300.0)
if(price>=500){ //满500
    price *= 0.8; //打8折
}
System.out.println("最终结算金额为:"+price);

//3)判断成绩合法----在0和100之间(包括)
double score = -54;
if(score>=0 && score<=100){ //95,850,-54
    System.out.println("成绩合法");
}
System.out.println("继续执行...");

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)
if(num%2==0){
    System.out.println(num+"是偶数");
}else{
    System.out.println(num+"是奇数");
}
System.out.println("继续执行...");

//2)满500打8折，不满500打9折
double price = 300.0;  //带数(600.0,300.0)
if(price>=500){
    price *= 0.8;
}else{
    price *= 0.9;
}
System.out.println("最终结算金额为:"+price);

//3)判断成绩是否合法--0到100(包括)之间表示合法，否则为不合法
double score = 95;
if(score>=0 && score<=100){
    System.out.println("成绩合法");
}else{
    System.out.println("成绩不合法");
}

补充：

自增/自减：

int a=5,b=5;
int c = a++; //底层:1)记录a++的值5  2)a自增1变为6  3)将记录的a++的值5赋值给c--了解
//简便记法:a++的值为5，所以c就为5-----重点
int d = ++b; //底层:1)记录++b的值6  2)b自增1变为6  3)将记录的++b的值6赋值给d--了解
//简便记法:++b的值为6，所以d就为6-----重点
System.out.println(a); //6
System.out.println(b); //6
System.out.println(c); //5
System.out.println(d); //6

任何复杂的程序逻辑都可以通过三种结构来实现：
- 顺序结构：从上往下逐行执行，每句必走
- 分支结构：有条件的执行某语句，并非每句必走
- 循环结构：

3.今日代码:

package day03;

public class Test03 {

public static void main(String[] args) {

    //输出几个整数取模，验证结果
    System.out.println(2%5);
    System.out.println(6%2);

    //声明两个整型变量，演示单独使用时的自增和自减
    int a = 4;
    a++;
    System.out.println(a); //5
    a--;
    System.out.println(a); //6

    //声明几个整型变量，演示被使用时的自增和自减
    System.out.println(a++);//5
    System.out.println(a);  //6
    System.out.println(++a);//7
    System.out.println(--a);//5
    System.out.println("输出"+a--);//5
    System.out.println("此时输出a的值应该是4:"+a);
    //声明几个变量，演示最基本的>，<，>=，<=，==，!=操作
    int f = 2,g = 6,k=2;
    boolean h = f > g; //false
    System.out.println(h);
    System.out.println(f<g);//ture
    System.out.println(f>=g);//false
    System.out.println(f<=k);//ture
    System.out.println(f==k);//ture
    System.out.println(f!=g);//ture
    System.out.println("===============");
    //演示关系运算符和算术运算符联合使用的效果
    System.out.println(f+g<k);//false
    System.out.println(f+k==g);//false
    System.out.println(f%g<k);//false
    System.out.println(f++);//false
    System.out.println("输出f结果为3:"+f);
    System.out.println(++f>3);//ture
    System.out.println("输出变量f结果为4:"+f);
    System.out.println("&&");
    //声明三个整型变量，演示&&和||，演示! 下面没有按照要求写
    //     - &&的演示要求：true+false、false+true、true+true、false+false
    //     - ||的演示要求：true+false、false+true、true+true、false+false
    //     - !的演示要求：true、false
    //   - 演示短路&&与短路||
    int a1 = 2, b = 3, c = 4;
    boolean b1 = a1 <b && c>b; //ture && ture = ture
    System.out.println(b1);
    System.out.println(a1<b && a1>b);//ture && false = false
    System.out.println(a1>c && b<c);//false && ture = false
    System.out.println(a1>b && a1>c);//false && false  = false
    System.out.println("||");
    System.out.println(a1<b || a1>b);//ture || false = ture
    System.out.println(c<a1 || c>b); //false || ture = ture
    System.out.println(c>b || b>a); //ture || ture  = ture
    System.out.println(a1>c || a1>b);//false ||false = false
    System.out.println("!");
    boolean b2 = !(a1<b); //a1<b为ture 加上! 等于!ture 等于false
    System.out.println(b2);
    boolean b3 = !(c<a1);
    System.out.println(b3);

    // - 声明一个整型变量，演示扩展赋值+=、-=、*=、/=、%=的效果
    //   - 声明short型变量s，演示简单赋值运算的自增10，演示扩展赋值运算的自增10
    System.out.println("赋值");
    int a3 = 1;
    a3 += 10;
    System.out.println(a3);//11
    a3 -= 2;
    System.out.println(a3);//9
    a3 *= 2;
    System.out.println(a3);//18
    a3 /= 6;
    System.out.println(a3);//3
    a3 %= 2;
    System.out.println(a3);//1

    short s = 10;
    //s = s+10; //编译错误，需强转，改为: s=(short)(s+10);
    s += 10;    //s = s + 10  ---->强转 s = (short)(s+10) 因为s是short类型的
    System.out.println(s);
    //字符串链接 +
    //- 声明整型变量age和字符串型变量name，输出字符串连接的结果
    //   - 输出几个数据的拼接，演示字符串连接的同化作用
    int  age = 14;
    String name = "卡乐咪";
    System.out.println("小"+name+"快要"+age+"岁了");
    System.out.println("有问题字符串连接的同化作用:"+10+10);
    System.out.println(10+10+"这就没问题");
    System.out.println("三目");
    //声明并初始化整型变量，使用条件运算符实现：若>0则给flag赋值为1，否则赋值为0
    //   - 声明两个整型变量，使用条件运算符实现：求这两个变量的最大值
    int a4 = -1;
    int flag = a4>0?1:0;
    System.out.println(flag);

    int a5 =8, b6 = 9;
    int max = a5<b6?b6:a5;
    System.out.println("最大值"+max);

    System.out.println("分支");
    //偶数的判断：声明并初始化一个整型变量，判断该数是否是偶数
    //   - 满500打8折：声明并初始化一个浮点型价格，若满500则打8折
    int a6 = 2;
    if (a6%2==0){
        System.out.println("偶数");
    }
    System.out.println("继续执行");

    double price = 600;
    if (price>=500){
        price *= 0.8;
        System.out.println("满足500享用八折优惠");
    }
    System.out.println("最终结算金额为:"+price);

    //




    //练习 三目
    int a1 =5,b1=3;
    int max = a1>b1?a1:b1;
    System.out.println("最大值"+max);
    //if else 判断
    int a2 = 5 , b2=3;
    int max1;
    if (a2>b2){
        max1 =a2;
    }else {
        max1 = b2;
    }
    System.out.println("if最大值:"+max1);
    

    //是否闰年
    int year = 2022;
    if (year%4==0 && year%100!=0 || year%400==0){
        System.out.println(year+"是闰年");
    }else {
        System.out.println(year+"是平年");
    }


      /*  if (age>18 && age<50){

        }
        if (age>=18 && age<=50){
        }
        if (score>=0 && score<=100 ){
        }
        if (score<0 || score>100){
        }
        */
    
    //成绩是否合法
    double score = 900;
    if (score<0 || score>100){
        System.out.println("成绩不合法");
    }else {
        System.out.println("成绩合法");
    }

}

}




4. 明日单词：

   ```java
   1)Scanner/scan：扫描仪
   2)import:引入、导入
   3)System:系统
   4)in:进入
   5)new:新的
   6)nextInt:下一个整数
   7)nextDouble:下一个浮点数
   8)switch:开关
   9)case:案例
   10)break:中断、退出
   11)command:命令
   12)by:通过
   13)times:次数
   14)while:当...的时候，循环的一种
   15)do:做、干
   16)math:数字
   17)random:随机
   18)guess/guessing:猜
   19)game:游戏
   20)level:等级
   21)count:数量
   22)score:分数

语言基础第3天：1.运算符 2.分支结构

语言基础第3天：

回顾：

精华笔记：

笔记：

补充：