Java基础

Java基础
环境

并非所有的计算机都可以开发java程序，java程序的开发与运行需要专门的环境。

因为java语言的程序是运行在java所专有的系统中。
- 要运行java程序我们需要在操作系统（windows，MACOS，Linux）安装jre（Java Runtime Environment，简称JRE）。
- 要编译（开发）java程序，我们就需要安装JDK（Java Development Kit）。
jre和JDK都是一个软件，jre这个软件可以运行java编译后的程序。JDK中包含了JRE，JDK中不止有JRE还有java程序的编译软件。我们作为java程序员，只要安装JDK即可。

[1]安装JDK

关键的步骤:

安装完成之后，会在安装的目录中产生一个文件夹：

java目录中有一个JDK和JRE，查看JDK的目录下的内容：

[2]配置环境变量

我们要使用 java -version 查看当前的JDK的版本。

打开命令窗口：

①在运行中输入CMD，回车。

②按键盘上的win键+R键。

所有的命令窗口默认都是在C盘，

我们需要连接几个简单dos命令。
- 盘符切换 : 进入任何和一个盘符，都是使用 盘符名称: 比如 : D :
- 进入某一个目录： cd 目录名称
我们要执行java命令，就要进入jdk的bin目录。

因为命令本身也是一段程序，所有要运行这个命令，必须能找到这个命令，所以我们要进入JDK的bin目录才能执行java的命令。

我们不可能每次执行java程序都要进入这个bin目录，所以要配置环境变量，环境变量的作用就是让操作系统可以在任何位置都能找到java的命令。

配置环境变量开始：

新建用户变量或者系统变量

修改PATH变量

新建编辑环境变量

测试运行环境和编译环境的版本：

java语言的介绍
- java语言是所有的面向对象语言的带头大哥。
- java语言是目前位置跨平台做的最好的一门语言。
java语言的运行

第一个java程序：

在任何位置创建一个记事本文件，后缀修改为 .java

我这里的命名是 Hello.java

在其中编写如下内容：
```
 public class Hello{
     public static void main(String []args){
         System.out.println("Hello Java!");
     }
 }
```
保存文件之后，在文件所在的目录进行编译。使用命令 javac 文件名， 运行字节码文件 : java

Hello

第一个java程序的几个问题：
- 源文件的后缀必须是.java
- 源文件的名字最好是英文，所有的单词的首字母最好大写。
- 程序中的类名和文件名必须完全一致
- java语言是严格区分大小写的，所以该大写的字母一定要大写。
- 所有的标点符号必须是英文状态输入。
- 每一句程序结束了必须使用“;”结尾。
java程序的运行过程

java程序三步走：

①编写源程序。所谓源程序就是我们编写的.java文件。里面的内容是程序员看得懂。

②编译远程。使用 javac 命令将源程序编译成字节码文件(.class文件)。java程序是运行在JVM上的，JVM只认识字节码文件。

③执行java字节码文件。使用 java 命令执行java字节码文件。

JVM

JVM本身是一个软件，在jre中就有JVM。

这台电脑使用的JVM是：

java语言一个非常重要的特性就是 跨平台 。

所谓 跨平台 ，就是我们在任何一个操作系统中将java源程序编译成字节码文件，然后这个字节码文件可以在任何其他的操作系统中正常运行。

java语言如何跨平台：

java语言跨平台就是通过JVM实现，java程序是运行在JVM上的，和操作系统本身是没关系。JVM就像一个花盆，java程序就好像花盆中的一颗植物。这棵植物只关心花盆，不关心花盆在哪里。

不同的操作系统上有不同的JVM。这个写JVM对java程序的解释是一样的。

所以Oracle为每一个不同的操作系统都提供了专门的JVM。我们现在所说的JVM只是一个规范（标准）。

目前市面上最流行的JVM就是HotSpot。就是全是的java的解释器就只有HotSpot。这就是它规范的原因。

开发工具

java程序的开发工具：

常见的开发工具：记事本、eclipse（免费的）、IDEA（可以试用一个月）、NetBeans........

java语法语法基础

Hello程序的说明

我们的第一个java程序：
```
 public class Hello {
     public static void main(String[] args) {
         System.out.println("Hello  Java!");
     }
 }
```
java程序的最小阻止单元是"类" (class)。

在java文件中（.java结尾）编写java类。

在Hello.java文件中的写法：

