简介

Java 是由 Sun Microsystems 公司于 1995 年 5 月推出的 Java 面向对象程序设计语言和 Java 平台的总称。由 James Gosling和同事们共同研发，并在 1995 年正式推出。

后来 Sun 公司被 Oracle （甲骨文）公司收购，Java 也随之成为 Oracle 公司的产品。

参考资料

IDEA Mac快捷键

IDEA

快捷键

  • 注：针对 Mac 版本

编辑

  • 末尾添加分号：command+shift+enter
  • 向下插入空行：shift+enter
  • 向上插入空行：command+enter
  • 向下复制当前行：command+d
  • 删除当前行：command+x
  • 批量编辑：option+拖动鼠标左键
  • 向上移动一行：shift+option+UP
  • 向下移动一行：shift+option+Down
  • 格式化代码：command+option+l
  • 运行当前类：Control+shift+r

调试部分、编译

  • 选择 Run：opt+cmd+F10

报错

IDEA 工具报错

git

提交或拉取代码 443
1
2
3
4
5
6
7
8
git config --global --unset http.proxy 
git config --global --unset https.proxy
ssh -T -p 443 git@ssh.github.com
# 进入 ~/.ssh/config 文件（没有的话新建）新增内如下
Host github.com
Hostname ssh.github.com
Port 443
User git

IDEA 使用 git 报错 443

Java 简介

Java 简介

①Java是一门面向对象的通用程序设计语言 ②不依赖特定平台，Write Once,Run Anywhere ③Java一般用作web系统开发，尤其是大型企业级项目 ④编译型和解释型语言，先编译然后在机器上进行解释 ⑤用Java开发的系统的特点：跨平台，安全性高 ⑥Java是一门面向高薪编程的语言

Java 与 Python 的区别

  • Java 是一个编译型和解释型的语言，先编译后解释，Python 是一个解释型语言性能相对 Java 要低（据说 Java 比 python 快 3 倍）
  • Java 是强数据类型，必须要指定数据类型，Python 是可以不定义数据类型

Java 环境校验

需要本地安装 JDK(本系列以 1.8 为例)

1
2
3
4
# 验证 Java 版本
java -version
# Java 编译器校验 java compile
Javac

Java 环境校验

编译和解释 Java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class HelloWord{
	public static void main(String[] args) {
		System.out.print("HelloWord");
	}
}
class Student{
	public static void main(String[] args) {
		System.out.print("Hello 阿达");
	}
}
/*
public:关键字，表示最大权限
class：声明类的关键字
HelloWorld:类名
static:静态，表示一个类的方法
void:空，表示无返回值
main:java程序的主函数（方法）或者说函数
String[ ]args：参数数组
System.out.println：换行打印到控制台的方法
"Hello World":字符串，作为函数的实际参数
*/

编译解释示意图

Java 程序结构

  • Java程序由类构成
    • 一个源程序可以包含多个类定义，最多包含一个public类定义
    • 如果包含了public类定义，文件名必须和public类名保持一致
    • 如果源程序无public类，则可选择任意一个类的名称（推荐）或者一个其他的名称作为文件名

三种情况编译示例图

  • 对Java应用程序来说，必须在其中的一个类中定义有main()方法，包含main()方法的类是该应用程序的主类
  • Java语句包含关键字、标识符、运算符和分隔符等元素。这些元素有着不同的语法含义和组成规则，，它们互相配合，共同组成Java的语句

标识符

  • 什么是标识符
    • Java 中变量、类、方法的名称就叫做标识符
    • 标识符就是自己定义的名称
  • 标识符的命名规则
    • 以字母、下划线或者$符号开头（不要以数字开头或关键字）
    • 后面的字符可以包含字母、数字、下划线和$符号
    • 遵循大驼峰&小驼峰的命名规范（尽量采用类名采用大驼峰、方法和变量采用小驼峰命名规范）
  • Java 严格区分字母大小写

