零基础学习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的使用

巴特西

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

最新文章

热门文章

巴特西

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

最新文章

热门文章

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