Java基础知识笔记-从HelloWorld开始

最新推荐文章于 2023-07-28 14:50:38 发布

JackLi_Liang

最新推荐文章于 2023-07-28 14:50:38 发布

阅读量760

点赞数 1

分类专栏：黑马学习笔记文章标签： python 编程语言

本文链接：https://blog.csdn.net/weixin_42269739/article/details/106023250

版权

黑马学习笔记专栏收录该内容

13 篇文章 1 订阅

订阅专栏

1 写在前面

JVM + 核心类库 = JRE + 编译器等开发工具 = JDK

Java环境变量的配置 : 计算机 -> 属性-> 高级系统设置 -> 系统变量 -> 新建系统变量

JAVA_HOME : 选择Java工具包的bin目录的上一级目录

Path : %JAVA_HOME%\bin

Java程序开发三步骤 : 编写, 编译, 运行

编译 : javac.exe 编译器运行 : java.exe 解释器

public class HelloWorld {
	public static void main(String[] args) {
		System.out.println("Hello World!");
	}
}

// 先 javac HelloWorld.java, 再 java HelloWorld

2 标识符的概念及规则

标识符 : 在程序中,我们自己定义的内容; 比如类, 方法, 变量的名字都称为标识符
命名规则 : 硬性要求
- 标识符可以包含英文字母26个(区分大小写),0-9数字,$(美元符号) 和 _(下划线)
- 标识符不能以数字开头
- 标识符不能是已有的关键字
命名规范 : 软性建议
- 类名规范 : 首字母大写, 后面每个单词首字母大写 (大驼峰式)
- 变量名规范 : 首字母小写, 后面每个单词首字母大写 (小驼峰式)
- 方法名规范 : 同变量名规范

3 常量

定义 : 是指在Java程序运行期间固定不变的数据

类型	含义	数据举例
整数常量	所有的整数	0, 1 , 5, -5
浮点数常量	所有的小数	1.4 , 0.0, -4.9
字符常量	单引号引起来的,只能写一个字符,必须有内容	‘a’, ‘好’
字符串常量	双引号引起来的,可以写多个, 可以不写	‘aaaaa’, 'Hello’
布尔常量	两个值	true, fasle
空常量	一个值; 空常量不能直接用来打印输出	null