分隔符

  • 分隔符
    • 分割符用来区分源程序中的基本成分，可以使编译器确认代码在何处进行分割
    • 分割符有注释符 空白符 普通分割符
  • 注释符
    • 注释是为了提高程序的可读性、可理解性
    • 注释仅用于阅读源程序，编译时会忽略所有注释
    • 注释符：// 单行注释 /* / 多行代码注释 /* */ 文档注释
  • 空白符
    • 空白符包括空格 回车 换行 制表符（Tab） 等符号
    • 作为程序中各基本成分之间的分割符
    • 各基本成分可以有一个或者多个分隔符
    • 系统编译时空白符同注释一样，最后会被忽略
  • 普通分割符
    • 用于区分程序中的各种基本成分
    • 普通分隔符不能忽略，在程序中有确切的含义
    • 常见的普通分割符
      • . 点：用于分割包、类、引用变量中的变量和方法
      • ; 分号：语句结束标志
      • : 冒号：说明语句符号
      • {} 大括号：定义类体、方法体、复合语句和数组初始化
      • [] 方括号：定义数组类型、引用数字的元素值
      • () 小括号：方法定义、方法访问中将参数括起来，或表达式中定义运算先后次序

变量

概念

  • 变量就是用来存储数据的，一个变量在程序中为一个标识符，在内存中是一块空间，提供了信息和数据临时存放的地方，具有记忆数据的功能
  • 变量是可以被改变的，命名通常用小写字母开头的单词，驼峰命名方式
  • 变量的三个元素：名称、类型和值

变量声明

  • 在 Java 中存储一个数据，必须将其保存在一个变量中，变量在使用前必须有定义，即有确定的类型和名称
  • 定义一个X变量，并赋值 4 给它：在数学中为 x=4
1
2
// Java 中定义变量一般写法
int x = 4 ;
  • 此处 int 是变量类型，在 Java 这门语言中任何数据都是有类型的，所以变量前面需要声明变量的类型
  • 上面这条语句告诉编译器给定义的数据类型和变量名建立一个变量

变量分类

基本数据类型变量

  • Java 中有八大基本数据类型，按照类型来可以分成四类八种
  • 注意事项：整型的字面值默认是int类型，声明 long 类型时后面加 L/l，浮点型的字面值默认是double类型声明 float 类型时后面加 F/f
  • 在同一个作用于中不能有相同的变量名，遵循小驼峰命名规则
类别 数据类型 名称 字节 位长 缺省值 取值范围 举例说明
布尔型 布尔型 boolean 1 1 false true、false boolean b = true;
整型（整数） 字节型 byte 1 8 0 -2^7 - 2^7-1 byte aByte = 10;
~ 短整型 short 2 16 0 -2^15 - 2^15-1 short aShort = 10;
~ 整形 int 4 32 0 -2^31 - 2^31-1 int aInt = 1000;
~ 长整形 long 8 64 0 -2^63 - 2^63-1 long aLong = 10L;
字符型 字符型 char 4 32 ‘\u0000’ ‘\u0000’~’\uffff’ char aChar = ‘c’;
浮点型（小数） 单精度 float 4 32 0.0 -2^31 - 2^31-1 float aFloat = 10.0F;
~ 双精度 double 8 64 0.0 -2^63 - 2^63-1 double aDouble = 10.0;

引用数据类型变量

  • 引用类型（复合类型）的变量它就是指的一个内存地址，一个位置信息（相当于门牌号）
  • 只想的内存中保存着变量所表示的一个值或一组值
  • 引用数据类型分类
    • 数组
    • 类（类类型如String或自定义的类）
    • 接口
    • 枚举

常用数据类型

类
  • 类（类类型如String或自定义的类）
  • 所有引用类型的默认值都是为 null 如果不初始化去引用就会报空指针异常
  • 语法：
1
2
// 定义一个字符串
String aString = "helloword";
  • 字符串类型的变量一般用来存储一串文字信息
  • 字符串可以跟任意类型的数据进行拼接得到新的字符串，拼接符号为【+】例：”hello”+”word” 、”hello”+666
