Java学习之路

一、JavaSE核心编程基础

1.Java语言概述

1.1如何学习Java——3W1H（重点！！！）

3W：What 是什么，Why 为什么，When 什么时候使用
1H：How怎么做
在我们学习和敲代码时，一定要遵循3W1H原则，要明白每个代码的功能，什么时候使用，以及怎么样用。这样才可以锻炼我们的编码能力

1.2Java开发环境的介绍

​  1）JDK、JRE、JVM

  ①JDK（(Java Development Kit)）：Java开发工具包，JDK是Sun 公司提供的一种免费的_Java软件开发工具包,里面包含了很多用于Java程序开发的工具,最常用的是编译和运行工具。

  ②JRE（Java Runtime Environment）：Java的运行环境。

  ​③JVM（Java Virtual Machine）：Java运行的虚拟机，JVM是java能够跨平台的核心机制。

1.3第一个Java程序——“HelloWorld”

public class HelloWorld{
	public static void main(String args[]){//main方法是程序运行的主入口
		//在IDEA中可以输入sout，进行快速输入System.out.println();
		//新手建议手敲一遍代码，先熟悉，暂时不用快捷键
		//在控制台输出HelloWorld
		System.out.println("HelloWorld");
	}	
}

1.4Java程序的运行机制

​  1）编写程序：首先，程序员使用高级语言编写程序，包括数据结构、算法和逻辑等内容。

​  2）编译程序：程序员使用编译器将程序源代码转换成机器语言代码。编译器将源代码分析、检查、优化，并生成目标代码。

​  3）目标代码：编译器生成的目标代码是一组二进制指令，它们被计算机识别和执行。

​  4）链接程序：在程序执行之前，链接程序将目标代码与其他库文件链接在一起，生成可执行文件，可执行文件包括可执行代码和数据。

​  5）执行程序：最后，计算机将可执行文件加载到内存中，按照指令执行程序。程序被载入内存后，计算机将按照指令的顺序执行程序，直到程序执行完毕或被终止。

  所有Java代码遵循从上往下运行，同一行从左往右运行，并且只运行一次。

1.5Java的本质

​  定义：Java是一门编译型语言，需要经过编译过程将人类写的代码，转化为电脑能理解的格式才可以运行。

​  ​  ​  ​  ​  ​编译

​  ​本质：.java文件------------>.class字节码文件

1.6Java的特点

​  ​1）简单性：Java语言简单高效。

​  ​​2）高安全性

​  ​​3）可跨平台：可以在各种操作系统下运行。

​  ​​4）可移植性：不需要修改文件即可在其他操作系统下运行。

​  ​​5）健壮性：简单地将就是程序对于各种非法地输入能够有很好地处理，并且使程序能够正常地继续运行下去。

1.7Java的分类

​  1）Java SE：Java核心语法及应用

​  ​2）Java EE：Java Web（Tomcat）

​  ​3）Java ME：移动端(和EE合并)

1.8Java的基本元素

​  ​1）标识符：标识符是指Java程序中自定义的名称，用来表示变量、方法、类、包等。标识符必须遵守一定的命名规则，比如必须以字母、下划线或美元符号开头，后面可以跟着字母、数字、下划线或美元符号等等。标识符就是个名字。

​  ​​2）关键字：关键字是Java语言中已经被定义好的具有特殊意义的单词，比如public、class、static等等。关键字不能作为标识符来使用。已经被官方使用的名字，不可以再使用。

​​  ​3）常量：常量是指在程序中固定不变的值，比如字符串常量、整数常量、浮点数常量等等。常量在Java中使用关键字final来定义，表示其值不能被修改。

​  ​4）变量：变量是程序中可以改变其值的数据存储空间，比如整型变量、字符型变量、布尔型变量等等。变量需要使用标识符来命名，并且需要在使用之前进行声 明和初始化。可以变化的量,内部存储的东西可以改变。
  i.变量的注意事项
  ​ ①变量的命名规范
  ​  ​必须以字母、下划线或美元符号开头，后面可以跟着字母、数字、下划线或美元符号等等。但是不能以数字开头。
​​    ​a.变量名应该以字母、下划线或美元符号开头，不能以数字开头。
  ​  ​b.变量名应该使用驼峰式命名法，即第一个单词小写，后面的单词首字母大写，例如：firstName。
  ​  ​c.变量名应该具有描述性，并且最好不要使用缩写或简写，例如：customerName而不是custName。