System.out.println(5);
System.out.println(5.0);
System.out.println('5');
System.out.println("admin);

4 数据基本类型

Java数据类型分为两大类 : 基本数据类型和引用数据类型

基本数据类型 : 整数, 浮点数, 字符, 布尔这四大类又可分为八种

引用数据类型 : 字符串, 类, 数组, 接口, Lambda

数据类型	关键字	内存占用	取值范围
字节型	byte	1个字节	-128 ~127
短整型	short	2 个字节	-32768 ~ 32767
整型	int	4个字节(默认)	-2的31次方 ~ 2的31次方-1
长整型	long	8个字节	-2的63次方 ~ 2的63次方-1
单精度浮点数	float	4个字节	1.4013E-45 ~ 3.4028E+38
双精度浮点数	double	8个字节	4.9E-324~1.7977E+308
字符	char	2个字节	0-65535
布尔	boolean	1个字节	true, false

注意事项 :

字符串不是基本类型, 而是引用类型
浮点型可能是一个近似值, 并非精确的值
数据范围与字节数不一定相关, 例如float数据范围比long更加广泛,但是float是4个字节,long是8个字节
浮点数当中默认类型是double,如果一定要使用float类型, 需要加上一个后缀F, 推荐使用大写字母后缀
如果是整数, 默认是int类型, 如果一定要使用long类型, 需要加上一个后缀F, 推荐使用大写字母后缀

5 变量

定义 : 在程序运行期间可以变化的量称为变量

Java中要求一个变量每次只能保存一个数据, 且必须要明确保存变量的数据类型

变量定义的格式包括三个要素：数据类型、变量名、数据值。

数据类型变量名称 = 数据值; // 创建了一个变量,并将数据值赋值给变量

注意事项 :

如果创建多个变量, 变量之间的名称不可以重复
对于float和long类型来说, 字母后缀F和L不要丢掉
如果使用byte或者short类型的变量, 那么右侧的数据值不能超过左侧类型的范围
没有进行赋值的变量, 不能直接使用; 一定要赋值之后, 才能使用
变量的使用不能超过作用域的范围[作用域: 从定义变量的一行开始, 一直到直接所属的大括号为止]

6 数据类型转换

自动类型转化 – 隐式转换

将取值小的范围自动提升为取值范围大的类型, 比如:一个int类型与byte字节类型相加运算是int类型

public static void main(String[] args){
        int i = 1;
        byte b = 2;
        // byte x = b + i; // 报错 
        // int类型和byte类型运算，结果是int类型 
        int j = b + i; 
        System.out.println(j);
}

同样道理当一个 int 类型变量和一个double 变量运算时，int 类型将会自动提升为 double 类型进行运算。

public static void main(String[] args) {
    int i = 1; 
    double d = 2.5; 
    //int类型和double类型运算，结果是double类型 
    // int类型会提升为double类型
    double e = d+i;
    System.out.println(e);
 }

转换规则 :范围小的类型向范围大的类型提升; byte, short ,char 运算时直接提升为 int

byte、short、char‐‐>int‐‐>long‐‐>float‐‐>double

强制类型转换 – 显式转换

将 1.5 赋值到 int 类型变量会发生什么? 产生编译失败, 肯定无法赋值

int i = 1.5
// // 错误 double 类型内存8个字节， int 类型内存4个字节。 1.5 是 double 类型，取值范围大于 int 。可以理解为 double 是8 升的水壶， int 是4升的水壶，不能把大水壶中的水直接放进小水壶去。 想要赋值成功，只有通过强制类型转换，将 double 类型强制转换成 int 类型才能赋值。

强制类型转换：将取值范围大的类型强制转换成取值范围小的类型。比较而言，自动转换是Java自动执行的，而强制转换需要我们自己手动执行。

转换格式 : 数据类型 (范围小) 变量名 (范围小) = (数据类型 – 范围小) 被转数据值(范围大);

int i = (int) 1.5;

public static void main(String[] args) { 
    //short类型变量，内存中2个字节 
    short s = 1;
    /*出现编译失败 s和1做运算的时候，1是int类型，s会被提升为int类型 s+1后的结果是int类型，将结果在赋值会short类型时发生错误 short内存2个字节，int类型4个字节 必须将int强制转成short才能完成赋值 */
    s = s + 1;//编译失败 
    s = (short) (s+1);//编译成功 
}

注意事项 :

强制类型转换一般不推荐使用, 有可能发生精度损失, 数据溢出

7 ASCII编码表

public static void main(String[] args){
    // 字符类型变量
    char c = 'a';
    int i = 1;
    // 字符类型和int类型计算
    System.out.println(c+i);  //输出结果为98
}

字符	数值
0	48
9	57
A	65
Z	90
a	97
z	122

在char类型和int类型计算的过程中，char类型的字符先查询编码表，得到97，再和1求和，结果为98。 char类型提升为了int类型。char类型内存2个字节，int类型内存4个字节。

8 运算符

算数运算符

算数运算符包括：
+	加法运算，字符串连接运算
-	减法运算
*	乘法运算
/	除法运算
%	取模运算，两个数字相除取余数
++、—	自增自减运算

Java中, 整数使用以上运算符 ,无论怎么计算, 也不会得到小数

public static void main(String[] args) { 
    int i = 1234;
    System.out.println(i/1000*1000);//计算结果是1000
}

一切基本数据类型与 String字符串用 + 都是拼接形成新的字符串

自增运算符 : ++

自减运算符 : –

使用格式 : 写在变量名称之前, 后缀写在变量名称之后, 例如: ++num, 也可以num++

使用方式 :

单独使用 : ++num, num++ 没有任何区别

混合使用 :

A - 如果是前++ ,那么变量立刻马上+1,然后拿着结果使用 [先加后用]

B - 如果是后++,那么使用变量本来的数值,然后再让变量+1 [先用后加]

注意事项 : 只有变量才能使用自增, 自减运算符; 常量不可改变, 所以不能用

赋值运算符

赋值运算符包括：
=	等于号
+=	加等于
-=	减等于
*=	乘等于
%=	取模等
/=	除等于

赋值运算符 : 就是将符号左边的值, 赋给左边的变量

 public static void main(String[] args){ 
    int i = 5; 
    i+=5;//计算方式 i=i+5 变量i先加5，再赋值变量i 
    System.out.println(i); //输出结果是10
}

比较运算符

比较运算符包括：
==	比较符号两边数据是否相等，相等结果是true。
>	比较符号左边的数据是否大于右边的数据，如果大于结果是true。
<	比较符号左边的数据是否小于右边的数据，如果小于结果是true。
>=	比较符号左边的数据是否大于或者等于右边的数据，如果小于结果是true。
<=	比较符号左边的数据是否小于或者等于右边的数据，如果小于结果是true。
!=	不等于符号，如果符号两边的数据不相等，结果是true。

比较运算符 : 两个数据之间比较的运算, 运算结果都是布尔值 true 或者 false

逻辑运算符

逻辑运算符包括：
&& 短路与	1. 两边都是true，结果是true 2. 一边是false，结果是false 短路特点：符号左边是false，右边不再运算 [全真为真]
！取反	1. ! true 结果是false 2. ! false结果是true
\|\| 短路或	1. 两边都是false，结果是false 2. 一边是true，结果是true 短路特点：符号左边是true，右边不再运算。 [一真为真]

三元运算符

运算法则 : 数据类型变量名 = 布尔类型表达式 ? 结果1 : 结果2

当布尔类型表达式值为true, 取结果1赋值给变量 ; 否则即当布尔类型表达式值为false, 取结果2赋值给变量;

9 JDK的JShell的简单使用

当我们编写的代码非常少的时候, 而又不愿意编写类, main方法, 也不愿意去编译和运行,就要使用JShell命令

在cmd当中输入 jshell进入,输入 /exit 退出命令

编译器的的优化 :

对于 byte/short/char 三种类型来说, 如果右侧赋值的数值没有超过范围, 那么javac编译器将会自动隐含地(强转)为我们补上一个(byte)(short)(char); 如果右侧超过了左侧的范围, 那么直接编译报错
在给变量赋值的时候, 如果右侧的表达式当中全都是常量, 没有任何变量, 那么编译器javac 将会直接将若干个常量表达式计算得到结果; short = 5 + 8; // 等号右边全都是常量, 没有任何变量参与运算编译之后, 得到的.class 字节码文件当中相当于[直接就是] : short result = 13;右侧的常量结果数值, 没有超过左侧范围, 所以正确; 这称之为"编译器的常量优化"

10 流程控制

顺序结构

在一个程序执行的过程中，各条语句的执行顺序对程序的结果是有直接影响的。也就是说，程序的流程对运行结果
有直接的影响。所以，我们必须清楚每条语句的执行流程。而且，很多时候我们要通过控制语句的执行顺序来实现
我们要完成的功能。

public static void main(String[] args){
//顺序执行，根据编写的顺序，从上到下运行
System.out.println(1);
System.out.println(2);
System.out.println(3);
}

判断语句

if(关系表达式)｛
语句体;
｝



public static void main(String[] args){
    System.out.println("开始");
    // 定义两个变量
    int a = 10;
    int b = 20;
    //变量使用if判断
    if (a == b){
    System.out.println("a等于b");
    }
    int c = 10;
    if(a == c){
    System.out.println("a等于c");
    }
    System.out.println("结束");
｝

执行流程 :

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

if…else

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

执行流程 :

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

if …else if …else

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。

public static void main(String[] args) {
    // x和y的关系满足如下：
    // x>=3 y = 2x + 1;
    //‐1<=x<3 y = 2x;
    // x<=‐1 y = 2x – 1;
    // 根据给定的x的值，计算出y的值并输出。
    // 定义变量
    int x = 5;
    int y;
    if (x>= 3) {
    y = 2 * x + 1;
    } else if (x >= ‐1 && x < 3) {
    y = 2 * x;
    } else {
    y = 2 * x ‐ 1;
    }
    System.out.println("y的值是："+y);
}

选择语句

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

执行流程 :

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

public static void main(String[] args) {
    //定义变量，判断是星期几
    int weekday = 6;
    //switch语句实现选择
    switch(weekday) {
    case 1:
    System.out.println("星期一");
    break;
    case 2:
    System.out.println("星期二");
    break;
    case 3:
    System.out.println("星期三");
    break;
    case 4:
    System.out.println("星期四");
    break;
    case 5:
    System.out.println("星期五");
    break;
    case 6:
    System.out.println("星期六");
    break;
    case 7:
    System.out.println("星期日");
    break;
    default:
    System.out.println("你输入的数字有误");
    break;
    }
}

switch语句中, 表达式的数据类型 ,可以是byte, short, int ,char ,enum(枚举), 还可以是字符串

循环语句

循环语句可以在满足循环条件的情况下, 反复执行某一段代码, 这段被重复执行的代码被称为循环体语句, 当反复执行这个循环体时, 需要在合适的时候把循环判断条件修改为false, 从而结束循环, 否则循环将一直执行下去, 形成死循环

for循环语句表达式

for(初始化表达式①; 布尔表达式②; 步进表达式④){
    循环体③
}

执行流程 :

执行顺序：①②③④>②③④>②③④…②不满足为止。

①负责完成循环变量初始化

②负责判断是否满足循环条件，不满足则跳出循环

③具体执行的语句

④循环后，循环条件所涉及变量的变化情况

public static void main(String[] args) {
    //定义变量从0开始，循环条件为<10
    for(int x = 0; x < 10; x++) {
    System.out.println("HelloWorld"+x);
    }
}
循环练习：使用循环，计算1-100之间的偶数和
public static void main(String[] args) {
    //1.定义一个初始化变量,记录累加求和,初始值为0
    int sum = 0;
    //2.利用for循环获取1‐100之间的数字
    for (int i = 1; i <= 100; i++) {
    //3.判断获取的数组是奇数还是偶数
    	if(i % 2==0){
    	//4.如果是偶数就累加求和
   		sum += i;
    	}
    }
    //5.循环结束之后,打印累加结果
    System.out.println("sum:"+sum);
}

do…while循环表达式

初始化表达式①
do{
循环体③
步进表达式④
}while(布尔表达式②);


输出10次HelloWorld
public static void main(String[] args) {
    int x=1;
    do {
    System.out.println("HelloWorld");
    x++;
    }while(x<=10);
}

do…while循环的特点：无条件执行一次循环体，即使我们将循环条件直接写成false，也依然会循环一次。这样的
循环具有一定的风险性，因此初学者不建议使用do…while循环。

跳出语句

break : 终止swtich或者循环

public static void main(String[] args) {
     for (int i = 1; i<=10; i++) {
     //需求:打印完两次HelloWorld之后结束循环
     if(i == 3){
     break;
     }
     System.out.println("HelloWorld"+i);
     }
 }

continue : 结束本次循环, 继续下一次的循环

public static void main(String[] args) {
    for (int i = 1; i <= 10; i++) {
    //需求:不打印第三次HelloWorld
    if(i == 3){
    continue;
    }
    System.out.println("HelloWorld"+i);
    }
}

死循环 : 也就是循环中的条件永远为true，死循环的是永不结束的循环。例如：while(true){}

嵌套循环
所谓嵌套循环，是指一个循环的循环体是另一个循环。比如for循环里面还有一个for循环，就是嵌套循环。总共的循环次数=外循环次数*内循环次数

外循环一次, 内循环多次

for(初始化表达式①; 循环条件②; 步进表达式⑦) {
    for(初始化表达式③; 循环条件④; 步进表达式⑥) {
        执行语句⑤;
    }
}

11 开发工具 Intellij IDEA

IDEA是一个专门针对java的集成开发工具(IDE), 由java语言编写, 所以, 需要有JRE运行环境并配置好环境变量; 他可以极大的提升我们的开发效率, 可以自动编译, 检查错误

项目Project --> 模块Module --> 包 Packpage

IDE的 HelloWorld 在模块的src目录下新建 java class,写上 psvm 快捷生成 main()

IDE的基本设置 : 更改自动补全为 Alt+/

IDEA常用快捷键

快捷键	功能
`Alt+Enter`	导入包, 自动修正代码
`Ctrl+Y`	删除光标所在行
`Ctrl+D`	复制光标所在行的内容, 插入光标位置下面
`Ctrl+Alt+L`	格式化代码
`Ctrl+/`	单行注释, 再按取消注释
`cTRL+Shift+/`	选中代码注释, 多行注释, 再按取消注释
`Alt+Ins`	自动生成代码, toString, get, set等方法
`Alt+Shift+上下箭头`	移动当前代码行

删除模块: 选中模块delete, 或者右键Remove Module

导入模块 : File --> Project Structure --> + -->import Module --> 选择对应的目录–>一直next,next

12 方法

定义 : 就是将一个功能抽取出来, 把代码单独定义在一个大括号内, 形成一个单独的功能;当我们需要这个功能的时候,就可以去调用, 这样既实现了代码的复用性, 也解决了代码冗余的现象

定义格式 :

修饰符 返回值类型 方法名 (参数列表) {
    代码 ...
    return ;
}

public static void main (String[] args) {
    方法体 ...
    return 返回值;
}

解释 :

修饰符 : 目前固定写法 public static
返回值类型 : 目前固定写法 void, 其他返回值会在后面接触
方法名: 我们定义的方法名 : 满足标识符的规范, 用来调用方法
参数列表 :方法在运算过程中的未知数据, 调用者调用方法时传递
return : 将方法执行后的结果数据带给调用者，方法执行到 return ，整体方法运行结束
结果 : 方法的返回值

注意事项 :

方法的定义位置在类中,在main()外面, 在 main中调用,先后顺序无所谓,和调用顺序有关
返回值类型, 必须要和 return语句返回的类型相同, 否则编译失败
不能用输出语句调用 void 类型的方法; 因为方法执行后没得结果,也不打印出任何内容
一个方法中可以有多个return语句,但是只能保证同时只能有一个被执行, return不能连写

方法的调用方式:

单独调用, 方法名称(参数);
打印调用, System.out.println(Sum(3,5));
赋值调用, 数据类型变量名称 = Sum(3,5);

方法的有无参数:

有参数: 小括号当中有内容, 当一个方法需要一些数据条件,才能完成任务的时候,就是有参数
例如两数相加, 必须知道两个数字各自是多少, 才能相加

无参数: 小括号当中留空, 一个方法不需要任何数据条件, 自己就能独立完成任务,就是无参数
例如定义一个方法, 打印10次Helloworld

有无返回值

package cn.itcast.day04.demo02;

public class Demo04Return {
	public static void main(String[] args) {
		int num = getSum(10,20);
		System.out.println("返回值"+ num);
		System.out.println("=============");

		printSum(2,3);
	}

	public static int getSum(int a, int b){
		int res = a + b;
		return res;
	}

	public static void printSum(int a,int b){
		int res = a + b;
		System.out.println(res);
	}

}

getSum就是有返回值的方法; printSum就是无返回值的方法

练习 1 : 定义一个方法, 用来判断两个数字是否相同

public class Demo01MethodSame(){

public static void main(String[] args) {
	System.out.println(isSame(10,20))  // false
    
}

public static boolean isSame(int a,int b){
    boolean same;
    if (a == b){
        same = true;
    }else{
        same = fasle;
    }
    
    boolean same = a = b?true:fasle;
    
    boolean same = a==b
   
    return same;
    
    return a == b;
}

}

练习2 : 定义一个方法, 永安里打印指定次数的HelloWorld

public class Demo03MethodPrint {

	public static void main(String[] args) {
		printCount(8);
	}

	/*
	三要素
	返回值类型 : void
	方法名 : printCount
	参数列表 : 到底打印多少次, 告诉我几次,就打印几次 次数 int :num
	 */

	public static void printCount(int num){
		for (int i = 0; i < num; i++) {
			System.out.println("HelloWorld" + (i+方法1));
		}

	}
}

方法定义的三要素 : 返回值类型, 方法名, 参数列表 [返回值类型必须与return返回的类型相同]

方法重载

定义 : 同一个类中, 允许重载一个以上的同名方法, 只要他们的参数列表不同即可, 与修饰符和返回值类型无关

参数列表 : 个数不同, 数据类型不同, 顺序不同

重载方法调用 : JVM通过方法的参数列表, 调用不同的方法

13 数组

定义 : 是一种容器, 可以同时存放多个数据值

特点 :

数组是一种引用数据类型
数组当中的多个数据, 类型必须统一
数组的长度在程序运行期间不可改变

数组的创建 , 也叫做数组的初始化

动态初始化(指定长度) : 在创建数组的时候, 直接指定数组当中的数据元素的个数
静态初始化(指定内容) : 在创建数组的时候, 不直接指定数据个数多少, 而是直接将具体的数据内容指定

动态初始化数组的格式 : 数据类型[] 数组名称 = new 数据类型[数组长度];

动态初始化时数组的元素会自动拥有一个默认值, 为 0; 根据数组的类型自动拥有

静态初始化时数组的元素会其实也会自动拥有一个默认值, 为 0; 只不过系统马上将默认值替换为了大括号当中的具体数值

解析含义 :

左侧数据类型 : 也就是数组当中保存的数据, 全都是统一的什么类型

左侧中的括号 : 代表我是一个数组

左侧的数组名称 : 给数组取一个名字

右侧中的new : 代表创建数组的动作

右侧数据类型 : 必须和左边的数据类型保持一致

右侧括号中的长度 : 也就是数组当中, 到底可以保存多少个数据, 是一个int数字

静态初始化数组的格式 : 数据类型[] 数组名称 = new 数据类型[]{元素1,元素2,元素3};

省略初始化数组的格式 : 数据类型[] 数组名称 = {元素1,元素2,元素3};

// 直接打印数组名称, 得到的是数组对应的, 内存地址的哈希值

int[] array = {10,20,30}
System.out.println(array);   // [I@75412c2f 十六进制

数组的访问

索引 : 每一个存储到数组的元素，都会自动的拥有一个编号，从0开始，到length-1结束, 这个自动编号称为数组索引(index)，可以通过数组的索引访问到数组中的元素。

格式 : 数组名[索引]

数组的赋值 : array[索引] = 具体的数值

Java的内存划分

Java的内存需要划分为五个部分:

1 栈(Stack) : 存放的都是方法中的局部变量, 方法的运行一定要在栈当中; 局部变量: 方法的参数,或者是方法{}内部的变量, 作用域: 一旦超过作用域, 立刻从栈内存才能当中消失

2 堆(Heap) : 凡是 new 出来的东西,都在堆当中; 堆内存里面的东西都有一个地址值 : 16 进制, 堆内存里面的数据, 都有默认值; 整数 --> 默认为0; 浮点数 --> 默认为0.0; 字符 --> 默认为’\u0000’; 布尔值 --> 默认为false; 引用类型 --> 默认为null

3 方法区(Method Area) : 存储.class 相关信息, 包含方法的信息

4 本地方法栈(Native Method Stack) : 与操作系统相关

5 寄存器(pc Register) : 与CPU相关

一个数组的从无到有

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jmnAa7re-1589014646889)(assets/1588914664068.png)]