数组

  • 概念：①数组是一种数据结构，它是一个容器，用来盛放数据 ②不同类型的数组可以盛放不同的数据类型

  • 特点：①数组属于引用数据类型，使用的时候需要new 开辟内存空间的 ②数组的容量是确定的，也就是说在定义数组的时候必须指定数组的大小 ③数组的类型是确定的，也就是在定义数组的时候必须声明数组的类型，一种类型的数组只能放一种类型的数据

  • 分类：一维数组，二维数组（Java 中没有二维数组的概念，是从 C中吸取的所以也这么叫了）

  • 语法：

    • 声明是直接开辟内存空间：
    1
    2
    3
    4
    // 语法一：数据类型	数组名称[] = new 数据类型[长度];
    int ages[] = new int[65];
    // 语法二(推荐使用，可读性高一点)：数据类型[] 数组名称 = new 数据类型[长度];
    int[] ages2[] = new int[65];
    • 分布声明：
    1
    2
    3
    4
    5
    6
    7
    /* 
    数据类型	数组名称[] = null;	(声明)
    数组名称 = new 数组类型[长度];	(实例化数组)
    */

    int[]	ages3 = null;
    ages3 = new int[50];
    • 静态声明
    1
    2
    // 创建一个数组，并对内部的元素进行初始化
    int[]	myArr = {0,1,2,3,4};
    • 二维数组：二维数组是一个特殊的一维数组，里面的元素还是一个一维数组，二维数组可以不声明第二维度的长度

    二维数组

运算符

运算符顺序

  • 运算顺序
    • ++ –
    • 括号
    • * / %
    • + -
  • 注意事项
    • 同一优先级运算符顺序为从左至右
    • 运算复杂的时候要一步步拆解运算
  • 建议
    • 不要把一个表达式写的过于复杂，可以分布来写
    • 少使用优先级，可读性差
    • 多使用（）来控制运算顺序

算数运算符

双目运算符

  • 算数运算符：双目运算符 单目运算符 三目运算符
  • 一般的双目算数运算符有： + - * / *(取模)

双目运算符

单目运算符

  • 一般的单目运算符有：++ –

    • 单目运算符,操作数在左边先使用操作数，操作数在右边先运算

    单目运算符

三目运算符

  • 三目运算符

关系运算符

  • 关系运算符又叫比较运算符

  • > < == != >= <=

    关系运算符

逻辑运算符

示例

  • &(逻辑与) &&(短路与) |(逻辑或) ||(短路或) !(逻辑非，取反)
  • 两种写法的结果一致
  • &和&&的区别在于短路与中，当前面的计算就能得到结果时就不会执行后面的逻辑运算，|和||同理
  • & && 当两个同时满足结果才为真 | ||当有一个条件满足结果就为真

&和&&示例

|和||示例

应用场景

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package com.tester.ada.operational;

public class LogicOperatorTester {
    public static void main(String[] args) {
//      登录场景
        String phone = "13888888888";
        String pwd = "123456";
//      登录成功条件：如果手机号长度是 11 位，并且密码长度是 6 位，就登录成功，否则提示账户信息错误
        if(phone.length() == 11 && pwd.length() == 6){
            System.out.println("短路与——>登录成功");
        }else {
            System.out.println("短路与——>账户信息错误");
        }
//      登录成功条件：如果手机号码长度不是 11 位，或者密码长度不是 6 位，提示账户信息错误
        if(phone.length() != 11 || pwd.length() != 6){
            System.out.println("短路或——>账户信息错误");
        }else {
            System.out.println("短路或——>登录成功");
        }
    }
}

应用场景示例

赋值运算符

  • 等于
  • 扩展的赋值运算符：+= -= *= /= %=

赋值运算符

其它运算符

循环控制结构

常见的循环控制结构

  • 任何变成语言的循环控制代码基本都是一样的
    • for
    • while
    • do…while
  • 循环语句
    • 在满足循环条件（布尔表达式）的情况下，反复的执行某段代码（循环体）

循环语句构成

  • 初始化语句：初始化工作，在循环开始前执行
  • 循环条件：布尔表达式，决定否是执行循环体
  • 循环体：循环条件为真时执行的代码块
  • 迭代语句：每次循环结束后，循环条件的变量，在核实的时候把循环条件设置为假，保证循环可以结束，从而避免死循环

while 与 do…while

比较

  • 区别
    • do…while…:先执行循环体，然后再判断循环条件，如果循环条件为真，进行下一次循环，否则终止循环，因此循环体里的代码至少执行一次，因为不管条件满不满足，它是先执行判断条件
    • while:先判断条件，条件为真才执行循环体
  • 注意
    • do…while…:循环的循环条件必须有一个分号，表示循环结束

while语法

1
2
3
while(条件){
  // TODO
};

while示例

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
package com.tester.ada.loopControl;