​    ​d.如果变量名由多个单词组成，则可以使用下划线分隔它们，例如：last_name。
  ​  ​e.Java是区分大小写的语言，因此变量名也应该区分大小写。

  ​ ②使用规则
  ​  a.先声明再调用

public class Demo{
	public static void main(String[]args){
        	//变量的声明
        	int num1 = 123456;//其中num1就是变量名，等号右边是变量的数值即变量值
        	//变量的调用：完成声明之后，直接使用变量名即变量的调用
        	int num =100;//既声明又赋值
        	int num2;//只声明，不赋值
        	int num3,num4,num5
                int num6=1,num7=2;
        	System.out.println(num1);
    }
}

1.9数据类型、变量、类型转换表示

​​  ​1）数据类型
​​  ​​ 定义：不同的数据有不同的作用，而划分数据的就是数据类型。
​​  ​​ 分类：
​​  ​​ i.基本数据类型

数据类型	字节数	位数	取值范围	备注	封装类（复合类型）
字节类型(byte)	1	8	-27（-128）~27-1==（127）==		Byte
短整型(short)	2	16	-215（-32768）~215-1==（32767）==		Short
整型(int)	4	32	-231（-2147483648）~231-1==（2147483647）==		Integer
长整型(long)	8	64	-263（-9223372036854775808）~263-1==（9223372036854775807）==	必须以l或L结尾,最好使用L	Long
单精度浮点型(float)	4	32	3.4e-38~3.4e38	必须以f或F结尾	Float
双精度浮点型(double)	8	64	1.7e-308~1.7e308		Double
布尔类型(boolean)	1（默认）	8（默认）	ture or false		Boolean
字符类型(char)	2	16	0~216-1==(65535)==	引号里面只能放单个字符，不能放多个。	Character

​​  ​​ ii.复合数据类型
​​  ​​  定义：一般将用户定义的新类型称为复合数据类型。在Java中，类和接口是两种用户定义的复合数据类型。（Scanner,Random……）

​​  ​2）变量
​​  ​​ i.声明变量：数据类型 变量名; ​​ 可以参考一下Java代码

public class Demo {
    public static void main(String[] args) {
        /**
         * 文档注释
         * 姓名：弯弯
         * 年龄：18
         * 身高：180
         * 手机号：123456789
         * 是否已婚：是
         * 性别：男
         * 未知
        */
        //声明变量的格式：数据类型 变量名 = 值;
        String name = "昆宝";
        //声明并赋值变量的格式：数据类型 变量名 = 值;
        int age =18;//“=”为赋值符号
        int height = 180;
        String phone = "123456789";
        boolean marry = true;
        char sex = '男';
    }
}

​​  ​3）数据类型的转换
​​  ​​ i.强制转换
  ​​  ①格式：目标类型 变量名 = （目标类型） 源类型变量名
  ​​  ②规则：a.不能对boolean类型进行类型转换。
  ​​    ​​  b.不能把对象类型转换成不相关类的对象
​  ​​    ​​  c.把容量大的类型转换为容量小的类型，转换过程中可能导致溢出或损失精度

public class QZZH{
    public static void main(String[]args){
        //强制类型转换
        int i=100;
        float b=1000f;
        i = (int) b;
   }
}

​​  ​​ ii.自动转换
  ​​  ①定义：整型、实型、字符型数据可以混合运算。运算中，不同类型的数据先转化为同一个类型，然后进行运算，转换从低级到高级。长度较短的类型可以自动变为长度较长的类型，这种转换即自动转换。

1.10 IDEA的使用

  ​1)快捷键

​  ​ ​文件格式对齐：对齐代码Ctrl+Alt+shift+L 然后选择whole file整个文件对齐（格式化）

​  ​ ​注释：ctrl+/或ctrl+shift+/

  ​2）乱码问题

​  ​ ​解决方案：选择.java文件，右键选择打开方式为记事本，然后另存为，改成我们需要的编码格式

1.11 补充知识

​​  ​1）Java是一门强类型语言，一旦某一个变量被定义类型，如果不经过强制转换，则它永远就是该数据类型了。

  2）前端和后端的区别
​  ​ ​前端：展示给用户看的
​  ​ ​后端：一般用户看不懂，主要负责的是业务逻辑

  3）工作空间（本质——文件夹）
​  ​ ​定义：一个用于存放所有项目的文件夹

  4）项目
​  ​ ​定义：项目可大（签到系统）可小（一个页面）。具备完整功能的代码工程

  5）包（package）
​  ​ ​定义：存放对应类型的文件

  6）文件（class）
​  ​ ​定义：java文件

  7）程序的耦合性
