零基础学习java------day3-运算符 以及eclipse的使用

今日内容：

1. 算数运算符

2. 赋值运算符

3. 关系运算符

4. 逻辑运算符

5. 位运算符

6.三目运算符

一 运算符

运算：对常量和变量进行操作的过程称为运算

运算符：对常量和变量进行操作的符号称为运算符

操作数：参与运算的数据称为操作数

1. 算数运算符

1.1. 加减乘除运算

1.1.1  加减乘除运算

+：   正号；加法运算；字符串的连接

—： 负号；减法运算

* ：  乘法

/  :  除法运算，取商

%：取余

注意事项：

　　整数和整数相运算得到的还是整数，运算时从左往后，先算乘除后加减，有括号先算括号

案例：

 1 class MathOperatorDemo{
 2     public static void main(String[] args){
 3         int a = 13;
 4         int b = 2;
 5         System.out.println(a+b); // 15
 6         System.out.println(a-b); // 11
 7         System.out.println(a*b); // 26
 8         System.out.println(a/b); // 6,两个int相运算，得到的结果还是int
 9         System.out.println(a%b); // 1
10     }
11 }

若想a/b等于6.5，则第8行代码改为如下两行之一：

System.out.println(1.0*a/b) //7.5
System.out.println((double)a/b) //7.5 , 若将a/b用括号括起来，则结果为7.0

1.2 加加和减减的运算

（1）++ ：前加加，放在变量的前面；后加加，放在变量的后面（只能操作变量）

单独使用的时候，二者相同，就是做了一个加1的操作

　参与运算时又区别：

　　　　　　前加加：先加1，后运算（包括赋值，打印语句，小括号）

　　　　　　后加加：先运算，后加1

案例：

class MathOperatorDemo2{
    public static void main(String[] args){
        int a = 10;
        int b = 10;
        System.out.println(a++); //10  后加加，先运算（打印）后加1，打印完后a=11
        System.out.println(++b); //11  前加加，先加1，后运算
    }
}

若在打印前，加上a++；b++；则两个打印的结果都为11

（2）练习

/*
 1:基本小题目
int a = 10;
int b = 10;
int c = 10;
a = b++;c=--a;b = ++a;a=c--;
请分别计算出a，b，c的值
**/

class MathOperatorTest{
    public static void main(String[] args){
        int a = 10;
        int b = 10;
        int c = 10;
        a = b++; //a=10,b=11 后加加，先赋值a=10，赋值后b加1变成了11，后面同理
        c = --a; //c=9,a=9
        b = ++a; //b=10,a=10
        a = c--; //a=9,c=8
        System.out.println(a); //9
        System.out.println(b); //10
        System.out.println(c); //8

    }
}

稍微复杂点的题目

int a = 4;
int b = (a++)+(++a)+(a*10);// 70　　

注意：括号也要看成一种运算

(a++) 后加加, 先运算,先算小括号,小括号的值4,后加1, a 变成了5

(++a) 前加加,先加1 ,a 变成了6, 小括号的值变成了6

4+6+60 = 70

2. 赋值运算符

符号：=，+=，-=，*=，/=，%=

=为基本的赋值运算符，其他的为扩展的赋值运算符

注意：+=，-=，*=，/=，%= 等符号中包含了一个强制类型转换

如下代码（为面试题）

short s = 1；
s = s + 1； // 错误，右边预算完数值类型为int，但左边的s为short类型，int范围大于short，所以会报错
s += 1；  // 等价于 s = (short)(s+1),所以不会报错

案例

class GiveValueOperatorDemo{
    public static void main(String[] args){
        int a = 13;
        int b = 2;
        System.out.println(a+=b); //15 a = a+b=15
        System.out.println(a-=b); //13 a = a-b=13
        System.out.println(a*=b); //26 a=26
        System.out.println(a/=b); //13
        System.out.println(a%=b); //1
        System.out.println(a=b); //2 a=2
        System.out.println(a==b); //true
    }
}