/**
 * @ClassName  WhileTester
 * @Description while 控制语句
 * @Author ada
 * @Computer Mac mini
 * @Date 2021/12/10 15:13
 */
public class WhileTester {
    public static void main(String[] args) {
        /**
         *  循环控制结构
         * 1:初始化语句：int a = 1; 初始化一个变量，循环需要一个起点
         * 2:循环条件：a <= 100 控制是都要执行循环逻辑（循环体），条件为 true 执行循环，为 false 则结束循环
         * 3:循环体：System.out.println(a); 需要循环去执行的逻辑
         * 4:迭代语句：a++;  改变某些变量的值，让循环条件在适当的时候为假，从而结束循环，避免死循环
         */
        int a = 1;
//        当 a 小于或等于 100 时输出 a
        while (a <= 100) {
            System.out.println(a);  //  当前为死循环，因为变量 A 未发生变化,只要 while 中间的条件值为真就会一直执行循环
            a++;    //让 a 发生变化，使条件语句变为假结束循环
        }
    }
}

do…while…语法

1
2
3
do{
  //TODO
} while(条件);

do…while…示例

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
package com.tester.ada.loopControl;

/**
 * @ClassName DoWhileTester
 * @Description do while 控制语句
 * @Author ada
 * @Computer Mac mini
 * @Date 2021/12/10 15:31
 */
public class DoWhileTester {
    public static void main(String[] args) {
        /**
         *  循环控制结构
         * 1:初始化语句：int a = 1; 初始化一个变量，循环需要一个起点
         * 2:循环条件：a <= 100 控制是都要执行循环逻辑（循环体），条件为 true 执行循环，为 false 则结束循环
         * 3:循环体：System.out.println(a); 需要循环去执行的逻辑
         * 4:迭代语句：a++;  改变某些变量的值，让循环条件在适当的时候为假，从而结束循环，避免死循环
         */
        int a = 1;
//        当 a 小于或等于 100 时输出 a
        do {
            System.out.println(a);
            a++;
        } while (a <= 100);
    }
}

for 循环

简介

  • for 循环是更为简介的循环语句
    • 执行 for 循环时，先执行初始化语句（只执行一次）
    • 执行循环体之前，先计算循环条件的值，如果为真，执行循环体
    • 执行循环体结束，再执行迭代条件
    • for 循环的判断条件比循环体多执行一次
  • 基本语法
1
2
3
for（int i = 1; i<=10; i++）{		//i代表一个整数初始化语句
  System.out.println(i);			 //打印变量 i 每次循环的值
}
  • 语法解释
    • i 代表循环开始的值
    • 第二个表达式“i <= 10”代表的是循环下去的条件，只有满足条件，循环才会继续下去
    • i++ 代表走完一次循环，所以 i 要自增，避免死循环
    • 三个表达式之间用“;”号来进行分割

普通 for 循环

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
28
29
30
package com.tester.ada.loopControl;

/**
 * @ClassName ForLoopTesterBase
 * @Description 基础 for 循环练习
 * @Author ada
 * @Computer Mac mini
 * @Date 2021/12/10 16:23
 */
public class ForLoopTesterBase {
    public static void main(String[] args) {
//        for 求和
        System.out.println("------------------------用 for 循环求 1-100 的和------------------------");
        int sum = 0;
        for (int i = 1; i <= 100; i++) {
            sum = sum + i;
            System.out.println("当i为【" + i + "】时,sum则为【" + sum + "】");
        }
//        while 求和
        System.out.println("------------------------用 while 循环求 1-100 的和------------------------");
        int a = 1;
        int sum2 = 0;
        while (a <= 100) {
            sum2 = sum2 + a;
            System.out.println("当a为【" + a + "】时,sum2则为【" + sum2 + "】");
            a++;
        }
    }

}

增强 for 循环

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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
package com.tester.ada.loopControl;

import java.util.*;

/**
 * @ClassName ForLoopTester
 * @Description for循环
 * @Author ada
 * @Computer Mac mini
 * @Date 2021/12/10 15:37
 */
