1、运算符
Java中的运算符有如下6种分类
1、算术运算符 ： + - * / % ++ –
2、赋值运算符 : = += -= *=
3、比较运算符 : > < >= <= == !=
4、逻辑运算符 : & && | || ^
5、位运算符 : & | >> << >>> ^ ~
6、三元运算符 : ? :
1.1算术运算符
| 符号 | 含义 |
|---|---|
| + | 加法运算、字符串拼接 |
| - | 减法运算 |
| * | 乘法运算 |
| / | 除法运算 |
| % | 取模运算（求余数） |
| ++ | 自增运算 |
| – | 自减运算 |
加法运算：
当加号+两边有任意一个String类型的数据时，此时加号+就不再是做加法运算，而是做字符串拼接。
int number1 = 10;
String s = "a";
System.out.println("s + number1 = " + s + number1); //a10
System.out.println("number1 + s = " + number1 + s); //10a
s = "1";
System.out.println("s + number1 = " + s + number1); //110
System.out.println("number1 + s = " + number1 + s); //101
除法运算：
0不能作为除数：错误示例：
// ArithmeticException: 算术异常(错误)
//System.out.println(10 / 0);
自增自减运算符
①++运算符做独立运算时，不管++写在变量前面还是变量后面，效果都是一样的
例如：number++ 、 ++number 这两个没有区别
int number = 10;
number ++; //number = number + 1
++ number; //number = number + 1
System.out.println(number); //number = 11
②非独立运算时，++写在变量前和变量后效果是不同的
/*++写在变量number后面，先赋值再自增*/
int number = 10;
int result_= number ++; //先把number的值赋值给result，然后number自身+1
System.out.println("number = " + number); //number = 11
System.out.println("result_ = " + result_); //result = 10
/*++写在变量number前面，先自增再赋值*/
int number1 = 10;
int result1 = ++number1; //number先自身+1，然后赋值给result1
System.out.println("number1 = " + number1); //number1 = 11
System.out.println("result = " + result1); //result1 = 11
1.2赋值运算符
| 符号 | 含义 |
|---|---|
| = | 等于，用来赋值 |
| += | 加等于 |
| -= | 减等于 |
| *= | 乘等于 |
| /= | 除等于 |
| %= | 取模等于 |
= ：赋值符号；Java中只要看到=符号，就表示把等号右边的内容赋值给左边
//创建byte类型变量num并赋值127
byte num = 127;
num += 2; //num = 127+2 =129 超过了byte类型的最大值
System.out.println("num = " + num); //输出num=-127
/*num+=5 和 num=num+5的区别*/
//创建byte类型的变量num1并赋值12
byte num1 = 12;
num1 += 5; //num1=17
System.out.println("num1 = " + num1); //输出17
//创建byte类型的变量num2并赋值12
byte num2 = 12;
num2 = num2 + 5; //报错
//报错原因：
num2：byte 5:int
---->byte+int--->int
<--->byte=int ：需要进行强制类型转换
num2 = (byte)(num2 + 5); //正确写法 强制类型转换：将int类型转换为byte类型
总结：[面试题] 对于num+=2 和 num = num + 2 这两个的计算结果是一样的，但不同的是计算的方式不一样 num+=2 ----> 其类型是不会发生变化的，例如num为byte类型，运算完之后类型还是byte num = num + 2 ----> 类型可能会发生变化
//特殊
/*对于基本数据类型中的byte和short类型的数据进行运算时
* 会把byte和short类型的数先转换为int类型，再进行运算*/
byte b = 5;
short s = 7;
// short intResult = b+s; //报错 因为结果为int类型
int intResult = b+s;
System.out.println("intResult = " + intResult);
1.3比较运算符
| 符号 | 含义 |
|---|---|
| > | 比较符号的左边的数据是否大于符号右边的数据，若大于结果为true，反之为false |
| < | 比较符号的左边的数据是否小于符号右边的数据，若小于结果为true，反之为false |
| >= | 比较符号的左边的数据是否大于或者等于符号右边的数据，若大于或等于结果为true，反之为false |
| <= | 比较符号的左边的数据是否小于或者等于符号右边的数据，若小于或等于结果为true，反之为false |
| == | 比较符号两边的数据是否相等，相等结果是true，不相等则为false |
| != | 不等于符号，比较符号两边的数据是否不相等，若不相等结果为true，反之为false |
总结：使用比较运算符，得到的结果一定是一个boolean类型的，要么为true ，要么为false
/*
符号两边的数据可以直接写一个数字或者是一个运算的表达式
*/
int number = 2;
System.out.println((number *= 2) == 1);// 4 == 1 false
System.out.println(1 > 2);//false
System.out.println(1 < 2);//true
System.out.println(2 >= 2);//true
System.out.println(1 <= 2);//true
System.out.println(1 != 2);//true
1.4逻辑运算符
| 符号 | 含义 |
|---|---|
| & | 逻辑与 |
| && | 短路与 |
| | | 逻辑或 |
| || | 短路或 |
| ^ | 逻辑异或 |
| ! | 逻辑取反 |
1.4.1逻辑与、短路与运算符
&、&& ： 一假则假
//&逻辑与 &&短路与
//相当于生活中的并且
/*解释：一假则假，表示符号两边只有有任意一边为false时，其结果为false
只有两边都有true时，其结果才是true*/
boolean b1 = true;
boolean b2 = true;
System.out.println("(b1 & b2) = " + (b1 & b2)); //true
System.out.println("(b1 && b2) = " + (b1 && b2)); //true
b1 = true;
b2 = false;
System.out.println("(b1 & b2) = " + (b1 & b2)); //false
System.out.println("(b1 && b2) = " + (b1 && b2)); //false
b1 = false;
b2 = true;
System.out.println("(b1 & b2) = " + (b1 & b2)); //false
System.out.println("(b1 && b2) = " + (b1 && b2)); //false
b1 = false;
b2 = false;
System.out.println("(b1 & b2) = " + (b1 & b2)); //false
System.out.println("(b1 && b2) = " + (b1 && b2)); //false
逻辑与& 和 短路与&& 的区别【面试题】
当使用短路与 && 时，符号左边为false时，右边就不再参与运算
当使用逻辑与 & 时，符号左边不管是否为false，右边都会参与运算
一般都是使用短路与&&,在某种情况下执行效率比逻辑与&稍高一点
1.4.2逻辑或、短路或运算符
| 、 || ： 一真则真
/* |逻辑或 ||短路或 */
/*解释：一真则真 ，表示符号两边只要有任意一边为true，其结果就是true
只有符号两边都为false时，其结果才是false*/
boolean b1 = true;
boolean b2 = true;
System.out.println("(b1 | b2) = " + (b1 | b2)); //true
System.out.println("(b1 || b2) = " + (b1 || b2)); //true
b1 = true;
b2 = false;
System.out.println("(b1 ^ b2) = " + (b1 | b2)); //true
System.out.println("(b1 ^ b2) = " + (b1 || b2)); //true
b1 = false;
b2 = true;
System.out.println("(b1 ^ b2) = " + (b1 | b2)); //true
System.out.println("(b1 ^ b2) = " + (b1 || b2)); //true
b1 = false;
b2 = false;
System.out.println("(b1 ^ b2) = " + (b1 | b2)); //false
System.out.println("(b1 ^ b2) = " + (b1 || b2)); //false
逻辑或| 和 短路或|| 的区别【面试题】
当使用短路或|| 时，符号左边为true时，右边就不再参与运算
当使用逻辑或 | 时，符号左边不管是否为true，右边都会参与运算
一般都是使用短路或||,在某种情况下执行效率比逻辑或|稍高一点
1.4.3逻辑异或运算符和逻辑取反运算符
^ ：同假异真
/*
逻辑异或 ^:
符号两边一样时，其结果为false
两边不一样时，其结果为true
*/
boolean b1 = true;
boolean b2 = true;
System.out.println("(b1 ^ b2) = " + (b1 ^ b2)); //false
b1 = true;
b2 = false;
System.out.println("(b1^b2) = " + (b1 ^ b2)); //true
b1 = false;
b2 = true;
System.out.println("(b1^b2) = " + (b1 ^ b2)); //true
b1 = false;
b2 = false;
System.out.println("(b1^b2) = " + (b1 ^ b2)); //false
/*
！ 逻辑取反
true变为false
false变为true
*/
boolean b1 = true;
System.out.println(!b1);//false
boolean b2 = false;
System.out.println(!b2);//true
总结 逻辑运算符
| a | b | a&b | a&&b | a|b | a||b | a^b | !a |
|---|---|---|---|---|---|---|---|
| true | true | true | true | true | true | false | false |
| false | false | false | false | false | false | false | true |
| true | false | false | false | true | true | true | false |
| false | true | false | false | true | true | true | true |
1.5 位运算符
| 符号 | 含义 |
|---|---|
| & | 按位与 |
| | | 按位或 |
| ^ | 按位异或 |
| ~ | 按位取反 |
| >> | 按位右移 |
| >>> | 按位无符号右移 |
| << | 按位左移 |
对于位运算，需要先转换为二进制之后再去运算
1.5.1 按位与运算符
int a = 10;
int b = 3;
// 10----> 1010 3---->0011
/*
1010
0011
--------
0010 ----> 转换为十进制：2
按位与：有0则0
*/
System.out.println(a & b);//10 & 3 = 2
1.5.2 按位或运算符
int a = 10;
int b = 3;
/*
1010
0011
---------
1011 ----> 转换为十进制：11
按位或：有1则1
*/
System.out.println(a | b); // 10 | 3 = 11
1.5.3 按位取反运算符
int a = 10;
/*
1010
-------
0101 -----> 转换为十进制：5
*/
System.out.println(~a); //5
1.5.4 按位异或运算符
int a = 10;
int b = 3;
/*
1010
0011
------------
1001 -----> 转换为十进制：9
按位异或：相同为0 ，不同的为1
*/
System.out.println(a ^ b); //9
1.5.5 按位右移运算符
int a = 10;
int b = 3;
//把变量a的二进制进行向右移动2位
/*
0000 1010
00 001010
---------------------
00 0010 -----> 转换为十进制：2
m >> n 相当于 m/n个2
*/
System.out.println(a>>2); //2
1.5.6 按位左移运算符
int a = 10;
int b = 3;
//把变量b的二进制向左移动2位
/*
00000011
00000011
---------------------
0000001100 -----> 转换位十进制：12
m << n 相当于 m*n个2
*/
System.out.println(b<<2); //12
1.6 三元运算符
三目运算符
语法格式：
boolean表达式 ? 结果1 : 结果2;
执行的流程：
①判断boolean表达式结果为true，三元运算符将结果1赋值
②判断boolean表达式结果为false，三元运算符将结果2赋值
int s = (1 != 2 ? 10 : 20);
System.out.println("s = " + s); //20
//练习
//获取两个数中最大的数
int number1 = 34;
int number2 = 23;
int maxVulue = number1 > number2 ? number1 : number2;
System.out.println("maxVulue = " + maxVulue); //34
//获取三个数中最大的数
int number3 = 90;
maxVulue = maxVulue > number3 ? maxVulue : number3;
System.out.println("maxVulue = " + maxVulue); //90
//嵌套 先算括号内的
maxVulue = (number1 > number2 ? number1 : number2) > number3 ? (number1 > number2 ? number1 : number2) : number3;
System.out.println("maxVulue = " + maxVulue); //90
2、Scanner键盘输入
Scanner类使用步骤：
1.导包 Scanner类所在的包名
import java.util.Scanner;
2.创建一个扫描器对象
Scanner input = new Scanner(System.in);
3.调用扫描器对象中的方法
next() : 用来接收String类型的数据
nextInt() : 用来接收int类型的数据
nextDouble() : 用来接收double类型的数据
nextByte() : 用来接收byte类型的数据
nextShort() : 用来接收short类型的数据
nextFloat() : 用来接收float类型的数据
nextBoolean() : 用来接收boolean类型的数据
nextChar() : 没有这个方法
说明：
1.对于第一步导包的过程，因为我们使用的是idea高级编辑器，里面有自动导包的功能
所有不需要我们手动去导包
2.扫描器对象的创建，目前是固定语法
//练习：获取两个数中的最大的数
/*int number1 = 34;
int number2 = 23;
int maxValue = number1 > number2 ? number1 : number2;
System.out.println("maxValue = " + maxValue);*/
System.out.println("-------------------------------------");
//创建扫描器对象
//万能快捷键： Alt + Enter
Scanner input = new Scanner(System.in);
//调用扫描器对象中的方法
//调用方法的方式：通过 input.方法名() 的方式来进行调用方法
System.out.println("请输入第一个数：");
/*
当使用input.nextInt()来去接收用户输入的int类型的数据时，
就不能去输入一些非整数类型的数据，否则会出现错误：InputMismatchException 输入不匹配错误
*/
int intNumber = input.nextInt();
System.out.println("intNumber = " + intNumber);
System.out.println("请输入第二个数：");
int intNumber2 = input.nextInt();
System.out.println("intNumber2 = " + intNumber2);
/*double doubleNumber = input.nextDouble();
System.out.println("doubleNumber = " + doubleNumber);*/
//使用三元运算符进行判断
//第一个数：intNumber 第二个数：intNumber2
int result = intNumber > intNumber2 ? intNumber : intNumber2;
System.out.println("两个数中最大的数 = " + result);
//使用键盘输入个人信息
//创建扫描器对象
Scanner input = new Scanner(System.in);
System.out.println("请输入用户名：");
//调用扫描器对象中的方法：next() nextInt() nextDouble() ...
String userName = input.next(); //String
System.out.println("请输入密码：");
int passWord = input.nextInt(); //int
String s = userName.equals("杜澳") && passWord == 123456 ? "登录成功" : "用户名或密码错误，登录失败！";
System.out.println(s);
3、方法
概念：
将一个功能抽取出来，把代码单独的定义在一个{}里面，形成一个单独的功能，当需要这个功能的时候，我们就可以 去调用这个方法，达到实现代码的复用性，也进一步解决了代码的冗余情况
创建语法：
public [static] <返回值类型> <方法名>([参数列表]){
功能代码
[return 返回值;]
}
备注：语法中出现的<>表示语法中必须要有的，不可省略
[]表示语法中可有可无的，在某些情况下可以不用写
只要返回值类型不是void，那么方法中一定要写return
语法说明：
1、修饰符：目前是一个固定的语法 public static
2、返回值类型：
①void：此方法没有返回值结果
②具体的数据类型：此方法执行完毕之后会有一个结果返回，把结果返回给调用者
3、方法名：见名知意
4、参数列表：
在参数列表中可以不写参数或者写多个参数，若写多个参数，则需要使用逗号把每个参数分隔开
例如：(int number1 , int number2)
参数列表的作用：方法在执行的过程中需要的一些未知的数据，我们就可以通过参数传递给方法
5、return：
将方法执行完毕之后的结果（方法的返回值）返回给调用者
当方法执行到return这个地方的时候，方法会结束掉
若返回值类型的地方写的是void，那么此时方法中的return可以不用写
return关键字的作用：
①用来返回方法的执行结果
②用来结束方法
方法分类：
按照是否有参数、是否有返回值，分为4种
①无参无返回
②无参有返回
③有参无返回方法
④有参有返回方法
3.1方法的创建
//main：程序的入口，也是一个方法
public static void main(String[] args) {
//方法不能嵌套，也就是说，方法里面不能创建另一个方法
//方法是需要手动调用的，不调用方法不会执行
//方法的调用：直接在主方法main中写方法名即可
m1();
//调用登录的方法
login();
//调用两个数求和的方法
//若方法有返回值的话，可以使用一个变量来接受返回值结果，或者直接使用输出语句输出到控制台
//调用方法一：变量接受，打印变量
int sum = sumToIntNumber();
System.out.println(sum);
//调用方法二：直接打印方法
System.out.println(sumToIntNumber());
//调用方法parameterWithoutReturnValue 有参数，无返回值
parameterWithoutReturnValue(10,30);
//调用方法parameterReturnValue 有参数，有返回值
System.out.println(parameterReturnValue(50, 100));
}
//在主方法main外面创建方法
//1、创建一个无参无返回的方法
public static void m1(){
System.out.println("^-^这是一个无参无返回值的方法^-^");
}
//创建一个无参无返回的方法（登录方法）
public static void login(){
//使用键盘输入账号密码
//创建扫描器对象
Scanner input = new Scanner(System.in);
System.out.println("请输入用户名：");
//调用扫描器对象中的方法：next() nextInt() nextDouble() ...
String userName = input.next(); //String
System.out.println("请输入密码：");
int passWord = input.nextInt(); //int
String s = userName.equals("杜澳") && passWord == 123456 ? "登录成功" : "用户名或密码错误，登录失败！";
System.out.println(s);
}
//2、创建一个无参数有返回值的方法
//两个数求和
public static int sumToIntNumber(){
int num1 = 10;
int num2 = 20;
int sum = num1 + num2;
return sum;
}
//3、创建一个有参数无返回值的方法
public static void parameterWithoutReturnValue(int num1 ,int num2){
int sum = num1 + num2;
System.out.println("sum = " + sum);
}
//4、创建一个有参数有返回值的方法
public static int parameterReturnValue(int num1 ,int num2){
int sum = num1 * num2;
return sum;
}
注意事项：
1.方法必须定义在类中方法外
2.方法不能定义在另一个方法里面
3.返回值类型，必须要和return关键字后面的返回值结果的类型相同，否则编译不通过，会直接报错
4.不能return语句之后写代码，return关键字用来结束方法，return之后的代码时永远不会被执行到
扫一扫
929
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