两个数组的内存图

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-X0tgG5zh-1589014646893)(assets/1588915403171.png)]

两个引用指向同一个数组的问题

把 arrayB = arrayA 把arrayA的内存地址赋值给arrayB

public class Demo05ArraySame {

	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

		arrayA[1] = 20;
		arrayA[2] = 30;
		System.out.println(arrayA);  // 地址值
		System.out.println(arrayA[0]); // 0
		System.out.println(arrayA[1]);	// 20
		System.out.println(arrayA[2]);	// 30

		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

		arrayB[1] = 200;
		arrayB[2] = 300;
		System.out.println(arrayB);  // 地址值
		System.out.println(arrayB[0]); // 0
		System.out.println(arrayB[1]);	// 200
		System.out.println(arrayB[2]);	// 300

		System.out.println("=================");
		System.out.println(arrayA[1]);	// 200
		System.out.println(arrayA[2]);	// 300
	}
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gEdRuuzX-1589014646897)(assets/1588916178290.png)]

操作 arrayA和arrayB, 他们俩其实就是一个数组

空指针异常

所有的引用类型变量, 都可以赋值为一个 null 值,但是代表其中什么都没有

数组必须进行new初始化才能使用其中的元素

如果只是赋值了一个null,没有进行new创建,那么将会发生空指针异常 NullPointerException

