Java基础-运算符

算术运算符Arithmetic Oprator:

+ - * :和数学中规则一样

/ :当操作数都是整型,结果也是整型,小数部分舍弃

% :结果是除法操作的余数.结果的符号取决于被模数.

++ -- :针对变量进行操作.

         前++ : 先对变量增加,再使用.

         后++ : 先使用变量原来的值,再增加.

         --同理:

+ : 当 + 两侧任意一侧是字符串的时候,+就是连接符.

作用:

         1.字符串拼接

         2.将其它类型的值转换成字符串,只需要让值和一个空串拼接即可.

/*
    演示算术运算符
    + - * /
    %:取余
    ++ :针对变量操作,每次都加1.
    -- :针对变量操作,每次都减1.
        当++,--放在变量后,表示先使用,后变化.
        当++,--放在变量前,表示先变化,然后再使用.
        
            +  :连接符,用于出现字符串的地方,简单的拼接.
*/
public class ArithmeticDemo{
    public static void main(String[] args){
        
        /*
        int a = 10;
        int b = 5;
        
                  //算术运算
        System.out.println(a + b);  //15
        System.out.println(a - b);  // 5
        System.out.println(a * b);  //50
        System.out.println(a / b);  //2
        System.out.println(a % b);  // 0
        */
        /*
                // + 有重载操作:在算数运算中,它是加法,在遇到字符串时,它是连接符.
        System.out.println("hello" + 10);   // hello10
        
            //注意 + 两侧的数据类型.
        System.out.println(a + b + "world");  // 15world
            // + 两侧都是字符串.
        System.out.println("hello" + "\world");  // helloworld
            
        System.out.println("hello" + (5 + 5));  //hello10  加()提升优先级.
        */
        
        /*
            //++表示对变量每次自增1
        int a = 10;
        //a++;
        //System.out.println(a);  //11
        
            //--表示对变量每次减1
        int b = 10;
        //b--;
        //System.out.println(b);  // 9
        System.out.println(a++);  //10   先使用a原来的值,然后让a增加1
        System.out.println(++b);  //11   先让变量值增加,然后使用   
        */
        
        // double d = 3.14;
        // System.out.println(++d); //4.1400000001
        /*
        //思考题1
        int a = 10;
        int b = 10;
        int c = 10;
        a = --c;   // c = 9, a = 9
        b = c++;   // b = 9, c = 10
        c = ++a;   // a = 10 , c = 10
        System.out.println(a + "," + b + "," + c);   // a = 10 , b = 9 , c = 10
        */
        
        //思考题2
        // int a = 10;
        // int b = 3;
        // System.out.println(a*1.0 / b);   // 3.333333333
                
        // int a = 4;
        // int b = (++a) + (a++) + (a*10);
        // System.out.println(a + "," + b);  // a = 6, b = 70
                //%结果的正负取决于被模数,就是%前面的数的正负.
        int a = -10;
        int b = -3;
        System.out.println(a % b);   // -1
        
    }
}

赋值运算符:Assignment operator

基本赋值运算符:

         =

扩展赋值运算符:

         += -= *= /= %=

特点:不改变等号左边的变量的类型,相当于系统自动加上了类型转换.

         short s = 1;

         s = s + 1;// int -> short

         s += 1; //自动类型转换

/*
    赋值运算符的演示:
        =    就是把右边的常量(字面量),变量,表达式的值赋值给左边的变量
        扩展赋值运算符:就是一些赋值运算符的简化写法.
            +=   a += 10 ->  a = a + 10;
            -=
            *=
            /=
            %=
            特点:不改变左侧变量的数据类型.
                short s = 1;
                s = s + 1;       //报错
                s += 1;        //不改变左侧变量的数据类型

*/
public class AssignmentDemo{
    public static void main(String[] args){
        
        
        // int a = 10;                //用常量给变量赋值
        // int b = a;              //用变量给变量赋值
        // b = b + a;              //用表达式的值给变量赋值
        // System.out.println(a + "," + b);  // 10,20
        
        //连续赋值
        // int a,b,c;
        // a = b = c = 10;
        // System.out.println(a + "," + b + "," + c);  //10,10,10
        
        
        short s = 1;
        s = (short)(s + 1);
        System.out.println(s);   // 2
        
        
    }
}

