这里是一些我个人在学习中整理的笔记，俗话说好记性不如烂笔头。对于我的笔记而言，可能不是很严谨，基于我的理解而写下的，仅供参考。有了好的基础框架，打好地基，才能建成高楼。

什么是JAVA

Java是一门面向对象的编程语言，不仅吸收了C++语言的各种优点，还摒弃了C++里难以理解的多继承、指针等概念，因此Java语言具有功能强大和简单易用两个特征。Java语言作为静态面向对象编程语言的代表，极好地实现了面向对象理论，允许程序员以优雅的思维方式进行复杂的编程。

Java具有简单性、面向对象、分布式、健壮性、安全性、平台独立与可移植性、多线程、动态性等特点。 Java可以编写桌面应用程序、Web应用程序、分布式系统和嵌入式系统应用程序等。

搭建JAVA的开发环境

推荐使用IntelliJ IDEA，eclipse等工具开发

IntelliJ IDEA官网https://www.jetbrains.com/

eclipse官网https://eclipseide.org/

JAVA程序开发运行流程

开发Java程序，需要三个步骤：

编写程序（源代码）→编译程序→运行程序

public class HelloWorld{
  //这是我们程序执行的入口
  //main方法
  public static void main(String args){
    System.out.println("HelloWorld");
  }
}

Java中的注释使用说明

注释是指在程序指定的位置添加说明信息，养成写注释的好习惯，让你的代码有更高的可读性，方便二次编写的快速上手

注意：注释不参与运行，仅起到说明的作用

注释的分类

//这是单行注释的内容

/*
这是多行注释的内容
这是多行注释的内容
这是多行注释的内容
这是多行注释的内容
*/

/**
  *这是文档注释的内容
  *这是文档注释的内容
  *这是文档注释的内容
  *这是文档注释的内容
  */
  
//当然哪一种都可随便使用，看自己的个人喜好

关键字

关键字的概述

文质斌斌：原形容人既文雅又朴实，后形容人文雅有礼貌。同“文质彬彬”。

兴高采烈：叔夜俊侠，故兴高而采烈。兴：兴致。采：精神

关键字：就是Java语言赋予的特定含义单词。

关键字的特点

• 关键字字母全部都是小写
• 常用的代码编辑器，IDEA 针对关键字有特殊的颜色标记，非常直观。比如notepad++针对关键字有特殊的颜色标记
• 常用关键字：public、class、static、void

常量

常量的概念

java常量就是在程序中固定不变的值，是不能改变的数据。

