✨你好啊，我是“ 罗师傅”，是一名程序猿哦。
🌍主页链接：楚门的世界 - 一个热爱学习和运动的程序猿
☀️博文主更方向为：分享自己的快乐 briup-jp3-ing
❤️一个“不想让我曾没有做好的也成为你的遗憾”的博主。
💪很高兴与你相遇，一起加油！

前言

目标：Java基础编程，熟练Java开发语法和规则，养成良好编程习惯

操作符

操作符：对字面值常量或变量进行操作的符号，也称 运算符 。
表达式：用操作符把字面值常量或变量连接起来的式子（符合Java语法），就
称之为表达式。

1
int a = b + c; // + 运算符  (b+c)表达式

运算符分类

  • 算术运算符
  • 赋值运算符
  • 比较|关系|条件 运算符
  • 逻辑运算符
  • 位运算符

算术运算符

% 求余运算符

1
2
3
4
5
6
7
8
int n = 13 % 5;
System.out.println(n); // 3
n = 13 % -5;
System.out.println(n); // 3
n = -13 % 5;
System.out.println(n); // -3
n = -13 % -5;
System.out.println(n); // -3

结论：求余运算，结果符号只跟左操作数的符号有关

字符串相加

+除了可以作为加法运算符，也可以作为字符串连接符。

字符串 + 其他任意类型数据，得到的结果都是字符串。

自增自减

  • 变量名++，变量名–
  • ++变量名，–变量名

如果单独使用，目的是对变量进行自增或自减，效果相同

1
2
a++; // 效果一样
++a;

如果作为表达式使用，则两者有明显区别：

1
2
3
4
int a = 10;
int b = a++; // 10
a = 10;
int c = ++a; // 11

–自减 的使用方式与自增类似。

面试题

1
2
3
4
5
6
7
// 1
public static void main(String[] args) {
    int x = 4;
    int y = (x--) + (--x) + (x * 10); // 4 + 2 + 2*10 = 26
    System.out.println("x: " + x); // x: 2
    System.out.println("y: " + y); // y: 26
}
1
2
3
4
5
6
7
// 2
public static void main(String[] args) {
    byte b = 10;
    b++;  // b++系统自动实现了（强制转换）即 b = (byte) (b+1)
    b = b + 1; // x b = (byte)(b+1) 需要手动实现
    //问哪句会报错,为什么？
}

赋值运算符

1
2
3
4
5
6
//面试题
short s = 10;
//s = s + 5; //error
s += 5; // 等价于 s = (short)(s+5);
s++; // 等价于 s = (short)(s+5); 系统内部自动强转了
System.out.println("s: " + s);

注意：+=、-=、=、/=、++、– 等扩展的赋值运算符，隐含了强制类型转换！*

比较运算符

逻辑运算符

移位运算符

如果要进行移位操作， 则需要先获取操作数的二进制形式（补码） ，然后按 位进行操作。

右移

  • >> 低位抛弃，高位补【符号位的值】
  • >>> 低位抛弃，高位补0
1
2
3
4
5
6
7
8
9
10
11
12
// 正数 [值]表示被抛弃的值
// 0 0(23) 0000 1010 原=反=补
int a = 10;
System.out.println("a: " + a);
// 0 0(23) 0000 1010
// 00 0(23) 000 0101 [0] ==> 5
int b = a >> 1;
System.out.println("a >> 1: " + b);

// 000 0(23) 0000 10 ==> 2
b = a >> 2;
System.out.println("a >> 2: " + b);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
// 负数
a = -10;
// 获取-10的二进制补码：
// 原 1 0(23) 0000 1010
// 反 1 1(23) 1111 0101
// 补 1 1(23) 1111 0110
// 运算: 111 1(23) 1111 01 [10] 
b = a >> 2; // 高位补1 负
// 结果推导：补 1 1(23) 1111 1101
// - 1
// 反 1 1(23) 1111 1100
// 保留符号位，其他位取反
// 原 1 0(23) 0000 0011
// 结果：-3
System.out.println("-10 >> 2: " + b);

