黑马Java笔记第二讲—java基础

🎨 个人介绍

👉大家好，我是：知识的搬运工旺仔

👉认真分享技术，记录学习过程的点滴，如果我的分享能为你带来帮助，请支持我奥🍻

👉你的支持，是我每天更新的动力。

👉赞点：👍 留言：✍ 收藏：⭐

👉个人格言：想法一步一步的落实，才是你我前进最佳选择。

1. 算数运算符

1.1 算术运算符的（理解）

1.1.1 运算符和表达式

运算符：对常量或者变量进行操作的符号

表达式：用运算符把常量或者变量连接起来符合 java 语法式子就可以称之为表达式

不同运算符连接的表达式体现的是不同类型的表达式

举个例子：

int a = 10;
int b =20;
int c = a + b;
1
2
3

+:是运算符，并且是算术运算符

a + b ：是表达式，由于 + 是 算术运算符，所以这个表达式叫算术表达式

1.1.2 算是表达式

注意：

1. / 和 % 的区别：两个数据做除法，/ 取结果的商，% 取结果的余数
2. 整数操作只能得到整数，要想得到小数，必须有浮点数参与运算

1.1.3 字符串的" + " 操作

1 ）char类型参与算术运算，使用的是计算机底层对应的十进制数值，需要我们记住三个字符对应的数值：

‘a’—97 ，a-z是连续的

‘A’—65 A-Z是连续的

‘0’—48 0-9是连续的

2 ）算数表达式中包含不同的基本数据类型的值的时候，整个算数表达式的类型会自动提升

3 ）提升规则：

1. byte类型，short类型 和 char 类型将被提升到 int 类型，不管是否有其他类型参与运算。
2. 整个表达式的类型自动提升到与表达式中最高等级的操作数相同的类型
3. 等级顺序：byte,short,char—>int—>long—>float—>double

tips:正是由于上述原因，所以在程序开发中我们很少使用byte或者short类型定义整数，也很少会使用char类型定义字符串，而使用字符串类型，更不会使用char类型做算数运算

1.1.4 字符串的 “ + ” 操作

1 ）当“ + ” 操作中出现字符串时，这个“+”是字符串连接符，而不是算符运算符

System.out.println("itheima"+666)
1

2 ）在“ + ” 操作中，如果出现了字符串，就是连接运算符，否则就是算数运算符。

3 ）当连续进行"+"操作时，从左到右逐个执行，只有遇见字符串后，“+”才是连接运算符

System.out.println(1+99+"年黑马"); // 一百年黑马
System.out.println(1 + 2 + "ithiema" + 3 + 4 )//输出3itheima34
System.out.println(1 + 2 + "itheima" + (3 + 4 ) ); //输出3itheima7
1
2
3

1.2 赋值运算符

1 ）赋值运算符的作用是将一个表达式的值赋值给左边，左边必须时可修改的，不能是常量

2 ）注意：

扩展的赋值运算符隐含了张智类型转换

1.3 自增自减运算符

注意事项：

1. ++ 和 – 既可以放在变量后边，也可以放在变量的前边
2. 单独使用的时候，++和-- 无论放在变量的前边还是后边，结果都一样
3. 参与操作的时候，如果放在变量的后边，先拿变量参与操作，后拿变量做++或者–
4. 参与操作的时候，如果放在变量的前边，先拿变量做++或者–，后拿变量参与操作

常见的用法：单独使用

int i = 10 ;
i++; // 单独使用
System.out.println("i:"+i) // i : 11
    
int j = 10;
++j;  // 单独使用
System.out.println("j:"+i) // j : 11
    
int x = 10;
int y = x++; // 赋值运算，++在后边，所以是使用原来的x赋值给y,x本身自增1
System.out.println("x:"+ x + ", y:"+ y);  //x : 11; y : 10
​
int m = 10;
int n = ++m; // 赋运算，++在后边，所以是使用m自增的值赋值给n,m,本身自增1
System.out.println("m:" + m + ", n:"+ n); // m:11,n:11
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