​  ​ ​定义：低耦合性方便替换，高耦合性不容易替换。各个部件或各个功能之间不会太多的相互影响。比如人的器官替换之后会导致死亡，即人是高耦合性，又比如电脑的CPU，可以相互替换，即低耦合性。

  8）可维护性
​  ​ ​定义：如何让程序方便更新和维护。

  9）字符集
​  ​ ​定义：字符集就是存了所有文字的字典。

2.流程控制语句_分支结构

2.1 运算符

  1）定义：用来运算的符号，因为代码中需要一些运算，所以需要使用运算符。

  2）运算符的类型（6种）
   i.算术运算符：+,-,*,/,%,++,–
    a++：先使用变量a，再将变量a自增
    ++a：先使用变量a，再将变量a自增

   ii.关系运算符：>,<,>=,<=,==,!=

   iii.布尔逻辑运算符：!,&&,||
     &&（短路且）：多个条件都为true，结果才为true
     ||：（短路或）：多个条件中，只要其中之一为true，结果为true
     !：求反，将true和false相互转换
     &（且）：多个条件都判断
     |（或）：多个条件都判断

   iv.位运算符：>>,<<,&,|,^,~
     &（与运算）定义：参加运算的两个数据，按二进制位进行“与”运算。运算规则：0&0=0; 0&1=0; 1&0=0; 1&1=1;即两位同时为“1”，结果才为“1”，否则为0
     |（或运算）定义：参加运算的两个对象，按二进制位进行“或”运算。运算规则：0|0=0； 0|1=1； 1|0=1； 1|1=1；参加运算的两个对象只要有一个为1，其值为1
     ^（异或运算）定义：参加运算的两个数据，按二进制位进行“异或”运算。运算规则：0^0=0； 0^1=1； 1^0=1； 1^1=0；参加运算的两个对象，如果两个相应位为“异”（值不同），则该位结果为1，否则为0。
     ~(按位取反)定义：将数据，按二进制位进行"取反"运算。运算规则：0–>1,1–>0（0变1,1变0）

   v.赋值运算符：=,及其扩展赋值运算+=，-+，%=，/=

   vi.三目运算符
     i.格式：条件表达式?返回值1(true):返回值2(false)

public class TernaryOperator {
    public static void main(String[] args) {
        //三目运算符
        //格式：条件表达式？结果1（true）:结果2(false)
        //逻辑表达式、关系表达式
        String answer = 5>4?"正确":"错误";
        System.out.println(answer);//正确
        System.out.println(3>4?"正确":"错误");//错误
    }
}

2.2 表达式

   1）定义：是一个式子，由运算符和变量组成

​   2）规则：从左往右运行

2.3 输入和输出

   1）输入
     定义：用户给电脑信息，在控制台中输入。

public class ScannerDemo{
    public static void main(String[]args){
        //输入工具（Scannr），由java官方写好的工具
        Scanner scanner = new Scanner(System.in);
        //从scanner的工具箱中获取输入数字的工具，输入前最好有提示
        System.out.print(" 请输入数字：")
        int num = scanner.nextInt();
    }
}

   2）输出
     定义：电脑给用户信息

public class OutputDemo{
    public static void main(String[]args){
    	//Idea的快捷键sout
        System.out.println("我是输出的写法哦");
    }
}

2.4 分支语句(if-else、多分支)

  定义：可以用来判断的语句，需要条件==[条件是布尔值或结果为布尔值的表达式]==
   1）if（范围）

public class IfDemo{
    public static void main(String[]args){
        /*
        if(条件){
			代码块
		}
        */
        if(5>4){
        	System.out.println("正确");
        }
    }
}

  2）if-else（范围）
   定义：if-else语句是Java中最基本的分支语句。if语句用于在满足条件时执行某些代码，而else语句用于在不满足if条件时执行另外一些代码。

public class If_elseDemo{
    public static void main(String[]args){
        /*
        if(条件){//true
			代码块
		}else{//false
			代码块
		}
        */
        if(4>5){
        	System.out.println("正确");
        }else{
			System.out.println("错误")
		}
    }
}

  3）if-else if-else（多分支、范围）
   定义：用于检查多个条件，若某一条件成立，则执行相应的代码块，并跳过其他条件的检查。

public class If_else_ifDemo{
    public static void main(String[]args){
        /*
        if(条件){//true
			代码块
		}else if(条件2){
			代码块
		}else if(条件3){
			代码块
		}else{
			代码块
		}
        */
        if(9==11){//显然不等，进入下一个else if
			System.out.println("9等于11");
		}else if (9==12){//显然不等，进入else if
			System.out.println("9等于12");
		}else if (9==13){//显然被不等 进入 else
			System.out.println("9等于13");
		}else {
			System.out.println("9等于10");
		}
    }
}