public class ForLoopTester {
    public static void main(String[] args) {
        /**
         *  循环控制结构
         * 1:初始化语句：int a = 1; 初始化一个变量，循环需要一个起点
         * 2:循环条件：a <= 100 控制是都要执行循环逻辑（循环体），条件为 true 执行循环，为 false 则结束循环
         * 3:循环体：System.out.println(a); 需要循环去执行的逻辑
         * 4:迭代语句：a++;  改变某些变量的值，让循环条件在适当的时候为假，从而结束循环，避免死循环
         */
        /**
         *语法
         * for(初始化语句; 循环条件 ; 迭代语句){
         *      循环体
         * }
         */
        for (int a = 0; a <= 1000; a++) {
            System.out.println(a);
        }
        /**
         * 双重 for
         */
        String[][] allNames = {
                {"ada1", "test1", "base1"},
                {"ada2", "test2", "base2", "git2"},
                {"ada3", "test3", "base3"}
        };
        for (int i = 0; i < allNames.length; i++) {
            String[] names = allNames[i];
            for (int j = 0; j < names.length; j++) {
                String name = names[j];
                System.out.println("数组allNames【" + i + "】【" + j + "】的值为“" + name + "”");
            }
        }
//        JDK1.5增强 for 循环
        /**
         * for(数据类型 变量名 : 遍历的变量){
         *     循环体
         * }
         */
        for (String[] className : allNames
        ) {
            for (String name : className
            ) {
                System.out.println(name);
            }
        }
//      jdk1.8遍历 Map  Lambda 表达式
        Map<String, Integer> items = new HashMap<>();
        items.put("test1", 100);
        items.put("test2", 200);
        items.put("test3", 300);
//      第一种简写式：
        items.forEach((k, v) -> System.out.println("Key1: " + k + " Value1: " + v));
//      第二种判断式：
        items.forEach((k, v) -> {
            System.out.println("Key2: " + k + " Value2: " + v);
            if ("test2".equals(k)) {
                System.out.println(v);
            }
        });
//      jdk1.8遍历 List Lambda 表达式
      List<String> alist = new ArrayList<>();  /* List<String> list= Lists.newArrayList();*/ //两种写法都可以
      alist.add("ada1");
      alist.add("ada2");
      alist.add("ada3");
      alist.add("ada4");
//      语法一
      alist.forEach(item -> System.out.println(item));
//      语法二
      alist.forEach(System.out::println);
//      jdk1.8遍历数组 Lambda 表达式(通过Arrays.asList先转下)
      Integer[] integers = {1, 2, 3};
      Arrays.asList(integers).forEach(integer -> System.out.println(integer));
    }
}

三种循环比较

  • do while 循环次数 = 判断次数
  • while 循环次数 = 判断次数-1
  • for 循环次数 = 判断次数-1
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
28
29
30
31
package com.tester.ada.loopControl;

/**
 * @ClassName CompareTester
 * @Description 流程控制
 * @Author ada
 * @Computer Mac mini
 * @Date 2021/12/10 16:08
 */
public class CompareTester {
    public static void main(String[] args) {
//  do while 循环次数 = 判断次数  当 a 等于 500 先循环输出 a然后判断 a 不小于或等于 100循环结束，判断一次循环一次
        int a = 500;
        do {
            System.out.println(a);
            a++;
        } while (a <= 100);

//  while 循环次数 = 判断次数-1  当 b 等于 200，判断结果不小于或等于直接不进入循环 循环零次，判断一次
        int b = 200;
        while (b <= 100) {
            System.out.println(a);
            b++;
        }

//  for 循环次数 = 判断次数-1   当 i 等于 150，判断结果不小于或等于直接不进入循环 循环零次，判断一次
        for (int i = 150; i <=100 ; i++) {
            System.out.println(i);
        }
    }
}

continue关键字

  • conitue 跳过本次循环(忽略本次循环)
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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
package com.tester.ada.loopControl;

/**
 * @ClassName ConitueTester
 * @Description Conitue 跳过本次循环(忽略本次循环)
 * @Author ada
 * @Computer Mac mini
 * @Date 2021/12/10 16:45
 */