练习：

int x = 10;
int y = x++ + x++ + x++;
System.out.println(y); // y = 10 +11 +12 ; y : 33
1
2
3

1.4 关系运算符（应用）

关系运算符有6种，分别为：小于，小于等于，大于、大于等于，不等于、等于

注意事项：

1. 关系运算符的结果都是boolean,要么是true,要么是false
2. 千万不要把"“误写成”=", "“是判断是否相等，”="是赋值

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);     //false
System.out.println( a < b);     //true
System.out.println(a <= b);     //true
​
//关系运算符的结果肯定是boolean类型，所以也可以将运算结果赋值给boolean类型的变量
boolean flag = a > b;
System.out.println(flag);
​
1
2
3
4
5
6
7
8
9
10
11
12
13
14

1.5 逻辑运算符

逻辑运算符把各个运算的关系表达式连接起来组成一个复杂的逻辑表达式，以判断程序中的表达式是否成立，判断结果是true或false

//定义变量
int i = 10;
int j = 20;
int k = 30;
​
//& 逻辑与 的关系： 只要表达式中一个为false,结果即为false
System.out.println((i > j) & (i > k));  //false  & false,  输出false
System.out.println((i < j) & (i > k));  //true  & false,  输出false
System.out.println((i > j) & (i < k));  //false  & true,  输出false
System.out.println((i < j) & (i < k));  //true  & true,  输出true
​
//| 逻辑或 的关系： 只要表达式中有一个值为true，结果为true
System.out.println((i > j) & (i > k));  //false  & false,  输出false
System.out.println((i < j) & (i > k));  //true  & false,  输出true
System.out.println((i > j) & (i < k));  //false  & true,  输出true
System.out.println((i < j) & (i < k));  //true  & true,  输出true
​
// ^ 逻辑异或 的关系 ： 相同为false ，不同为 true
System.out.println((i > j) & (i > k));  //false  & false,  输出false
System.out.println((i < j) & (i > k));  //true  & false,  输出true
System.out.println((i > j) & (i < k));  //false  & true,  输出true
System.out.println((i < j) & (i < k));  //true  & true,  输出false
​
// ! 逻辑非 的关系：取反
System.out.println((i>j));  // false
System.out.println(!(i>j));  // false  输出true
​
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

1.6 短路运算符

说明：

1. 在逻辑与运算符中，只要有一个表达式的值为false，nam结果就可以判定为false，没必要将所有表达式的值都计算出来
2. 短路与 运算符 中：一旦发现值为true，右边的表达式将不在参与运算

说说 & 、 | 、&& 、|| 的区别：

1. & ：无论左边真假，右边都要执行
2. && ：如果左边为true,右边执行；如果左边false，右边不执行
3. | ：无论左边真假，右边都要执行
4. || ：如果左边为false，右边执行;如果左边为true，右边不执行

​
//定义变量
int x = 3;
int y = 4;
System.out.println((x++ > 4) & (y++ > 5));  //两个表达式都会运算
System.out.println(x); // x : 4
System.out.println(y); // y : 5
​
System.out.println((x++ > 4) & (y++ > 5));  //左边已经可以确定结果为false，右边不参与运算
System.out.println(x); // x : 4
System.out.println(y); // y : 5
1
2
3
4
5
6
7
8
9
10
11

1.7 三元运算符

1 ）三元运算符语法格式：

 关系表达式 ? 表达式1 : 表达式2;
1

2 ）解释：

1. 问号前面的位置是判断的条件，判断结果为boolean,为true时调用表达式1，为false调用表达式2
2. 其逻辑为：如果条件表达式成立或者满足 执行 表达式1，否则，执行第二个

3 ）举例：

int a = 10;
int b = 20;

// 判断 a > b 是否为true,如果为true 取 a ,如果为false，取 b
int c = a > b ? a : b;    // a > b 为 false 所以 取 b
1
2
3
4
5