3. 关系运算符

关系运算符（也叫比较运算符），特点是返回的结果都是布尔类型的值，要么是true，要么是false

== ：连接基本数据类型，比较数值是否相等；连接引用数据类型，比较的是地址值

!= ： 不等于

> ；<；>=；<=;

instanceof:   判断对象是否属于类  "hello" instanceof String  =====> true   此关系运算符只能用于引用数据类型

案列

class RelationOperatorDemo{
    public static void main(String[]args){
        int a = 15;
        int b = 2;
        System.out.println(a=b);//2
        System.out.println(a==b);//true
        System.out.println(a!=b);//false
        System.out.println(a>b);//false
        System.out.println(a<b);//false
        System.out.println(a>=b);//true
        System.out.println(a<=b);//true
        System.out.println("jh " instanceof String);//true
    }
}

4. 逻辑运算符

4.1 基本规则

逻辑运算符通常用来连接布尔类型的值

（1）& : AND(并且)      两个都是true 结果才是true              false&true = false

（2）| ：OR(或者) 只要有一个是true,那么结果就是true       false|true = true

（3）^ :   XOR(异或) 不同为true, 相同为false                       true^true=false

（4）! 非: (取反)    !true = false

优先级: & 先于  ^    先于   |

6>x>3 在java 中不能这么写, 要写成x>3 & x<6

案例

class LogicOperatorDemo{
    public static void main(String[] args){
        System.out.println((4>3)&(2!=1)); // true: true&true
        System.out.println((4>3)^(2==1));// true true^false
        System.out.println((4<3)|(2!=1));//true false|true
        System.out.println((4>=3)^(2!=1)&(2!=1));//false true^true&true
        System.out.println(!(2!=1));//false
    }
}

4.2 短路运算

（1）

&: 两个都是true, 结果就为true，不管前面运算的结果是什么,后面的表达式都进行运算

&&: 在连接两个布尔类型的表达式的时候,如果&& 前面的表达式的结果为false，那么其实已经可以确认整个表达式的结果就是false,短路运算符,后面就不在进行运算了

& 和&& 最终运算出来的结果是一致的

（2）

|: 只要有一个是true,结果就是true，不管前面表达式的结果如何,后面都进行运算

||: 短路或者. 如果前面的表达式结果为true,那么整个表达式的结果就为true,后面就不在运算了

案例

class LogicOperatorDemo2{
    public static void main(String[] args){
        int x = 3;
        int y = 4;
        System.out.println((x++ > 3) & (y++ > 4)); //false，&后面的代码也执行了，从后面打印显示的y值可以知道
        System.out.println(x);//4
        System.out.println(y);//5
    }
}

若代码变成如下（注释为运行结果），则

System.out.println((x++ > 3) && (y++ > 4));//false，由结果可知，&&后面的代码没有运行
System.out.println(x);//4
System.out.println(y);//4

同理符号“ | ”  也一样

4.3 连接数字

& ，| ，^ 除了可以连接布尔类型外,还可以用来连接整数,短路运算符不能连接数字. 在连接数字的时候,是针对二进制进行运算的, 将连接的数字转成二进制的补码,逐位进行运算, 把0 当做false ,把1 当做true
"~"  也是一个运算符,是把数字转成二进制的补码后逐位(包括符号位)取反

练习题：

a = 15, b=2 求a&b，a|b，a^b，~2

class LogicOperatorDemo3{
    public static void main(String[] args){
        int a = 15;
        int b = 2;
        System.out.println(a&b); //2
        System.out.println(a|b); //15
        System.out.println(a^b); //13
        System.out.println(~b); // -3
    }
}

解释如下

5 . 位运算符

针对二进制的补码做移位的操作
<<: 最高位丢弃,空位补0
>>: 空位补最高位
>>>: 无符号右移, 最高位补0