2.5 嵌套分支语句

  1）定义：在一个分支结构中又完整的嵌套了另一个完整的分支结构，里面的分支的结构称为内层分支外面的分支结构称为外层分支。规范:不要超过3层。

public class Demo {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入你的成绩");
        double result = scanner.nextDouble();
        System.out.println("请输入你的性别");
        char sex = scanner.next().charAt(0);
        if (result > 8.0){
            System.out.println("恭喜你进入决赛");
            if (sex == '男'){
                System.out.println("进入男子组");
            } else {
                System.out.println("进入女子组");
            }
        } else {
            System.out.println("你已被淘汰");
        }
    }
}

2.6 switch语句

   1）switch语句（固定值判断/单一变量）
    用于对表达式的值进行多重匹配，若某一匹配成功，则执行相应的代码块。break的作用是打断语句，根据需要，决定要不要加break，default的位置没有要求
   2）switch的变量可以有什么数据类型? int其他?
    答：swtich的变量的数据类型数量和java的版本有关。
     ①在Java7之前，switch只能支持byte,short,int,char或者相关对应的封装类以及Enum类型
     ②在Java7中，switch增加支持了String类型，即String,byte,short,int,char,Enum类型（6种）
     ③在Java7之后，switch支持10种类型
     i.基本类型：byte,char,shourt,int（4种）
     ii.对应包封装：Byte,Short,Character,Intege;String,Enum（6种）
   总结：实际上switch只支持int类型。Java实际只能支持int类型的switch语句，其他的类型是如何支持的？
     1）基本类型的byte,char,short都可以自动向上转换为int类型，实际上用的还是int。
     2）基本类型包装类Byte，Short，Character，Integer，由于Java的自动拆箱机制，可以把这些对象自动转换为基本类型。
     3）String类型实际switch比较的是string.hashCode值，它是一个int类型。4）enum类型实际比较的是enum的ordinal值（表示枚举值的顺序），它也是一个int类型。

switch (表达式/变量) {
            case 值1:
                // 匹配成功时执行的代码
                break;
            case 值2:
                // 匹配成功时执行的代码
                break;
            default:
                // 所有值都不匹配时执行的代码
        	break;
        }

3.流程控制语句_循环结构

3.1循环for/while/do

  1）for(计算机运算第一步是初始变量，第二步是范围判断，第三是执行循环体，最后再增量)
    i.格式

/*for(初始变量;范围判断;增量){
    //循环体;
}*/
public class Test{
    publib static void main(String[]args){
        int sum=0;
        for(int i=1;i<=100;i++){
            sum=sum+i;
        }
        System.out.println(sum);
    }
}

    ii.优点
      for循环有固定循环次数，确定循环次数的语句。while根据条件进行循环，不确定循环次数的语句。

  2）while
    i.格式:

while(条件){
        //条件：布尔值或结果为布尔值的表达式
        //当条件为true时，会不断执行内部语句
	//循环体;
}
//Eg
public class Test{
    public static void main(String[] args){
        int count=0;
        while(count<10){
            count++;
            System.out.println("HelloWorld"+count)
        }
    }
}

  3）do-while
    i.格式:先执行do里面的语句，再判断。若为true则继续执行do里面的语句。

do{
    语句；
}
while(布尔表达式);

3.2嵌套循环

  1）局部变量
    定义：每个变量都有一定的作用域

public class Test{
    public int num =1;//类变量(局部变量)
    public static int num=1;//全局变量
    public static void main(String[] args){
        int a=1;// 方法变量，main方法里的变量（局部变量）
        for(int i=0;i<10;i++){
            for(int j=1;j<10;j++){//循环里，局部变量，j只存在自己的循环中               
            }
        }
    }
} 

  2)嵌套循环（画三角形）

