第十三部分 方法
13.1 定义方法的格式详解
修饰符 返回值类型 方法名(参数列表){
//代码省略...
return 结果;
}
- 修饰符:
public static
(现阶段固定写法) - 返回值类型: 表示方法运行的结果的数据类型,方法执行后将结果返回到调用者。
- 参数列表: 方法在运算过程中的未知数据,调用者调用方法时传递。
- return: 将方法执行后的结果带给调用者,方法执行到 return ,整体方法运行结束。
- 参数如果有多个,使用逗号进行分隔。
- return后面的“返回值”,必须和方法名称前面的“返回值类型”保持对应。
- 对于一个void没有返回值的方法,不能写return后面的返回值,只能写return自己。return;表示结束方法,也可以省略不写。
- 一个方法当中可以有多个return语句,但是必须保证同时只有一个会被执行到,两个return不能连写。
13.2 方法调用
- 三种方法
- 单独调用:方法名称(参数);
- 打印调用:System.out.println(方法名称(参数));
- 赋值调用:数据类型 变量名称 = 方法名称(参数);
public class Method {
public static void main(String[] args) {
// 单独调用
sum(10, 20);
System.out.println("===========");
// 打印调用
System.out.println(sum(10, 20)); // 30
System.out.println("===========");
// 赋值调用
int number = sum(15, 25);
number += 100;
System.out.println("变量的值:" + number); // 140
}
public static int sum(int a, int b) {
System.out.println("方法执行啦!");
int result = a + b;
return result;
}
}
- 注意
- 对于有返回值的方法,可以使用单独调用、打印调用或者赋值调用。
- 对于无返回值的方法,只能使用单独调用,不能使用打印调用或者赋值调用。
public class MethodReturn {
public static void main(String[] args) {
int num = getSum(10, 20);
System.out.println("返回值是:" + num);
System.out.println("==============");
printSum(100, 200);
System.out.println("==============");
System.out.println(getSum(2, 3)); // 正确写法
getSum(3, 5); // 正确写法,但是返回值没有用到
System.out.println("==============");
// 对于void没有返回值的方法,只能单独,不能打印或者赋值
// System.out.println(printSum(2, 3)); // 错误写法!
// System.out.println(void);
// int num2 = printSum(10, 20); // 错误写法!
// int num3 = void;
// void num4 = void;
}
// 有返回值
public static int getSum(int a, int b) {
int result = a + b;
return result;
}
// 没有返回值
public static void printSum(int a, int b) {
int result = a + b;
System.out.println("结果是:" + result);
}
}
13.3 方法重载
- 方法重载(Overload): 指在同一个类中,允许存在一个以上的同名方法,只要它们的参数列表不同即可,与修饰符、参数名称和返回值类型无关。
- 参数列表: 个数不同,数据类型不同,顺序不同。
- 重载方法调用: JVM通过方法的参数列表,调用不同的方法。
public class Demo01MethodOverload {
public static void main(String[] args) {
System.out.println(sum(10, 20)); // 两个参数的方法
System.out.println(sum(10, 20, 30)); // 三个参数的方法
System.out.println(sum(10.0, 20.0, 30.0, 40.0)); // 四个参数的方法
}
public static int sum(int a, double b) {
return (int) (a + b);
}
public static int sum(double a, int b) {
return (int) (a + b);
}
public static int sum(int a, int b) {
System.out.println("有2个参数的方法执行!");
return a + b;
}
// 错误写法!与方法的返回值类型无关
// public static double sum(int a, int b) {
// return a + b + 0.0;
// }
// 错误写法!与参数的名称无关
// public static int sum(int x, int y) {
// return x + y;
// }
public static int sum(double a, double b) {
return (int) (a + b);
}
public static int sum(int a, int b, int c) {
System.out.println("有3个参数的方法执行!");
return a + b + c;
}
public static double sum(double a, double b, double c, double d) {
System.out.println("有4个参数的方法执行!");
return a + b + c + d;
}
}
- 比较两个数据是否相等
public class OverloadSame {
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;
}
}
}
第十四部分 数组
14.1 数组概念
- 概念: 数组就是存储数据长度固定的容器,保证多个数据的数据类型要一致。
14.2 数组定义
14.2.1 动态初始化(指定长度)
- 格式: 数组存储的数据类型[ ] 数组名字 = new 数组存储的数据类型[长度];
// 创建一个数组,里面可以存放300个int数据
int[] arrayA = new int[300];
// 创建一个数组,能存放10个double类型的数据
double[] arrayB = new double[10];
// 创建一个数组,能存放5个字符串
String[] arrayC = new String[5];
14.2.2 静态初始化(指定内容)
- 标准格式: 数据类型[ ] 数组名 = new 数据类型[ ]{元素1,元素2,元素3…};
- 省略格式: 数据类型[ ] 数组名 = {元素1,元素2,元素3…};
// 直接创建一个数组,里面装的全都是int数字,具体为:5、15、25
int[] arrayA = new int[] { 5, 15, 25, 40 };
int[] arrayC = {5, 15, 20};
// 创建一个数组,用来装字符串:"Hello"、"World"、"Java"
String[] arrayB = new String[] { "Hello", "World", "Java" };
String[] arrayD = {"Hello", "World", "Java"};
- 静态初始化没有直接指定长度,但是仍然会自动推算得到长度。
- 静态初始化标准格式可以拆分成为两个步骤。
- 动态初始化也可以拆分成为两个步骤。
- 静态初始化一旦使用省略格式,就不能拆分成为两个步骤了。
- 不确定数组当中的具体内容,用动态初始化;否则,已经确定了具体的内容,用静态初始化。
// 静态初始化的标准格式,可以拆分成为两个步骤
int[] arrayB;
arrayB = new int[] { 11, 21, 31 };
// 动态初始化也可以拆分成为两个步骤
int[] arrayC;
arrayC = new int[5];
// 静态初始化的省略格式,不能拆分成为两个步骤。
// int[] arrayD;
// arrayD = { 10, 20, 30 };
14.3 数组的访问
-
索引: 每一个存储到数组的元素,都会自动的拥有一个编号,从0开始,这个自动编号称为数组索引 (index),可以通过数组的索引访问到数组中的元素。
-
格式: 数组名[索引]
public class ArrayUse {
public static void main(String[] args) {
int[] array = { 10, 20, 30 };
System.out.println(array); // 内存地址哈希值
// 直接打印数组当中的元素
System.out.println(array[0]); // 10
System.out.println(array[1]); // 20
System.out.println(array[2]); // 30
// 也可以将数组当中的某一个单个元素,赋值交给变量
int num = array[1];
System.out.println(num); // 20
}
}
- 使用动态初始化数组的时候,其中的元素将会自动拥有一个默认值。规则如下:
- 如果是整数类型,那么默认为
0
- 如果是浮点类型,那么默认为
0.0
- 如果是字符类型,那么默认为
'\u0000'
- 如果是布尔类型,那么默认为
false
- 如果是引用类型,那么默认为
null
- 如果是整数类型,那么默认为
public class ArrayUse {
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
}
}
14.4 Java中的内存划分
14.4.1 内存概述
- 内存是计算机中的重要原件,临时存储区域,作用是运行程序。我们编写的程序是存放在硬盘中的,在硬盘中的程序是不会运行的,必须放进内存中才能运行,运行完毕后会清空内存。
- Java虚拟机要运行程序,必须要对内存进行空间的分配和管理。
14.4.2 Java虚拟机的内存划分
为了提高运算效率,就对空间进行了不同区域的划分,因为每一片区域都有特定的处理数据方式和内存管理方式。
- JVM的内存划分
区域名称 | 作用 |
---|---|
方法栈(Stack) | 方法运行时使用的内存,比如main方法运行,进入方法栈中执行 。同时也存放着方法中的局部变量(方法的参数或者时方法{ }内部的变量),一旦超出作用域,立刻从栈内存中消失。方法的运行一定要在栈中运行。 |
堆内存(Heap) | 存储对象或者数组,new来创建的,都存储在堆内存。 |
方法区(Method Area) | 存储可以运行的.class文件。 |
本地方法栈(Native Method Stack) | JVM在使用操作系统功能的时候使用,和我们开发无关。 |
寄存器(pc Register) | 给CPU使用,和我们开发无关。 |
- 堆内存
- 堆内存里面的东西都有一个地址值
(16进制)
- 堆内存里面的数据,都有默认值,规则:
- 如果是整数类型,那么默认为
0
- 如果是浮点类型,那么默认为
0.0
- 如果是字符类型,那么默认为
'\u0000'
- 如果是布尔类型,那么默认为
false
- 如果是引用类型,那么默认为
null
- 如果是整数类型,那么默认为
- 堆内存里面的东西都有一个地址值
14.5 数组在内存中的存储
14.5.1 一个数组内存图
14.5.2 两个数组内存图
14.5.3 两个变量指向一个数组
14.6 数组常见操作
14.6.1 数组越界
- 如果访问数组元素的时候,索引编号并不存在,那么将会发生数组索引越界异常
(ArrayIndexOutOfBoundsException)
。
public class ArrayIndex {
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
// 错误写法
// 并不存在3号元素,所以发生异常
// System.out.println(array[3]);
}
}
14.6.2 空指针异常
- 数组必须进行new初始化才能使用其中的元素。如果只是赋值了一个null,没有进行new创建,那么将会发生空指针异常
(NullPointerException)
。
public class ArrayNull {
public static void main(String[] args) {
int[] array = null; // 空指针
// array = new int[3];
System.out.println(array[0]); // 访问不到
}
}
14.6.3 获取数组长度
- 格式: 数组名称.length
- 数组一旦创建,程序运行期间,长度不可改变。
public class ArrayLength {
public static void main(String[] args) {
int[] arrayA = new int[3];
int[] arrayB = {10, 20, 30, 3, 5, 4, 6, 7, 8, 8, 65, 4, 44, 6, 10, 3, 5, 4, 6};
int len = arrayB.length;
System.out.println("arrayB数组的长度是:" + len);
System.out.println("=============");
int[] arrayC = new int[3];
System.out.println(arrayC.length); // 3
arrayC = new int[5];
System.out.println(arrayC.length); // 5
}
}
14.6.4 数组遍历
- 数组遍历: 将数组中的每个元素分别获取出来,就是遍历。
public class Array {
public static void main(String[] args) {
int[] array = { 15, 25, 30, 40, 50, 60, 75 };
// 首先使用原始方式
System.out.println(array[0]); // 15
System.out.println(array[1]); // 25
System.out.println(array[2]); // 30
System.out.println(array[3]); // 40
System.out.println(array[4]); // 50
System.out.println(array[5]); // 50
System.out.println("=================");
// 使用循环,次数其实就是数组的长度。
// 可使用快捷键:6.fori + enter
for (int i = 0; i < 6; i++) {
System.out.println(array[i]);
}
System.out.println("=================");
// int len = array.length; // 长度
// 可使用快捷键:array.fori + enter
for (int i = 0; i < array.length; i++) {
System.out.println(array[i]);
}
}
}
14.6.5 数组反转
- 数组反转: 数组元素顺序颠倒
public class ArrayReverse {
public static void main(String[] args) {
int[] array = { 10, 20, 30, 40, 50 };
// 遍历打印数组本来的样子
for (int i = 0; i < array.length; i++) {
System.out.println(array[i]);
}
System.out.println("============");
/*
初始化语句:int min = 0, max = array.length - 1
条件判断:min < max
步进表达式:min++, max--
循环体:用第三个变量倒手
*/
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.7 数组作为方法参数和返回值
14.7.1 数组作为方法参数
- 数组作为方法参数传递,传递的参数是数组内存的地址。
public class ArrayParam {
public static void main(String[] args) {
int[] array = { 10, 20, 30, 40, 50 };
System.out.println(array); // 地址值
printArray(array); // 传递进去的就是array当中保存的地址值
System.out.println("==========AAA==========");
printArray(array);
System.out.println("==========BBB==========");
printArray(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]);
}
}
}
14.7.2 数组作为方法返回值
-
一个方法可以有0、1、多个参数,但是只能有0或者1个返回值,不能有多个返回值。
-
数组作为方法的返回值,返回的是数组的内存地址。
public class ArrayReturn {
public static void main(String[] args) {
int[] result = calculate(10, 20, 30);
System.out.println("main方法接收到的返回值数组是:");
System.out.println(result); // 地址值
System.out.println("总和:" + result[0]);
System.out.println("平均数:" + result[1]);
}
public static int[] calculate(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; // 平均数
*/
int[] array = { sum, avg };
System.out.println("calculate方法内部数组是:");
System.out.println(array); // 地址值
return array;
}
}
- 任何数据类型都能作为方法的参数类型,或者返回值类型。
- 方法的参数为基本类型时,传递的是数据值.。方法的参数为引用类型时,传递的是地址值。
上一篇: Java学习(四)—— IntelliJ IDEA的安装及简单使用
下一篇: Java学习(六)—— 面向对象思想