运算符规则

1.运算符

1.1算数运算符

class Demo4{
	public static void main(String[] args){
		//算数运算符
		System.out.println(4+5);//9
		System.out.println(4-5);//-1
		System.out.println(4*5);//20
		System.out.println(7/5);//1
		System.out.println(-7/5);//-1
		System.out.println(7/-5);//-1
		//余数的符号位与被除数一致
		System.out.println(4%5);//4
		System.out.println(-4%5);//-4
		System.out.println(4%-5);//4
		
		//++ 记住++
		//--
		/*
		
		*/
		int a = 3;
		int b = 4;
		int x = a++;//当++在后时,先赋值,再自身+1
		int y = ++b;//当++在前时,先自身+1,再赋值
		System.out.println("a:"+a);//4
		System.out.println("b:"+b);//5
		System.out.println("x:"+x);//3
		System.out.println("y:"+y);//5
		
		//练习 有一个三位数，求百位上 的数字   
		int x1 = 123;
		//先除以10
		x1 = x1 /10; //12
		//再除以10
		x1 = x1 / 10; //1
		
		//找个位的数字
		int m = 456;
		 m = m % 10;//6
		
	}
}

1.2赋值运算符

class Demo5{
	public static void main(String[] args){
		//赋值运算符
		//在使用+=运算符时,必须保证a是有值的.
		int a = 5;
		a += 5;//相当于 a = a + 5;
		}
	}

1.3关系运算符

class Demo5{
	public static void main(String[] args){
		//关系运算符
		//运算符的结果是boolean型.
		//注意区别:== 与 = 
		System.out.println(3>4);
		System.out.println(3>=4);
		System.out.println(3<4);
		System.out.println(3<=4);
		System.out.println(3==4);
	}
}

1.4逻辑运算符

class Demo5{
	public static void main(String[] args){
//逻辑运算符
		//特点:1.运算符的两边的元素一定是true/false  2.结果一定是true/false
      
		//逻辑与  &    逻辑或   |     逻辑异或    ^    逻辑非   !
		//&:一假则假,全真才真
		//|:一真则真,全假才假
		//!:真则假,假则真
		
		
		System.out.println(true & false);//false
		System.out.println(true | false);//true
		System.out.println(true ^ false);//true
		System.out.println(!false);//true
		
		int a11 = 2,b=1,c=3;
		boolean b1 = (3 > 5) && false  && a11++ > b && 4>7  && false  && false  && false;
		boolean b2 = (3 > 5) || false  ||  false || 4>7;
		System.out.println(b1+"   a11:"+a11);//false   10
         }
     }		

1.5位运算符