public class Demo1 {
    public static void main(String[] args) {
        //第一个图
        /*for(int i=5;i>0;i--){
            for(int j=1;j<i;j++){
                System.out.print(" ");
            }
            for(int j=0;j<5;j++){
                System.out.print("*");
            }
            System.out.println();
        }*/

        //第二个图
/*            *
             ***
            *****
           *******
         **********
       */
        /*for(int i=1;i<=5;i++){//y轴，行
             for(int j=1;j<=5-i;j++){
                 System.out.print(" ");
             }
             for(int j=1;j<=i*2-1;j++){
                 System.out.print("*");
             }
            System.out.println();
        }*/

        //第三个图 菱形
        /*for(int i=1;i<=5;i++){
            for(int j=1;j<=5-i;j++){
                System.out.print(" ");
            }
            for(int j=1;j<=2*i-1;j++){
                System.out.print("*");
            }
            System.out.println();
        }
        for(int i=1;i<=5;i++){
            for(int j=1;j<=i;j++){
                System.out.print(" ");
            }
            for(int j=7;j>=(i*2)-1;j--){
                System.out.print("*");
            }
            System.out.println();
        }*/

        //第四个图
        /*for(int i=1;i<=5;i++){
            for(int j=1;j<=5-i;j++){
                System.out.print(" ");
            }
            for(int j=1;j<=2*i-1;j++){
                if(j==1 ||j==2*i-1)
                System.out.print("*");
                else{
                    System.out.print(" ");
                }
            }
            System.out.println();
        }
        for(int i=1;i<=5;i++){
            for(int j=1;j<=i;j++){
                System.out.print(" ");
            }
            for(int j=7;j>=(i*2)-1;j--){
                if(j==7||j==(i*2)-1){
                    System.out.print("*");
                }
                else{
                    System.out.print(" ");
                }
            }
            System.out.println();
        }*/

        //第五张图
        /*for(int i=1;i<=5;i++){//y轴，行
             for(int j=1;j<=5-i;j++){
                 System.out.print(" ");
             }
             for(int j=1;j<=i*2-1;j++){
                 if(j==1 || j==i*2-1){
                     System.out.print("*");
                 }
                 else if(i==5){
                     System.out.print("*");
                 }
                 else{
                     System.out.print(" ");
                 }
             }
            System.out.println();
        }*/
    }
}

3.3break/continue/return

  1）continue
    结束本次循环，然后进入下一次循环。
  2）break
    退出整个循环，即循环结束。或者终止语句（switch中的case）打断switch或终止循环
  3）return
    返回值或者作为函数（方法）的暂停

public class Demo {
    public static void main(String[] args) {
        //break的使用
        System.out.print("break的输出：");
        for(int i=1;i<=10;i++){
            if(i == 5){
                break;
            }
            System.out.print(i+" ");//break的输出：1 2 3 4
        }
        System.out.println();
        //continue的使用
        System.out.print("continue的输出：");
        for(int i=1;i<=10;i++){
            if(i == 5){
                continue;
            }
            System.out.print(i+" ");//continue的输出：1 2 3 4 6 7 8 9 10 
        }
    }
}

4.数组及数据结构

4.1 数组

  1）数组==(数据的集合)==
    ①概述：一次性声明大量的用于存储数据的变量；这些要存储的数据通常都是相同类型的数据。
    ​②定义：数组是一种用于存储多个相同类型数据的存储模型。
    ​③作用：一个变量名存储多个数值，变量名指向这个十六进制的物理地址。变量只能存储一个值。

  4）格式：
    ①数据类型[] 变量名
    ②数据类型 变量名[]

public class ArraryDemo{
    public static void main(String[]args){
        int[] arr;//定义了一个int类型的数组，数组名是arr
        int arr[];//定义了一个int类型的变量，变量名是arr数组
    }
}

  5）规则：
    ①Java中的数组必须先初始化，然后才可以使用。初始化是为数组中的数组元素分配内存空间，并为每个元素赋值。
    ​②数组初始化方式：i.动态初始化 ii.静态初始化
    ​③动态初始化：初始化时只指定数组长度、有系统的为数组分配初始值。只给长度，不给具体内容
    ④动态初始化的格式：数据类型[] 变量名 = new 数据类型[数组长度];
    ⑤一般数组用循环一起用
  6）数组的访问：
    ①数据变量的访问方式：数组名[索引（下标）]
    ②数组内部保存的数据的访问方式：数组名[索引]//编号从0开始
    ③索引（小标）：索引是数组中数据的编号方式，作用就是用于访问数组中的数据，数组名[索引]等同于变量名是一种特殊的变量名；索引从0开始，是连续的，逐一增加，每次加1。下标从0开始，最大到数组长度-1
  7）数组的访问原理
    ​①原理数组的地址存在栈空间中，数组的内存在堆空间中生成，要访问数组中的元素时，由栈空间的地址寻找到堆空间中，然后访问数组里的元素。
  8）数组的索引和数组的长度
    ​①数组的索引是从0开始，而数组的长度是从1开始

import java.lang.reflect.Array;
import java.util.Arrays;