public class Hello 是固定写法。这里Hello称之为类名，类名必须和文件名完全一致。public和class 是固定的关键字。类中的程序要写在一对 {}

上面类中的:
```
     public static void main(String[] args) {
         System.out.println("Hello  Java!");
     }
```
称之为主函数，主函数的签名： public static void main(String[] args) 固定写法！！！。

主函数中要执行的程序要写在一对 {} 中。我们目前写的就是在控制台输出“Hello Java”。

基本结构：

类和主函数之间，主函数和要执行的程序之间都是有缩进的。这个缩进是一个制表符。任何一个结构的开始的 { 都是在语句的后面，结束的"}"都是在下面的。

数据类型

为什么要有数据类型？

我们认知周边的事物就是分类识别，同样计算机要处理数据，也是分类处理数据，所有就有了数据类型。

java中的数据类型：

java中的8中基本数据类型：
- byte 字节型。在内存中占8个bit。表示范围是 -128 ~127
- shrot 短整型。在内中占2个字节。16个bit。 -32768 ~ 32767
- int 整形。在内存中占4个字节。 32个bit。-2147483648 ~ 2147483647
- long 长整型。在内存中占8个字节。64个bit。-9223372036854775808 ~ 9223372036854775806
- float 浮点型。在内存中占4个字节。32个bit。1.4E-45 ~ 3.4028235E38
- double双精度型。在内存中占8个字节。64个bit。4.9E-324 ~ 1.7976931348623157E308
- char字符型。表示"一个"字符。在内存中占2个字节。16个bit。 0~ 65535
- boolean布尔型。表示true或者false。在内存中理论上占一个bit位。在java中boolean的值只有true和false。
特殊的引用类型：String 表示字符串。多个字符：“Hello”。

变量

变量是存储数据的最小单元。

java语言是强数据类类型，申明变量的时候必须注名变量要存储的数据类型。申请之后，变量的类型不能随意改变。

申请变量的语法：
```
 数据类型  变量名；
```
给变量赋值依然是使用赋值运算符 = :
```
 变量名 = 变量的值 ;
 //申请的同时赋值
 数据类型 变量名 = 变量的值；
```
使用变量的时候，直接使用变量的名称即可。

案例：
```
 public class Demo1 {
     public static void main(String [] args){
         // 申请变量
         int age;
         // 给变量赋值(不同数据类型，赋值方式不一样)
         age = 18; // 整形直接写数字即可。
         // 申请的同时赋值
         double score = 86.9; // double类型的直接写数字即可。
         // 使用变量输出这两个变量值
         System.out.println(age);
         System.out.println(score);
     }
 }
```
不同类型的变量的赋值方式：
```
 // 不同类型的变量的赋值方式
 // byte类型， 数字，注意范围不要超过byte的范围
 byte b = 127;
 // short，数字，主要范围不要超过short范围
 short s = 32000;
 // int类型 数字，主要范围不要超过int范围
 int i = 65432656;
 // long类型，数字，注意如果数字超过了int的范围，则需要使用"L/l"表示当前数字是长整型
 long l = 2111111111111110L;
 // 字符型  单个字符，必须使用单引号包裹
 char ch = '男';
 // 浮点型 如果赋值是小数，必须有后缀"F/f"。
 float f = 12.0F;
 // 双精度型  数字，直接写。  可以在后面使用"D/d"。
 double d = 12.5;
 // boolean类型。  在java中boolean只有true或者false。
 boolean flag = true;
 
 // 非基本类型的String  类型的名字是String，赋值要使用双引号
 String name = "旗木卡卡西";
```
命名规则和规范

类名，变量名的命名规则：（绝对不能触犯）
- 不能以数字开头
- 不能有特殊符号
- 不能是java的关键字或者保留字符。
类名，变量名的命名规范：
- 所有类名单词的首字母必须大写 Demo
- 所有的变量名第一个单词全部小写，其余单词的首字母必须大写 firsrName
- 如果是缩写，类名则全部大写，变量名则全部小写
- 言简意赅。
- 尽量使用英文单词，如果是拼音，不允许使用拼音和英文的混合。千万不要使用拼音缩写。更不要使用中文。
数据类型转换

所谓数据类型转换，就是各种不同的数据类型之间的转换。

问题：不同的数据类型在内存中的所占的bit位是不一样的。那么数字 10 在内存中占多少bit位？

理论上数字10只需要4个bit位（1010）。但是数字10有不同的类型：
```
 byte b  = 10;
 short s = 10;
 int i = 10;
 long l = 10;
 float f = 10;
 double d = 10;
```
上面的定义在内存中的情况：

任何一个类型在无论数值多大，在内存中占的位置大小是固定的。

我们将任何一个byte类型的数据直接赋值给int类型，是否行得通？
```
byte x = ???;
int i = x;
```
其实就是任何小的类型到大的类型都是自动转换的。

还有一个特殊的情况就是： char可以自动转换为int。

看图记忆：

几个问题：

给长整型赋值：

当我们写任何整形数字的时候

，如果没有任何修饰（后缀）。这个数字默认是int类型。

如果是将这个数字赋值给byte或者short，则默认会转换为对应的类型，当然范围必须在对应的类型的范围内。
```
byte x = 10;
short s = 100;
```
但是如果将整形数字赋值给长整型变量，这个数字则默认就是整形的。如果超过了整形的范围，就会报错，必须使用"L"标明是长整型。
```
long l = 21111111110L;
```
给float赋值：
```
float f = 12.5;
```
所有的小数在默认情况下都是double。所以当给float的变量赋值小数的时候，必须使用"F"后缀。

小的类型到大的类型是自动转换的，那么大类型能否转换小类型。

计算机认为将int转换为short的时候，空间放不下，可能会丢失数据。我们知道不会丢失，所以我们可以强制转换。

语法：[目标类型就是我们要转换成的类型，源数据就是原始的数据]
```
目标类型 变量名  =  （目标类型）源数据。
```
```
int x = 10;
        // 强制类型转换
        short s2 = (short)x;
```
上面的案例中是没有数据丢失的。
```
double d = 12.5;
// 强制类型转换
int a = (int)d;
System.out.println(a);
```
上面的强制类型转换会导致小数部分直接被丢弃。

基本类型和字符串之间的转换

任何类型转换为字符串都可以使用 : xxxx + ""

字符串转换为其他类型：

[1]字符串转换为整形

前提是字符串必须是整数形式的字符串，比如： "128","369"。

操作语法：
```
String age = "20";
// 使用Integer.parseInt(str) 将字符串转换为数字
int age_ = Integer.parseInt(age);
System.out.println(age_);
```
如果字符串格式不争取，则会报错：

[2]转换为Float或者Double或者Short或者byte或者......
```
String str = "10";
byte b1 = Byte.parseByte(str);
short s3 = Short.parseShort(str);
long ll = Long.parseLong(str);
float f1 = Float.parseFloat(str);
double d1 = Double.parseDouble(str);
// 取出字符串中的某一个字符， 其中0就索引。
char ch = str.charAt(0);
String bstr = "false";
boolean flag = Boolean.parseBoolean(bstr);
```
语句

控制台的输出语句，纯粹的为了方便我们学习，在实际工作中，几乎没啥用。

固定的语法：

java会议室管理系统

zip 0星超过10%的资源 11KB

下载
```
System.out.print();// 输出不换行
System.out.println();// 输出且换行
```
```
// 直接输出一个字符串，并且换行
System.out.println("今天天气不太好！");
System.out.println("的确不太好");
// 输出字符串，但是不换行
System.out.print("这是第一行，");
System.out.print("还是第一行");
System.out.println();// 输出一个空的换行
// 可以输出任何类型的数据
System.out.println('帅');
System.out.println(15);
System.out.println(15L);
System.out.println(12.5);
System.out.println(true);
// 可以在（）中使用“+”连接任何类型和字符串
System.out.println("小明的名字是:" + "小明");
System.out.println("小明的成绩是：" + 89);
// 如果是两个数字，”+“可能会出现数学运算
System.out.println(5+6);
// 任何变量都不需要双引号，可以直接输出或者使用"+"连接
String name = "旗木卡卡西";
int age = 28;
System.out.println(name + "的年龄是" + age);
int x = 3;int y = 4;
int temp = x ;
x = y;
y = temp;
System.out.println("x = " + x);
System.out.println("y = " + y);
```
在输出语句中还有一些特殊的符号

在字符串中可以使用 \n 表示换行。可以使用 \t 表示一个制表符。可以使用 \\ 表示一个 \

看案例：
```
// \n表示换行
        System.out.println("你好！\n 今天天气不错!");
        System.out.println("张三\t李四\t王五");
        System.out.println("我的程序在C:\\code下");
        //  输出一个成绩表
        System.out.println("姓名  语文 数学 英语");
        System.out.println("张三   80  89   85");
        System.out.println("张三丰 80  89   85");
        System.out.println("卡卡西 80  89   85");
        System.out.println("-------------------");
        System.out.println("姓名\t语文\t数学\t英语");
        System.out.println("张三\t80\t89\t85");
        System.out.println("张三丰\t80\t89\t85");
        System.out.println("卡卡西\t80\t89\t85");
```
java基础语法

运算符

[1]算数运算符
```
 +，-，*，/，% ，++,--
```
和之前学习的JS中的使用完全一致。

但是在强数据类型的语言中，一个表达式的最终的结果取决于这个表达式中类型最大的操作数。

案例：
```
         int x = 5,y = 2;
         double z = x / y;
         System.out.println("z = " + z);// 2.0
```
得到的z是2.0而不是2.5。就是因为x和y都是int类型。所以结果会强制转换为int类型。

案例：
```
         int a = 5;
         double b = 20.0 / 5;
```
应用问题：总共有168条数据。计划每页放20条数据，请计算总共需要多少页？
```
 //总共有168条数据。计划每页放20条数据，请计算总共需要多少页？
 int total = 168;
 int size = 20;
 //int maxPageNum = total % size == 0 ? total / size:(total / size + 1);
 int maxPageNum = (int)Math.ceil(total * 1.0 / size);//ceil() 方法执行的是向上取整计算，它返回的是大于或等于函数参数，并且与之最接近的整数。
 System.out.println("最大页码是：" + maxPageNum);
```
总结：

下面的情况：后面的表达式中有double类型的操作，前面的变量是int类型，无法接收。
```
  int m  = 10 + 2 / 5 * ( 1.2 * 5);
```
解决方案：

①将对应的double类型的操作数强制转换为int
```
 int m  = 10 + 2 / 5 * ( (int)1.2 * 5);
```
②将整个表达式的结果强制转换为int
```
 int m  = (int)(10 + 2 / 5 * ( 1.2 * 5));
```
[2]关系运算符
```
 >,>=,<,<=,==,!=
```
java中没有 === 和 !==

任何一个表达式中如果出现了比较运算符，则整个表达式的结果肯定是一个布尔值。

[3]逻辑运算符
```
!,&&,||
***问题：&和&&有什么区别？
```
&&和|| 有短路作用。在java中 & 和 | 也可以做逻辑运算，但是没有短路作用。

案例：
```
int x = 3,y = 4;
boolean flag = x > 3 && (y = 5) > 4;
System.out.println(flag);
System.out.println("x = " + x);
System.out.println("y = " + y);
```
当我们使用"&&"的时候，最终的结果中flag = false，x = 3，y = 4。

当我们将“&&”修改为“&”的时候，flag = false， x = 3, y = 5;

[4]赋值运算符
```
=，+=，-=，*=，/=，%=
```
[5]三目运算

当表达式1的结果为true的时候，整个表达式的结果是表达式2的结果否则是表达式3的结果
```
表达式1?表达式2：表达式3；
```
应用：找出两个数中较大的一个数。
```
int m = 5,n = 7;
int max = m > n ? m : n;
System.out.println(max);
```
流程控制

分支流程

[1]if系列
```
if(表达式){if语句；}
```
```
if(表达式){if语句}else{else语句}
```
```
if(表达式){if语句}else if(表达式){elseif语句}....[else]
```
上面的分支语句的语法中所有的表达式都必须是布尔类型的。

在JS中if(表达式)会自动转换布尔值。但是在java中不行的。

[2]switch
```
switch(表达式){
    case value1:
        statement1;
        break;// 可选
    case value2:
        statement2:
        break;
        .....
    default:
        statement;
}
```
在JDK1.7之前switch中的表达式只能是int或者char类型或者枚举。不能是任何其他类型。

在JDK1.7之后，新增了String。

循环流程

[1]while(){}

要注意的是：（）中的表达式必须是布尔值。

java中的while往往使用来做不知道循环次数的循环，或者死循环。

问题：录入学身的成绩，并且计算平均分。
```
public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int score = 0;
        int sum = 0;
        int count = 1;
        while(true){
            System.out.println("请录入第"+count+"位同学的成绩(输入-1表示结束):");
            score = sc.nextInt();
            if(score == -1){
                break;
            }
            sum += score;
            count++;
        }
        System.out.println("总共录入了"+count+"位同学的成绩，平均分为："+(sum / count));
    }
```
[2]do{}while()；

表达式也必须是布尔值。和while的区别就是肯定至少会执行一次。

[3]for(;;){}
```
for(;;){}
for(表达式1;表达式2;表达式3){
          循环语句
}
```
第一次进入for循环的时候，首先执行表达式1，在判断表达式2，如果是true执行循环语句，如果是false就退出循环。

当循环语句执行结束之后，执行表达式3,继续判断表示2的结果，根据结果进入下次循环或者退出循环。
```
for(int i = 0;i< 10;i++){
    System.out.println(i);
}
```
[4]break和continue

break：跳出整个循环。

continue：结束本次循环，继续下次循环。

控制台输入

我们可以使用System.out.print()在控制台输出任何内容。

我们也可以使用System.in.read()在控制台录入任何内容。

java提供了一个专门的类，Scanner，这个Scanner可以从控制台录入任何基本数据类型。

用法：
```
// ①引入Scanner包
import java.util.Scanner;
public class Demo{
    public static void main(String[] args) {
        // ②创建一个Scanner对象
        Scanner sc = new Scanner(System.in);
        // ③录入数据
        // 录入一个字符串
        System.out.println("请输入您的姓名：");
        String name = sc.next();// 读取字符串
        System.out.println("请输入您的年龄：");
        int age = sc.nextInt();// 读取控制台的整形数字
        System.out.println("姓名:"+name+"\n年龄："+age);
    }
}
```
注意的事情：

JAVA基础编程练习题50题及经典算法90题【含源码及答案】

zip 4星超过75%的资源 93KB

下载

[1]sc.next() 按照空字符截断字符串

如果输入内容如下：
```
旗木  卡卡西
```
只能读取到 旗木 而 卡卡西 会进入下一个API的调用（可能会报错）。

如果一行的输入中一定是有空格的，则可以使用sc.nextLine();

[2]读取控制台的数字 :
- sc.nextInt()
- sc.nextDouble()
- sc.nextFloat()
当使用这些API的时候，输入的格式必须正确，否则就会报异常：

变量作用域

所谓变量的作用域就是这个变量从申明到结束。（这个变量可以使用的位置）

java 中变量的作用域就是从变量的申明开始，到离这个变量最近的结束的“｝”结束。
```
public class Demo6 {
    // 成员变量，作用域是在整个类中。
    static String name = "这是一个成员变量";
    public static void main(String[] args) {
        // 局部变量  在main方法中使用
        int x = 10;
        if (x > 5){
            // 局部变量，只能在if语句块中使用。
            int z = 100;
        }
        // 变量a和y 都只能在for循环中使用
        // a在整个循环中都可以使用。
        // y 每次循环都会创建一个新的。
        for(int a = 0;a > 10; a --){
            int y = 1000;
            System.out.println("0");
        }
        // 如果要在main方法中使用成员变量，则成员变量必须使用static修饰。
        System.out.println(name);
    }
}
```
双层循环

问题1：在控制台输出矩形
```
public class Demo7 {
    public static void main(String[] args) {
        /**
         *   *****
         *   *****
         *   *****
         *   *****
         *   *****
          */
        for(int i = 0;i < 5 ; i ++) { // 控制行
            for(int j = 0;j < 5;j ++) { // 每行显示的个数
                System.out.print("*");
            }
            System.out.println();// 換行
        }
//        for(int i = 0;i < 5 ; i ++) {
//            System.out.print("*");
//            System.out.print("*");
//            System.out.print("*");
//            System.out.print("*");
//            System.out.println("*");
//        }
//        for(int i = 0;i < 5 ; i ++) {
//            System.out.println("******");
//        }
//        System.out.println("******");
//        System.out.println("******");
//        System.out.println("******");
//        System.out.println("******");
    }
}
```
问题2: 在控制台输出一个正三角形
```
/**
 * 双层循环
 * *
 * **
 * ***
 * ****
 * *****
 */
public class Demo8 {
    public static void main(String[] args) {
        for (int i = 0;i < 5;i ++){// 5行
            // 当j < i + 1的时候，随着行的变量 i + 1 正好是 1~5的变化
            for(int j = 0;j < i + 1 ;j ++){ // 控制每行的个数
                System.out.print("*");
            }
            System.out.println();// 换行
        }
    }
}
```
问题3：输出如下的图形
```
*
   **
  ***
 ****
*****
```
```
public class Demo9 {
    public static void main(String[] args) {
        for (int i = 0;i < 5;i ++){// 5行
            // 一进来，每一行就开始了。
            // 先输出空格  空格的个数的变化是  4,3,2,1,0
            for(int j = 0;j < 5 - i - 1 ;j ++){ // 控制每行的个数
                System.out.print(" ");
            }
            // 然后输出*  个数变化  1,2,3,4,5
            // 当j < i + 1的时候，随着行的变量 i + 1 正好是 1~5的变化
            for(int j = 0;j < i + 1 ;j ++){ // 控制每行的个数
                System.out.print("*");
            }
            System.out.println();// 换行
        }
    }
}
```
问题4：输入如下的图形
```
*
   ***
  *****
 *******
*********
```
解决方案1：
```
public class Demo10 {
    public static void main(String[] args) {
        for (int i = 0;i < 5;i ++){// 5行
            // 一进来，每一行就开始了。
            // 先输出空格  空格的个数的变化是  4,3,2,1,0
            for(int j = 0;j < 5 - i - 1 ;j ++){ // 控制每行的个数
                System.out.print(" ");
            }
            // 然后输出*  个数变化  1,2,3,4,5
            // 当j < i + 1的时候，随着行的变量 i + 1 正好是 1~5的变化
            for(int j = 0;j < i + 1 ;j ++){ // 控制每行的个数
                System.out.print("*");
            }
            // 每一行增加的*的个数变化是 0,1,2,3,4
            for(int j = 0;j < i;j ++){ // 控制每行的个数
                System.out.print("*");
            }
            System.out.println();// 换行
        }
    }
}
```
解决方案2：
```
public class Demo11 {
    public static void main(String[] args) {
        for (int i = 0;i < 5;i ++){// 5行
            // 输出空格 4,3,2,1,0
            for(int j = 0 ; j < 5 - i -1; j ++){
                System.out.print(" ");
            }
            // 输出*  1,3,5,7,9
            for(int j = 0;j < 2 * i +1;j++){
                System.out.print("*");
            }
            System.out.println();// 换行
        }
    }
}
```
算法问题1：
```
1,1,2,3,5,8,13,21,34.......循环计算第56位是多少？
```
```
/**
 * 已知 斐波拉契数列（兔子数列）的第一位和第二位都是1，请计算第56位是多少？
 */
public class Demo12 {
    public static void main(String[] args) {
        long a =1,b = 1;
        for(int x = 3; x <= 56;x ++){
            // 计算下一个数
            long m = a + b;
            System.out.println("第"+x+"位是"+m);
            // b赋值给a，m赋值给b
            a = b;
            b = m;
        }
    }
}
```
数组

变量就是在内存中开辟一个空间，存储一个数据，然后给这个空间起一个别名。他们和在一起就是一个变量。

数组就是在内存开辟一组连续的空间，这组连续的空间的格式是一致的。给这组连续的空间一起起一个别名。给每个空间给上编号。他们和在一起就是一个数组。

数组的几个特点：
- 在内存中是连续的空间，每个空间都有对应的索引。索引都是从0开始的。
- 一个数组中的数据类型都是一致的。
- 数组一旦初始化，长度是不能改变的。
数组的初始化和简单使用

[1]数组的申明和初始化

在java中数组使用 []申明,语法

[]在数组名的前面或者后面都可以，但是一般写在数组名的前面。数组名的命名要求和变量名的命名要求完全一致。

案例：
```
// 申明数组
int [] scores;
String [] names;
```
数组的初始化：语法

方式1：
```
数组名 = new  数据类型[length]; // 这里的length必须存在，是整形
```
方式2：
```
数组名 = new 数据类型[]{"卡卡西","佐助","鸣人"} // 直接给数组元素赋值的情况下，千万不要写length
```
方式3:
```
// 申明数组的同时初始化
数据类型 [] 数组名 = {25,68,98,54,56} // 直接使用{}给数组赋值，但是这种方式只能使用在申明的同时就初始化的情况。
```
案例：
```
// 初始化
scores = new int [5]; // scores中的5个元素的默认值都是0
names = new String[]{"卡卡西","佐助","小丸子"};// 不要写长度
// 申明数组的同时初始化
double [] ds = {12.5,12.3,12.6};
```
当我们使用方式1创建了一个数组的时候，这个数组是有默认值的。
```
String [] names = new String[10]; // 这个数组的默认值是 null。
```
各种不同的数据类型的数组的默认值是：
- byte [] 默认值 0
- short [] 默认值 0
- int [] 默认值 0
- long[] 默认值 0L
- float [] 默认值 0.0F
- double [] 默认值 0.0D
- char [] 默认值 \u000 其实就是一个空字符
- boolean [] 默认值是 false。
- 其他类型数组默认值全部是 null。
[2]数组的使用

tips：在java中数组元素的索引只能是int类型。

获取指定索引的元素：
```
String name = 数组名[index];
```
给指定索引的元素赋值:
```
数组名[index ] = "哈哈";
```
获取数组的元素个数
```
int length = 数组名.length;
```
tips:在java中任何使用我们使用的数组的索引超过了数组元素的索引界限时，都会抛出异常。

案例：
```
public class Demo14 {
    public static void main(String[] args) {
        // 申明数组
        int [] scores;
        String [] names;
        // 初始化
        scores = new int [5]; // scores中的5个元素的默认值都是0
        names = new String[]{"卡卡西","佐助","小丸子"};// 不要写长度
        // 申明数组的同时初始化
        double [] ds = {12.5,12.3,12.6};
        // 数组的简单使用
        String [] ns = new String[5];
        ns[0] = "大圣";
        ns[1] = "二师兄";
        ns[2] = "小丸子";
        ns[3] = "乔峰";
        ns[4] = "虚竹";
        // 获取数组的中某一个元素
        String name = ns[1];
        System.out.println("name-1:"+name);
        System.out.println("------------------");
        for (int i = 0;i < ns.length; i ++){
            System.out.println(ns[i]);
        }
    }
}
```
冒泡排序

排序是所有算法中最为重要的。在笔试中非常的常见。

笔试题：对如下的数组进行从大到小的排序
```
 int[] arr = {56,86,25,47,98,25,35};
```
所谓排序是说在程序执行结束之后，内存中的数组修改为如下的样式
```
 int[] arr = {98,86,56,47,35,25,25};
```
```
 import java.util.Arrays;

 /**
  * 冒泡
  */
 public class Demo2 {
     public static void main(String[] args) {
         int[] arr = {56,86,25,47,98,25,35};
         for(int i = 0; i < arr.length - 1;i ++){// 执行多少轮
             for (int j = 0;j < arr.length - 1 - i;j ++){// 内部循环的次数是 逐个递减
                 // 比较j和j+1两个元素的大小
                 if(arr[j] < arr[j + 1]){
                     // 交换两个元素的位置
                     int temp = arr[j];
                     arr[j] = arr[j+1];
                     arr[j+1] = temp;
                 }
             }
         }
         System.out.println(Arrays.toString(arr));
     }
 }
```
断点调试

找bug：如果程序报错了，根据错误提示可以查找问题所在。如果程序没有报错，就必须猜测问题所在。断点调试查找问题。bug不是语法错误。

写好程序，在需要调试的位置添加断点：

加好断点之后，右键debug启动。启动之后，程序会暂停在添加断点的位
相关阅读:
retrofit网络框架源码解析
 华为路由器即做ipsec vpn又能上互联网
 使用JDK自带java.util.logging.Logger引起的冲突问题
 阿里平头哥发布RISC-V高能效处理器玄铁C908，打造端云一体生态
 828 B2B企业节引爆数字化需求首周惠及中小企业数量同比增长117%
QT中摄像头的使用
 入手不亏，4款简单易用的典藏软件，真正的电脑利器
 CS224W Colab_1 笔记
 华为OD机考算法题：MVP争夺战
 守护进程（初学者必备）
原文地址：https://blog.csdn.net/lt_xiaodou/article/details/126135521

环境

java语言的介绍

java语言的运行

开发工具

java语法语法基础

Hello程序的说明

数据类型

变量

命名规则和规范

数据类型转换

语句

java基础语法

运算符

流程控制

分支流程

循环流程

控制台输入

变量作用域

双层循环

数组

数组的初始化和简单使用

冒泡排序

断点调试