Java学习第五天

一、方法

1.1方法的概念

1、概念：一段特定功能的代码 需要多次执行的时候 就可以使用一对大括号将其包裹 给这段代码取一个名称 每次使用这段代码的时候 就可以使用这个名称来进行访问

2、例子：

nextInt()==>通过键盘来获取录入的整数 可以避免大量冗余（重复）的代码

3、生活中例子：

中午吃饭炒白菜

农民伯伯 需要播种 施肥 浇水 收割……

中间商 需要去收购 抬高价格 运输到市场 吆喝

厨师 买菜 洗菜 切菜 炒菜 装盘 上菜

中午吃菜

4、好处

A.提高代码的可拓展性

B.提高代码的安全性（方法内的资源外部是不能直接进行访问）

C.简化程序的设计

1.2方法的定义

1、语法：

访问修饰符 返回值类型 方法名称（参数列表）{

方法体

return 返回值

}

2、案例：

XX找一个前端女朋友 （返回值 结果）

需要一个微信号 （原料 参数列表）

聊天==>吃饭==>约会==>看电影……七天…… （方法体）

3、案例：

牛奶

牛奶 结果 返回值

奶牛 原料

挤奶 消毒 运输 打包…… 方法体

4、解释

访问修饰符 public static

返回值类型 在定义方法的时候 就明确其返回值类型 返回值类型可以是基本数据类型 也可以是引用数据类型

方法的名称：取一个名称 规则：小驼峰命名 通俗易懂 顾名思义

参数列表 原料 执行方法需要到原料 参数列表可以有 可无

方法题 执行的具体逻辑代码

return返回值 执行具体的逻辑代码返回的结果

5、代码

有void时执行下面的逻辑就好了 没有返回值 有void就没有return

step01定义一个没有参数 没有返回值的方法

