自己定义的名字都叫标识符
命名规范
遵循驼峰式命名，多个单词首字母大写，类首字符大写，后面遵循驼峰式命名，方法第一个单词小写，后面遵循驼峰式命名
关键字：
带有颜色的字，成为关键字，起名字不能和关键字起相同的名字
4类8种：
整数型：
byte、1个字节
short、2个字节
int、4个字节
long、8个字节
浮点型：
float 4个字节
double 8个字节
字符型：
char 2个字节
布尔类型：
boolean
引用数据类型：
数组。集合、对象、除了基本数据类型，其他都是引用类型
解析随机数：先转换成int类型，开始从0到3，在后面+1，变成从1到3
int i = (int) (Math.random() * 3)+1;
System.out.println(i);
算数运算符：+ - * / % ++ –
final修饰的变量为常量，不允许重新赋值，常量必须都是大写
final int MAX = 100;
运算符的优先级问题： ++ 级别 > +
Scanner 类,扫描枪键盘录入的数据
Scanner scanner = new Scanner(System.in);
scanner.nextInt(); int类型变量
= 将等号右边的值赋值给左边
+= -= *= /=
int a += b 相当于 a = a + b 是一个意思
如果是字符串两边有区别，注意，运算时最好类型相同时做运算
< == >= <= != 返回的boolean类型，不是true就是false
短路与&& 短路或|| ！ 就相当生活中的 和 或 非 相反
逻辑与& 逻辑或
区分：短路运算符左右两边都是布尔值，逻辑运算符左右是具体数值
布尔表达式 ？ “成立执行的语句” ： “不成立执行的语句”
if (表达式 布尔值) {
返回true执行这里的代码块，否则不执行
}
if多分支语法：
if （表达式 布尔值） {
返回true执行这里的代码块，否则不执行
}else if（表达式 布尔值）{
返回true执行这里的代码块，否则不执行
}…
else{
最后兜底的执行语句
}
注意事项：if多分支中，满足一个条件，后边的就不执行，因为有隐藏条件，和上一个条件是相反的
if双分支语法：
if（表达式 布尔值） {
满足条件执行的语句
}else {
不满足条件执行的语句
}
switch语句格式：
switch注意事项：
1、switch后面是一个()，（）中表达式返回的结果是一个等值，这个等值的类型可以为：
int、byte、short、string、枚举类型
2、这个（）中的等追会依次跟case后面的值进行比较，如果匹配成功，就执行：后面的代码
3、为了防止代码的”穿透“效果：在每个分支后面加上一个break关键字，遇到break这个分支就结束了
4、类似else的”兜底““备胎”的分支：default分支
5、default分支可以写在任意的位置上，但是如果没有在最后一行，后面必须加上break关键字，如果在最后一行，break可以省略
6、相邻分支逻辑是一样的，name就可以只保留最后一个分支，上面的都可以省去不写了
7、switch和if的区别：
switch表达式是等值，if是布尔表达式
如果表达式是区县判断的情况，用if做好
int score = 20;
switch (score) {
case 10:
System.out.println("A");
break;
case 20:
System.out.println("B");
break;
case 30:
System.out.println("c");
break;
default:
System.out.println("成绩错误");
}
int i = 1; 初始化变量
while (i <= 5) { 控制条件
执行代码块
i++; 步进语句
}
int i = 1;
do {
//执行代码块
i++;
}while (i<=5);
注意：do while循环有限执行一次执行代码块
for (初始化语句; 控制条件; 步进语句) {
执行代码块
}
for (int i = 0; i < 5; i++) {
执行代码块
}
for（；；）{
}
while（true）{
}
作用：结束后面的循环，不在执行
for (int i = 0; i < 100; i++) {
System.out.println(i);
if (i == 36) {
break;
}
}
break结束循环，满足if里的条件，后面的循环就不走了
for (int i = 0; i < 100; i++) {
System.out.println(i);
while (i == 36) {
break;
}
}
此时的break只是结束while的循环，特点：结束最近的一次循环
a:for (int i = 0; i < 100; i++) {
System.out.println(i);
while (i == 36) {
break a;
}
}
//此时的break结束带标号a的循环
作用：只结束本次循环，下边有循环可以继续执行，比较弱鸡
满足的执行continue，然后可以继续下一次循环
for (int i = 1; i <= 100; i++) {
if (i%5!=0) {
continue;
}
System.out.println(i);
}
作用：和循环无关，循环中遇到ruturn，那么return所在的方法被终结
for (int i = 1; i <= 100; i++) {
while (i==50) {
return;
}
System.out.println(i);
}
System.out.println("遇到return，我不会被执行了");
//输出1-100能被5整除的数，每行打印6个
int count = 0; 用来计数
for (int i = 1; i <= 100; i++) {
if (i%5==0) { 满足被5整除
System.out.print(i+"\t"); 空格
count++; 计数+1
if (count%6==0) {
System.out.println(); 换行
}
}
}
实现一个功能：
【1】请录入10个整数，当输入的数是666的时候，退出程序。
【2】判断其中录入正数的个数并输出。
【3】判断系统的退出状态：是正常退出还是被迫退出。
int conunt = 0;
boolean flag = true;
for (int i = 1; i <= 10; i++) {
Scanner scanner = new Scanner(System.in);
System.out.println("请录入第" + i + "个字");
int anInt = scanner.nextInt();
if (anInt == 666) {
System.out.println("遇到666，程序结束");
flag = false;
break;
}
if (anInt > 0) {
conunt++;
}
}
System.out.println("一共有" + conunt + "个正数");
if (flag) {
System.out.println("程序是正常执行的");
} else {
System.out.println("程序是被强行终止的");
}
【1】什么是方法？
方法(method)就是一段用来完成特定功能的代码片段，类似于其它语言的函数(function)。
方法用于定义该类或该类的实例的行为特征和功能实现。 方法是类和对象行为特征的抽象。方法很类似于面向过程中的函数。面向过程中，函数是最基本单位，整个程序由一个个函数调用组成。面向对象中，整个程序的基本单位是类，方法是从属于类和对象的。
【2】方法声明格式：
[修饰符1 修饰符2 …] 返回值类型 方法名(形式参数列表){
Java语句；… … …
}
【3】方法的调用方式：
对象名.方法名(实参列表)
【4】方法的详细说明
形式参数：在方法声明时用于接收外界传入的数据。
实参：调用方法时实际传给方法的数据。
返回值：方法在执行完毕后返还给调用它的环境的数据。
返回值类型：事先约定的返回值的数据类型，如无返回值，必须显示指定为为void。
【5】代码：
public class TestMethod01{
//方法的定义：（写方法）
public static int add(int num1,int num2){
int sum = 0;
sum += num1;
sum += num2;
return sum;//将返回值返回到方法的调用处
}
public static void main(String[] args){
//10+20:
//方法的调用：（用方法）
int num = add(10,20);
System.out.println(num);
/*
int num1 = 10;
int num2 = 20;
int sum = 0;
sum += num1;
sum += num2;
System.out.println(sum);
*/
//30+90:
int sum = add(30,90);
System.out.println(sum);
/*
int num3 = 30;
int num4 = 90;
int sum1 = 0 ;
sum1 += num3;
sum1 += num4;
System.out.println(sum1);
*/
//50+48:
System.out.println(add(50,48));
}
}
【6】总结：
1.方法是：对特定的功能进行提取，形成一个代码片段，这个代码片段就是我们所说的方法
2.方法和方法是并列的关系，所以我们定义的方法不能写到main方法中
3.方法的定义–》格式：
修饰符 方法返回值类型 方法名(形参列表){
方法体;
return 方法返回值;
}
4.方法的作用：提高代码的复用性
5.总结方法定义的格式：
5)方法体：具体的业务逻辑代码
6) return 方法返回值;
方法如果有返回值的话： return+方法返回值，将返回值返回到方法的调用处
方法没有返回值的话：return可以省略不写了，并且方法的返回值类型为：void
public class TestMethod02{
public static void add(int num1,int num2){
int sum = 0;
sum += num1;
sum += num2;
System.out.println(sum);
//return;
}
public static void main(String[] args){
//10+20:
//方法的调用：（用方法）
add(10,20);
//30+90:
add(30,90);
//50+48:
//System.out.println(add(50,48));//报错：TestMethod02.java:22: 错误: 此处不允许使用 '空' 类型
}
}
什么时候有返回值，什么时候没有返回值？ 看心情–》看需求
6.方法的定义需要注意什么？
1）形参列表要怎么写：定义几个参数，分别是什么类型的 —》不确定因素我们会当做方法的形参
2) 方法到底是否需要返回值 ，如果需要的话，返回值的类型是什么
7.方法的调用需要注意什么？
1）实际参数要怎么传入：传入几个参数，传入什么类型的
2） 方法是否有返回值需要接受
import java.util.Scanner;
public class TestMethod03{
public static void main(String[] args){
//功能：我心里有一个数，你来猜，看是否猜对
//1.你猜一个数
Scanner sc = new Scanner(System.in);
System.out.println("请你猜一个数：");
int yourGuessNum = sc.nextInt();
//2.我心里有一个数
int myHeartNum = 5;
//3.将两个数比对：
System.out.println(yourGuessNum==myHeartNum?"猜对了":"猜错了");
}
}
对猜数功能提取为一个方法：
import java.util.Scanner;
public class TestMethod03{
public static void main(String[] args){
//功能：我心里有一个数，你来猜，看是否猜对
//1.你猜一个数
Scanner sc = new Scanner(System.in);
System.out.println("请你猜一个数：");
int yourGuessNum = sc.nextInt();
//调用猜数的方法：
guessNum(yourGuessNum);
}
//方法的定义：功能：实现猜数功能：
public static void guessNum(int yourNum){
//我心里有一个数(1-6)
int myHeartNum = (int)(Math.random()*6)+1;
//将两个数比对：
System.out.println(yourNum==myHeartNum?"猜对了":"猜错了");
}
}
方法区、栈内存、堆内存
方法区：用来存储方法
栈内存：存放成员变量
堆内存：存放new的对象
【1】什么是方法的重载：
方法的重载是指一个类中可以定义多个方法名相同，但参数不同的方法。 调用时，会根据不同的参数自动匹配对应的方法。
注意本质：重载的方法，实际是完全不同的方法，只是名称相同而已！
【2】构成方法重载的条件：
❀不同的含义：形参类型、形参个数、形参顺序不同
❀ 只有返回值不同不构成方法的重载
如：int a(String str){}与 void a(String str){}不构成方法重载
❀ 只有形参的名称不同，不构成方法的重载
如：int a(String str){}与int a(String s){}不构成方法重载
【3】代码：
public class TestMethod05{
public static void main(String[] args){
//10+20:
int sum = add(10,20);
System.out.println(sum);
//20+40+80:
//System.out.println(add(add(20,40),80));
System.out.println(add(20,40,80));
//30+60+90+120:
//System.out.println(add(add(30,60),add(90,120)));
System.out.println(add(30,60,90,120));
//9.8+4.7:
//System.out.println(add(9.8,4.7));
System.out.println(add(9.8,4.7));
}
//定义一个方法：两个数相加：两个int类型数据相加
public static int add(int num1,int num2){
return num1+num2;
}
//定义一个方法：三个数相加：
public static int add(int num1,int num2,int num3){
return num1+num2+num3;
}
//定义一个方法：四个数相加：
public static int add(int num1,int num2,int num3,int num4){
return num1+num2+num3+num4;
}
//定义一个方法：两个数相加：两个double类型的数据相加
public static double add(double num1,double num2){
return num1+num2;
}
}
总结：
1.方法的重载：在同一个类中，方法名相同，形参列表不同的多个方法，构成了方法的重载。
2.方法的重载只跟：方法名和形参列表有关，与修饰符，返回值类型无关。
3.注意：形参列表不同指的是什么？
（1）个数不同
add() add(int num1) add(int num1,int num2)
（2）顺序不同
add(int num1,double num2) add(double num1,int num2)
（3）类型不同
add(int num1) add(double num1)
4.请问下面的方法是否构成了方法的重载？
(1)add(int a) 和 add(int b) —>不构成,相当于方法的重复定义
(2)public static int add(int a) 和 public static void add(int b) —>不构成
【4】扩充：
public class TestMethod06{
public static void main(String[] args){
add(5);
//级别：byte,short,char–>int–>long–>float—>double
}
public static void add(double num1){
System.out.println("------2");
}
public static void add(float num1){
System.out.println("------3");
}
public static void add(long num1){
System.out.println("------4");
}
/*
public static void add(int num1){
System.out.println("------1");
}
*/
}
最最注意事项：方法的重载只与方法名和参数列表有关，与返回值类型和权限访问修饰符没有半毛钱关系
【1】数组的定义
数组是相同类型数据的有序集合。数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成。其中，每一个数据称作一个元素，每个元素可以通过一个索引（下标）来访问它们。
数组的四个基本特点：
1.长度是确定的。数组一旦被创建，它的大小就是不可以改变的。
2.其元素的类型必须是相同类型，不允许出现混合类型。
3.数组类型可以是任何数据类型，包括基本类型和引用类型。
4.数组有索引的：索引从0开始，到 数组.length-1 结束
5.数组变量属于引用类型，数组也是对象。
PS:数组变量属于引用类型，数组也是对象，数组中的每个元素相当于该对象的成员变量。数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中存储的。
【2】数组的学习：
public class TestArray02{
public static void main(String[] args){
//数组的作用：用来存储相同类型的数据
//以int类型数据为案例：数组用来存储int类型数据
//1.声明(定义数组)
int[] arr; //定义一个int类型的数组，名字叫arr
//int arr2[];
//如果数组只声明，没有后续操作，那么这个数组相当于没定义
//int[] arr3 = null;//空 辨别：数组赋值为null和什么都没有赋值 不一样的效果
//2.创建
arr = new int[4];//给数组开辟了一个长度为4的空间
//编译期声明和创建会被合为一句话: int[] arr = new int[4];
//3.赋值
arr[0] = 12;
arr[3] = 47;
arr[2] = 98;
arr[1] = 56;
arr[2] = 66;
/*
arr[4] = 93;
出现异常：Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 4
Array 数组
Index 索引
OutOf 超出
Bounds 界限
Exception 异常
---》数组索引越界异常
*/
//4.使用
System.out.println(arr[2]);
System.out.println(arr[0]+100);
//通过数组一个属性来获取 length 长度
System.out.println("数组的长度是："+arr.length);
}
}
【1】代码：数组的练习
import java.util.Scanner;
public class TestArray03{
public static void main(String[] args){
//功能：键盘录入十个学生的成绩，求和，求平均数：
//定义一个int类型的数组，长度为10 ：
int[] scores = new int[10];
//定义一个求和的变量：
int sum = 0;
Scanner sc = new Scanner(System.in);
for(int i=1;i<=10;i++){//i:控制循环次数
System.out.print("请录入第"+i+"个学生的成绩：");
int score = sc.nextInt();
scores[i-1] = score;
sum += score;
}
System.out.println("十个学生的成绩之和为："+sum);
System.out.println("十个学生的成绩平均数为："+sum/10);
//求第6个学生的成绩：
//System.out.println(scores[5]);
/*
System.out.println(scores[0]);
System.out.println(scores[1]);
System.out.println(scores[2]);
System.out.println(scores[3]);
//....
System.out.println(scores[9]);
*/
//将数组中的每个元素进行查看--》数组的遍历：
//方式1：普通for循环---》正向遍历：
for(int i=0;i<=9;i++){
System.out.println("第"+(i+1)+"个学生的成绩为："+scores[i]);
}
//方式2：增强for循环:
//对scores数组进行遍历，遍历出来每个元素都用int类型的num接收：
int count = 0;
for(int num:scores){
count++;
//每次都将num在控制台输出
System.out.println("第"+count+"个学生的成绩为："+num);
}
/*
增强for循环：
优点：代码简单
缺点：单纯的增强for循环不能涉及跟索引相关的操作
*/
//方式3：利用普通for循环： 逆向遍历：
for(int i=9;i>=0;i--){
System.out.println("第"+(i+1)+"个学生的成绩为："+scores[i]);
}
}
}
数组的初始化方式总共有三种：静态初始化、动态初始化、默认初始化。
静态初始化
除了用new关键字来产生数组以外，还可以直接在定义数组的同时就为数组元素分配空间并赋值。
eg:
int[] arr = {12,23,45};
int[] arr = new int[]{12,23,45};
注意：
1.new int[3]{12,23,45};–>错误
2.int[] arr ;
arr = {12,23,45}; —>错误
动态初始化
数组定义与为数组元素分配空间并赋值的操作分开进行。
eg:
int[] arr ;
arr = new int[3]
arr[0] = 12;
arr[1] = 23;
arr[2] = 45;
默认初始化
数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。
int[] arr = new int[3]; —> 数组有默认的初始化值
【1】实现一个功能：给定一个数组int[] arr = {12,3,7,4,8,125,9,45}; ，求出数组中最大的数。
思路图：
public class TestArray04{
public static void main(String[] args){
//实现一个功能：给定一个数组int[] arr = {12,3,7,4,8,125,9,45}; ，求出数组中最大的数。
//1.给定一个数组
int[] arr = {12,3,7,4,8,125,9,45,666,36};
//2.求出数组中的最大值：
//先找一个数上擂台，假定认为这个数最大：
int maxNum = arr[0];
for(int i=0;i<arr.length;i++){
if(arr[i]>maxNum){
maxNum = arr[i];
}
}
System.out.println("当前数组中最大的数为："+maxNum);
}
}
【2】将求最大值的方法提取出来：
public class TestArray04{
public static void main(String[] args){
//实现一个功能：给定一个数组int[] arr = {12,3,7,4,8,125,9,45}; ，求出数组中最大的数。
//1.给定一个数组
int[] arr = {12,3,7,4,8,725,9,45,666,36};
//2.求出数组中的最大值：
//调用方法：
int num = getMaxNum(arr);
System.out.println("当前数组中最大的数为："+num);
}
/*
想提取一个方法：求数组中的最大值
求哪个数组中的最大值 ---》不确定因素：哪个数组 (形参)---》返回值：最大值
*/
public static int getMaxNum(int[] arr){
//先找一个数上擂台，假定认为这个数最大：
int maxNum = arr[0];
for(int i=0;i<arr.length;i++){
if(arr[i]>maxNum){
maxNum = arr[i];
}
}
return maxNum;
}
}
【1】查询指定位置的元素
public class TestArray05{
public static void main(String[] args){
//查询指定位置的元素
//给定一个数组：
int[] arr = {12,34,56,7,3,10};
//查找索引为2的位置上对应的元素是什么？
System.out.println(arr[2]);
}
}
上面代码体现了数组的一个优点：
在按照位置查询的时候，直接一步到位，效率非常高
【2】查询指定元素的位置–》找出元素对应的索引
public class TestArray06{
public static void main(String[] args){
//查询指定元素的位置--》找出元素对应的索引
//给定一个数组：
int[] arr = {12,34,56,7,3,56};
// 0 1 2 3 4 5
//功能：查询元素888对应的索引：
int index = -1; //这个初始值只要不是数组的索引即可
for(int i=0;i<arr.length;i++){
if(arr[i]==12){
index = i;//只要找到了元素，那么index就变成为i
break;//只要找到这个元素，循环就停止
}
}
if(index!=-1){
System.out.println("元素对应的索引："+index);
}else{//index==-1
System.out.println("查无次数！");
}
}
}
【3】将查指定元素对应的索引的功能提取为方法：
public class TestArray06{
public static void main(String[] args){
//查询指定元素的位置--》找出元素对应的索引
//给定一个数组：
int[] arr = {12,34,56,7,3,56};
// 0 1 2 3 4 5
//功能：查询元素888对应的索引：
//调用方法：
int index = getIndex(arr,999);
//后续对index的值进行判断：
if(index!=-1){
System.out.println("元素对应的索引："+index);
}else{//index==-1
System.out.println("查无次数！");
}
}
/*
定义一个方法：查询数组中指定的元素对应的索引：
不确定因素：哪个数组，哪个指定元素 （形参）
返回值：索引
*/
public static int getIndex(int[] arr,int ele){
int index = -1; //这个初始值只要不是数组的索引即可
for(int i=0;i<arr.length;i++){
if(arr[i]==ele){
index = i;//只要找到了元素，那么index就变成为i
break;//只要找到这个元素，循环就停止
}
}
return index;
}
}
【1】main方法：程序的入口，在同一个类中，如果有多个方法，那么虚拟机就会识别main方法，从这个方法作为程序的入口
【2】main方法格式严格要求：
public static void main(String[] args){}
public static —>修饰符 ，暂时用这个 -->面向对象一章
void —>代表方法没有返回值 对应的类型void
main —>见名知意名字
String[] args —>形参 —》不确定因素
【3】问题：程序中是否可以有其他的方法也叫main方法？
可以，构成了方法的重载。
public class TestArray10{
public static void main(String[] args){
}
public static void main(String str){
}
}
1.可变参数：作用提供了一个方法，参数的个数是可变的 ,解决了部分方法的重载问题
int…num
double…num
boolean…num
2.可变参数在JDK1.5之后加入的新特性
3.方法的内部对可变参数的处理跟数组是一样
4.可变参数和其他数据一起作为形参的时候，可变参数一定要放在最后
5.我们自己在写代码的时候，建议不要使用可变参数。
public static void main(String[] args){
//method01(10);
//method01();
//method01(20,30,40);
method01(30,40,50,60,70);
//method01(new int[]{11,22,33,44});
}
public static void method01(int num2,int...num){
System.out.println("-----1");
for(int i:num){
System.out.print(i+"\t");
}
System.out.println();
System.out.println(num2);
}
}
import java.util.Arrays;
public class TestArray13{
public static void main(String[] args){
//给定一个数组：
int[] arr = {1,3,7,2,4,8};
//toString:对数组进行遍历查看的，返回的是一个字符串，这个字符串比较好看
System.out.println(Arrays.toString(arr));
//binarySearch:二分法查找：找出指定数组中的指定元素对应的索引：
//这个方法的使用前提：一定要查看的是一个有序的数组：
//sort：排序 -->升序
Arrays.sort(arr);
System.out.println(Arrays.toString(arr));
System.out.println(Arrays.binarySearch(arr,4));
int[] arr2 = {1,3,7,2,4,8};
//copyOf:完成数组的复制：
int[] newArr = Arrays.copyOf(arr2,4);
System.out.println(Arrays.toString(newArr));
//copyOfRange:区间复制：
int[] newArr2 = Arrays.copyOfRange(arr2,1,4);//[1,4)-->1,2,3位置
System.out.println(Arrays.toString(newArr2));
//equals:比较两个数组的值是否一样：
int[] arr3 = {1,3,7,2,4,8};
int[] arr4 = {1,3,7,2,4,8};
System.out.println(Arrays.equals(arr3,arr4));//true
System.out.println(arr3==arr4);//false ==比较左右两侧的值是否相等，比较的是左右的地址值，返回结果一定是false
//fill：数组的填充：
int[] arr5 = {1,3,7,2,4,8};
Arrays.fill(arr5,10);
System.out.println(Arrays.toString(arr5));
}
}
public class TestArray15{
public static void main(String[] args){
//定义一个二维数组：
int[][] arr = new int[3][];//本质上定义了一个一维数组，长度为3
int[] a1 = {1,2,3};
arr[0] = a1;
arr[1] = new int[]{4,5,6,7};
arr[2] = new int[]{9,10};
}
}
四种遍历方式：
public class TestArray15{
public static void main(String[] args){
//定义一个二维数组：
int[][] arr = new int[3][];//本质上定义了一个一维数组，长度为3
int[] a1 = {1,2,3};
arr[0] = a1;
arr[1] = new int[]{4,5,6,7};
arr[2] = new int[]{9,10};
//读取6这个元素：
//System.out.println(arr[1][2]);
//对二维数组遍历：
//方式1：外层普通for循环+内层普通for循环：
for(int i=0;i<arr.length;i++){
for(int j=0;j<arr[i].length;j++){
System.out.print(arr[i][j]+"\t");
}
System.out.println();
}
//方式2：外层普通for循环+内层增强for循环：
for(int i=0;i<arr.length;i++){
for(int num:arr[i]){
System.out.print(num+"\t");
}
System.out.println();
}
//方式3：外层增强for循环+内层增强for循环：
for(int[] a:arr){
for(int num:a){
System.out.print(num+"\t");
}
System.out.println();
}
//方式4：外层增强for循环+内层普通for循环：
for(int[] a:arr){
for(int i=0;i<a.length;i++){
System.out.print(a[i]+"\t");
}
System.out.println();
}
}
}
数组的初始化方式总共有三种：静态初始化、动态初始化、默认初始化。
静态初始化
除了用new关键字来产生数组以外，还可以直接在定义数组的同时就为数组元素分配空间并赋值。
eg:
int[][] arr = {{1,2},{4,5,6},{4,5,6,7,8,9,9}};
int[][] arr =new int[][] {{1,2},{4,5,6},{4,5,6,7,8,9,9}};
动态初始化
数组定义与为数组元素分配空间并赋值的操作分开进行。
eg:
int[][] arr = new int[3][]; //本质上定义了一维数组长度为3，每个“格子”中放入的是一个数组
arr[0] = {1,2};
arr[1] = {3,4,5,6};
arr[2] = {34,45,56};
eg:
int[][] arr = new int[3][2];
public class TestArray16{
public static void main(String[] args){
int[][] arr = new int[3][2];
//本质上：定义一维数组，长度为3，每个数组“格子”中，有一个默认的长度为2的数组：
arr[1] = new int[]{1,2,3,4};
//数组遍历：
for(int[] a:arr){
for(int num:a){
System.out.print(num+"\t");
}
System.out.println();
}
}
}
默认初始化
数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。
调试在开发中大量应用：
【1】Debug的优化设置：更加节省内存空间：
设置Debug连接方式，默认是Socket。 Shared memory是Windows 特有的一个属性，一般在Windows系统下建议使用此设置，
内存占用相对较少。
一步一步的向下运行代码，不会走入任何方法中。
一步一步的向下运行代码，不会走入系统类库的方法中，但是会走入自定义的方法中。
一步一步的向下运行代码，会走入系统类库的方法中，也会走入自定义的方法中。
跳出方法
结束程序
进入到下一个断点，如果没有下一个断点了，就直接运行到程序结束。
在当前次取消未执行的断点。
【1】条件判断：
说明:
调试的时候，在循环里增加条件判断，可以极大的提高效率，心情也能惧悦。
具体操作:
在断点处右击调出条件断点。可以在满足某个条件下，实施断点。