比较运算符:Compare Operator

结果肯定是一个boolean类型

==

!=

> 

< 

>=

<=

instanceof : 判断某个对象是否是某个类的实例.

比较运算符可以比较:

常量,变量,表达式

/*
    比较运算符的演示
    ==
    !=
    >
    <
    >=
    <=
    instanceof:判断某个对象是否是某个类的实例.
    总结:比较运算符的结果肯定是一个boolean类型值(true/false)

*/
public class CompareDemo{
    public static void main(String[] args){
        /*
        //比较两个常量
        System.out.println(10 == 20);   //false
        
        //比较两个变量
        int a = 10;
        int b = 20;
        System.out.println(a == b); //false
        System.out.println(a != b); //true
        System.out.println(a >= b); //false
        System.out.println(a <= b); //true
        System.out.println(a > b); //false
        System.out.println(a < b); //true
        */
        //比较表达式
        int a = 20;
        boolean b1 = a > (a - 10);
        System.out.println(b1);   //true
        
        
    }
}

逻辑运算符:Logic Operator

/*
    逻辑操作符的演示
    &     :两个操作数都是true,结果才为true,否则就是false
    |     :两个操作数都有一个是true,其结果就为true
    &&    :短路与,当左侧操作数为false时,整体的结果已经是false,右侧就不参与运算了
    ||    :短路或,当左侧操作数为true时,整体的结果已经是true,右侧就不参与运算了.
    ^     :异或,两个操作数不同时,结果为true,否则为false
    !     :取反,单操作数,相反.


*/
public class LogicDemo{
    public static void main(String[] args){
        /*
        System.out.println(true && true);      //布尔常量进行逻辑运算
        
            //布尔类型的变量进行运算
        boolean b1 = true ;
        boolean b2 = false ;
        boolean b3 = true ;
        System.out.println(b1 & b2);   // false
        System.out.println(b1 | b2);   // true
        System.out.println(b1 && b2);  // false
        System.out.println(b1 || b2);  // true
        System.out.println(b1 ^ b2);   // true
        System.out.println(b1 ^ b3);   // false
        System.out.println(!b1);       // false
        */
        /*    
            //短路操作
        int a = 1;
        boolean b = true && (a++) > 1;    
        System.out.println(a);    //  a = 2
        System.out.println(b);    //  b = false
        */
        /*
            //&&左侧为false,直接结果为false,右侧不参与运算.
        int a = 1;
        boolean b = false && (a++) > 1;    
        System.out.println(a);    //  a = 1
        System.out.println(b);    //  b = false
        */
        
        
    }
}

位运算符:Bitwise Operator

/* 
    位运算符的演示:
        << : 对操作数的二进制表示形式操作,左边移出的位丢弃,右边全以0填充
        >> : 带符号右移,左边空出的位,以符号位填充.
        >>> : 无符号右移,左边空出的位,总以0填充.
        &  : 按位与操作.
        |  : 按位或操作.
        ^  : 按位异或操作.
        ~  : 按位取反.


*/
public class BitDemo{
    public static void main(String[] args){
            
        /*
        System.out.println(3 << 2);  //  相当于3*2^2 = 12   
             //带符号右移
        System.out.println(3 >> 2);  //  0
        System.out.println(-1 >> 2);  //  -1    
        System.out.println(-1 >> 9);  //  -1    
        System.out.println(-1 >> 30);  //  -1    
        
             //无符号右移
        System.out.println(-1 >>> 1);  //  21yi    
        */
            //按位与操作
        System.out.println(3 & 6);   //  2
            //按位或操作
        System.out.println(3 | 6);   //  7
            //按位异或操作
        System.out.println(3 ^ 6);   //  5
            //按位取反
        System.out.println(~6);   //  -7
        
        
        
        
    }
}

三元运算符:Ternary Operator

格式:

(布尔表达式) ? 表达式1:表达式2;

布尔值为true,整体是表达式1的值.否则是表达式2的值.