public class ConitueTester {
    public static void main(String[] args) {
        // 求 1-100 所有奇数的和
        System.out.println("------------------------用 for 循环求 1-100 所有奇数的和------------------------");
        int sum = 0;
        for (int i = 1; i <= 100; i++) {
            if (i % 2 == 1) {
                sum = sum + i;
                System.out.println("当i为【" + i + "】时,sum则为【" + sum + "】");
            }

        }
        System.out.println("------------------------用 while 循环求 1-100 所有奇数的和------------------------");
        int a = 1;
        int aSum = 0;
        while (a <= 100) {
            if (a % 2 == 1) {
                aSum = aSum + a;
                System.out.println("当a为【" + a + "】时,aSum则为【" + aSum + "】");
            }
            a++;
        }
        // 求 1-100 的和，如果是偶数跳过
        System.out.println("------------------------用 for 循环求 1-100 的和，如果是偶数跳过------------------------");
        int sum2 = 0;
        for (int j = 1; j <= 100; j++) {
            if (j % 2 == 0) {
                continue;
            }
            sum2 = sum2 + j;
            System.out.println("当j为【" + j + "】时,sum2则为【" + sum2 + "】");
        }

        System.out.println("------------------------用 while 循环求 1-100 的和，如果是偶数跳过------------------------");

        int k = 1;
        int kSum = 0;
        while (k<=100){
            if (k%2==0){
                k++;
                continue;
            }
            kSum=kSum+k;
            System.out.println("当K为【" + k + "】时,kSum2则为【" + kSum + "】");
            k++;
        }
    }
}

break关键字

  • break循环控制语句, 跳出整个循环（结束整个循环）
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
28
29
30
31
32
33
34
package com.tester.ada.loopControl;

/**
 * @ClassName BreakTester
 * @Description break循环控制语句, 跳出整个循环（结束整个循环）
 * @Author ada
 * @Computer Mac mini
 * @Date 2021/12/10 16:50
 */
public class BreakTester {
    public static void main(String[] args) {
//      for  当 a=55 时停止循环  break跳出
        int sum = 0;
        for (int i = 1; i <= 100; i++) {
            if (i == 55) {
                break;
            }
            sum = sum + i;
            System.out.println("当i为【" + i + "】时,sum则为【" + sum + "】");
        }

//      while  当 a=55 时停止循环  break跳出
        int a = 1;
        int aSum = 0;
        while (a <= 100) {
            if (a == 55) {
                break;
            }
            aSum = aSum + a;
            System.out.println("当a为【" + a + "】时,aSum则为【" + aSum + "】");
            a++;
        }
    }
}

条件控制

  • 条件控制语句又叫分支控制结构

常见的条件控制语句

  • if…
1
2
3
if(条件1){
  //如果条件1成立，则执行这里的代码,然后跳出代码块 语法中的条件表达式可以用 & && | || 进行多个条件组合
}
  • if…else if…
1
2
3
4
5
if(条件1){
  //如果条件1成立，则执行这里的代码,然后跳出代码块 语法中的条件表达式可以用 & && | || 进行多个条件组合
}else if(条件2){
  //如果条件2成立，则执行这里的代码,然后跳出代码块 语法中的条件表达式可以用 & && | || 进行多个条件组合
}
  • if…else if…else
1
2
3
4
5
6
7
if(条件1){
  //如果条件1成立，则执行这里的代码,然后跳出代码块 语法中的条件表达式可以用 & && | || 进行多个条件组合
}else if(条件2){
  //如果条件2成立，则执行这里的代码,然后跳出代码块 语法中的条件表达式可以用 & && | || 进行多个条件组合
}else{
  //如果条件1和条件2都不成立，则执行这里的代码,然后跳出代码块
}
  • switch 语句
    • switch有轮换的意思，针对 switch 里的变量a去匹配所有的 case 值，若匹配则执行相关 case 下的代码逻辑
    • case 代表一种情形
    • “:” 冒号表示若复合此种情形，后面就要执行的代码
    • break 有打破的意思，这里表述不再往下执行
    • default 表示若前面的 case 都没有满足条件，将要执行这里的代码
    • 注意事项 switch 语句能够接受的变量类型时有限的，case 常用参数类型为：char byte short int String enum
1
2
3
4
5
6
7
8
9
10
11
switch(变量a){ 
  case A:
    		//TODO
    		break;
 case A:
    		//TODO
    		break;
  default:
    		//TODO
    		break;    
}
  • 三目运算
1
2
3
4
5
6
int adaAge = 20;
int linkAge = 20;
// 三目运算: 条件 ? 条件为真执行 : 否则执行
// 需求:如果 ada 的年龄比 link 的大，输出 ada 是 link 的大哥，否则输出 ada 不是 link 的大哥
String result = adaAge > linkAge ? "1.ada是 link 的大哥" : "2.ada 不是 link 的大哥 ";
System.out.println(result);