数组的长度属性

每个数组都具有长度，而且是固定的，在程序运行期间不可变,Java中赋予了数组的一个属性，可以获取到数组的长度，语句为：数组名.length ，属性length的执行结果是数组的长度，int类型结果。由次可以推断出，数组的最大索引值为数组名.length-1 。

int[] arrayC = new int[3];
arrayC = new int[5];
System.out.println(arrayC) // 此时并没有改变数组的长度,而是新创建了一个数组, 改变了arrayC的引用 --> 指向新的数组

数组的遍历输出

public static void main(String[] args) {
    int[] arr = { 1, 2, 3, 4, 5 };
    for (int i = 0; i < arr.length; i++) {
        System.out.println(arr[i]);
    }
}

数组获取最大值元素

public static void main(String[] args) {
    int[] arr = { 5, 15, 2000, 10000, 100, 4000 };
    //定义变量，保存数组中0索引的元素
    int max = arr[0];
    //遍历数组，取出每个元素
    for (int i = 1; i < arr.length; i++) {
        //遍历到的元素和变量max比较
        //如果数组元素大于max
        if (arr[i] > max) {
            //max记录住大值
            max = arr[i];
        }
    }
    System.out.println("数组最大值是： " + max);
}

数组反转

blic static void main(String[] args) {
    int[] arr = { 1, 2, 3, 4, 5 };
    /*
    循环中定义变量min=0最小索引
    初始化语句 min=0最小索引,max=arr.length‐1最大索引
    条件判断  min <= max
    步进表达式  min++,max‐‐
    */
    for (int min = 0, max = arr.length ‐ 1; min <= max; min++, max‐‐) {
        //利用第三方变量完成数组中的元素交换
        int temp = arr[min];
        arr[min] = arr[max];
        arr[max] = temp;
    }
    // 反转后，遍历数组
    for (int i = 0; i < arr.length; i++) {
        System.out.println(arr[i]);
    }
}

