Java&day02

1.运算符

1.算术运算符

符号	作用
+	加
-	减
*	乘
/	除
%	取余

1.1.1 运算符和表达式

    运算符：对常量或者变量进行操作的符号
   表达式：用运算符把常量或者变量连接起来符合java语法的式子就可以称为表达式。
   不同运算符连接的表达式体现的是不同类型的表达式。
      +   -    *    /     % 
  注意：
       /和%的区别：两个数据做除法，/取结果的商，%取结果的余数。
       整数操作只能得到整数，要想得到小数，必须有浮点数参与运算。

public class demo1 {
    public static void main(String[] args) {
        //代码演示：
        System.out.println(10 + 20);  //30
        System.out.println(10 - 20);  //-10
        System.out.println(10 * 20);  //200
        System.out.println(10 / 3);   // 整数和整数计算的结果必须是整数 3
        System.out.println(10 % 3);   // 1
        System.out.println(7  % 10);  // 7
        System.out.println(13 % 5);   // 3
    }
}

2.字符的+操作

      每个字符的底层其实都是一个数字
     要记住常用的字符的值。
     在字符加数字的情况下，结果会变成一个数字

public class demo1 {
    public static void main(String[] args) {
        //代码演示：
        System.out.println('a' + 1);  //98    'a' -->  97
        System.out.println('A' + 1);  //66    'A' -->  65
        System.out.println('0' + 1);  //49    '0' -->  48 
        System.out.println('我'+ 1); //25106  '我'-->  25105
    }
}

3.字符串的+操作

    字符串遇到+就不是加法运算了，是拼接效果。
    字符串和任何类型连接都会变成一个更大的字符串。

public class demo1 {
    public static void main(String[] args) {
        //代码演示：
        System.out.println("黑马" + 66 + 6);    //"黑马666"
        System.out.println(99 + 1 + "黑马");    //"100黑马"
        System.out.println("黑马" + (66 + 6));  //"黑马72"

        // 10+20=30
        System.out.println(10 + "+" + 20 + "=" + 30);     // 10+20=30

        int a = 6;
        //使用这个a打印出:     6+6=12
        System.out.println(a + "+" + a + "=" + (a+a));  //6+6=12
    }
}

4.赋值运算符

符号	作用	说明
=	赋值	a=10，将10赋值给变量a
+=	加后赋值	a+=b，将a+b的值给a
-=	减后赋值	a-=b，将a-b的值给a
*=	乘后赋值	a*=b，将a×b的值给a
/=	除后赋值	a/=b，将a÷b的商给a
%=	取余后赋值	a%=b，将a÷b的余数给a

注意：

  扩展的赋值运算符隐含了强制类型转换。

public class demo1 {
    public static void main(String[] args) {
        /=    +=    -=    *=    /=     %=

       // 代码演示：
        //把10赋值给int类型的变量a
        int a1 = 10;

        //扩展的赋值运算符演示
        int a = 10;
        a += 20;    //相当于 a = a + 20;
        System.out.println(a);//30

        a -= 5;     //       a = a - 5;
        System.out.println(a); //25
    }
}

5.自增自减运算符

符号	作用	说明
++	自增	变量的值加1
--	自减	变量的值减1

++(给变量自身加一)    --(给变量自身减一)  

++前置:
    ++a;
        先加一，后运算
后置++:
    a++;
        先运算，后加一

 

public class demo1 {
    public static void main(String[] args) {
       // 代码演示：
        //在单独使用时,不涉及运算,前置和后置效果是一样的
        int a = 10;
        a++;
        //++a;
        System.out.println(a); //11


        int a = 10;
        //先把a的值赋值给b，然后a自身再加一
        int b = a++;
        System.out.println(a); //11
        System.out.println(b); //10


        int a = 10;
        //先让a自身加一,然后再把a的值赋值给b
        int b = ++a;
        System.out.println(a); //11
        System.out.println(b); //11


        int a = 10;
        int b = 20;
        //       10 + 21
        int c = a++ + ++b;
        System.out.println(c); //31
    }
}

6.关系运算符

符号	说明
==	a==b，判断a和b的值是否相等，成立为true，不成立为false
！=	a!=b，判断a和b的值是否不相等，成立为true，不成立为false
>	a>b，判断a是否大于b，成立为true，不成立为false
>=	a>=b，判断a是否大于等于b，成立为true，不成立为false
<	a<b，判断a是否小于b，成立为true，不成立为false
<=	a<=b，判断a是否小于等于b，成立为true，不成立为false

>   <   ==   !=   >=   <=

关系运算符的结果一定是boolean类型。
=是赋值   ==是判断相等  ,千万不要把 == 写成 = ！！！ 

7.逻辑运算符

 

符号	作用	说明
&	逻辑与	a&b，a和b都是true，结果为true，否则为false
|	逻辑或	a|b, a和b都是false，结果为false，否则为true
^	逻辑异或	a^b，a和b结果不同为true，相同为false
!	逻辑非	!a，结果和a的结果正好相反
&&	短路与	作用和&相同，但是有短路效果
||	短路或	作用和|相同，但是有短路效果

 &    :与
                左右两端都是true,结果才是true,否则是false
|   :或
                左右两端都是false,结果才是false,否则是true
    
^   :异或
                两边相同为false,两边不同为true
        !   :非
                取反

 

&&  ：短路与
        如果左边结果是false，右边就不会执行了。
    