if 语法

  • 注意事项 if…else if…else…代码块中至少有一个并且只能有一个 if，可以有多个或零个else if 最多有一个 else 或者零个
  • 语句中只会进入一个分支满足执行完后就会跳出代码块，如示例中的 adaAge > linkAge if 和 else if 都满足，第一个满足后执行完就会跳出整个分支代码块
  • 语法中的条件表达式可以用 & && | || 进行多个条件组合
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
package com.tester.ada.conditionalControl;

/**
 * @author ada
 * @ClassName IfConditional
 * @Description TODO
 * @Computer Macbook pro
 * @Date 2021/12/14 20:39
 */
public class IfConditionalTester {
    public static void main(String[] args) {
        int adaAge = 20;
        int linkAge = 18;
//        逻辑：如果 ada 的年龄比 link 的年龄大输出 ada 是 link 的大哥，否则如果 ada 的年龄比 link 的年龄小输出 link 是 ada 的大哥，否则
        if (adaAge > linkAge) {
            System.out.println("1.ada 是 link 的大哥");
        // 这个else if 条件也是满足的，不过上面的 if 满足了就直接跳出整个代码块了
        } else if (adaAge > linkAge) {
            System.out.println("2.ada 是 link 的大哥");
        } else if (linkAge > adaAge) {
            System.out.println("3.ada 是 link 的大哥");
        } else {
            System.out.println("4.ada 和 link 同岁");
        }
    }
}

if 语法示例

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
28
29
30
31
32
package com.tester.ada.conditionalControl;

/**
 * @author ada
 * @ClassName IfConditionalTester2
 * @Description if 语法练习
 * @Computer Macbook pro
 * @Date 2021/12/14 21:32
 */
public class IfConditionalTester2 {
    public static void main(String[] args) {
        int dayInt = 3;
//        需求：给我一个数字，告诉我今天是星期几
        if (dayInt == 1) {
            System.out.println("今天是星期一");
        } else if (dayInt == 2) {
            System.out.println("今天是星期二");
        } else if (dayInt == 3) {
            System.out.println("今天是星期三");
        } else if (dayInt == 4) {
            System.out.println("今天是星期四");
        } else if (dayInt == 5) {
            System.out.println("今天是星期五");
        } else if (dayInt == 6) {
            System.out.println("今天是星期六");
        } else if (dayInt == 7) {
            System.out.println("今天是星期天");
        } else {
            System.out.println("数值不在范围内");
        }
    }
}

if 语法示例2

switch 语法

switch 语法一

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
28
29
30
31
32
33
34
35
36
37
38
39
package com.tester.ada.conditionalControl;

/**
 * @author ada
 * @ClassName SwitchConditionalTester
 * @Description TODO
 * @Computer Macbook pro
 * @Date 2021/12/14 22:03
 */
public class SwitchConditionalTester {
    public static void main(String[] args) {
        int day = 6;
        switch (day) {
            case 1:
                System.out.println("今天是星期一");
                break;
            case 2:
                System.out.println("今天是星期二");
                break;
            case 3:
                System.out.println("今天是星期三");
                break;
            case 4:
                System.out.println("今天是星期四");
                break;
            case 5:
                System.out.println("今天是星期五");
                break;
            case 6:
                System.out.println("今天是星期六");
                break;
            case 7:
                System.out.println("今天是星期天");
                break;
            default:
                System.out.println("数值不在范围内");
        }
    }
}

switch 示例

switch 语法二

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
28
29
package com.tester.ada.conditionalControl;

/**
 * @author ada
 * @ClassName SwitchConditionalTester
 * @Description TODO
 * @Computer Macbook pro
 * @Date 2021/12/14 22:03
 */
public class SwitchConditionalTester {
    public static void main(String[] args) {
        int day = 5;
        switch (day) {
            case 1:
            case 2:
            case 3:
            case 4:
            case 5:
                System.out.println("今天是工作日");
                break;
            case 6:
            case 7:
                System.out.println("今天是休息日");
                break;
            default:
                System.out.println("数值不在范围内");
        }
    }
}

switch 示例2

case 穿透

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
28
29
30
31
32
33
34
35
package com.tester.ada.conditionalControl;