数组作为方法的参数传递

数组作为方法的参数传递, 传递的参数是数组的内存地址

public static void main(String[] args) {
    int[] arr = { 1, 3, 5, 7, 9 };
    //调用方法，传递数组
    printArray(arr);
}
/*
创建方法，方法接收数组类型的参数
进行数组的遍历
*/
public static void printArray(int[] arr) {
    for (int i = 0; i < arr.length; i++) {
        System.out.println(arr[i]);
    }
}

数组作为方法的返回值返回

数组作为方法的返回值返回, 返回的是数组的内存地址

一个方法可有0, 1, 多个参数,但是只能有0或者1个返回值, 不能有多个返回值

如果希望一个方法当中产生多个结果数据返回, 使用一个数组作为返回值类型即可

public static void main(String[] args) {
    //调用方法，接收数组的返回值
    //接收到的是数组的内存地址
    int[] res = cal(10,20,30);
    for (int i = 0; i < res.length; i++) {
        System.out.println("总和:"+ res[0]);
        System.out.println("平均数:"+ res[0]);
    }
}
/*
创建方法，返回值是数组类型
return返回数组的地址
*/
public static int[] cal(int a,int b,int c) {
    int sum = a+b+c; // 总和
    int avg = sum /3;  // 平均数
    
    int[] arr = {sum,avg};
    
    return arr;
}