public class Test01 { //定义一个没有返回值、没有参数的方法 public static void showIf(){ System.out.println("今天天气真好！适合约会。"); } }

step02定义一个有参数 有返回值的方法

public class Test01 { /** * * @param num1 * @param num2 * @return 两个数之和 */ public static int getSum(int num1, int num2){ //求两个数之和 int sum = num1 +num2; return sum; } }

1.3方法调用

1、方法调用：直接书写方法名就可以调用 例如：shuwIf() getSum(2,3)

2、解释调用的语法

部分名称	说明
getSum	方法的名称
（2，3）	调用方法传递实际的数据（实实在在的数据）

3、总体特点：

方法必须调用后 才能执行

1.4方法调用的方式

调用的方式	说明
直接调用	只需要执行代码的逻辑 不需要返回值
打印调用	调用方法的之后 需要查看方法的返回值结果 就可以使用打印调用
赋值调用	调用方法之后 需要将方法的返回值结果 给其它变量使用

step01直接调用

public class Test02 { public static void main(String[] args) { showInfo(); } public static void showInfo(){ for (int i = 1; i<=5;i++){ for (int j = 1;j<=5;j++){ System.out.print("*"); } System.out.println(""); } } }

step02打印调用

public class Test02 { public static void main(String[] args) { System.out.println(getSum(30, 50)); } /** * * @param num1 * @param num2 * @return */ public static int getSum(int num1 , int num2){ int sum = num1 + num2; return sum; } }

step03赋值调用

public class Test02 { public static void main(String[] args) { int s=getSum(60,20); System.out.println(s*100); } /** * * @param num1 * @param num2 * @return */ public static int getSum(int num1 , int num2){ int sum = num1 + num2; return sum; } }

1.5方法注意事项

1、方法定义的注意事项

A.所有额方法都是平级的关系 没有上下级关系

B.方法定义在类中

C.方法定义的时候 不能进行相互嵌套

D.方法在调用的时候 可以进行相互调用的 甚至可以自己调用自己的（递归）

2、方法调用注意事项

A.方法参数

形参 形式的参数（象征意义的参数） 在定义方法的时候使用形参 其实就是声明变量 多个形参需要以逗号来进行分割

实参 实际意义的参数（具体的数据）在调用方法的时候使用实参 其实就是给变量赋值 实参必须与形参的顺序以及数据类型一致

B.返回值

1、return 可以用于来返回数据 也可以用来结束方法

如果方法定义的时候 使用void进行修饰的时候 就可以使用 return；来结束方法

如果方法定义的时候 有返回值 那么必须使用return返回具体数据

2、方法的返回值 是返回给调用者（谁调用返回给谁）

1.6案例

案例1

step01需求

step02分析

返回修饰符 public static

返回值类型 void

方法体 打印0-n的数据

使用循环

使用选择语句

step03代码

public class Test03 { public static void main(String[] args) { print(33); } public static void print(int n){ if (n<0){ System.out.println("输入错误，无法打印！"); }else{ for (int i= 0;i <=n;i++){ System.out.print(i+"\t"); } } } }

案例2

step01需求

 

step02分析：

返回值 String

参数 成绩

方法体： 验证是否合格

选择结构

step03代码：

public class Test03 { public static void main(String[] args) { System.out.println(isFlag(99)); System.out.println(isFlag(59)); } public static String isFlag(int score){ if(score>60){ return"成绩合格！"; }else{ return "成绩不合格，重修吧你，在学一次更好。"; } } }

1.7方法重载

1、重载的规则：在同一个类中 方法名相同 参数不同 于访问修饰符与返回值无关

2、解释：

在同一个类中：重载的方法智能在一个类中

方法名相同：方法名完全相同 包括大小写

参数不同：

a.参数的类型不同 b.参数个数不同

c.参数名字无关

访问修饰符 public static

返回值无关：可以有返回值 也可以没有返回值

3、案例：

定义一个方法求整个整数之和

定义一个方法求三个整数之和

定义一个方法求两个小数之和

4、好处

没有重载之前：

相同逻辑的代码 需要定义多个方法 并且方法名是不同 增加程序员的记忆负担 不利于代码后期扩展与维护

有重载之后：

相同逻辑的代码 需要定义多个方法 方法名字相同 只需要记忆一个方法名字即可 减轻程序员的记忆负担 有利于后期的扩展与后期维护

代码：

没有重载之前：

public class Test04 { public static void main(String[] args) { System.out.println(show01(45, 35)); System.out.println(show02(11, 22, 33)); System.out.println(show03(59.5, 39.5)); } //求两个整数之和 public static int show01(int num1,int num2){ int sum = num1+num2; return sum; } //求三个整数之和 public static int show02(int num1,int num2,int num3){ int sum = num1+num2+num3; return sum; } //求两个小数之和 public static double show03(double num1,double num2){ double sum =num1+num2; return sum; } }

重载之后：

public static void main(String[] args) { System.out.println(show(10, 20)); System.out.println(show(10, 20, 30)); System.out.println(show(11.11, 22.22)); } //求两个整数之和 public static int show(int num1,int num2){ int sum= num1+num2; return sum; } //求三个整数之和 public static int show(int num1,int num2,int num3){ int sum = num1+num2+num3; return sum; } //求两个小数之和 public static double show(double num1,double num2){ double sum = num1+num2; return sum; } }

1.8案例

step01

 

step02分析

1、方法的重载

2、将任意的数据类型转换字符串类型 只需要+“”

3、方法：

public static

String

参数列表 各种数据类型

方法体 转换

step03代码：

public class Test05 { public static void main(String[] args) { System.out.println(toString(10).charAt(1)); System.out.println(toString(2.66).charAt(2)); System.out.println(toString(true).charAt(3)); } public static String toString(int z){ return z+""; } public static String toString(double d){ return d+""; } public static String toString(boolean b){ return b+""; } public static String toString(char c){ return c+""; } }

1.9方法的内存图

1、jvm java虚拟机 Java程序运行的时候会在内存中开辟空间 jvm 将内存划分为五块 其中重要的一块是栈内存

栈内存：先进后出（玩具枪的的子弹） 进栈 （压栈） 出栈（弹栈）

2、所有方法在运行的时候 都会在栈内存中开辟空间

 

二、数组

2.1数组概念

1、数组：就是用于存储一组相同数据类型的数据的容器（粮仓、鱼缸）

2、案例

需求：表示班级50个同学的名称

没有数组之前：使用50个变量来表示50个同学的名字 需要定义大量的变量名 变量名记忆麻烦 产生大量的冗余代码 操作比较麻烦

有数组之后：可以使用一个容器来存储学生的名称 数组存取数据是有规律的（根据索引来存取） 所以操作起来比较方便

3、特点：

A.数组的长度是固定的

B.数组中存储的元素必须是同一数据类型 可以是基本数据类型 也可以是引用数据类型

2.2数组动态初始化

1、动态初始化：在数组创建的时候 不给数组赋值

2、语法：

数据的数据类型 [ ]数组名称 = new 数组的数组类型[长度]

3、解释

数组的数据类型 存储数组中元素的数据类型 既可以是基本数据类型 也可以是引用数据类型

[ ] 表示一维数组 [ ][ ] 表示二维数组

数组名称:表示栈内存 就是数组的地址值

= 表示将栈内存的地址值 赋值给栈内存的引用

new 表示在堆内存中开辟空间

数组的数据类型 前后数组的数据类型必须是一致

[长度] 表示数组中存储元素的个数

4、例子： int [ ] nums =new int [3];

5、注意点：

直接打印数组的名称 打印的是数组的地址值

地址值解释：

[I@1540e19d

[ ==>表示的是一维数组

I ==>int类型

@ ==>没有特殊含义 表示连接的符号

1540e19d==>地址值的hashcode值

总结：就是地址值

2.3数组的操作

1、数组的操作

就是对数组进行赋值与取值 数组的赋值与取值是：数组通过索引（下标）来进行赋值与取值操作 数组的索引是从0开始的

数组索引的最大值：数组的长度-1

数组的长度==>数组名称 .length 例如：arrays.length

2、数组的赋值与取值

赋值的语法：数组的名称 [索引] =数据； 例如：nums[0]=10

取值的语法：数组名称 [索引] 例如：nums[0]

3、数组是有默认值

int ==>0

double ==>0.0

boolean ==>false

char ==> '\u000' ==>空格

引用类型 null

代码示例：

public class Test06 { public static void main(String[] args) { //动态初始化一个数组 int [] nums= new int [4]; nums[0]=10; nums[1]=20; nums[2]=30;//不赋值的时候系统会给默认值 nums[3]=40; System.out.println(nums);//会输出地址值 System.out.println(nums[0]); System.out.println(nums[1]); System.out.println(nums[2]); System.out.println(nums[3]); System.out.println(nums.length);//输出数组长度 } }

2.4数组的静态初始化

1、概念：静态初始化 在创建数组额时候 就给数组赋值

2、语法：数组的数据类型 [ ] 数组名称 = new数组的数据类型 [ ] {元素的罗列}

3、例子： int [ ] nums = new int [ ]{10,20,30}

4、注意点：

A.中括号中不能指定数组的长度

B.数组中多个数据 使用逗号来进行分隔

C.元素罗列的数据类型必须与数组的数据类型一致

5、简化方式

数组的数据类型 [] 数组名称 = {元素罗列}

注意点：必须写在同一行 不能分开来写

代码示例：

public class Test06 { public static void main(String[] args) { //静态初始化一个数组 int [] arrays =new int [] {10,20,30,40}; //取值 System.out.println(arrays[0]); System.out.println(arrays[1]); System.out.println(arrays[2]); System.out.println(arrays[3]); //简写方式-第二种方法 int [] num ={60,70,80,90}; System.out.println(num[0]); System.out.println(num[1]); System.out.println(num[2]); System.out.println(num[3]); //错误的写法 // int [] nums1 ; // nums1={100,110,120}; } }

三、jvm内存划分

1、内存

A.编写的Java代码事存在硬盘中 硬盘中的数据事永久保存的

B.运行的Java程序会在内存中开辟空间 内存中的数据事临时存储的

2、jvm将内存划分为五块 房子（厨房 卧室 客厅） 方便对数据进行存储 便于统一管理

3、五块内存

栈内存（重点）

特点：先进后出 进栈 压栈 出栈 弹栈

A.所有的局部变量都是存在栈内存中

B.所有的方法在执行的时候都会在栈内存中开辟空间

堆内存（重点）

A.只要是new的资源 都会在堆内存中开辟空间 例如new 对象 new 数组

方法区（重点）

A.静态资源都存在方法区中

B.类加载信息（class）都是在方法区

本地方法区

调用本地方法 就是调用C与C++的方法

只要是使用 native修饰的都是C与C++的方法

程序计数器

与cpu有关 控制程序代码的执行

五、一个数组创建的内存图

六、两个数组创建的内存图

七、两个引用指向同一个堆内存的内存图

八、数组中常见的异常

1、生活中的异常 上班堵车 ……上课异常……

2、异常：执行代码发生了错误 就是异常

3、数组中常见的异常 数组下标越界异常 空指针异常

4、数组下标异常

A..ArrayIndexOutOfBoundsException

B.产生的原因：对数组进行操作的时候 索引超出了数组的最大范围

C.解决：

A.对数组进行操作的时候 对索引进行判断 是否在这个范围之内

5、空指针异常

A.NullPointerException

B.产生的原因：栈内存引用没有指向任何堆内存的地址值 却要从堆内存中获取值

C.解决：在使用数组的时候 对数组进行非空验证

step01数组下标越界

public class Test07 { public static void main(String[] args) { //动态初始化数组 int [] nums= new int[2]; nums[0]=100; nums[1]=90; if (2>=0&&2<nums.length){ System.out.println(nums[2]); } } }

step02空指针异常

public class Test07 { public static void main(String[] args) { //动态初始化数组 int [] arrays= new int[2]; arrays=null; if (arrays !=null&&arrays.length>0){ System.out.println(arrays[0]); } } }