||  ：短路或
        如果左边结果是true，右边就不会执行了。

public class demo1 {
    public static void main(String[] args) {
  

       // 代码演示：
        int a = 10;
        int b = 20;
        //a++是后置,所以先运算后加一 10>10 false
        //++b是前置,所以先加一后运算 21>20 true
        System.out.println(a++>10 & ++b>20);   // false&true  --> false

        //在执行这行之前a已经是11了,11>10 true
        //在执行这行之前b已经是21了,21>21 false
        System.out.println(a++>10 | b++>21);   // true|false  --> true


        System.out.println(true  ^ true);    //false
        System.out.println(false ^ true);    //true
        System.out.println(true  ^ false);   //true
        System.out.println(false ^ false);   //false

        //!取反
        System.out.println(!(a>20));   //true
        System.out.println(!!(a>20));  //false



        //代码演示：
        int c = 10;
        int d = 20;
        //c++后置,10>10 false c变成11  右边不执行
        System.out.println(c++>10 && ++d>20);  //false

        //++d前置,先变成21,21>21 false  11>10 true             
        System.out.println(++d>21 || c++>10);  //true

        System.out.println(c); //12
        System.out.println(d); //21
    }
}

8.三元运算符

  格式：
       数据类型 变量名 = 关系表达式 ? 表达式1 : 表达式2;
    
  流程：
      如果关系表达式是true,就把表达式1赋值给变量
      如果关系表达式是false,就把表达式2赋值给变量

 

public class demo1 {
    public static void main(String[] args) {
        //代码演示：
        //求两个数字的较小值
        int a = 10;
        int b = 5;

        int c = a > b ? b : a;

        System.out.println(c);  //5

        //练习：
        //求三个整数的最大值
        int height1 = 150;
        int height2 = 210;
        int height3 = 220;

        //先求两个人的较大值
        int temp = height1 > height2 ? height1 : height2;

        //再拿较大值和第三个值比较
        int max = temp > height3 ? temp : height3;

        System.out.println("最大值是:" + max);
    }
}

9.优先级结论

  运算符其实是有优先级的
  比如&&的优先级大于||

  System.out.println(true || true && false);     //true

  //这个()可写可不写,但是尽量写上为了看起来清楚先执行的是后面
  System.out.println(true || (true && false));   //true

  优先级不需要记，写代码的时候，尽量把优先级手动表示清楚

2.键盘输入

 

1. 导包

   import java.util.Scanner;

2. 创建对象

   Scanner sc = new Scanner(System.in);

3. 输入数据

   int a = sc.nextInt();

//导包
import java.util.Scanner;

public class demo1{
	//所有的变量名都是可以随便命名的
	public static void main(String[] args){
		
		//创建对象
		Scanner sc = new Scanner(System.in);
		
		//输入数据
		int a = sc.nextInt();
		
		//输出一下这个数据
		System.out.println("数据是：" + a);
		
	}
}

3.流程控制语句

  java中一共有三种流程语句，顺序结构、分支结构和循环结构

1.if语句

  格式：
      if(条件判断){
          语句体;
      }
    
  流程：
      如果条件判断的结果是true,语句体就执行
      如果条件判断的结果是false,语句体就跳过不执行

public class demo1{
	public static void main(String[] args){
		
		int a = 10;
		
		System.out.println("开始");
		
		if(a>20){
			System.out.println(a + "大于20");
		}
		
		System.out.println("结束");
	}
}

2.if...else语句

  格式：
      if(条件判断){
          语句体1;
      }else{
          语句体2;
      }
    
  流程：
      如果条件判断的结果是true,就执行语句体1
      如果条件判断的结果是false,就执行语句体2
      也就是说两个语句体一定会执行一个，也叫作是互斥判断。

public class demo1 {
    public static void main(String[] args) {
        int a = 30;
        int b = 20;
        //求两个数的较大值
        if(a > b){
            System.out.println("较大值是:" + a);
        }else{
            System.out.println("较大值是：" + b);
        }
    }
}

3.if...else if...语句

  格式：
     if(条件判断1){
        语句体1;
      }else if(条件判断2){
         语句体2;
     }else if(条件判断3){
         语句体3;
     }else{
         语句体4;
     }
    
流程：
    如果条件判断1的结果是true,就执行语句体1,别的不会执行了。
    如果条件判断1的结果是false,就会继续条件判断2，如果判断2的结果是true,就执行语句体2，别的不会执行了
    ……
    如果所有的if结果都是false，就执行else里面的语句体4
    
    else if()可以写任意多个，最后的else可以不写，也叫做是多分支判断，多个之中选一个执行。

 

import java.util.Scanner;
public class demo1{
    public static void main(String[] args){
		/*		
				0 ~ 60  不及格
				60~ 70  及格
				70~ 80  良好
				80~100  优秀
		*/

        Scanner sc = new Scanner(System.in);

        System.out.println("请输入一个分数：");
        int a = sc.nextInt();

        //判断
        if(a>=0 && a<60){
            System.out.println("不及格！！！");
        }else if(a>=60 && a<70){
            System.out.println("及格！！！");
        }else if(a>=70 && a<80){
            System.out.println("良好！！！");
        }else if(a>=80 && a<=100){
            System.out.println("优秀！！！");
        }else{
            System.out.println("啥也不是！！！！");
        }
    }
}