2. 数据输入

我们可以通过Scanner类来获取用户的输入，使用步骤如下：

1、导包。Scanner类在java.util包下，所以需要将该类导入。导包的语句需要定义在类上面

import java.util.Scanner
1

2、创建Scanner对象

Scanner input = new Scanner(System.in);
1

3、 接收数据

int i = input.Scanner();
1

4、实例

import java util.Scanner
public class ScannerDemo {
    puiblic static void main(String[] args) {
        //创建键盘输入类
        Scanner input = new Scanner(System.in);
        //接收数据
        int x = input.nextInt();
        //输出数据
        System.out.println("x:" + x);
    }
}
1
2
3
4
5
6
7
8
9
10
11

3. 流程控制语句

在一个程序控制的过程中，各条语句的执行顺序对程序的结果是有直接影响的。所以，我们必须清楚每条语句的执行流程。而且，很多时候要通过控制语句的执行顺序来实现我们想要的功能

3.1 流程控制语句分类

1. 顺序结构
2. 分支结构（if ,switch)
3. 循环结构（for , while , do…while)

3.2 顺序结构

1. 顺序结构是程序中最简单，最基本的流程控制，没有特定的语法结构，按照代码的先后顺序，依次执行，程序中大多数的代码都是这样执行的

3.3 分支结构之 if 语句

1 ）if 语句格式

格式 ：
    if ( 关系表达式 ) {
        语句体；
    }
1
2
3
4

2 ）执行流程：

1. 首先计算关系表达式的值
2. 如果关系表达式的值为true就执行语句体
3. 如果关系表达式的值为false就不执行语句体
4. 继续执行后面的语句内容

3 ）示例

public static void main(String[] args) {
        //定义两个变量
        int a = 10;
        int b = 20;
        //需求：判断a和b的值是否相等
        if (a == b) {
            System.out.println("a 等于 b");
        }

        int c = 10;
        if (a == c) {
            System.out.println("a 等于 c");
        }

        System.out.println("结束");
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

2 ）if语句2

格式：
    if(关系表达式) {
        语句体1;
    }else {
        语句体2;
    }
1
2
3
4
5
6

执行流程：

1. 首先计算关系表达式的值
2. 如果关系表达式的值为true就执行语句体1
3. 如果关系表达式的值为false就执行语句体2
4. 继续执行后面的语句内容

实例：

 public static void main(String[] args) {
        System.out.println("开始");
        //定义变量
        int a = 10;
        int b = 20;
        b = 5;
        
        // 进行判断
        if (a > b) {
            System.out.println("a 的值 大于 b");
        }else {
            System.out.println("a 的值 小于 b");
        }

        System.out.println("结束");
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

if语句格式3

格式：
    if(关系表达式1) {
        语句体1;
    }else if (关系表达式2) {
        语句体2;
    }else {
        语句体3;
    }
1
2
3
4
5
6
7
8

执行流程：

1. 首先计算关系表达式1的值
2. 如果值为true 就执行语句体1；如果值为false 就计算关系表达式2的值
3. 如果值为true 就执行语句体2；如果值为false就计算关系表达式3的值
4. …
5. 如果没有任何关系表达式为true，就执行语句体 n+1

实例：

public static void main(String[] args) {
        System.out.println("开始");
        // 键盘输入类
        Scanner input = new Scanner(System.in);
        System.out.println("请输入一个星期数：");
        int week = input.nextInt();
        if (week == 1) {
            System.out.println("星期一");
        } else if (week == 2) {
            System.out.println("星期二");
        } else if (week == 3) {
            System.out.println("星期三");
        } else if (week == 4) {
            System.out.println("星期四");
        } else if (week == 5) {
            System.out.println("星期五");
        } else if (week == 6) {
            System.out.println("星期六");
        } else {
            System.out.println("星期天");
        }
        System.out.println("结束");
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

🎈看完了不妨给我点个赞吧，👉你的支持，是我每天更新的动力…