b = a >>> 2;
// -10补： 1 1(23) 1111 0110
// >>> 2位，高位补0
// 00 1 1(23) 1111 01
// 结果: 很大的一个正整数 1073741821
System.out.println("-10 >>> 2: " + b);

左移

  • << 高位抛弃，低位补0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
a = -10;
b = a << 2;
// -10补码：1 1(23) 1111 0110
// 左移2位，结果：
// 1(22) 1111 011000
// 即： 1 1(23) 1101 1000 补码
// -1 得反码： 1 1(23) 1101 0111
// 保留符号位，其他为取反，得原码：
// 原: 1 0(23) 0010 1000 ==> -40
System.out.println("a << 2: " + b); // -40

// 如果左移位数太多，超出了数值表示范围，如何处理？
// 数值 << n 等同 数值 << (n%当前数值类型所占比特位数) 比如int为32位
b = a << 33;
System.out.println("a << 33: " + b); // -20
System.out.println("a << (33%32): " + b); // -20

小结：

  • 每左移1位，等同于 值*2
  • 数值左移n位（>=最高位），等同于数值<<(n%当前值所属类型所占比特位)

位运算符

  • ~ 连通符号位都进行取反

^特殊用法

不使用中间变量得前提下，交换2个变量的值。

1
2
3
4
5
6
7
8
9
10
11
public static void swap(int x, int y) {
    System.out.println(x + " " + y); // 10 11
    // 10 11
    x = x ^ y; // 1010 1011 = 0001
    y = x ^ y; // 0001 1011 = 1010
    x = x ^ y; // 0001 1010 = 1011
    System.out.println(x + " " + y); // 11 10
}
public static void main(String[] args) {
    swap(10, 11);
}

扩展练习