public class JavaSyntax { 
     public static void main(String[] args) { 
     //特点:直接操作的是位 
	//为什么要使用位运算符?因为位运算符的速度比普通的快
    /* &(按位与):全1则1,有0则0: 作用:定向清0 
    * |(按位或):全0则0,有1则1
    * ^(按位异或):相同则0,不同则1 作用:交换两个数的值 
    * ~(按位取反):1则0,0则1 
    */ 
    /*
    * 过程实现
    * byte a=4 b=5 
    a=4的补码是 00000100 简写 0100
    b=5的补码是 00000101 简写 0101 
    *
    * 0100 
    * 0101 & 
    * 0100 4 
    *
    * 0100 
    * 0101 | 
    * 0101 5 
    *
    *
    * 0100 
    * 0101 ^ 
    * 0001 1 
    *
    * 0100 ~ 
    * 1011 *
    */ 
    //实例一:使用&实现定向清零
    //网段:对于IPv4,两个IP地址,他们的前三个部分相同就说在同一个网段.
    //网关:是当前网段中的一个ip地址,我们可以简单的理解成守门员.
    //子网掩码:用来确认ip地址是否处于当前的网段 
    //IP地址:大家上网时在网上的唯一凭证(身份证),默认肯定要跟网关在同一网段. 
    /*
    * 网段: 192.168.1.0 
    * 网关: 192.168.1.1 
    * IP地址:192.168.1.34 
    * 子网掩码:255.255.255.0 
    *
    * 192.168.1.34 
    * 255.255.255.0 & 
    *
    * 192.168.1.0 用这个值与网段比较,相同则认为在当前网段. 
    *
    */ 
    /*
    * 实例二:使用^实现交换两个数的值 
    */ 
    int x = 4 ,y =5; 
    //第一种方法:借助三方变量
    int tmp = 0; 
    tmp = x; 
    x = y;
    y = tmp; 
    //第二种方式:使用^
    x = x ^ y;
    y ^= x;
    x ^= y;
    System.out.println("x:"+x+" y:"+y);
    /*
    * 0101 x 
    * 0100 y ^ 
    * 0001 X
    *
    * 0100 y 
    * 0001 X ^ 
    * 0101 y--------5 
    *
    * 0001 X 
    * 0101 y ^ 
    * 0100 x--------4 
    */ 
    //移位运算符:操作位的. >> << >>> 
    //特点:操作位的 
	System.out.println(5>>1);
    //解析:正数的补码和原码相同
    //补码: 00000101 
    //右移 00000010
    //左移 00001010 
    //注意:左移后再右移或者右移后再左移都不一定能得到原来的结果 
    //作用:用于乘除法,例子:二分查找 
    
    //扩展:负数的运算 
    int x = -8; 
    System.out.println(x >> 2); // 1111 1110 
    /*分析: 
    //对于>> 高位补符号位,分析时可以简写10001000 
    -8的原码: 10001000 
        反码: 11110111 注意:最高位符号位不变 
        补码: 11111000 
        运算后: 11111110 注意:高位补1 
        求原码,取反: 10000001 
        加一: 10000010 -2 
        */ 
    System.out.println("值:"+ (x >>> 2));
    // 00111111 11111111 11111111 11111110 
    /*分析: 
    -8原码: 10000000 00000000 00000000 00001000
    -8反码: 11111111 11111111 11111111 11110111 
    -8补码: 11111111 11111111 11111111 11111000 
    -8无符号右移后结果:00111111 11111111 11111111 11111110 
    注意:左 侧补零(高位补0) */ }

2.三目运算符

描述:三目运算符， 是一个带有些逻辑的运算符， 基础语法如下：

布尔结果表达式/布尔变量 ? 值1 ： 值2

如果问号前面的布尔值为true， 整体的结果为值1。 否则整体的结果为值2。

public class Demo1 {
    public static void main(String[] args) {
        //三目运算符 ?:
        //求 a,b的最大值
        int a = 4;
        int b = 3;
        int c = a>b?a:b;
        System.out.println(c);

        //求a,b,c三个数的最大值
        int d = (a>b?a:b)>c?(a>b?a:b):c;

        //结果:4.0
        System.out.println(a>b?4:4.5);
    }
}

3.流程控制

3.1流程控制简介

​ ①顺序结构：从上到下，按照顺序执行。

​ ②分支结构：程序进行到某一处有多种可能性时，根据条件，选择执行。

​ ③循环结构：同一串代码需要重复执行。

3.2if语句

​ ①if(条件){…}

​ ②if(条件){…}else{…}

​ ③if(条件){…}else if(条件){…}else{…}

​ ④if(条件){ if(条件){…} } else {…}

1.分支-if

import java.util.Scanner;

public class Demo2 {
    public static void main(String[] args) {
        //分支-if
        //if (/* 条件判断 true or false */) {
        //    // 条件结果为true执行大括号以内的语句
        //}
        ///*
        //执行流程：
        //	代码运行到if分支结构，首先判断if之后的条件是否为true，如果为true，执行大括号里面的语句，如果为false直接执行大括号之外的语句，
        //*/

        /*
        Scannner的使用
         */
        //创建Scannner的对象,并设置输入流------通过scanner可以让用户从控制台手动输入数据
        Scanner scanner = new Scanner(System.in);
        int value1 = scanner.nextInt();
//      float v2 =   scanner.nextFloat();
//      double d1 =   scanner.nextDouble();
//       String s1 = scanner.next();//字符串
//       long l1 = scanner.nextLong();

        //System.out.println(value1+"    "+v2+"      "+d1);

        //java成绩如果大于60，奖励一颗糖
        int score = value1;
        if(score > 60){
            System.out.println("奖励糖");
        }

        System.out.println("go on");


        int java = 100;
        int html = 80;
        if ((java>98 && html>80) || (java==100 && html>70)){
            System.out.println("奖励");
        }
    }
}

2.双分支if…else…

public class Demo3 {
    public static void main(String[] args) {
        //双分支
        //如果是男生就永远18岁，否则永远16岁。
        String sex = "男";
        //如果是字符串进行比较,要使用equals方法,这个方法会将sex代表的数据域"男"进行对比,结果返回true/false
        if (sex.equals("男")){
            System.out.println("永远18岁");
        }else {
            System.out.println("永远16岁");
        }
    }
}

3.多分支

public class Demo4 {
    public static void main(String[] args) {
        //多分支结构
        //判断某一个月属于哪一个季节
        /*
        分析:因为有四个季节,所以是多分支
        冬季:12,1,2
        春季:3,4,5
        夏季:6,7,8
        秋季:9,10,11
         */
        int month = 3;
        if (month == 3){
            System.out.println("春");
        }else if (month == 4){
            System.out.println("春");
        }else if (month == 5){
            System.out.println("春");
        }else if (month == 6){
            System.out.println("夏");
        }else if (month == 7){
            System.out.println("夏");
        }else if (month == 8){
            System.out.println("夏");
        }else if (month == 9){
            System.out.println("秋");
        }else if (month == 10){
            System.out.println("秋");
        }else if (month == 11){
            System.out.println("秋");
        }else {
            System.out.println("冬");
        }

        //优化
        if (month == 3 || month == 4 || month == 5){
            System.out.println("春");
        }else if (month == 6 || month == 7 || month == 8){
            System.out.println("夏");
        }else if (month == 9 || month == 10 || month == 11){
            System.out.println("秋");
        }else {
            System.out.println("冬");
        }

        //再优化
        if (month >= 3 && month <= 5){
            System.out.println("春");
        }else if (month == 6 || month == 7 || month == 8){
            System.out.println("夏");
        }else if (month == 9 || month == 10 || month == 11){
            System.out.println("秋");
        }else {
            System.out.println("冬");
        }

        //再优化---提高用户体验
        if (month>=1 && month<=12){
            if (month >= 3 && month <= 5){
                System.out.println("春");
            }else if (month == 6 || month == 7 || month == 8){
                System.out.println("夏");
            }else if (month == 9 || month == 10 || month == 11){
                System.out.println("秋");
            }else {
                System.out.println("冬");
            }
        }else {
            System.out.println("亲,输错了,请重新输入1-12之间的数字");
        }
    }
}

3.3switch语句

1.语句逻辑

​ switch语句通过case进行分支，通过switch后的变量与case的变量进行比较，如果与某个case后的值相同，就执行case后相应的语句，如果与每一个case都不相同则执行defult后的语句。

2.siwtch的语法规则

​ 1.表达式expr的值必须是下述几种类型之：

byte、short、int、char、enum(枚举)；java7之后可以是String。

​ 2.case子句中的值const 必须是常量值(或final的变量)，case中的值不能是一

个范围

​ 3.所有case子句中的值应是不同的,否则会编译出错；

​ 4.default子句是可选的（不是必须的）

​ 5.break语句用来在执行完一个case分支后使程序跳出switch语句块；否则会继续执行下去

public class Demo5 {
    public static void main(String[] args) {
        //  switch(表达式expr){//int,byte,short,char,enum,String
        //   		case const1:
        //   			statement1;
        //   			break;
        //   		case const2:
        //   			statement2;
        //   			break;
        //   			… …
        //   		case constN:
        //  			statementN;
        //   			break;
        //   		default:
        //   			statement_dafault;
        //   			break;
        //   	}
        //
        //判断某一个月属于哪一个季节
        int month = 41;
        switch (month) {
            case 3:
                System.out.println("春");
                break;
            case 4:
                System.out.println("春");
                break;
            case 5:
                System.out.println("春");
                break;
            case 6:
                System.out.println("夏");
                break;
            case 7:
                System.out.println("夏");
                break;
            case 8:
                System.out.println("夏");
                break;
            case 9:
                System.out.println("秋");
                break;
            case 10:
                System.out.println("秋");
                break;
            case 11:
                System.out.println("秋");
                break;
            default:
                System.out.println("冬");
                break;
        }

        //优化
        
        switch (month) {
            default:
                System.out.println("冬");
                break;
            //注意:case后面只能跟一个值
            case 3:
            case 4:
            case 5:
                System.out.println("春");
                break;
            case 6:
            case 7:
            case 8:
                System.out.println("夏");
                break;
            case 9:
            case 10:
            case 11:
                System.out.println("秋");
                break;
        }
    }
}

3.break的穿透性

         System.out.println("冬");
            break;
        //注意:case后面只能跟一个值
        case 3:
        case 4:
        case 5:
            System.out.println("春");
            break;
        case 6:
        case 7:
        case 8:
            System.out.println("夏");
            break;
        case 9:
        case 10:
        case 11:
            System.out.println("秋");
            break;
    }
}

}

###### 3.break的穿透性

​	当switch的变量和某一个case值匹配上之后， 将会跳过后续的case或者default的匹配，直接向后穿透。