Java基础
一.基础
一.开发前言：
互联网程序开发域，各种系统以及服务器后台处理大数据的存储，查询，数据挖掘等。
1.计算机基础知识：
二进制：计算机全部采用二进制数表示，包含0，1两个数，逢二进一。每一个0或者每一个1，叫做比特。
二进制的转换：辗转相除法。
字节：
常见计算机中的最小存储单元。计算机存储的任何数据，都是以字节的形式存储。其中，8个二进制位（bit）0000 0000表示为一个字节，写成1 byte或者1 B。
2.Java语言开发环境搭建
- JRE:是Java程序的运行时的环境，包含Java和运行时所需要的核心类库。
- JDK：是java程序开发工具包，包含JRE和开发人员使用的工具，要运行一个已有的Java程序，那么只需要安装JRE即可，要开发一个全新的Java程序，那么必须安装JDK。
3.编写程序
-
编写一个基础编码：Hello Word.
public class HelloWord{ public static void main(){ System.out.printin("Hello Word!") } }
2.代码编译。
4.关键字
-
有特殊含义的，不可以随意使用的文字。
-
特点：
完全小写的字母。
编译器中含有特殊颜色。
5.标识符
是指在程序中，我们自己定义的内容，比如类的名字，方法的名字，都是标识符。
- 命名规则：（硬性要求）
- 标识符可以包含英文的26个字母（区分大小写），0~9数字，常见符号（如$）和下划线。
- 标识符不能以数字开头。
- 标识符不能是关键字。
- 命名规范：（软性要求）
- 类名规范：首字母大写，后面的每个单词首字母大写。（大驼峰式）
- 变量名规范：首字母小写，后面的每个单词的字母大写。（小驼峰式）
- 方法名规范：同变量名
6.1常量
-
概述：是指在Java程序运行期间固定不变的数据。
-
分类：
数据类型 关键字 内存占用 取值范围 字节型 byte 1个字节 -128~127 短整型 short 2个字节 -32768~32767 整型 int(默认) 4个字节 -2的31次方到2的31次方-1 长整型 long 8个字节 -2的63次方到2的63次方-1 单精度浮点数 float 4个字节 3.402823e+38 ~ 1.401298e-45（e+38表示是乘以10的38次方，同样，e-45表示乘以10的负45次方） 双精度浮点数 double 8个字节 1.797693e+308~ 4.9000000e-324 字符型 char 2个字节 0~65535 布尔类型 boolean 1个字节 true false /** * 输出各种基础类型的bit大小，也就是所占二进制的位数,1Byte=8bit */ private static void getBit() { //The number of bits used to represent a {@code byte} value in two's complement binary form. //用来表示Byte类型的值的位数，说到底，就是bit的个数，也就是二进制的位数。 System.out.println("Byte: " + Byte.SIZE); System.out.println("Short: " + Short.SIZE); System.out.println("Character: " + Character.SIZE); System.out.println("Integer: " + Integer.SIZE); System.out.println("Float: " + Float.SIZE); System.out.println("Long: " + Long.SIZE); System.out.println("Double: " + Double.SIZE); System.out.println("Boolean: " + Boolean.toString(false)); }
3.注意事项：
- 字符串不是基本类型，而是引用类型。
- 浮点型可能只是一个近似值，并非精确值。
- 数据范围与字节数不一定相关，例如float数据范围比long更加广泛，但是float是4字节，long是8字节。
- 浮点数中默认类型是double，如果一定要使用float类型，需要加上一个后缀F，如果是整数，默认为int类型，如果要使用long类型，需要加入一个后缀L，推荐使用大写字母后缀。
6.2.对象类型
7.变量
程序运行期间，内容可以发生改变的量。
创建一个变量且使用的格式：
- 数据类型 变量名称：//创建了一个变量。
变量名称 = 数据值： //赋值
2. 数据类型 变量名称 = 数据值 //在创建一个变量的同时，立刻放入指定的数据值
public class Number{
public ststic void main(String[] args){
//使用第一种
int num1;
num1 = 10;
System.out.println(num1);
num1 = 20;
System.out.println(num1);
//使用第二种
int num2 = 25;
num2=20;
System.out.println(num2);
num2=35;
System.out.println(num2);
}
}
3. 注意事项：
- 如果创建多个变量,那么变量之间名称不可以重复.
- 对于float和long类型来说,字母后缀F和L不可以去掉
- 如果使用byte或者short类型的变量,右侧数值不能超过左侧数据类型的范围
- 没有进行赋值的变量不能直接使用,必须经过赋值
- 变量使用不能超过其作用域的范围.[作用域:从定义的一行开始,一直到直接所属的大括号结束为止.]
- 可以通过一个语句来创建多个变量.先创建,然后各自赋值.也可以同时各自赋值.
8.数据类型转换
- 自动转换(隐式):
- 特点:代码不需要进行特殊处理,自动完成.
- 规则:数据范围从小到大.
2. 强制类型转换(显式):
- 特点：代码需要进行特殊的格式处理，不能自动完成
- 格式：范围小的类型，范围小的变量名–（范围小的类型）原本范围大的数据。
- 注意事项：
-
- 强制类型装换一般不推荐使用，因为有可能发生精度损失，数据溢出。
-
- byte/short/char这三种类型都可以发生数字运算
-
- byte/short/char这三种类型都可以发生数字运算，被首先提升为int类型，然后再计算。
-
- boolean类型不能发生数据类型转换。
//自动转换
public class DataType1{
public static void main(Strings[] args){
System.out.println(1024);//这是一个整数,默认类型为int类型
System.out.println(3.14);//这是一个浮点数,默认就是double类型
//左边是long类型，右边为默认的int类型，左右不一样。
//一个等号代表赋值，将右边的int常量，交给左侧的龙变量进行存储
//int--->long,符合了数据范围从小到大的要求
long num1 = 100;
System.out.println(num1);//100
//左边是double类型，右边为float类型，左右不一样。
//float--->double,符合了数据范围从小到大的要求。
double num2 = 2.5F;
System.outy,println(num2);//2.5
//左边是float类型，右边为long类型，左右不一样。
//long--->float,符合了数据范围从小到大的要求。
float num3 = 30L;
System.out.println(num3);//30.0
}
}
//强制转换
public class DataType2{
public static void main(Strings[] args){
//左边为int类型，右边卫long类型，不一样
//long--->int 不是从小到大
//不能自动转换
int num = 100;
System.out.println(num);
//long强制装换为int类型，数据溢出
int num2 = (int)6000000000L;
System.out.println(num2);
//double-->int 强制转换，精度损失
int num3 = (int)3.5;
System.out.println(num3);//所有的小数位都被舍弃。
char zifu1 = 'A';//字符变量
System.out.println(zifu1 + 1);//66 也就是大写字母A被当做大写字母65进行处理。
//一旦char类型进行了数学运算，那么字符就会按照一定的规则翻译为一个数字
byte num4 = 40;
bute num5 = 50;
//byte-->byte-->int,int-->int
int result1 = num4+num5;
System.out.println(result1);//90
short num6 = 60;
//byte-->short-->int,int-->int
//int 强制转换为short,注意必须保证逻辑上真实大小
int result2 = (short) (num4+num6);
}
}
- 字符解析转换：
9.运算符
进行特定的操作的符号。
表达式：用运算符连起来的式子。
- 四则运算；
加减乘除
除法运算要特别注意：被除数/除数 = 商……余数。
-
注意事项：
1. 一旦运算符当中有不同类型的数据，那么结果将会是数据类型范围大的那种。 2. 加法使用用法： -
数值就是普通加法。
-
字符char型会被提升为int，然后再计算。
-
对于字符串String（首字母大写，但不是关键字）来说，加号代表字符串的连接操作。其中，任何数据类型和字符串进行连接的时候，结果都会变成字符串。
10.自增自减运算符
自增运算符：++
自减运算符：–
含义：让一个变量涨一个数字1，或者让一个变量降一个数字1。
使用格式：写在变量名称之前，或者变量名称之后、
使用方式：
- 单独使用，不和其他任何操作混合，自己独立成为一个步骤。
- 混合使用：和其他操作混合。
使用区别：
-
在单独使用的时候，前++和后++没有任何区别。
-
在混合使用时，存在区别：
1. 如果是前++，那么变量立刻马上+1，然后拿着结果进行使用。【先加后用】 1. 如果是后++，那么首先使用变量本来的数值，然后再让变量+1。【先用后加】 -
自减运算同自增。
注意事项：
只有变量才能使用自增自减运算符，常量不可发生改变，不能使用。
11.赋值运算符
分类：
基本运算符：就是一个等号=，代表将右侧的数据交给左侧的变量。
复合赋值运算符：+= ,-= ,*=,/=,%=。
注意事项:
- 只有变量才能使用赋值运算符,常量不可以进行赋值。
- 复合赋值运算符其中隐含了一个强制类型转换。
12.比较运算符
相等==, 小于< ,大于> , 小于等于<= ,大于等于>=, 不等于!=。
注意事项：
- 比较运算符的结果一定是一个boolean值，成立就是true，不成立就是false。
- 如果进行多次判断，不可以连着写。
13.逻辑运算符
与(并且) ： &&
或(或者) ： ||
非(取反) ： !
二.方法
1.定义
- 定义格式：public static void 方法名称（）{
方法体
}
方法名称的命名规则与变量一致；
方法体：在大括号中包含的任意条语句
2. 注意事项：
- 方法定义的先后顺序无所谓。
- 方法的定义不能产生嵌套包含关系。
- 方法定义完成之后，不会执行，如果要执行，一定要进行方法的【调用】。
2.调用
- 定义格式：
方法名称（）;
三.判断语句
1.单if语句
if(关系表达式){
语句体；
}
- 首先判断关系表达式看其结果是TRUE还是false;
- 如果是ture则执行语句体；
- 如果是false则不执行语句体。
2.标准的if else格式
if(关系表达式) {
语句体1；
}else{
语句体2;
}
- 首先判断关系表达式看其结果是是true还是false；
- 如果是true就执行语句体1；
- 如果是false就执行语句体2；
3.拓展的if else语句
if(判断条件1){
执行语句1；
}else if(判断条件2){
执行语句2；
}
……
}else if(判断条件n){
执行语句n；
}else {
执行语句n+1;
}
- 首先判断关系表达式看其结果是是true还是false；
- 如果是true就执行语句体1；
- 如果是false就继续判断关系表达式2看其结果是true还是false；
- 如果是true就执行语句体2；
- 如果是false就继续判断关系表达式……看其结果是true还是false；
- ……
1.语句练习：
- 题目1.
- 指定考试成绩，判断等级。
- 90-100 优秀
- 80-89 好
- 70-79 良
- 60-69 及格
- 60以下 不及格
public class KaoShi(){
public static void main(String[] args){
int socore = 90;
if(score>=90&&score<=100){
System.out printf("优秀");
}else if(score>=80&&score<=89){
System.out printf("好");
}else if(score>=70&&score<=79){
System.out printf("良");
}else if(score>=60&&score<=69){
System.out printf("及格");
}else if(score>=0&&score<=60){
System.out.printf("不及格");
}else {
System.out.printf("数据不合理！");
}
}
}
2. 题目2
使用三元运算符和标准的if-else语句分别实现，取两个数中的最大值。
public class BiJiao{
public static void main(String[] args){
int a = 105;
int b = 20;
//首先使用三元运算符
int max = a>b?a:b;
//使用if-else语句
int max;
if(a>b){
max = a;
}else{
max = b;
}
System.out.printf("最大值："+max);
}
}
四.选择语句
1.选择语句–switch
-
格式：
switch(表达式){ case 常量值1; 语句体1; break; case 常量值2; 语句体2; break; …… default; 语句体n+1; break; }- 执行流程：
-
首先计算出表达式的值
-
其次，和case依次比较，一旦拥有对应的值，就会执行相应的语句，在执行过程中，遇到break就会结束。
-
最后，如果所有的case都和表达式的值不匹配，就会执行default语句体部分，然后程序结束掉。
3. 注意事项： -
多个case后面的数值不可以重复。
-
switch后面小括号中只能是以下的数据类型：
- 基本数据类型：byte/short/char/int
- 引用数据类型：String字符串/enum枚举
-
switch语句格式灵活，前后顺序可以颠倒，而且break语句可以省略。（但是一般建议不要省略）”匹配哪一个case就从哪一位置向下执行，知道遇到了break或者整体结束为之。“
五.循环语句
1.循环结构的基本组成部分，一般分为四部分：
- 初始化语句：在循环最开始的时候执行，而且只执行一次。
- 条件判断：如果成立，则循环继续，如果不成立，则循环退出。
- 循环体：重复要做的事情内容，若干行语句。
- 步进语句：每次循环之后都要进行的扫尾工作，每次循环结束后都要执行一次。
-
循环语句1–for
- 格式
for(初始化表达式①；布尔表达式②；步进表达式④){ 循环体③ }- 执行流程:
- 执行顺序：①②③④>②③④>②③④……②不满足为止；
- ①负责完成循环变量初始化；
- ②负责判断是否满足循环条件，不满足则跳出循环；
- ③具体执行的语句
- ④循环后，循环条件所涉及及变量的变化情况。
-
循环语句2–while
- 标准格式：while(条件判断){
循环体；
}
2. 扩展格式：
初始化语句；
while(条件判断){
循环体；
步进语句；
}
初始化表达式①
while(布尔表达式②){
循环体③;
步进表达式④;
}
3. 执行流程：
- 执行顺序：①②③④>②③④>②③④……②不满足为为止；
- ①负责完成循环变量初始化；
- ②负责判断是否满足循环条件，不满足则跳出循环；
- ③具体执行的语句；
- ④循环后，循环条件所涉及及变量的变化情况。
- 循环语句3–do~while
- 循环格式
初始化表达式①
do{
循环体③;
步进表达式④;
}while(布尔表达式②)
2. 执行流程：
- 执行顺序：①②③④>②③④>②③④……②不满足为为止；
- ①负责完成循环变量初始化；
- ②负责判断是否满足循环条件，不满足则跳出循环；
- ③具体执行的语句；
- ④循环后，循环条件所涉及及变量的变化情况。
2.三种循环的区别
- 如果条件判断从来没有满足过，那么for循环和while循环会执行0次，但是do~while循环会执行至少一次。
- for循环的变量在小括号当中定义，只有循环内部才可以使用，while循环和do!while循环初始化语句本来就在外边，所以出来循环后还可以继续使用。
3.条件控制语句
break语句
- 用法：
- 可以使用在switch语句中，一旦执行，整个switch语句立刻结束。
- 可以使用在循环语句中，一旦执行，整个循环语句立刻结束，打断循环。
- 建议：
- 当次数已经确定的情况下多用for循环,否则多用while循环。
continue语句
- continue语句一旦执行，立刻跳过当前次循环剩余内容，立马开始下一次循环。
4.死循环
- 概念：
- 永远停不下来的循环。
- 标准格式：
while(true){
循环体;
}
5.循环嵌套
- 概念：
指一个循环的循环体是另一个循环，，总共的循环次数=外循环次数*内循环次数。
- 格式：
for(初始化表达式①；布尔表达式②；步进表达式⑦){
for(初始化表达式③；布尔表达式④；步进表达式⑥){
执行语句⑤
}
}
- 执行流程：
- 执行顺序：①②③④⑤⑥>④⑤⑥>⑦②③④⑤⑥>④⑤⑥
- 外循环一次，内循环多次。
- 时间练习：
public class Demo{
public void main(String[] args){
for(int hour = 0;hour<24;hour++){//外层控制小时
for(int minute = 0;minute<60;minute++){//内层控制小时之内的分钟
System.out.println(hour +"点"+minute+"分);
}
}
}
}
二.集成开发环境
一.IDEA的概念
安装
项目结构
基本配置
常用快捷键
三.复习简单方法
一.简单方法的使用
例子：
-
public class Demo{ public void main(String[]args){ for(int j =0;j<5;j++){ for(int i=0;i<5;i++){ System.out.println("*"); } Systm.out.println(); } } }- 复习：
- 定义格式：public static void 方法名称（）{}
- 调用格式：方法名称（）;
- 注意事项：
- 方法定义的先后顺序无所谓。
- 方法的定义不能产生嵌套包含关系。
- 方法定义完成之后，不会执行，如果要执行，一定要进行方法的【调用】。
- 复习：
二.完整调用格式
- 方法其实就是若干语句的功能集合。
- 方法就好比是一个工厂。
- 参数（原料），就是进入方法的数据。
- 返回值（产出值），就是从方法中出来的数据。
- 完整格式：修饰符 返回值类型 方法名称（参数类型 参数名称，…………）{
方法体；
return 返回值；
}
- 修饰符，现阶段固有写法 public static
-
返回值类型：也就是方法的最终产生的数据结果是什么类型
-
方法名称：方法的名字，规则和变量一样，小驼峰
-
参数类型：进入方法的数据是什么类型。
-
参数名称：进入方法的数据对应的变量名称。
- ps:参数如果有多个，使用逗号进行分隔
- 方法体：方法需要做的事情，若干行代码，
- return，两个作用，第一停止当前的方法，第二将后面的返回值还给调用处
- 返回值：也就是方法执行后最终产生的数据结果。
-
注意：return后面的“返回值”，必须和方法名称前面的”返回值类型“，保持对应。
-
定义一个两个int数字想加的方法：三要素。
-
返回值类型：int
-
方法名称：sum
-
参数列表：int a,int b
-
public class Demo{ public static void main(Strinf[]args) //单独调用 sum(10,20); System.out.println("-------------"); //打印调用 System.out.println(sum(10,20)); System.out.println("-------------"); //赋值调用 int num =sum((15,25)); num +=100; System.out.println("变量的值："+num); } public static int sum(int a,int b){ System.out.println("方法执行了："); int result =a +b; return result; }
-
-
方法的三种调用格式：
- 单独调用：方法名称（参数）；
- 打印调用：System.out.println(方法名称（参数）)；
- 赋值调用：数据类型 变量名称 = 方法名称（参数）；
-
注意：此前学习的方法，返回值类型固定写为void 这种方法只能单独使用，不能进行打印调用或者赋值调用。
-
三.方法参数
有参数
小括号中有内容，当一个方法需要一些数据条件，才可以完成任务，就是有参数。
无参数
小括号当中留空，一个方法中不需要任何的数据条件，自己就能独立完成任务，就是无参数。
public class Demo{
public void main(String[]args){
melthlod1(10,20);
System.out.println("=========");
melthod2;
}
//有参数的
public static void methlod1(int a,int b){
int result = a*b;
System.out.println("结果是:"+result);
}
//打印输出固定10次文本字符串
public static void melthod2(){
for(int i= 0;i<10;i++){
System.out.println("Hello Word!");
}
}
}
四.方法返回
有返回值
//题目要求：定义一个方法，用来【求出】两个数字之和。
public class Demo{
public void main(String[]args){
//main方法实现调用
int num = getSum(10,20);
System.out.println("返回值是:"+num);
System.out.println("=========");
//均是正确写法
System.out.println(getSum(2,3));
getSum(2,3);
}
//方法：负责两数相加
public static void getSum(int a,int b){
int result = a+b;
return result;
}
}
无返回值
//题目要求：定义一个方法，用来【打印】两个数字之和。
public class Demo{
public void main(String[]args){
printSum(100,200);
//对于void没有返回值的方法，只能单独，不能打印或者赋值调用
System.out.println(getSum(2,3));//错误写法
int num2 = printSum(10,20);//错误写法
int num3 = void;//错误写法
}
//方法：负责两数相加,但我没有返回值。只会打印输出
public static void printSum(int a,int b){
int result = a+b;
System.out.println("结果是:"+result);
}
}
- 注意事项：
- 对于有返回值的方法，可以使用单独调用，打印调用或者赋值调用。
- 对于无返回值的方法，只能使用单独调用，不能使用打印调用或者赋值调用。
五.练习
练习一
- 题目要求：定义一个方法，用来判断两个数字是否相同。
- 三要素
- 返回值类型：boolean
- 方法名称：isSame
- 参数列表：int a,int b
public class Demo {
public static void main(String[] args) {
System.out.println(isSame(10,20));//false
System.out.println(isSame(20,20));//true
}
public static boolean isSame(int a,int b){
//不同的写法
//第一种
// boolean same;
// if(a==b){
// same = true;
// }
// else {
// same = false;
// }
// return same;
//第二种
// same = a==b?true:false
// boolean same = a==b?true:false
//第三种
boolean same = a==b;
//第四种
return a==b;
}
}
练习二
- 题目要求：定义一个方法，用来求出1~100之间所有数字的和值
- 三要素：
- 返回值：有返回值，计算结果是一个int数字。
- 方法名称：getSum。
- 参数列表：数据范围已经确定，是固定的，故而不需要参数。
public class Demo {
public static void main(String[] args) {
System.out.println("结果是："+getSum());
}
public static int getSum(){
int sum = 0;
for (int i = 1; i <= 100; i++) {
sum +=i;
}
return sum;
}
}
练习三
-
题目要求：定义一个方法，用来打印指定次数的Hello World
-
三要素：
- 返回值类型：只是进行一大堆的打印，并没有计算
- 方法名称：printCount
- 参数列表：次数：int
public class Demo { public static void main(String[] args) { printCount(10); } public static void printCount(int num){ for (int i = 0; i < num; i++) { System.out.println("Hello world!"+(i+1)); } } }
六.方法的注意事项
- 方法应该定义在类当中，但不能在方法当中再定义方法，不能嵌套。
- 方法定义的前后顺序无所谓。
- 方法定义之后不会执行，如果希望执行，一定要调用：单独调用，打印调用，赋值调用。
- 如果方法有返回值，那么必须写上“return返回值”，不能没有。
- return后面的返回值数据，必须和方法后面的返回值对应起来。
- 对于一个void没有返回值的方法，不能写return后面的返回值，只能写return自己。
- 对于void方法中最后一行的return可以省略不写。
- 一个方法中可以有多个return语句，但是必须保证同时只有一个会被执行到。两个return不能连写。
七.重载
一.基本使用
- 因为功能类似方法来说，由于参数列表的不同，但需要很多不同的方法名称。故而使用方法的重载。
- 方法的重载(Overload).
- 多个方法的名称一样，但是参数列表不一样。
- 优点：只需要记住一个方法名称，就可以实现类似的多个功能。
二.注意事项
方法的重载与下列因素有关：
- 参数个数不同。
- 参数类型不同。
- 参数的多类型顺序不同。
方法重载与下列因素无关：
- 与参数的名称无关。
- 与方法的返回值类型无关。
三.练习
练习一：
-
题目要求：比较两个数据是否相等，参数类型分别为两个byte类型，两个short类型，两个int类型，两个long类型。
-
public class Demo { public static void main(String[] args) { byte a = 10; byte b = 20; System.out.println(isSame(a,b)); System.out.println(isSame((short) 20,(short) 20)); System.out.println(isSame(11,12)); System.out.println(isSame(10l,10l)); } public static boolean isSame(byte a,byte b){ System.out.println("两个byte参数的方法执行！"); boolean same; if (a==b){ same = true; }else { same = false; } return same; } public static boolean isSame(short a,short b){ System.out.println("两个short参数的方法执行！"); boolean same = a==b?true:false; return same; } public static boolean isSame(int a,int b){ System.out.println("两个int参数的方法执行！"); return a==b; } public static boolean isSame(long a,long b){ System.out.println("两个long参数的方法执行！"); if(a==b){ return true; }else { return false; } } }
练习二
-
判断方法是重载关系。
-
public static void open(){}//正确重载 public static void open(int a){}//正确重载 static void open(int a,int b)//代码错误，与第8行冲突 public static void open(double a,int b){}//正确重载 public static void open(int a,double b){}//代码错误，与第6行冲突 public void open(int a,double b){}//代码错误，与第5行冲突 public static void OPEN(){}//代码正确不会报错，但是并不是有效重载 public static void open(int i,int j){}//代码错误，与第3行冲突
练习三
-
基本数据类型和（引用类型）String的打印（println）；
-
z在调用输出语句的时候，println方法其实就是进行了多种数据类型的重载形式。
-
public class Demo { public static void main(String[] args) { myPrint(100);//int myPrint("hello");//String; } public static void myPrint(byte num){ System.out.println(num); } public static void myPrint(short num){ System.out.println(num); } public static void myPrint(int num){ System.out.println(num); } public static void myPrint(long num){ System.out.println(num); } public static void myPrint(float num){ System.out.println(num); } public static void myPrint(double num){ System.out.println(num); } public static void myPrint(char zifu){ System.out.println(zifu); } public static void myPrint(boolean is){ System.out.println(is); } public static void myPrint(String str){ System.out.println(str); } }
八.数组
1.概念
- 数组：是一种容器，可以保存多个数据值。
- 特点：
- 数组是一种引用的数据类型。
- 数组当中的多个数据，类型必须统一。
- 数组的长度在程序运行期间不可更改。
2.定义格式
-
数组的初始化：在内存中创建一个数组，并且向其中赋予一些默认值。
-
初始化方式：
-
动态初始化：(指定长度)；
- 创建数组的时候，直接指定数组当中的数据元素个数。
- 格式：数组类型[] 数组名称 = new 数据类型[数据长度]；
- 左侧数据类型：就是数组当中保存的数据，全部都是统一的类型。
- 左侧的中括号：代表就是一个数组。
- 左侧的数组名称：给数组起一个名字。
- 右侧的new：代表创建数组的动作。
- 右侧数据类型：必须与左侧数据类型保持一致。
- 右侧中括号长度：也就是在数组当中，到底可以保存多少个数据，是一个int数字。
-
public class Demo { public static void main(String[] args) { //创建一个数组，当中可以存放300个int数据 //格式：数组类型[] 数组名称 = new 数据类型[数据长度]； int [] arrayA = new int[300]; //创建一个数组，当中可以存放10个double类型的数据 double[] arrayB = new double[10]; //创建一个数组,当中存放5个字符串 String[] arrayC = new String[5]; } } -
静态初始化：(指定内容)；
-
创建数组的时候，不直接指定数据个数的多少，而是直接将具体的数据内容进行指定。
-
标准格式：数据类型[]数组名称 = new 数据类型[]{具体的元素……}。
public static void main(String[] args) { //直接创建一个数组，里面装的全部都是int数字，具体为:5，15，25 int[] arrayA = new int[]{5,15,25}; //创建一个数组，用来装字符串："Hello","World","Java"; String[]arrayB = new String[]{"Hello","World","Java"}; } -
注意事项：
- 虽然静态初始化没有直接告诉长度，但根据大括号里面的元素具体内容，也可以自动推算出长度。
- 静态初始化的标准格式可以拆分为两个步骤。
- 动态初始化也可以拆分为两个步骤。
- 静态初始化的省略格式不可以拆分为两个步骤。
-
当使用静态初始化数组的时候，格式还可以省略一下。
- 数据类型[]数组名称 = {具体的元素……}；
-
public static void main(String[] args) { //使用了省略格式的静态初始化。 int[]arrayA = {10,20,30}; //静态初始化的标准格式可以拆分为两个步骤。 int [] arrayB; arrayB = new int[]{11,21,31}; //动态初始化也可以拆分为两个步骤。 int[]arrayC; arrayC = new int[5]; //静态初始化的省略格式不可以拆分为两个步骤。 // int[]arrayD; // arrayD = {10,20,30}; }
-
-
-
使用建议：当不确定数组当中的具体内容，用动态初始化，否则，已经确定了具体的内容，用静态初始化。
3.获取数组元素
-
直接打印数组名称的话，得到的是数组对应的，内存地址哈希值。
-
访问数据元素：
- 格式：数组名称[索引值]。
- 索引值：就是一个int数字，代表数组当中元素的编号。
- 【注意】：索引值从0开始，一直到”数组长度-1“为止。
-
public class Demo { public static void main(String[] args) { //静态初始化的省略格式 int[]array = {10,20,30}; System.out.println(array);//[I@7f31245a //直接打印数组名称的话，得到的是数组对应的，内存地址哈希值。 //直接打印数组当中的元素 System.out.println(array[0]);//10 System.out.println(array[1]);//20 System.out.println(array[2]);//30 System.out.println("============================="); //也可以将数组当中的某一个单个元素，赋值交给变量 int num = array[1]; System.out.println(num); } }
4.赋值数组元素
-
使用动态初始化数组的时候，其中的元素将会自动拥有一个默认值。规则如下：
- 如果是整数类型，那么默认为0；
- 如果是浮点类型，那么默认为0.0；
- 如果是字符类型，那么默认为’\u0000’；
- 如果是布尔类型，那么默认为false；
- 如果是引用类型，那么默认为null；
-
注意事项：
- 静态初始化其实也有默认值的过程，但系统自动马上将默认值替换成为了大括号中的具体数值。
-
代码：
public class Demo { public static void main(String[] args) { //静态初始化的省略格式 int[]array = new int[3]; System.out.println(array);//内存地址值 System.out.println(array[0]);//0 System.out.println(array[1]);//0 System.out.println(array[2]);//0 System.out.println("======================="); //将数据123赋值交给数组array当中的1号元素 array[1] = 123; System.out.println(array[0]);//0 System.out.println(array[1]);//123 System.out.println(array[2]);//0 } }
5.内存的划分
栈内存（Stack）
存放的都是方法中的局部变量。方法的运行一定要在栈当中。
- 局部变量：方法的参数，或者方法{}内部的变量。
- 作用域：一旦超出作用域，立刻从栈内存当中流失。
堆内存（Heap）
凡是new出的东西，都在堆当中。
- 堆内存里面的东西都有一个地址值:16进制。
- 堆内存里面的数据，都有默认值，规则：
- 如果是整数类型，那么默认为0；
- 如果是浮点类型，那么默认为0.0；
- 如果是字符类型，那么默认为’\u0000’；
- 如果是布尔类型，那么默认为false；
- 如果是引用类型，那么默认为null；
方法区（Method Area）
存储class相关信息，包含方法的信息。
本地方法栈（Native Method Stack）
与操作系统有关。
寄存器（pc Register）
与CPU有关。
6.一个数组的内存图
public class Demo {
public static void main(String[] args) {
//静态初始化的省略格式
int[]arrayA = new int[3];
System.out.println(arrayA);//内存地址值
System.out.println(arrayA[0]);//0
System.out.println(arrayA[1]);//0
System.out.println(arrayA[2]);//0
System.out.println("=======================");
//将数据123赋值交给数组array当中的1号元素
arrayA[1] = 10;
arrayA[2] = 20;
System.out.println(arrayA[0]);//0
System.out.println(arrayA[1]);//10
System.out.println(arrayA[2]);//20
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-T0B6hOo9-1638801464552)(D:\笔记\javaimages\屏幕截图 2021-11-28 162013.png)]
7.两个数组的内存图
public class Demo {
public static void main(String[] args) {
//静态初始化的省略格式
int[]arrayA = new int[3];
System.out.println(arrayA);//内存地址值
System.out.println(arrayA[0]);//0
System.out.println(arrayA[1]);//0
System.out.println(arrayA[2]);//0
System.out.println("=======================");
//将数据123赋值交给数组array当中的1号元素
arrayA[1] = 10;
arrayA[2] = 20;
System.out.println(arrayA[0]);//0
System.out.println(arrayA[1]);//10
System.out.println(arrayA[2]);//20
int[]arrayB = new int[3];
System.out.println(arrayB);//内存地址值
System.out.println(arrayB[0]);//0
System.out.println(arrayB[1]);//0
System.out.println(arrayB[2]);//0
System.out.println("=======================");
//将数据123赋值交给数组array当中的1号元素
arrayB[1] = 100;
arrayB[2] = 200;
System.out.println(arrayB[0]);//0
System.out.println(arrayB[1]);//100
System.out.println(arrayB[2]);//200
}
}
8.两个引用指向同一个数组
public class Demo {
public static void main(String[] args) {
//静态初始化的省略格式
int[]arrayA = new int[3];
System.out.println(arrayA);//内存地址值
System.out.println(arrayA[0]);//0
System.out.println(arrayA[1]);//0
System.out.println(arrayA[2]);//0
System.out.println("=======================");
//将数据123赋值交给数组array当中的1号元素
arrayA[1] = 10;
arrayA[2] = 20;
System.out.println(arrayA[0]);//0
System.out.println(arrayA[1]);//10
System.out.println(arrayA[2]);//20
//将arrayA数组的地址值，赋值给arrayB数组
int[]arrayB = arrayA;
System.out.println(arrayB);//内存地址值
System.out.println(arrayB[0]);//0
System.out.println(arrayB[1]);//0
System.out.println(arrayB[2]);//0
System.out.println("=======================");
//将数据123赋值交给数组array当中的1号元素
arrayB[1] = 100;
arrayB[2] = 200;
System.out.println(arrayB[0]);//0
System.out.println(arrayB[1]);//100
System.out.println(arrayB[2]);//200
}
}
9.数组索引越界
-
数组的索引值编号从0开始，一直到“数组长度-1”为之。
-
如果访问数组元素的时候,索引编号并不存在,那就会发生索引越界异常:ArrayIndexOutOfBoundsException。
-
原因：索引编号写错了。
-
解决办法：修改成为存在的正确索引编号。
-
public class Demo { public static void main(String[] args) { int[]array = {15,25,35}; System.out.println(array[0]);//15 System.out.println(array[1]);//25 System.out.println(array[2]);//35 //错误写法，并不存在的元素 System.out.println(array[3]); } }
10.空指针异常
- 所有的引用类型都可以赋值为一个null值，但代表其中什么都没有。
- 数组必须进行new初始化才能使用其中的元素，如果只是赋值了一个null，没有进行new创建，那么就会发生空指针异常：NullPointerException
- 原因：忘了new。
- 解决：补上new。
11.获取数组长度
- 如何获取数组长度：
- 格式：数组名称：.length
- 数字一旦创建，程序运行期间，长度不可改变。
12遍历数组
-
遍历数组，就是对数字中的每一个元素进行逐一，挨个处理，默认的处理方式就是打印输出。
-
public class Demo { public static void main(String[] args) { int[] array = {15, 25, 45, 96, 45,60,75}; //原始方式 System.out.println(array[0]); System.out.println(array[1]); System.out.println(array[2]); System.out.println(array[3]); System.out.println(array[4]); System.out.println(array[5]); System.out.println("===================="); //使用循环,次数就是数组的长度 for (int i = 0; i < 6; i++) { System.out.println(array[i]); } System.out.println("===================="); int len = array.length; for (int i = 0; i < array.length; i++) { System.out.println(array[i]); } } }
13.练习
-
求出一个数组中的最值
-
最大值
public class Demo { public static void main(String[] args) { int[] array = {5,15,30,20,10000}; int max = array[0]; for (int i = 1; i < array.length; i++) { //如果当前元素，比max更大，则换人 if (array[i]>max){ max = array[i]; } } System.out.println("最大值:"+max); } } -
最小值
public class Demo { public static void main(String[] args) { int[] array = {5,15,30,20,-20,10000}; int min= array[0]; for (int i = 1; i < array.length; i++) { //如果当前元素，比min更小，则换人 if (array[i]<min){ min = array[i]; } } System.out.println("最小值:"+min); } } -
数组元素的反转
-
数组元素反转，就是对称位置的元素交换。
-
题目要求：
- 本来的样子{1，2，3，4}
- 之后的样子{4，3，2，1}
- 要求不能使用新数组，就用原来的唯一一个数组。
-
代码：
public class Demo { public static void main(String[] args) { int[] array = {10,20,30,40,50,60,70,80,90}; for (int i = 0; i < array.length; i++) { System.out.println(array[i]); } System.out.println("==================="); for (int min = 0,max = array.length-1;min<max;min++,max--){ int temp = array[min]; array[min] = array[max]; array[max] = temp; } //再次打印输出之后的样子 for (int i = 0; i < array.length; i++) { System.out.println(array[i]); } } }
-
14.数组作为方法参数
- 数组可以作为方法的参数。
- 当调用方法的时候，向方法的小括号进行传参，传递进去的其实是数组的地址值。
public class Demo {
public static void main(String[] args) {
int[] array = {10,20,30,40,50,60,70,80,90,100};
System.out.println(array);//地址值
printArray(array);//传递进去的就是array当中保存的地址值。
System.out.println("================AAA================");
printArray(array);
System.out.println("================BBB================");
printArray(array);
// for (int i = 0; i < array.length; i++) {
// System.out.println(array[i]);
// }
// System.out.println("aaa");
// for (int i = 0; i < array.length; i++) {
// System.out.println(array[i]);
// }
// System.out.println("bbb");
// for (int i = 0; i < array.length; i++) {
// System.out.println(array[i]);
// }
}
/*
三要素：
返回值类型：只是进行打印而已，不需要进行计算，也没有结果，用void
方法名称：printArray
参数列表：必须给我数组，我才能打印其中的元素。int[]array
*/
public static void printArray(int[]array){
System.out.println("printArray方法收到的参数是：");
System.out.println(array);
for (int i = 0; i < array.length; i++) {
System.out.println(array[i]);
}
}
}
15.数组作为方法返回值
-
一个方法可以有0，1，多个参数，但是只能有0或者1个返回值，不能有多个返回值。
-
如果希望一个方法中产生了多个结果三个护具进行返回，怎么办？
-
解决方案：使用一个数组作为返回值类型即可。
-
任何数据类型都能作为方法的参数类型，或者返回值类型。
-
数组作为方法的参数，传递进去的其实是数组的地址值。
-
数组作为方法的返回值，返回的其实也是数组的地址值。
-
public class Demo { public static void main(String[] args) { int[]result = calculte(10,20,30); System.out.println("main方法接收到的返回值数组是："); System.out.println(result); System.out.println("总和："+result[0]); System.out.println("平均数"+result[1]); } public static int[] calculte(int a,int b,int c){ int sum = a+b+c; int avg = sum/3; int[]array = new int[2]; array[0] = sum; array[1] = avg; System.out.println("calculate方法内部数组是："); System.out.println(array);//地址值 return array; } } ``
15万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