public class ArrayDemo {
    public static void main(String[] args) {
        //静态数组的创建
        //方法一
        int[] arr1 = new int[3];//声明一个长度为3的整数数组，所有的元素初始化为0
        //arr1 = {1,2,3};//如果使用new运算符创建了数组对象并初始化了其大小，则不能再使用类似于arr1 = {1,2,3};这样的语法来给数组赋值。因为大括号花括号语法只能用于声明和静态初始化数组，而不能用于重新赋值。
        arr1[0]=1;
        arr1[1]=2;
        arr1[2]=3;
        System.out.print("arr1:");
        for(int i=0;i<=(arr1.length)-1;i++){
            System.out.print(arr1[i]+" ");
        }
        //方法二
        int[] arr2 = {1,2,3};//声明一个长度为3的整数数组,并给每个元素赋值
        System.out.println();
        System.out.print("arr2:");
        for(int j=0;j<=Array.getLength(arr2)-1;j++){
            System.out.print(arr2[j]+" ");
        }
        System.out.println();
        /*
        * Arrays.toString()
        * Arrays.toString()方法可以将一个数组转换为字符串并返回。该方法通常用于调试和日志记录。
        */
        String StringArray1 = Arrays.toString(arr1);
        System.out.println("StringArray1："+StringArray1);//StringArray1：[1, 2, 3]
        String StringArray2 = Arrays.toString(arr2);
        System.out.println("StringArray2："+StringArray2);//StringArray2：[1, 2, 3]

        /*
        * Arrays.sort()
        * Arrays.sort()方法可以对一个数组进行排序。该方法默认按升序对数组进行排序。
        */
        int[] arr3={5,3,2,1};
        System.out.println("初始的arr3："+Arrays.toString(arr3));//初始的arr3：[5, 3, 2, 1]
        Arrays.sort(arr3);//将数组进行排序
        System.out.println("排序后的arr3:"+Arrays.toString(arr3));//排序后的arr3:[1, 2, 3, 5]
    }
}

4.2 静态数组

  1）静态数组
    ①定义：声明数组时就确定其大小的数组，一旦固定长度，长度就无法改变
    ​② 格式：数据类型[] 数组名={};

import java.lang.reflect.Array;
import java.util.Arrays;

public class ArrayDemo {
    public static void main(String[] args) {
        //静态数组的创建
        //方法一
        int[] arr1 = new int[3];//声明一个长度为3的整数数组，所有的元素初始化为0
        //arr1 = {1,2,3};//如果使用new运算符创建了数组对象并初始化了其大小，则不能再使用类似于arr1 = {1,2,3};这样的语法来给数组赋值。因为大括号花括号语法只能用于声明和静态初始化数组，而不能用于重新赋值。
        arr1[0]=1;
        arr1[1]=2;
        arr1[2]=3;
        System.out.print("arr1:");
        for(int i=0;i<=(arr1.length)-1;i++){
            System.out.print(arr1[i]+" ");
        }
        //方法二
        int[] arr2 = {1,2,3};//声明一个长度为3的整数数组,并给每个元素赋值
        System.out.println();
        System.out.print("arr2:");
        for(int j=0;j<=Array.getLength(arr2)-1;j++){
            System.out.print(arr2[j]+" ");
        }
    }

4.3 动态数组

  ​3）动态数组
    ​​①定义：在运行时根据需要动态增长或缩小的数组。Java中的动态数组是通过ArrayList类实现的
    ​;​②格式：数据类型[] 数组名=new 数据类型[数组长度];
    ​​③规则：动态数组声明后，复合类型素组初始化数值为null，基本类型的默认值（初始化）为0

package Demo;

import java.util.ArrayList;
import java.util.Arrays;

public class ArrayDemo2 {
    public static void main(String[] args) {
        //1.创建一个空的ArrayList
        ArrayList<Integer> myList = new ArrayList<Integer>();
        //2.向ArrayList中添加元素
        myList.add(10);
        myList.add(20);
        myList.add(30);
        System.out.println(myList.toString());
        //3.获取ArryList中的元素
        int element = myList.get(0);//获取第一个元素
        System.out.println(element);//10
        //4.修改ArrayList中的元素
        myList.set(0,100);//将数组第一个位置的值改为100
        //5.删除ArrayList中的元素
        myList.remove(0);//删除第一个元素
        System.out.println(myList.toString());
        //6.获取ArrayList的大小
        int size = myList.size();
        //7.遍历ArrayList中的元素
        for(int i=0;i<myList.size();i++){
            int element1=myList.get(i);
            System.out.println(element);
        }
    }
}

