1.常用CMD命令#

2.环境变量#

在软件启动包所在目录下输入软件启动包的名字如idea64.exe就可以启动idea软件。

如果想要在CMD的任意目录下，都可以启动某一个软件，那么就可以把这个软件的路径配置到环境变量中的PATH里面：

1. 右键我的电脑，选择属性

2. 点击左侧的高级系统设置

3. 选择高级，再点击下面的环境变量

4. 找系统变量里面的PATH

5. 把软件的完整路径，配置到Path当中就可以了

6. 就是把自己配置的路径，移动到最上面（可做可不做）

在CMD中打开软件时，会先找当前路径，再找环境变量，在环境变量中是从上往下依次查找的，如果路径放在最上面查找的速度比较快。

3.Java概述#

4.HelloWorld小案例#

1. 创建一个文件HelloWorld.java文件：

1
public class HelloWorld {
2
        public static void main(String[] args) {
3
                System.out.println("HelloWorld");
4
        }
5
}

1. 在所在目录下打开cmd窗口

2. 运行指令javac HelloWorld.java和java HelloWorld

   • javac + 文件名 + 后缀名 （就是编译java文件，编译后会产生一个.class文件）

   • java + 文件名（运行编译之后的class文件）

注意：

执行javac和java指令需要先配置环境变量：

①JAVA_HOME：告诉操作系统JDK安装在了哪个位置（未来其他技术要通过这个找JDK）

②Path：告诉操作系统JDK提供的javac(编译)、java(执行)命令安装到了哪个位置

5.Java语言的发展#

Java有很多版本，其中三个最重要的版本：

• Java5.0：这是Java的第一个大版本更新。

• Java8.0：这个是目前绝大数公司正在使用的版本。因为这个版本最为稳定。

• Java15.0：这个是我们课程中学习的版本。

高版本的Java完全兼容低版本的Java，但是低版本的Java不一定兼容高版本的Java。

Java的三大平台：

JavaSE：其他两个版本的基础

JavaME：Java语言的小型版，用于嵌入式消费类电子设备或者小型移动设备的开发。

JavaEE：用于Web方向的网站开发。（主要从事后台服务器的开发）

6.Java语言跨平台的原理#

• 操作系统本身其实是不认识Java语言的。

• 但是针对于不同的操作系统，Java提供了不同的虚拟机。

虚拟机会把Java语言翻译成操作系统能看得懂的语言。

1.注释#

1. 单行注释

1
// 这是单行注释文字

2. 多行注释

1
/*
2
这是多行注释文字
3
这是多行注释文字
4
这是多行注释文字
5
*/

3. 文档注释

1
/**
2
 * @author 黑马程序员
3
 * @version v1.0
4
 */

注意：多行注释不能嵌套多行注释，但是可以嵌套单行注释。

2.数据类型#

java的数据类型分为基本数据类型和引用数据类型。

四类八种基本数据类型：

注意点：

• byte的范围：-128~127

• 整数类型和小数类型的取值范围大小关系：double > float > long > int > short > byte

• 如果要定义一个long类型的变量，那么在数据值的后面需要加上L后缀（大小写都可以，建议大写）

• 如果要定义一个float类型的变量，那么在数据值的后面需要加上F后缀（大小写都可以）

数据类型的选择：

• 如果要定义 一个整数类型的变量，不知道选择哪种数据类型了，默认使用int

• 如果要定义 一个小数类型的变量，不知道选择哪种数据类型了，默认使用double

• 如果要定义一个long类型的变量，那么在数据值的后面需要加上L后缀（大小写都可以，建议大写。）

• 如果要定义一个float类型的变量，那么在数据值的后面需要加上F后缀（大小写都可以）

3.标识符#

4.键盘录入#

1.导包：找到类所在位置

1
import java.util.Scanner;

2.创建对象

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

3.接收数据：以接受整数为例

1
int inputStr = sc.nextInt();

5.IntelliJ IDEA#

IntelliJ IDEA是Java语言开发的集成环境，它把代码的编写，编译，执行，调试等多种功能综合到一起，从而简化开发流程。