/*
    演示三元运算符:
    格式:
        (布尔值)?表达式1:表达式2;
    ()可选,建议加上.
    
*/
public class TernaryDemo{
    public static void main(String[] args){
        //直接使用布尔常量
        System.out.println((false)?1:2);
        
        int x = (false)?1:2;//
        
        //
        // int a = 10;
        // int b = 20;
        // double d = (b > a) ? 1.0:2.0;
        // System.out.println(d);
        
        //
        // int a = 4,b = 4;
        // System.out.println((a > b) ? a : b);
        
    }
}

程序流程控制:

if分支:

第一种:

if(条件表达式){

         语句体;

}

 

第二种:

if(条件表达式1){

         语句体1;

}else{

         语句体2;

}

 

第三种:

if(条件表达式1){

         语句体1;

}else if(条件表达式2){

         语句体2;

}else if(条件表达式3){

         语句体3;

}

...

else{

         语句体n;

}

*
    分支结构(选择结构)
    第一种:
        if(条件表达式){
            语句体;//可以是多条语句
        }
        
    
    第二种:
        if(条件表达式){
            语句体1;//可以是多条语句
        }else{
            语句体2;//可以是多条语句
        }
    
    第三种:
        if(条件表达式1){
            语句体1;//可以是多条语句
        }else if(条件表达式2){
            语句体2;//可以是多条语句
        }else if(条件表达式3){
            语句体3;//可以是多条语句
        }
        ...
        else{
            语句体n;//可以是多条语句
        }
        
*/



public class IfDemo1{
    public static void main(String[] args){
        // int a = 150;
        /*
        if(a > 0){
            System.out.println("a > 0");
        }
        //..
        System.out.println("if后的语句");
        */
        
        /*
        //第二种格式;
        if(a > 0){
            System.out.println("a>0");
        }else{
            System.out.println("a<=0");
        }
        System.out.println("if后的语句");
        */
        /*
        //第三种格式
        if(a < 0){
            System.out.println("a < 0");
        }else if(a < 10){ //else隐含一个条件 a >= 0,
            System.out.println("a >= 0 a < 10");
        }else if(a < 20){//隐含条件 a >= 10,
            System.out.println("a >= 10 a < 20");
        }else{    //隐含条件 a >= 20
            System.out.println("a >= 20");
        }
        //
        System.out.println("if后的语句");
        */
        
        
        // int a = 10;
        // int b = 20;
        // if(a > 0 && b > 5){
            
        // }else{
            
        // }
        
        // System.out.println((a > b)?a:b);
        
        //if后的{}可以省略,但是此时只能控制到第一个;结束
        if(false){
            System.out.println("ok");
            System.out.println("可以");
        }
        
        //建议不论if后面有多少条语句,一定要加{}
        
        
        
    }
}

如何在程序中接受从键盘上录入数据?

1.导包

         import java.util.Scanner;

         一定要在类定义的前面

2.创建对象

         Scanner s = new Scanner(System.in);

         现在只能出现在main方法中.

 

3.调用方法获取数据

         int x = s.nextInt();                       获取int值

         double d = s.nextDouble();       获取double值

/*
    从键盘录入三个int值,取其中的最大值.
    作业:
        使用三元运算符求键盘录入的三个数中的最大值(嵌套/不嵌套)
*/
//导包
import java.util.Scanner;

public class ScannerDemo1{
    public static void main(String[] args){
        //创建扫描器对象
        Scanner s = new Scanner(System.in);

        //提示输入三个数
        System.out.println("输入第一个int值:");
        int a = s.nextInt();
        System.out.println("输入第二个int值:");
        int b = s.nextInt();
        System.out.println("输入第三个int值:");
        int c = s.nextInt();
        /*
        //if-else取最大值
        if(a > b){
            if(a > c){
                System.out.println("最大值是: " + a);
            }else{ //c >= a
                System.out.println("最大值是: " + c);
            }
        }else{//b >= a
            if(b > c){
                System.out.println("最大值是: " + b);
            }else{ //c >= b
                System.out.println("最大值是: " + c);
            }
        }
        */
        //三元运算符求最大值.
        // int Max1 = (a > b)?a:b;
        // int Max2 = (Max1 > c)?Max1:c;
        // System.out.println("最大值为: " + Max2);
        
        int Max = (((a > b)?a:b)>c)?((a > b)?a:b):c;
        System.out.println("最大值为: " + Max);
    }
}