规律:
左移几位就相当于乘以2 的几次方
右移几位就相当于除以2 的几次方

案例

class BitOperatorDemo{
    public static void main(String[] args){
        System.out.println(15>>2);// 3
        System.out.println(15<<2);// 60
    }
}

6. 三目运算符

也称之为三元运算符
格式:
(关系表达式)?表达式1：表达式2；
 如果条件为true，运算后的结果是表达式1；
如果条件为false，运算后的结果是表达式2；
 表达式1 和表达式2 的最终结果是一个明确的值(不能写输出语句)

练习

/**
    1. 定义两个float 类型的变量, 返回最小值
    2. 定义一个int 类型的变量,如果这个数是偶数,就返回true, 否则返回false
    3. 定义两个long 类型变量,如果这两个数相等,就返回"相等",否则返回不相等
    4. 定义三个double 类型的变量,求出这三个数中的最大值
*/
class ThreeEyesTest{
    public static void main(String[] args){
    //1
    float f1 = 12.3F;
    float f2 = 56;
    float min = f1<f2?f1:f2;
    System.out.println(min);//12.3
    System.out.println(f1<f2?f1:f2);
    //2
    int a = 100;
    boolean bo = a%2==0?true:false;
    boolean bo1 = a%2==0;
    System.out.println(bo);//true
    //3
    long b1 = 100;
    long b2 = 200L;
    String result = b1==b2?"相等":"不相等";
    System.out.println(result);//不相等
    //4
    double d1 = 12.3;
    double d2 = 45;
    double d3 = 89.3;
    double temp = d1>d2?d1:d2;// 求前两个数中的最大值
    double max = temp >d3?temp:d3;// 再用前两个数中的最大值和第三个数比较,
    System.out.println(max);
    System.out.println(d1>d2?(d1>d3?d1:d3):(d2>d3?d2:d3));
    System.out.println(d1>d2&d1>d3?d1:d2>d3?d2:d3); //如果d1 大于d2 并且d1>d3,最大值就是d1,否则d1 不是最大值,最大值就在d2 和d3 中

嵌套练习

需求：
利用条件运算符的嵌套来完成此题：
学习成绩>=90 分的同学用A 表示，
80-89 分之间的用B 表示，
70-79 分以下的用C 表示,
60-69 分以下的用D 表示,
60 以下用E。

class StudentScoreSystem{
    public static void main(String[] args){
        int score = 69;
        String result = score>=90?"A":score>=80?"B":score>=70?"C":score>=60?"D":"E";
        System.out.println(result);
    }
}

二 . 键盘录入

1. 导包: import 全类名(包名+类名)这句话要放到class 的上面

如： import java.util.Scanner

2. 创建Scanner 的对象
    Scanner 对象名(变量名) = new Scanner(System.in);

3. 使用对象获取键盘录入的信息:
    对象名.nextInt();             获得 int
    对象名.nextDouble()              double
    ....
    没有nextChar 这个方法
    对象名.nextLine();          获取字符串的

注意事项: 如果一个程序中,即使用了nextInt(nextDouble.nextLong....) ,同时还使用了nextLine

如果把nextLine 放到了nextInt(nextDouble.nextLong....) 的下面,就会导致nextLine 还未接收到内容就结束了
解决方案：

1. 把nextLine 放到nextInt(nextDouble.nextLong....) 上面
2. 可以使用next 替换nextLine

import java.util.Scanner;
class ScannerDemo{
    public static void main(String[] args){
        //2. 创建对象
        Scanner sc = new Scanner(System.in);
        //3 使用对象获取键盘录入的信息
        System.out.println("请输入您的年龄");
        int age = sc.nextInt();//如果输入的类型不是int,java.util.InputMismatchException
        System.out.println("请输入您的姓名");
        String name = sc.next();
        System.out.println("您好,"+name+",原来您的年龄是:"+age+",您好年轻啊");
    }
}

三 eclipse的使用