1.算数运算符#

1
+ - * :跟小学数学中一模一样没有任何区别；
2

3
/：整数相除结果只能得到商，如果结果想要小数，必须要有小数参与运算（一个或两个）。
4

5
%：取模、取余。只能对整数操作，取两个数相除的余数。

技巧：

1. 判断整数a是否是偶数：

a%2，结果为0表示a是偶数，结果是1表示a是奇数。

2. 获取任意一个整数a上每一位数：

个位：a % 10

十位：a / 10 % 10

百位：a / 100 % 10

千位：a / 1000 % 10

…以此类推

2.自增自减运算符#

1
++  自增运算符
2
--  自减运算符

a++和++a的区别：

1
a++是先使用a，再进行++运算。
2
++a是先进行++运算，再使用a。

3.扩展赋值运算符#

+=、-=、*=、/=、%=

就是把左边跟右边进行运算，把最终的结果赋值给左边，对右边没有任何影响。

注意点：

扩展的赋值运算符中隐层还包含了一个强制转换，比如 a += b ;实际上相当于 a = (byte)(a + b);

4.关系运算符#

关系运算符最终的结果一定是布尔类型的，结果要么是true，要么是false。

5.逻辑运算符#

&：逻辑与（而且），两边都为真，结果才是真，只要有一个为假，那么结果就是假。

|：逻辑或（或者），两边都为假，结果才是假，只要有一个为真，那么结果就是真。

^：异或，如果两边相同，结果为false，如果两边不同，结果为true。

！：取反，false取反就是true，true取反就是false。

6.短路逻辑运算符#

分类： && ||

当左边不能确定整个表达式的结果，右边才会执行。

当左边能确定整个表达式的结果，那么右边就不会执行了。从而提高了代码的运行效率。

7.三元运算符#

格式：关系表达式 ？ 表达式1 ：表达式2

三元运算符的最终结果一定要被使用，要么赋值给一个变量，要么直接打印出来。

8.隐式转换#

自动类型提升，即把一个取值范围小的数据或者变量，赋值给另一个取值范围大的变量。此时不需要我们额外写代码单独实现，是程序自动帮我们完成的。例如long a = 10;，int型常量10自动转换成long型赋值给变量a。

两种提升规则：

• 取值范围小的，和取值范围大的进行运算，小的会先提升为大的，再进行运算

• byte、short、char三种类型的数据在运算的时候，都会直接先提升为int，然后再进行运算

• 取值范围从小到大的关系：byte < short < int < long < float < double

9.强制转换#

如果要把一个取值范围大的数据或者变量赋值给另一个取值范围小的变量。是不允许直接操作，需要用到强制类型转换。

语法：

1
目标数据类型 变量名 = （目标数据类型）被强转的数据；
2

3
例如：double a = 12.3;
4
     int b = (int) a;

注意：强制转换有可能会导致数据发生错误。（数据的精度丢失）

10.字符串相关操作#

字符串的+操作：如果加操作出现了字符串，那么后面的加都会拼接成一个字符串（字符串加操作之前的加不受影响）。例如1 + 2 + "abc" + 2 + 1，结果为3abc21。

字符的+操作：当+操作中出现了字符，会拿着字符到计算机内置的ASCII码表中去查对应的数字，然后再进行计算。例如'a' + 1的结果为98。

11.原码、反码和补码#

12.位运算符#

• 这些运算符都是针对补码操作的

• 左移一次相当于乘2，右移一次相当于除2

13.运算符的优先级#

在Java中涉及了很多的运算符，每一种运算符都有各自的优先级。但是这些优先级不需要记忆，只要知道小括号优先于所有即可。

1.顺序结构#

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

2.判断和选择结构#

1
if (关系表达式) {
2
    语句体;
3
}

1
int a = 100; //相当于两条语句：1.定义变量a 2.给变量a赋值为100

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

1
if (关系表达式1) {
2
    语句体1;
3
} else if (关系表达式2) {
4
    语句体2;
5
}
6
…
7
else {
8
    语句体n+1;
9
}