    ④查找数组中的最大值元素

import java.util.Scanner;
//静态数组
public class ArrayDemo3 {
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        int[] arr ={123,190,334,159};
        int max=arr[0];
        for(int i=1;i<=(arr.length)-1;i++){//不用从0开始，因为index=0的值已经赋值给max了
            if(arr[i]>max){
                max=arr[i];
            }
        }
        System.out.println(max);
    }
}
//动态数组
//数组长度为5，随机数1-100，填入数组，然后求最大值
public class arrayDemo {
    public static void main(String[] args) {
        Random random = new Random();
        int[] intArray=new int[5];
        int max = 0;
        for (int i = 0; i <intArray.length ; i++) {
            intArray[i]=random.nextInt(100)+1;
            max=intArray[0];
            if(max<intArray[i]){
                max=intArray[i];
            }
        }
        Arrays.sort(intArray);
        System.out.println("数组的最大值为："+max);
        System.out.println(Arrays.toString(intArray));
    }
}

4.4 多维数组

​  1）定义：存放了数组的数组，即多维数组
​  2）一维数组和二维数组
    ①一维数组：数组内没有存放数组，只是普通内容。
    ②二维数组：数组里存放的就是若干个一维数组
    ③三维数组：存放多个二维数组

4.5 补充知识

​  1）如果是复合类型的数组，动态初始化之后，内容默认为null（空）
​  2)”==“和“equals”的区别
​  ​  ①“==”判断的是物理地址
​  ​  ②Java节省内存的机制：相同变量占同一个空间（指向相同的内存空间）

public class Demo{
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入字符串：");
        String str = scanner.next();
        System.out.println("输入的是："+str);
        System.out.println(str=="y");//false
        System.out.println("y"=="y");//true
    }
}

​  ​  ③比较字符串相等的方式：str.equals(“y”)。equals对比的是内容复合类型使用
​  3）代码冗余
​  ​  ①​定义：重复出现的代码多
​  ​  ②​代码的问题：①写的繁琐 ②不方便维护
​  ​  ​③解决方案：函数（方法），将重复的代码封到函数里，然后调用函数即可减少冗余

  ​数组题
  ​ 1）定义一个长度为 100 的数组，随机填充 0~1000 之间的整数，要求数组里的每个数字之间不能重复。

public class Demo1 {
    public static void main(String[] args) {
        Random random =new Random();
        int[] intArray = new int[5];
        for (int i = 0; i < intArray.length; i++) {
            int newNum=random.nextInt(5);
            //先获取随机出来的数字，判断该数字是否重复
            for(int j=0;j<i;j++){//循环已经出现过的数字
                if(newNum==intArray[j]){
                    newNum=random.nextInt(5);
                    System.out.println("出现重复");
                    j=-1;
                }
            }
            intArray[i]=newNum;
    }
        System.out.println("初始数组："+Arrays.toString(intArray));

    }
}

  ​ 2）定义一个长度为 10 的数组，随机填充 5~30 之间的整数。 打印数组的所有内容，然后再次打印在数组中出现重复过出现的数字。

import java.util.Arrays;
import java.util.Random;

//2、定义一个长度为 10 的数组，随机填充 5~30 之间的整数。 打印数组的所有内容，然后再次打印在数组中出现重复过出现的数字。
public class Demo2 {
    public static void main(String[] args) {
        Random random =new Random();
        int[] intArray =new int[10];
        int num=0;//存重复的数
        for (int i = 0; i < intArray.length; i++) {
            intArray[i]=random.nextInt(10);
            for(int j=0;j<i;j++){
                num=intArray[i];
                if(num==intArray[j]) {
                    System.out.println("数组中重复的数为："+num);
                    break;
                }
            }
        }
        System.out.println(Arrays.toString(intArray));
    }
}

  ​ 3）定义一个长度为 10 的数组，随机填充 0~50 之间的整数， 然后根据十位数的数字将其排列成一个新数组。例如 [2, 10, 3, 32, 5, 41, 10, 11, 20]， 随后重新排列数组，要求新数组形式如下 [[2, 3, 5], [10, 11], [20],[32],[41]]。

import java.lang.reflect.Array;
import java.util.Arrays;
import java.util.Random;