/**
 * @author ada
 * @ClassName SwitchConditionalTester3
 * @Description TODO
 * @Computer Macbook pro
 * @Date 2021/12/14 22:24
 */
public class SwitchConditionalTester3 {
    public static void main(String[] args) {
        int day = 2;
        switch (day) {
            case 1:
                System.out.println("今天是星期一");
                break;
            case 2:
                System.out.println("今天是星期二"); // 这里没有 break，出现 case 穿透
            case 3:
                System.out.println("今天是星期三");
            case 4:
                System.out.println("今天是星期四");
            case 5:
                System.out.println("今天是星期五");
            case 6:
                System.out.println("今天是星期六");
                break;
            case 7:
                System.out.println("今天是星期天");
                break;
            default:
                System.out.println("数值不在范围内");
        }
    }
}

case 穿透示例

三目运算符

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package com.tester.ada.conditionalControl;

/**
 * @author ada
 * @ClassName ternaryOperatorTester
 * @Description TODO
 * @Computer Macbook pro
 * @Date 2021/12/14 22:38
 */
public class ternaryOperatorTester {
    public static void main(String[] args) {
        int adaAge = 20;
        int linkAge = 20;
//        三目运算: 条件 ? 条件为真执行 : 否则执行
//        需求:如果 ada 的年龄比 link 的大，输出 ada 是 link 的大哥，否则输出 ada 不是 link 的大哥
        String result = adaAge > linkAge ? "1.ada是 link 的大哥" : "2.ada 不是 link 的大哥 ";
        System.out.println(result);
    }
}

三目运算符示例

变量的定义

变量的分类

  • 按数据类型

    • 基本数据类型，四类八种
    • 引用数据类型（复合数据类型）：String、数组

  • 按数据范围

    • 局部变量1：方法体中定义的变量，作用域从定义处到代码块的第一个}
    • 局部变量2：形式参数（形参），作用在整个方法
    • 局部变量3：代码块内的，在一个方法中有定义了一个代码块，{方法中的代码块}，这里的局部变量只能在定义处到代码块结束前
    • 全局变量：在类中定义，也叫做成员变量、类属性、实体，作用域在定义处到类结束 静态的属性只能被静态的方法调用
    • 全局变量的特点
      • 有修饰符（public protected 默认修饰符 private）
      • 在函数外部
      • 作用域为整个类，随类或对象消亡时消亡
    访问位置 private 默认修饰符 protected public
    定义的类中 √ √ √ √
    同一个包中 × √ √ √
    子类中 × × √ √
    其它包中 × × × √

    访问权限示例

  • 注意事项：①局部变量必须被初始化 ②局部变量没有修饰符 ③全局变量可以不初始化，值为默认值（缺省值）④全局变量或对象没有初始化然后还去调用它的方法或属性会报空指针异常 比如一个 String aStr 类型的全局变量没有初始化，还去调用 aStr.length（）就会报空指针异常一个变量或对象还没初始化（已经为 null 了），就没有指向任何一块空间，这个时候你还要去访问它的属性或方法就要报空指针异常 ⑤如果局部变量和全局变量重名了，会采取就近原则访问局部变量，如果要访问全局变量用加用 ClassName.varName（建议一个类中不要去定义重名的变量名称，阅读性差）

空指针异常

变量定义及范围

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
28
29
30
package com.tester.ada.variable;

import java.util.stream.BaseStream;

/**
 * @author ada
 * @ClassName VariableTester
 * @Description TODO
 * @Computer Macbook pro
 * @Date 2021/12/15 21:52
 */
public class VariableTester {
    static String aStr = "类中的静态全局变量";
    String dStr = "类中的全局变量";
    public static void main(String[] args) {
        String bStr = "main方法中的局部变量";
        System.out.println(bStr);
        System.out.println(aStr);
        System.out.println(cStr);   // cStr 是 myFunction 中的局部变量，无法使用
        System.out.println(dStr);   // dStr 是类中的全局变量，无法在静态方法中使用非静态变量
    }

    public void myFunction() {
        String cStr = "myFunction 中的局部变量";
        System.out.println(cStr);
        System.out.println(bStr);   // bStr 是 main 方法中的局部变量，无法使用
        System.out.println(aStr);
        System.out.println(dStr);
    }
}

变量定义示例