方法的参数为基本数据类型时,传递的是数据值; 方法的参数为引用类型时, 传递的是地址值

同理, 引用类型作为方法的返回值时, 返回的也是地址值

main(String[] args) {
int[] arr = { 1, 3, 5, 7, 9 };
//调用方法，传递数组
printArray(arr);
}
/*
创建方法，方法接收数组类型的参数
进行数组的遍历
*/
public static void printArray(int[] arr) {
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}


**数组作为方法的返回值返回**

数组作为方法的返回值返回, 返回的是数组的内存地址

一个方法可有0, 1, 多个参数,但是只能有0或者1个返回值, 不能有多个返回值

如果希望一个方法当中产生多个结果数据返回, 使用一个数组作为返回值类型即可

```java
public static void main(String[] args) {
    //调用方法，接收数组的返回值
    //接收到的是数组的内存地址
    int[] res = cal(10,20,30);
    for (int i = 0; i < res.length; i++) {
        System.out.println("总和:"+ res[0]);
        System.out.println("平均数:"+ res[0]);
    }
}
/*
创建方法，返回值是数组类型
return返回数组的地址
*/
public static int[] cal(int a,int b,int c) {
    int sum = a+b+c; // 总和
    int avg = sum /3;  // 平均数
    
    int[] arr = {sum,avg};
    
    return arr;
}

方法的参数为基本数据类型时,传递的是数据值; 方法的参数为引用类型时, 传递的是地址值

同理, 引用类型作为方法的返回值时, 返回的也是地址值

JackLi_Liang

关注

1
点赞
踩
5

收藏

觉得还不错? 一键收藏
0
评论
Java基础知识笔记-从HelloWorld开始

1 写在前面JVM + 核心类库 = JRE + 编译器等开发工具 = JDKJava环境变量的配置 : 计算机 -> 属性-> 高级系统设置 -> 系统变量 -> 新建系统变量JAVA_HOME : 选择Java工具包的bin目录的上一级目录Path : %JAVA_HOME%\binJava程序开发三步骤 : 编写, 编译, 运行编译 : javac.exe 编译器运行 : java.exe 解释器public class HelloWorld { publi
复制链接

扫一扫