public static void main(String[]args){
  System.out.println("---------字符串常量---------");
  System.out.println（"你好世界，世界你好"）;
  System.out.println("---------整数常量---------");
  System.out.println(666);
  System.out.println(888);
  System.out.println(555);
  System.out.println("---------小数常量---------");
  System.out.println(3.125);
  System.out.println(66.66);
  System.out.println("---------字符常量---------");
  System.out.println('男');
  System.out.println('女');
  System.out.println("---------布尔常量---------");
  System.out.println(true);
  System.out.println(false);
  System.out.println("---------空常量,是不能输出的---------");
  //System.out.println(null);

数值类型

Java语言是强类型语言，对于每一个数据都给出了明确的数据类型，不同的数据类型也分配了不同的内存空间，所以他们用来表达的数据大小也是不一样的。

byte类型：1个字节

boolean类型：1个字节

short类型：2个字节

char类型：2个字节

int类型：默认4个字节

float类型：4个字节

long，double类型：8个字节

定义long类型时，需要在后面加L

定义float类型时，需要在后面加F

变量

变量的概述

在程序运行过程中，其值可以发生改变的值，变量的值存放在内存条中。

变量的组成

变量的数据类型 变量名称=200

public static void main(String[]args){
 //定义变量  变量数据类型  变量名称=(赋值)
  int m=200;
  System.out.println(m);
  int m=300;
  System.out.println(m);
}

public static void main(String[]args){
 //定义变量  变量数据类型  变量名称=(赋值)
  byte b=1;
  System.out.println(b);
  boolean b=true;
  System.out.println(b);
  //变量b已经被定义为byte类型，再次定义成boolean将会编译报错
  //将boolean类型的变量名更改为b2
}

public static void main(String[]args){
  long l;
  System.out.println(l);
  //为赋值的变量不能够使用
  //给long的变量赋值为1，long l=1;
}

public static void main(String[]args){
  float f=3.145;
  System.out.println(f);
  //编译将会报错
  //3.145为double类型，无法以float形式输出
  //应改正为float f=3.145f
  //在double类型后加f表示float类型
}

标识符

标识符的概述

就是给类，方法，变量等起名字的符号。

标识符定义规则(硬性要求)

• 标识符可以包含 英文字母26个(区分大小写)，0-9数字，$(美元符号)和__(下划线)
• 标识符不能以数字开头
• 标识符不能是关键字

标识符定义规则(软性要求)

• 类名规范：首字母大写，后面每个单词首字母大写(大驼峰式)
• 方法名规范：首字母小写，后面每个单词首字母大写(小驼峰式)

类型转换

自动类型转换

把一个表示数据范围小的数值或者变量赋值给另一个表示数据范围大的变量。例如：double a=10;

public static void main(String[]args){
  //演示自动类型转换  整数10  int内存中4个字节
  double d=10;
  System.out.println(d);
  int i=b;
  System.out.println(d);
}

强制类型转换

把一个表示数据范围大的数值或者变量赋值给另一个表示数据范围小的变量。

格式：目标数据类型 变量名=(目标数据类型)值或者变量。

范例：int j = (int) 99.99;

例如：低类型(短字节)可以转换为高类型(长字节)；int型转换成double型，char型转换成int型等等。

public static void main(String[]args){
  //演示强制类型转换将double类型强制类型转换int类型
  int j=(int) 99.99;
  System.out.println(i);
}

表示数值范围从小到大

算术运算符

运算符：对常量或者变量进行操作的符号

表达式：用运算符把常量或者变量连接起来符号

如： int a=0;

int b=1;

int c=a+b;

+:是运算符，并且是算术运算符

a+b：是表达式，由于+是算术运算符，所以这个表达式叫算术表达式。

public static void main(String[]args){
  int a=8;
  int b=5;
  System.out.println("a/b=");
  System.out.println(8.0/b); // 88/5==1.6
  System.out.println("a*b=:");
  System.out.println(a*b); // 8*5==40
  System.out.println("a-b=:");
  System.out.println(a-b); // 8-5==3
  System.out.println("a+b=:");
  System.out.println(a+b); // 8+5==13
  System.out.println("a%b=:"); // 8/5==1.6
  System.out.println(a%b); // 8%5==3
  System.out.println(a%b); // 8%5==3
  //两个数都是为整数计算结果就是整数 不会带上小数点
}

字符的“+”操作

拿字符在计算机底层对应的数值来进行计算的

‘A’→ 65 A-Z是连续的

‘a’→ 97 a-z是连续的

算术表达式中包含多个基本数据类型的值的时候，整个算术表达式的类型会自动进行提升

提升规则：

byte类型，short类型和char类型将被提升到int类型

整个表达式的类型自动提升到表达式中最高等级操作数同样的类型

等级顺序：byte,short,char->int->long->float->double

底层计算使用ASCII

public static void main(String[] args){
  int a=20;
  char c='A';//'a'底层数值类型值=97'A'底层数值类型值=65
  System.out.println(a+c) ;
  short s=20;
  byte b=l;
  //c=66+s=20+b=1==87
  int j=c+s+b;
  System.out.println(j);
  doub1e j2=89.99+s+c;
  System.out.println(j2);
}

当“+”操作中出现字符串时，这个”+”是字符串连接符，而不是算术运算。

案例：

在”+”操作中，如果出现了字符串，就是连接运算符，否则就是算术运算。当连续进行“+”操作时，从左到右逐个执行。

//定义变量维码
int i =10;
System.out.println("siyi:"+i) ;
System. out.println(1+i) ;
System. out. println(1+i+"siyi"+3+4) ;
System. out. println(1+i+"siyi"+(3+4)) ;

增自减运算符

注意事项:

• ++和–既可以放在变量的后边，也可以放在变量的前边。
• 单独使用的时候，++和-－无论是放在变量的前边还是后边，结果是一样的。
• 参与操作的时候，如果放在变量的后边，先拿变量参与操作，后拿变量做++或者－-。
• 参与操作的时候，如果放在变量的前边，先拿变量做++或者－-，后拿变量参与操作。
• 最常见的用法：单独使用。

public static voidd main(String[]args){
  int i=10;
  // int sum=i+l;
  // i++;
  // int i=i(l0)+l
  //i++ 先将原来i的值=10 赋值给我们的j=10;在来对我们i做+1的操作赋值给i=10+1=11;8
  int j=++i;
  System.out.println("j:"+j);
}

关系运算符

关系运算符有6种关系，分别为小于、小于等于、大于、等于、大于等于、不等于。

注意事项：关系运算符的结果都是boolean类型，要么是true，要么是false。

逻辑运算符

逻辑运算符把各个运算的关系表达式连接起来组成一个复杂的逻辑表达式，以判断程序中的表达式是否成立，判断的结果是 true 或 false。

在数学中，一个数据x，大于3，小于6，我们可以这样来进行表示：3<x<6。在Java中，需要把上面的式子先进行拆解，再进行合并表达。

拆解为：x>3和x<6

合并为：x>3&&x<6

&&其实就是一个逻辑运算符。我们可以这样说，逻辑运算符，是用来连接关系表达式的运算符。

当然，逻辑运算符也可以直接连接布尔类型的常量或者变量。

短路逻辑运算符

只要有一个表达式的值为false，那么结果就可以判定为false了，没有必要将所有表达式的值都计算出来，短路与操作就有这样的效果，可以提高效率。同理在逻辑或运算中，一旦发现值为true，右边的表达式将不再参与运算。

逻辑与&，无论左边真假，右边都要执行。

短路与&&，如果左边为真，右边执行；如果左边为假，右边不执行。

逻辑或|，无论左边真假，右边都要执行。

短路或||，如果左边为假，右边执行；如果左边为真，右边不执行。

3>6&&4<10

3>6 false

三元运算符

三元运算符语法格式

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

解释：问号前面的位置是判断的条件，判断结果为boolean型，为true时调用表达式1,为false时调用表达式2。其逻辑为：如果条件表达式成立或者满足则执行表达式1，否则执行第二个。

int a = 10;
int b = 20;
int c = a > b ？ a：b；
// 判断 a>b 是否为真，如果为真取a的值，如果为假，取b的值

案例1

需求：动物园里有两只老虎，已知两只老虎的体重分别为180kg、200kg，请用程序实现判断两只老虎的体重是否相同。

int weight1 = 180;
int weight2 = 200;
boolean b = welght1== weight27 ? true :  false;
System. out. println("b:" + b) ;

案例2

在我们班级中有三名同学，已知他们的身高分别为150cm、210cm、165cm，请用程序实现获取这三名同学的最高身高。

int height1 = 150;
int height2 = 210;
int height3 = 165;
int tempHeight = height1 > height2 ? height1 : height2;
int maxHeight = tempHeight > height3 ? tempHeight : height3;
System. out. println("maxHeight:" + maxHeight) ;

Scanner打印机用法

Sanner使用基本步骤

①导包import java.util.Scanner;

导包的动作必须出现在定义的类上面

②创建对象

Scanner sc=new Scanner(System.in) ;

sc是为变量的名称 可以发生变化 其他的都不允许发生变化

③接受数据

int i=sc.nextInt();/／ 接受一个int数据

i是为变量的名称可以发生变化其他的都不允许发生变

import java.util.Scanner;
public class Demo{
  public static void main(String[]args){
    //创建了一个打印机
    Scanner sc= new Scanner(System.in);
    System.out.println("请您输入一个数值类型的数据");
   // 接受用户在控制台中输入int类型
    int i=sc.nextInt();
    System.out.println（"您输入的数值类型值为:"+i）;
  }
}   

Scanner类实现求两个数之和

Scanner sc= new Scanner(System.in) ;
System.out.println（"请输入第一个数"）；
int a=sc.nextInt() ;
System.out.println（"请输入第二个数"）;
int b=sc.nextInt();
System.out.println（"两个数计算结果:"+(a+b));

