初学Java 第三天

笔记
1. 运算符：

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

     ```java
     1)%:取模/取余，余数为0即为整除
     2)++/--:自增1/自减1，可在变量前也可在变量后
       2.1)单独使用时，在前在后都一样
       2.2)被使用时，在前在后不一样
           a++的值为a------------(a--的值为a)
           ++a的值为a+1----------(--a的值为a-1)
     
     //演示%:
     System.out.println(5%2); //1，商2余1
     System.out.println(8%2); //0，商4余0
     System.out.println(2%8); //2，商0余2
     
     //演示++单独使用:
     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++; //不用记底层处理: 1)保存a++的值5  2)a自增1变为6  3)将保存的a++的值5赋值给c
                  //记住简便记法:将a++的值5赋值给c
     int d = ++b; //不用记底层处理: 1)保存++b的值6  2)b自增1变为6  3)将保存的++b的值6赋值给d
                  //记住简便记法:将++b的值6赋值给d
     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
     int d = --b; //将--b的值4赋值给d
     System.out.println(a); //4
     System.out.println(b); //4
     System.out.println(c); //5
     System.out.println(d); //4
     ```

   - 关系：>、<、>=、<=、==、!=   boolean

     ```java
     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(b>=a); //true
     System.out.println(a<=c); //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(a++>5); //false-----a自增1变为6
     System.out.println(a++>5); //true------a自增1变为7
     ```

   - 逻辑：&&、||、！   boolean

     ```java
     1)&&:短路与(并且)，两边都为真则为真，见false则false
          ---当第1个条件为false时，则发生短路(后面的不执行了)
       ||:短路或(或者)，有真则真，见true则true
          ---当第1个条件为true时，则发生短路(后面的不执行了)
        !:逻辑非(取反)，非真则假，非假则真
     2)逻辑运算是建立在关系运算的基础之上的
       逻辑运算的结果也是boolean型
     
     //演示&&、||、!:
     int a=5,b=10,c=5;
     boolean b1 = b>=a && b<c;
     System.out.println(b1);          //true&&false=false
     System.out.println(b<=a && b>c); //false&&true=false
     System.out.println(a==b && c>b); //false&&false=false
     System.out.println(b!=c && a<b); //true&&true=true
     
     System.out.println(b>=a || b<c); //true||false=true
     System.out.println(b<=a || b>c); //false||true=true
     System.out.println(b!=c || a<b); //true||true=true
     System.out.println(a==b || c>b); //false||false=false
     
     boolean b2 = !(a<b);
     System.out.println(b2);     //!true=false
     System.out.println(!(a>b)); //!false=true
     
     //演示短路&&和||:
     int a=5,b=10,c=5;
     boolean b4 = a<b || c++>2; //第一个条件为true时短路
     System.out.println(b4); //true
     System.out.println(c);  //5，发生短路了
     
     boolean b3 = a>b && c++>2; //第1个条件为false时短路
     System.out.println(b3); //false
     System.out.println(c);  //5，发生短路了
     ```

   - 赋值：

     ```java
     1)简单赋值运算符:=
     2)扩展赋值运算符:+=,-=,*=,/=,%=
       ---扩展赋值自带强转功能
     
     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);
     ```

   - 字符串连接：

     ```java
     1)+:
       1.1)若两边都是数字，则做加法运算
       1.2)若旁边出现了字符串，则做字符串连接
     
     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"; //声明字符串型变量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
     ```

   - 条件：

     ```java
     1)语法:
         boolean?数1:数2
     2)执行过程:
         整个表达式是有值的，它的值要么是?号后的数1，要么是:号后的数2
         计算boolean的值:
           若为true，则整个表达式的结果为?号后的数1
           若为false，则整个表达式的结果为:号后的数2
     
     int num = 0;
     int flag = num>0?1:-1;
     System.out.println(flag); //-1
     
     int a=8,b=55;
     int max = a>b?a:b;
     System.out.println("max="+max);
     ```

     

2. 分支结构：

   - if结构：1条路

     ```java
     1)语法:
         if(boolean){
           语句块--------------基于条件所执行的语句
         }
     2)执行过程:
         判断boolean的值:
            若为true，则执行语句块(if结束)
            若为false，则if直接结束
     
     //1)偶数的判断:
     int num = 5; //带数(6,5)
     if(num%2==0){
         System.out.println(num+"是偶数");
     }
     System.out.println("继续执行...");
     
     //2)满500打8折:
     double price = 300.0; //消费金额  带数(600.0,300.0)
     if(price>=500){ //满500
         price = price*0.8; //打8折
     }
     System.out.println("最终结算金额为:"+price);
     ```

   - if...else结构：2条路

     ```java
     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; //打8折
     }else{
         price *= 0.9; //打9折
     }
     System.out.println("最终结算金额为:"+price);   
     ```







作业代码
package day03;