使用位操作符，对变量a（10）进行某一位置0或置1操作。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// 指定位置为 1
public class Test3_SetOne {
    // ⽅法声明如下：
    public static int setBit(int v,int n){
        // 提示：使⽤ | 及 <<
        // 补全代码
        v = v | (1 << (n - 1));
        return v;
    }
    public static void main(String[] args) {
        int r = setBit(10,3);
        System.out.println("r: " + r); // 14
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
// 指定位置为 0 
public class Test4_SetZero {
    // ⽅法声明如下：
    public static int setZero(int v,int n){
        // 提示：使⽤ ~ 及 <<
        // 补全代码
        v = v & ~(1 << (n-1));
        return v;
    }
    public static void main(String[] args) {
        int r = setZero(10,2);
        System.out.println("r: " + r); // 8
    }
}

三目运算符

三目运算符也称条件运算符

格式：

  • （关系表达式）？表达式1 ：表达式2；
  • 关系表达式成立，返回表达式1，否则返回表达式2。
1
2
int max = (a > b) ? a : b;
int min = (a < b) ? a : b;

流程控制

  • 顺序结构
  • 分支结构
    • if语句
    • switch分支语句
  • 循环结构
    • for
    • while
    • do while

顺序结构

if判断

switch分支

1
2
3
4
5
6
7
8
9
10
11
12
13
switch (表达式) { //表达式可以为byte、short、int、char，JDK5加
        入枚举，JDK7加入String
            case 1: //分支入口
        语句体1;
        break;
    case 2: //分支入口
        语句体2;
        break;
        ...
            default:
        语句体n+1;
        break;
}

for循环

while循环

do-while

区别

  • for和while循环先判断条件是否成立，然后决定是否执行循环体（先判断后 执行）
  • do…while先执行一次循环体，然后判断条件是否成立，是否继续执行循环体 （先执行后判断）

break

continue

循环嵌套

label

代码中出现多层循环嵌套，label标签配合break关键字，可以使程序从内部循 环中跳出。

注意：label不是关键字

1
2
3
4
5
6
7
8
9
public static void main(String[] args) {
    lable1:for(int i = 0; i < 3; i++){//外层循环
        lable2:for(int j = 0; j < 5; j++){//内层循环
            if(j == 2){
                break lable1; // 此时可以跳出最外层for循环
            }
        }
    }
}

注意，默认情况下，在嵌套循环中，break和continue只能对当前循环起作用。

Random

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
//第一步，导包
import java.util.Random
public class Test05_Random {
    public static void main(String[] args){
        //第二步，创建对象
        Random r = new Random();
        for(int i = 1; i <= 10; i++){ 
            // nextInt() 默认[0,1)
            // nextInt(n) [0,n)
            //第三步，调用nextInt(max-min+1) + min; 产生随机数
            int num = r.nextInt(20-10+1) + 10; // 10-20 =  [10,21)
            System.out.println(num);
        }
    }
}
  • 注意：获取[min,max]范围随机数的公式如下
  • int number = r.nextInt(max-min+1) + min;

方法

方法（method）: 就是完成特定功能的代码块！ 提高了代码的复用性与可读性

定义

1
2
3
修饰符 返回值类型 方法名(形式参数列表) {
    方法体语句;
}
  • 修饰符：public、static、private、protect、final
  • 返回值类型：根据该方法的具体功能而定
    • 如果方法的作用仅作输出，不需要返回数据，则为void
    • 如果方法需要计算一个结果并返回，则为结果类型（int、double、String等）
  • 方法名
    • 见名知意，方法名的描述性要好
    • 驼峰命名法，如果只有一个单词全小写（小驼峰）
      • 例：display() sum()
    • 如果多个单词构成，则第一个单词全小写，后续单词首字母大写
      • 例：sayHello() getMax() findStudentById()
  • 形式参数列表
    • 根据该方法的具体功能而定
    • 具体案例如下：
      • 计算2个int数的和，则 int getSum(int a, int b)
      • 计算3个数的平均数，则 double getAvg(int x, int y, int z)
      • 遍历一个数组，则 void outArray(int[] array)
  • 方法体语句：方法的具体实现，要根据方法功能书写代码

调用

方法调用格式： 方法名(实际参数列表);

1
int max = getMax(10, 20);

注意事项：

  • 方法必须先定义，再调用
  • 实际参数列表可以是常量，也可以是变量，也可以是表达式
  • 实际参数类型要匹配形式参数类型（要么完全相同，要么能自动隐式类型转换）
  • main方法是入口方法，一个程序中唯一，其可以调用其他普通方法
  • 其他方法不能调用main方法，普通方法可以相互调用

传值调用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public static void swap(int x, int y) {
    System.out.println("交换前，x: " + x + " y: " + y); // 10 20
    x = x ^ y;
    y = x ^ y;
    x = x ^ y;
    System.out.println("交换后，x: " + x + " y: " + y); // 20 10s
}
public static void main(String[] args) {
    int a = 10;
    int b = 20;
    //调用方法
    swap(a,b);
    System.out.println("交换后，a: " + a + " b: " + b); // 10 20
}

思考：为什么a、b两个元素的值没有交换？

重载

方法重载：指同一个类中定义的多个方法之间的关系，如果多个方法要构成重载，则需要同时满足下面条件~

  • 多个方法在同一个类中
  • 多个方法具有相同的方法名
  • 多个方法的参数列表不相同（类型不同或者数量不同）
  • 重载跟函数的返回值类型无关
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public class Test {
    //重载1：求两个int类型数据和的方法
    public static int sum(int a, int b) {
        return a + b;
    }
    //重载2：求两个double类型数据和的方法
    public static double sum(double a, double b) {
        return a + b;
    }
    //重载3：求三个int类型数据和的方法
    public static int sum(int a, int b, int c) {
        return a + b + c;
    }
    public static void main(String[] args) {
        // 调用方法时，Java虚拟机会通过实际参数的不同来区分同名的方法，从而实现精准调用
        int result = sum(10, 20);
        System.out.println(result);
        double result2 = sum(10.0, 20.0);
        System.out.println(result2);
        int result3 = sum(10, 20, 30);
        System.out.println(result3);
    }
}

❤️❤️❤️忙碌的敲代码也不要忘了浪漫鸭！

千淘万浪虽辛苦，吹尽黄沙始到金💪