1
格式：
2
switch (表达式) {
3
        case 1:
4
                语句体1;
5
                break;
6
        case 2:
7
                语句体2;
8
                break;
9
        ...
10
        default:
11
                语句体n+1;
12
                break;
13
}

1
//输出2 3 4 -1
2
public static void main(String[] args) {
3
        int a = 2;
4
        switch (a) {
5
            case 1:
6
                System.out.println(1);
7
                break;
8
            case 2:
9
                System.out.println(2);
10
            case 3:
11
                System.out.println(3);
12
            case 4:
13
                System.out.println(4);
14
            default:
15
                System.out.println(-1);
16
                break;
17
        }
18
    }

1
// -> 自带break
2
switch (week) {
3
    case 1, 2, 3, 4, 5 -> System.out.println("工作日");
4
    case 6, 7 -> System.out.println("休息日");
5
    default -> System.out.println("没有这个星期");
6
}

3.循环结构#

1
for (初始化语句;条件判断语句;条件控制语句) {
2
        循环体语句;
3
}

1
public class ForTest02 {
2
    public static void main(String[] args) {
3
                //存放求和结果
4
                int sum = 0;
5
                for(int i=1; i<=5; i++) {
6
                        sum = sum + i; //累加
7
                }
8
                //打印求和结果
9
                System.out.println("1-5之间的数据和是：" + sum);
10
    }
11
}

1
while(条件判断语句){
2
        循环体;
3
        条件控制语句;
4
}

1
int height = 8844430; //珠穆朗玛峰高度
2
double paper = 0.1; //纸张厚度
3

4
int count = 0; //计数器，统计折叠次数
5

6
while(paper < height){
7
    //折叠纸张
8
    paper = paper * 2;
9
    count++;
10
}
11

12
//4.打印一下纸张的厚度
13
System.out.println(count);//27

1
do{
2
    循环体;
3
    条件控制语句;
4
}while(条件判断语句);

1
for(;;){
2
    System.out.println("循环执行一直在打印内容");
3
}

1
while(true){
2
    System.out.println("循环执行一直在打印内容");
3
}

1
do{
2
    System.out.println("循环执行一直在打印内容");
3
}while(true);

1
Scanner sc = new Scanner(System.in);
2
int number;
3
loop: //为循环起别名loop
4
    while (true) {
5
        System.out.println("请输入一个数字(0结束循环)：");
6
        number = sc.nextInt();
7
        switch (number) {
8
            case 0:
9
                break loop; //输入0结束死循环loop
10
            case 1:
11
                System.out.println("一");
12
                break; //跳出switch语句
13
            case 2:
14
                System.out.println("二");
15
                break; //跳出switch语句
16
            case 3:
17
                System.out.println("三");
18
                break; //跳出switch语句
19
            default:
20
                System.out.println("输入数字太大");
21
                break; //跳出switch语句
22
        }
23
    }

4.Random#

Random类是实现随机数生成的。

1. 导包

1
import java.util.Random;
2
导包的动作必须出现在类定义的上边。

2. 创建对象

1
Random r = new Random ();
2
上面这个格式里面，只有r是变量名，可以变，其他的都不允许变。

3. 生成随机数

1
int number = r.nextInt(随机数的范围);
2
上面这个格式里面，只有number是变量名，可以变，其他的都不允许变。
3
随机数范围的特点：从0开始，不包含指定值。比如：参数为10，生成的范围[0,10)
4
技巧：[a,b]表示为r.nextInt(b - a + 1) + a

1.一维数组#

1
数据类型[] 数组名
2

3
例如：
4
int[] array

1
数据类型  数组名[]
2

3
例如：
4
int array[]

1
数据类型[] 数组名 = new 数据类型[]{元素1，元素2，元素3，元素4...};
2

3
例如：
4
int[] arr = new int[]{11,22,33};

1
数据类型[] 数组名 = {元素1，元素2，元素3，元素4...};
2

3
例如：
4
int[] array = {1,2,3,4,5};