//定义一个长度为 10 的数组，随机填充 0~50 之间的整数， 然后根据十位数的数字将其排列成一个新数组。
//例如 [2, 10, 3, 32, 5, 41, 10, 11, 20]， 随后重新排列数组，要求新数组形式如下
//[[2, 3, 5], [10, 11], [20],[32],[41]]。
public class Demo3 {
    public static void main(String[] args) {
        //工具包
        Random random = new Random();

        //定义变量和数组
        int zero = 0, one = 0, two = 0, three = 0, four = 0, five = 0;
        int[] storeArray = new int[10];
        int temp = 0;
        //随机数
        for (int i = 0; i < storeArray.length; i++) {
            storeArray[i] = random.nextInt(51);
        }

        for (int i = 0; i < storeArray.length; i++) {
            temp = storeArray[i];
            if ((temp / 10) == 0) {
                zero++;//十位数为0的情况
            } else if ((temp / 10) == 1) {
                one++;//十位数为1的情况
            } else if ((temp / 10) == 2) {
                two++;//十位数为2的情况
            } else if ((temp / 10) == 3) {
                three++;//十位数为3的情况
            } else if ((temp / 10) == 4) {
                four++;//十位数为4的情况
            } else if ((temp / 10 == 5)) {
                five++;//十位数为5的情况
            }
        }

        int[] zeroArray = new int[zero];
        int[] oneArray = new int[one];
        int[] twoArray = new int[two];
        int[] threeArray = new int[three];
        int[] fourArray = new int[four];
        int[] fiveArray = new int[five];

        int flag0 = 0;
        int flag1 = 0;
        int flag2 = 0;
        int flag3 = 0;
        int flag4 = 0;
        int flag5 = 0;
        for (int i = 0; i < storeArray.length; i++) {
            if (storeArray[i] < 10 && flag0 < zeroArray.length) {
                zeroArray[flag0] = storeArray[i];
                flag0++;
            } else if ((storeArray[i] >= 10 && storeArray[i] < 20) && flag1 < oneArray.length) {
                oneArray[flag1] = storeArray[i];
                flag1++;
            } else if ((storeArray[i] >= 20 && storeArray[i] < 30) && flag2 < twoArray.length) {
                twoArray[flag2] = storeArray[i];
                flag2++;
            } else if ((storeArray[i] >= 30 && storeArray[i] < 40) && flag3 < threeArray.length) {
                threeArray[flag3] = storeArray[i];
                flag3++;
            } else if ((storeArray[i] >= 40 && storeArray[i] < 50) && flag4 < fourArray.length) {
                fourArray[flag4] = storeArray[i];
                flag4++;
            } else if ((storeArray[i] >= 40 && storeArray[i] < 50) && flag5 < fourArray.length) {
                fourArray[flag5] = storeArray[i];
                flag5++;
            }
        }
        /*System.out.println(Arrays.toString(storeArray));
        System.out.println(Arrays.toString(zeroArray));
        System.out.println(Arrays.toString(oneArray));
        System.out.println(Arrays.toString(twoArray));
        System.out.println(Arrays.toString(threeArray));
        System.out.println(Arrays.toString(fourArray));
        System.out.println(Arrays.toString(fiveArray));*/
        int[][] Array={zeroArray,oneArray,twoArray,threeArray,fourArray,fiveArray};
        System.out.println(Arrays.deepToString(Array));
    }
}

5.方法（函数）

  
    

5.1 方法的概念

  1）定义：具有独立功能的代码块组织成为一个整体，使其具有特殊功能的代码。用来解决一类问题的代码的有序集合，是一个功能模块。函数是一串具有特定功能的，高度封装的代码块。
    ①方法必须先创建才可以使用，该过程成为方法的定义
    ​②方法创建后并不是直接可以运行的，需要手动使用后才执行，该过程成为方法调用。
  2）常见错误
    ​①方法不能定义在main方法中
    ​②方法的名称区分大小写
  ​3）方法–>面向过程，（函数—>面向对象）的声明
    ​​语法格式：
    ​访问修饰符 返回类型 方法名([参数列表]){
    ​​//方法体
    ​​}
  ​4）五大要素
    ​​①访问修饰符：方法允许被访问的权限范围。public（公共的）,protected（受保护的）,privated（私有的）

访问提示符	同一个类中	同一个包中	不同包中的子类	不同包中的非子类（任意类）
private	√
default	√	√
protected	√	√	√
public	√	√	√	√

5.2 使用方法的命名

5.3方法的命名规则

5.4方法的语法和组成

5.5方法的调用

5.6补充知识

6.初步面向对象编程

7.继承、抽象

8.接口、多态

9.Java面向对象总结

10.API使用方法——String，ArrayList类

11.Java异常处理机制

12.Swing UI编程AWT布局

13.事件处理模型

14.图形编程

15.Mysql初步应用

16.JDBC编程