public class ZhaoXiangHao01 {
    public static void main(String[] args) {
       //第一题 运算符的练习：关系
        /*1.输出几个整数取模，验证结果
        2.声明两个整型变量，演示单独使用时的自增和自减
        3.声明几个整型变量，演示被使用时的自增和自减

         */

        //1.
        System.out.println(9%2);//1
        System.out.println(7%2);//1
        System.out.println(3%2);//1
        //2.
        int a1 = 5,a2 = 6,a3 = 8,a4 = 3;
        a1++;
        ++a2;
        a3--;
        --a4;
        System.out.println(a1);
        System.out.println(a2);
        System.out.println(a3);
        System.out.println(a4);
        //3.
        int a5 = 5,a6 = 6;
        int a7 = a5++;//5
        int a8 = a6--;//6
        int a9 = ++a5;//7
        int a10 = --a6;//4
        System.out.println(a7);
        System.out.println(a8);
        System.out.println(a9);
        System.out.println(a10);
        /*第二题运算符的练习：关系
          1.声明几个变量，演示最基本的>，<，>=，<=，==，!=操作
           2.演示关系运算符和算术运算符联合使用的效果
        */
        //1.
        int b1 = 5,b2 =6,b3=5;
        System.out.println(b1>b2);//false
        System.out.println(b1<b2);//true
        System.out.println(b1>=b3);//false
        System.out.println(b2>=b3);//true
        System.out.println(b1==b3);//true
        System.out.println(b1!=b3);//false
        //2.
        System.out.println(b1+10>b2);
        System.out.println(b2-5>b3);
        System.out.println(b2-1==b3);


        /*第三题1. 运算符的练习：逻辑
         1.声明三个整型变量，演示&&和||，演示!
         2.&&的演示要求：true+false、false+true、true+true、false+false
         3.||的演示要求：true+false、false+true、true+true、false+false
         4.!的演示要求：true、false
         50演示短路&&与短路||

         */
        //
        //1.
        int c1 = 10,c2 = 20, c3 =  30;
        System.out.println(c1<=c2 && c3>c2);//true
        System.out.println(c1>c2 && c3>c2);//false
        System.out.println(c2>c1 || c1>c3);//true
        //2.
        System.out.println(c1<c2 && c2>c3);//true && false = false
        System.out.println(c1>=c2 && c2<c3);//false && true = false
        System.out.println(c2<=c3 && c3>=c1);//true && true = true
        System.out.println(c1>c3 && c2<c1);//false && false = false
        //3.
        System.out.println(c1>=c3 || c2>c1);//true || false = true
        System.out.println(c2>c3 || c3>c1);// false || true = true
        System.out.println(c3>=c2 || c1<=c2);//true || true = true
        System.out.println(c2>c3 || c1>c2);//false || false =false
        //4.
        int c4 = 5,c5 = 10,c6 =20;
        boolean c7 = c4>c5 && c6++>4;
        System.out.println(c7);//false
        System.out.println(c6);//20
        boolean c8 = c4<c5 || c6++>3;
        System.out.println(c8);//true
        System.out.println(c6);//20
        /*第四题运算符的练习：赋值
          1.声明一个整型变量，演示扩展赋值+=、-=、*=、/=、%=的效果
          2.声明short型变量s，演示简单赋值运算的自增10，演示扩展赋值运算的自增10

         */
        //1.
        int d1 = 9;
        System.out.println(d1);//19
        d1 *= 6;
        System.out.println(d1);//114
        d1 -=4;
        System.out.println(d1);//110
        d1 /=2;
        System.out.println(d1);//55
        d1 %=9;
        System.out.println(d1);//1
        d1 += 10;
        //2.
        short d2 = 10;
        d2 =(short)(d2+10);//
        System.out.println(d2);
        /*第五题 运算符的练习：字符串连接
         1.声明整型变量age和字符串型变量name，
         2.输出字符串连接的结果输出几个数据的拼接，演示字符串连接的同化作用
         */
        //1.
        int  age = 23;
        System.out.println("唐阿慧");//唐阿慧
        System.out.println(age+"岁");//23岁
        System.out.println("唐阿慧"+"今年"+23+"岁");//唐阿慧今年23岁
        //2.
        String name = "TAH";
        System.out.println(10+20+""+50);//3050
        System.out.println(50+60+"");//110
        /*第六题1. 运算符的练习：条件/三目
        1. 声明并初始化整型变量，使用条件运算符实现：若>0则给flag赋值为1，否则赋值为0
        2.声明两个整型变量，使用条件运算符实现：求这两个变量的最大值
         */
        //1.
        int e1 = 6;
        int e2 = e1>0?1:-1;
        System.out.println(e2);//1
        //2.
        int e3 = 5, e4 = 6;
        int e5 = e3>e4?e3:e4;
        System.out.println("e5="+e5);
        /*第七题 分支结构的练习：if
        1.偶数的判断：声明并初始化一个整型变量，判断该数是否是偶数
        2.满500打8折：声明并初始化一个浮点型价格，若满500则打8折
         */
        //1.
        int f1 = 6;
        if (f1%2==0){
            System.out.println(f1+"是偶数");
        }
        System.out.println("继续执行....");
        double f2 = 500;
        if (f2>=400) {
            f2*=0.6;
        }else {
            f2*=0.4;
        }
        System.out.println(f2);



    }
}