1
数据类型[] 数组名 = new 数据类型[数组的长度];
2

3
例如：
4
int[] agesArr = new int[3];

1
int[] arr = {1,2,3,4,5};
2
System.out.println(arr);//[I@6d03e736

1
数组名[索引];

1
for(int i = 0; i < arr.length; i++){
2
    //在循环的过程中，i依次表示数组中的每一个索引
3
    System.out.println(arr[i]);//就可以把数组里面的每一个元素都获取出来，并打印在控制台上了。
4
}

2.二维数组#

二维数组的本质还是一维数组，只是数组的每一个元素是一个一维数组的地址值，而二维数组也是一个地址值。

二维数组的操作和一维数组很类似，但也有不同，这里只介绍不同地方。

1
数据类型[][] 数组名 = new 数据类型[][]{{元素1, 元素2, ...},{元素1, 元素2, ...},...}
2

3
例如：
4
int[][] arr=new int[][]{{11, 22},{33, 44, 55}}

1
数据类型[][] 数组名 = {{元素1, 元素2, ...},{元素1, 元素2, ...},...}
2

3
例如：
4
int[][] arr={{11, 22},{33, 44, 55}}

1
数据类型[][] 数组名 = new 数据类型[m][n];
2

3
例如：
4
int[][] arr=new int[2][3]

1
arr[0]可以获取二维数组arr中的第一个一维数组，本身是一个地址。
2

3
arr[0][0]可以获取二维数组arr中的第一个一维数组中的第一个元素，本身是一个值。

1
int[][] arr = {{1, 2, 3}, {5, 6, 7, 8}};
2
for (int i = 0; i < arr.length; i++) {
3
    for (int j = 0; j < arr[i].length; j++) {
4
        System.out.println(arr[i][j]);
5
    }
6
}

1.方法的定义与调用#

1
public static void 方法名 () {
2
        // 方法体;
3
}
4

5
例如：
6
public static void method () {
7
        System.out.println("我是一个method方法");
8
}

1
方法名();
2

3
例如：
4
method();

1
public static void 方法名 (参数1) {
2
        方法体;
3
}
4
public static void 方法名 (参数1, 参数2, 参数3...) {
5
        方法体;
6
}
7

8
例如：
9
public static void isEvenNumber(int number){
10
    ...
11
}
12
public static void getMax(int num1, int num2){
13
    ...
14
}

1
方法名(参数)；
2
方法名(参数1,参数2);
3

4
例如：
5
isEvenNumber(10);
6
getMax(10,20);

1
public static 数据类型 方法名 ( 参数 ) {
2
        return 数据 ;
3
}
4

5
例如：
6
public static boolean isEvenNumber( int number ) {
7
        return true ;
8
}
9
public static int getMax( int a, int b ) {
10
        return a > b ? a : b;
11
}

1
方法名 ( 参数 ) ;
2
数据类型 变量名 = 方法名 ( 参数 ) ;
3

4
例如：
5
isEvenNumber ( 5 ) ;
6
boolean  flag =  isEvenNumber ( 5 );

1
public static 返回值类型 方法名(参数) {
2
   方法体;
3
   return 数据 ;
4
}

2.方法重载#

方法重载概念：方法重载指同一个类中定义的多个方法之间的关系，满足下列条件的多个方法相互构成重载：

1. 多个方法在同一个类中

2. 多个方法具有相同的方法名

3. 多个方法的参数不相同，即类型不同、数量不同或顺序不同

注意事项：

• 重载仅对应方法的定义，与方法的调用无关

• 重载仅针对同一个类中方法的名称和参数（形参），而和返回值无关（返回值可以不同）

例如<下面的两个> compare 方法同名、参数类型不同,就构成了重载

1
//int
2
public static boolean compare(int a, int b) {
3
    System.out.println("int");
4
    return a > b;
5
}
6

7
//long
8
public static boolean compare(long a, long b) {
9
    System.out.println("long");
10
    return a > b;
11
}

一图流回顾#

六章一句话#

最容易踩的几个坑#

两条值得记住的规律#