流程控制语句

• 顺序结构
• 分支结构(if,Switch)
• 循环结构(for, while, do… while)

判断语句1－if写法1

if(关系表达式）{
  语句体;
}

1. 首先判断关系表达式看其结果是true还是false
2. 如果是 true就执行语句体
3. 如果是 false就不执行语句体

  int a=20;
  int b=20;
  if(a==b) {
    System.out.println("a等于b");
  }
  if(a!=b) {
    System.out.println("a不等于b"）;
  }

判断语句1－if写法2

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

1. 首先判断关系表达式看其结果是true还是false
2. 如果是true就执行语句体1;
3. 如果是false就执行语句体2。

  int a=20;
  int b=30;
  if(a>b) {
    System.out.println("a的值大于b");
  }else{
     System.out.println("a的值不大于b");
  }

判断语句1－ if案例 奇偶数

需求：任意给出一个整数，请用程序实现判断该整数是奇数还是偶数，并在控制台输出该整数是奇数还是偶然数

分析思路

1. 键盘录入数据
2. 判断该录入的键盘数是奇数还是偶数
3. 如何判断一个数是偶数还是奇数?

number%2 如果余数为0则是为偶数 如果有余数则是为奇数

  Scanner sc= new Scanner(System.in) ;
  System.out.println("请输入一个数值类型的值");
  int a=sc.nextInt();
  if(a2==0){
    System.out.println("a+该数是为偶数");
  }else{
    System.out.println("a+"该数是为奇数");
  }

多重if判断语句

if (判断条件1）{
  执行语句1;
}else if(判断条件2){
  执行语句2;
}
...
}else if (判断条件n){
  执行语句n;
}else{
  执行语句n+1;
}

首先判断关系表达式1看其结果是true还是false

如果是true就执行语句体1

如果是false就继续判断关系表达式2看其结果是true还是false

如果是true就执行语句体2

如果是false就继续判断关系表达式…看其结果是true还是false

…

如果没有任何关系表达式为true，就执行语句体n+1。

//创建键盘录入数据
Scanner sc= new Scanner(System.in);
System.out.println("请输入星期数:")；
//获取到键盘录入的数据
int week=sc.nextInt();
if(week==1){
  System.out.println("星期一")；
}else if(week==2){
  System.out.println("星期二");
}
...
else if(week==7){
  System.out.println("星期日");
}else{
  System.out.println（"您输入的星期数有问题..")；
}

// 创建键盘录入数据
Scanner sc= new Scanner(System.in);
System.out.println("请输入成绩:");
// 获取到键盘录入的数据
int result=sc.nextlnt();
if(result>90&&result<=100){
  System.out.println("成绩为优秀");
}else if(result>=80&&result<=90){
  System.out.println("成绩为良");
}else if(result>=70&&result<80){
  System.out.println("成绩为中等");
}else if(result>=60&&result<70){
  System.out.println("成绩为及格");
}else {
  System.out.println("成绩为不及格");
}

switch语句的用法

switch(表达式){
    case 值1:
      语句体1;
    break;
    case 值2:
      语句体2;
    break;
    ...
    default:
      语句体n+1;
    break;
}

格式说明

1. 表达式取值为byte,short,int,char,JDK5以后可以是枚举，JDK7以后可以是字符串(String)
2. case：后面跟的是要和表达式进行比较的值
3. 语句体：这个部分可以是一条或者多条语句
4. break：表示中断，结束的意思，可以控制switch语句的结束
5. default：当所有的值都和表达式不匹配的时候，就执行default控制的语句。其实他就相当于if语句的else

执行流程

1. 首先计算出表达式的值
2. 其次，和case依次比较，一旦有对应的值，就会执行相应的语句，在执行的过程中，遇到break就会结束。
3. 最后，如果所有的case都和表达式的值不匹配，就会执行default语句体部分，然后程序结束掉。

//创建键盘录入数据
Scanner sc= new Scanner(System.in);
System.out.println("请输入星期数:")；
//获取到键盘录入的数据
int week=sc.nextInt();
switch(week){
  case 1:System.out.println("星期—");
  //如果匹配上case 则会 break退出 switch语句
  break;
  case 2:System.out.println("星期二");
  //如果匹配上case 则会 break退出 switch语句
  break;
  ...
  default:
    System.out.println("您输入的星期数不正确!");
  break;
}

//创建键盘录入数据
Scanner sc= new Scanner(System.in);
System.out.println("请输入月份:")；
//获取到键盘录入的数据
int month=sc.nextInt();
switch(month){
  case 3:
  case 4:
  case 5:
    System.out.println("春");
  break;
  case 6:
  case 7:
  case 8:
    System.out.println("夏");
  break;
  case 9:
  case 10:
  case 11:
    System.out.println("秋");
  break;
  case 12:
  case 1:
  case 2:
    System.out.println("冬");
  break;
  default:
    System.out.println("您输入的星月数不正确!");
  break;
}

循环语句内容

• 循环语句1－for
• 循环语句2－while
• 循环语句3－do…while
• 控制跳转语句
• 嵌套循环

循环结构的组成

初始化语句：用于表达循环开启时的起始状态，简单说就是循环开始时候什么样

条件判断语句：用于表示循环反复执行的条件，简单说就是判断循环是否能一直执行下去

循环体语句：用于表示循环反复执行的内容，简单说就是循环反复执行的事情

条件控制语句：用于表示循环执行中每次变化的内容，简单说就是控制循环是否能执行下去

循环结构对应的语法

初始化语句：这里可以是一条或多条语句，这些语句可以完成一些初始化操作

条件判断语句：这里使用一个结果值为boolean类型的表达式，这个表达式能决定是否执行循环体。例如：a<3

循环体语句：这里可以是任意语句，这些语句将反复执行

条件控制语句：这里通常是使用一条语句来改变变量的值，从而达到控制循环是否继续向下执行的效果。常见的i++，i－这样的操作。

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

执行流程

1. 执行初始化语句
2. 执行条件判断语句，看其结果是true还是false，如果是false，循环结束，如果是true，继续执行
3. 执行循环体语句
4. 执行条件控制语句
5. 回到2过程继续

for(int i=1;i<=5;i++){
  System. out. println("i"+i);
}

System.out.println("求1-5的总和");
int sum=0;
for(int i=1;i<=5;i++){
  //sum=sum+i;
  sum+=i;
  //sum+=i；==等价于sum=sum+i;
}
System.out.println("sum:"+sum);

int sum=0;
for(int i =1;i<=100;i++){

  if(i%2==0){//执行的限制条件

  sum+=i;

  }

}

for(int i =100;i<=999;i++){
  int ge=i%10;
  int shi=i/10%10;
  int bai=i/100;
  if((ge*ge*ge+shi*shi*shi+bai*baibai)==i){
   System.out.println("水仙花数："+i); 
  }

//折叠次数
int count=0;
//珠穆朗玛峰高度(毫米)
int zf=8848430;
//纸张厚度
double page=0.1;
while(page<=zf){
  page*=2;
  count++;
}
System.out.println("需要折叠"+count+"次");

do while循环语句

完整格式：
初始化语句;

do{

  循环体语句;

  条件控制语句;

  }while(条件判断语句);（注意do..while语句是以;结束语句与其他循环语句不同）

执行流程：

①执行初始化语句

②执行循环体语句

③执行条件控制语句

④执行条件判断语句，看其结果是true还是false

如果是false，循环结束

如果是true，继续执行

③回到②继续

死循环

//for死循环写法：
for(;;){
}
//while死循环写法：
while(true){
}
//do while死循环写法：
do{
}while(true);
//注意：死循环后可能会非常消耗cpu的资源可能会引发导致cpu飙高100%

三种不同循环语句区别

for循环适合针对一个范围判断进行操作，即已知循环次数。while循环适合判断次数不明确的操作，切循环结束后依旧可以使用。

for、while循环都必须先判断条件是否成立，然后决定是否执行循环体。

do…while循环比较特殊，它先执行循环体，然后根据判断条件决定是否再次执行循环，即do…while至少执行一次循环。

跳转控制语句

跳转控制语句(break),跳出循环，结束循环

跳转控制语句(continue),跳过本次循环，继续下次循环

注意：continue只能在循环中进行使用！

continue用法：使用for循环1-10不输出偶数结果

for(int i=1;i<10;i++){
  if(i%2==0){
    continue;//结束本次循环
  }
  System.out.println("i:"+i);
}

循环嵌套

循环嵌套的需求：

在控制台输出一天的小时和分钟，分钟和小时的范围：

公式：

分钟：0<=minute<60

小时：0<=hour<24

for(int hour=0;hour<=24;hour++){
  for(int minute;minute<=60;minute++){
    System.out.println(hour+"时"+minute+"分");
  }
  System.out.println("--------------------");
}

Random随机数

作用：用于产生一个随机数

1：导包

import java.util.Random;

导包的动作必须出现在类的定义上边

2：创建对象

Random r=new Random();

上边这个格式里面，r是变量名，可以变，其他的都不允许变

3：获取随机数

int number =r.nextInt(10);//获取数据的范围：[0.10)包括0，不包括10

上边这个格式里面，number是变量名，可以变，数字10可以变，其他的都不可以变

import java.util.Random;
import java.util.Scanner;
  public static void main(String[] args){
    Random rd=new Random();
    int number1=rd.nextInt(100)+1;
    while(true){
      System.out.println("请您输入一个数字");
      Scanner sc=new Scanner(System.in);
      int number2=sc.nextInt();
      if(number2>number1){
        System.out.prinln("您输入的数字大于随机数");
      }else if(number2<number1){
        System.out.prinln("您输入的数字小于随机数");
      }else{
        System.out.prinln("恭喜您猜对了");
        break;
      }
    }
  }

数组概述

在一个班级中，有非常多学生需要存储每位学生的考试成绩.

比如a=98;b=97;c=96;d=88;…

1）数组概述：一次性声明大量的用于存储数据的变量;

这些要存储的数据通常都是相同类型数据。例如：全班同学的考试成绩。

2）数组：是一种用于存储多个相同类型数据的存储模型

数组定义格式

范例1：推荐使用

定义格式1:数据类型变量名

int[] arr;

//含义：定义了一个int类型的数组，数组名是arr;

范例2:

数据类型变量名[]

int arr [];

//含义：定义了一个int类型的变量，变量名是arr数组；

数组动态初始化

1.数组初始化概述：Java中的数组必须先初始化，然后才能使用；初始化就是为数组中的数组元素分配内存空间，并为每个数组元素赋值。

2.数组初始化方式：动态初始化、静态初始化

3.动态初始化：初始化时只指定数组长度，有系统为数组分配初始值

4.动态初始化格式:

数据类型[] 变量名 = new 数据类型[数组长度];

//数据类型[]变量名=new数据类型[数组长度]；
int[] array = new int[3];
/*
*
*int[] array =new int[3];
*左边int[]array
*int数组中的元素是为int数据类型
*[]定义数组
*array数组的变量名称
*=
*new给数组分配内存空间
*int数组中的元素是为int数据类型
*[3]3数组的长度[数组的长度]
*右边new int[3];
*/

数组元素的访问

1）数组变量的访问方式：数组名

2）数组内部保存的数据的访问方式：数组名[索引]//编号从0开始

3）索引：索引是数组中数据的编号方式，作用就是用于访问数组中的数据，数组名[索引等同于变量名是一种特殊的变量名；索引从0开始，是连续的，逐一增加，每次加一

4） 例子： System.out.println(arr[O]); //访问数组的第一个元素

1）数组变量的访问方式：数组名

2）数组内部保存的数据的访问方式：数组名[索引]//编号从0开始

3）索引：索引是数组中数据的编号方式，作用就是用于访问数组中的数据，数组名[索引等同于变量名是一种特殊的变量名；索引从0开始，是连续的，逐一增加，每次加一

4） 例子： System.out.println(arr[O]); //访问数组的第一个元素

数组内存分配

Java程序在运行时，需要在内存中分配空间，为了提高运算效率，有对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式

JDK内存空间分为：堆、栈、方法区、本地方法栈等。

数组静态初始化

静态初始化：初始化时指定每个数组元素的初始值，由系统决定数组长度
格式：数据类型[] 数组名 = new 数据类型[]{元素1,元素2,元素3,..};
举例: int[] arr = new int[]{1,2,3};

简化格式：数据类型[] 数组名 ={元素1,元素2,元素3,..];
int[] arr = {1,2,3};

//静态初始化数组
int[] arr = new int[]{1,2,3};
//精简写法
int[] arr = {1,2,3};
System.out.println(arr);
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);

数组的常见问题

ArraylndexOutOfBoundsException:数组索引I越界异常
原因：你访问了不存在的索引。

NullPointerException:空指针异常
原因：数组已经不在指向堆内存了。而你还用数组名去访问元素。

数组的遍历

格式:数组名称.length(数组长度)
案例:arr.length

int[] arr = {66,88,99,10}
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
System.out.println(arr[3]);

for(int i=0;i<4;i++){
  System.out.println(arr[i]);
}

for(int i=0;i<arr.length;i++){
  System.out.println(arr[i]);
}

数组获取最大值

//1.定义一个数组存放数字
int[] arr={151,158,170,162,131,168,126};
//临时保存的最大值
int max=arr[0];//临时最大值151
for(int i=1;i<arr.length;i++){
  if(arr[i]>max){
    //修改临时保存的max值
    max=arr[i];
  }
}
//输出最大值
System.out.println("数组中最大的值："+max);

方法的概述

方法(method)是将具有独立功能的代码块组织成为一个整体，使其具有特殊功能的代码集

1.方法必须先创建才可以使用，该过程成为方法定义
2.方法创建后并不是直接可以运行的，需要手动使用后才执行，该过程成为方法调

public static void main(String[] args){
  max(10,20);
}

public static void max(int a,int b){
  //获取两个数中的最大值
  int max=a>b?a:b;
  //输出最大值
  System.out.println(max);
}

方法定义与调用

定义方法
格式：
public static void 方法名 () {
//方法体；
}
范例：
public static void siyi () {
//方法体；
}
方法调用：
格式：方法名称();
范例：siyi();

注意：方法必须先定义后才可以调用，否则程序将会报错