[Java] 方法，数组
作者：互联网
文章目录
项目的结构
- 当然，package里面还可以包括很多class
- package有大包和小包，例如：创建package ，命名为cn.aaa.bbb.c，这里就是cn包包括aaa包包括bbb包包括c包
IDEA
常用快捷键
要修改快捷键的话自行csdn哈哈哈哈哈哈哈哈哈哈
1 方法
1.1 语法
格式
修饰符 返回值类型 方法名称（参数类型1 参数名称1，参数类型2 参数名称2）{
方法体;
return 返回值类型;
}
注意事项:
- 方法的名称用小驼峰
1.2 调用方式
- 1 单独调用: 方法名称(参数) //void 函数常用
- 2 打印调用: System.out.println(函数名(参数));//注意,不能返回void
- 3 赋值调用: 数据类型 = 函数名(参数); //返回值类型不为void时常用
调用流程:
- 1 找到方法的调用处
- 2 传入参数
- 3 执行方法体
- 4 将返回值带到方法的调用处
1.3 练习题
题目1: 定义一个方法,用来判断两个数字是否相同
package method.demo1;
public class Demo1 {
public static String IsSame ( int a, int b){
String C = a==b? "相同": "不同" ;
return C;
}
public static void main(String[] args) {
String ret = IsSame(10,20);
System.out.println(ret);
}
}
题目2:求出1-100所有数的和的结果
package method.demo2;
public class Demo2 {
public static int sum(){
int Sum = 0;
for(int i =1;i<=100;i++){
Sum +=i;
}
return Sum;
}
public static void main(String[] args) {
System.out.println(sum());
}
}
1.4 方法的注意事项
-
方法应该定义在类当中,但是不能定义在方法中
-
方法的前后顺序无所谓
-
一定要调用才能使用
-
如果方法有返回值,那么一定要写"return"
-
一个方法中可以有多个return,但是必须保证只有一个被执行,因此return不能连写
1.5 方法的重载
英文: OverLoad
有若干种类型:
- 同返回值不同参数(个数不同,类型不同)
- 返回类型和方法的修饰符可以不相同
注意: 返回值类型相同不能发生重载
1.6 重载练习
练习一
public static void a(){}
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行冲突
6 public void open(int i, double d){}
public static void OPEN(){}//不是重载,是新方法,且命名不规范
8 public static void open(int i ,int j){}
2 数组
定义: 一次性存储多个数据类型相同的变量的值的一种容器
特点:
- 数组是一种引用数据类型
- 数组当中的多个数据,类型必须统一
- 数组的长度在运行期间不可改变
2.1 数组的初始化
定义:在内存中创建一个数组,并且赋予一些默认值
两种方式:
- 动态初始化(指定长度)
- 静态初始化(指定内容),他的长度就是内容的长度
动态初始化
数据类型[] 数组名称 = new 数据类型[数组长度];
int []aaa = new int[3];
静态初始化
数据类型[] 数组名称 = new 数据类型[]{元素1,元素2...};
int []aaa = new int[]{1,2,3,4,5,6,7,7};
//也可以
int aaa[] = {元素1,元素2...};//这是省略格式
注意!!
动态初始化时不可以省略写,即,不可以 int a[5]; 但是可以int [] a;
为什么要加new? 因为Java中数组时没有静态的,数组的内存都是通过new动态分配的.
2.2 访问数组元素进行获取
- 直接打印地址,得到的是数组对应的内存地址的哈希值.
- 因此,我们需要数组名称[索引值]
数组的索引值从0开始
2.3 数组的赋值
例子:
package method.demo1;
public class Demo1 {
public static void main(String[] args) {
int [] array = new int[3];
for(int i =0;i<3;i++){
System.out.println(array[i]);//没有赋值的时候,报的数是0
}
}
}
这说明,数组初始化的时候,数组会给每一个元素自动拥有一个默认值
- int类型是0 float是0.0 字符类型是\u0000 布尔类型是false 引用类型是null
- 静态初始化其实也是有默认值的,但是系统马上把默认值换成你加上的值
2.4 Java的内存
Java的内存需要划分为5个部分:
- **栈(Stack): ** 存放的都是方法中的局部变量 (注意,方法的参数也是局部变量) 一旦超出作用域,该数据立刻从栈区中消失 注意::!!方法的运行一定是在栈当中的
- 堆(Heap): 凡是new出来的东西,都是在堆里面的,堆内存里面的数据都有一个地址值,他是16进制的,堆内存里面的数据,都有一个默认初始值,规则就是数组的初始值
- 方法区(Method Area): 储存 .class的相关信息,包含方法的信息
- 本地方法栈(Native Method Stack): 于操作系统相关
- 寄存器(pc Register): 与CPU相关.
重点是前三个,原因是我们太垃圾了,不配了解后面两个
2.5 数组的内存图
一个数组的内存图
代码:
package method.demo1;
public class Demo1 {
public static void main(String[] args) {
int[] array = new int[3];//动态初始化
System.out.println(array);
array[1] = 10;
array[2] = 20;
System.out.println(array);
}
}
//我们可以发现,修改数组的值并不影响堆区数组的地址值
两个数组的互相影响:
package method.demo1;
public class Demo1 {
public static void main(String[] args) {
int[] arrayA = new int[3];
System.out.println(arrayA);
arrayA[1] = 10;
arrayA[2] = 20;
for(int i =0;i<3;i++){
System.out.println(arrayA[i]);
}
int[] arrayB = arrayA;//关键步骤
System.out.println(arrayB);
arrayB[1] = 20;
arrayB[2] = 30;
for(int i =0;i<3;i++){
System.out.println(arrayA[i]);
}
}
}
从代码我们可以看出来,当代码int[] arrayB = arrayA;执行时,arrayB的地址已经指向了arrayA在堆区的数组,因此arrayB数组的值的改变会导致arrayA的值也因此改变.
图如下
2.6 数组牵引越界
代码如下
package method.demo1;
public class Demo1 {
public static void main(String[] args) {
int[] arrayA = new int[3];
System.out.println(arrayA);
arrayA[1] = 10;
arrayA[2] = 20;
for(int i =0;i<4;i++){
System.out.println(arrayA[i]);
}//这里会发生越界异常，因为索引的编号超过了数组的长度 -1
}
}
2.7 数组空指针异常(NullPointerException)
代码如下
package method.demo1;
public class Demo1 {
public static void main(String[] args) {
int[] arrayA = null;
for(int i =0;i<4;i++){
System.out.println(arrayA[i]);
}//这里会发生空指针异常
}
}
2.8 获取数组的长度
简单,但是重要
代码如下:
package method.demo1;
public class Demo1 {
public static void main(String[] args) {
int[] arrayA = {1,2,3,4,5,6,23,5,523,325,325,325,323,352,523,325};
System.out.println(arrayA.length);
}
}//这是数组的属性的运用
练习1,数组的遍历输出,我就不写了哈哈哈哈哈哈哈哈哈哈
练习2,求数组的最大值:(我自己的解法,不过好像和他的想法一样,危,说明算法思想还是太垃圾)
package method.demo1;
public class Demo1 {
public static void main(String[] args) {
int[] arrayA = {2, 444, 22, 1245, 125125, 12665126,23,124,566};
int max = 0;
max = arrayA[0];
for (int i = 0; i < arrayA.length - 1; i++) {
if (max < arrayA[i+1]){
max = arrayA[i+1];
}
}
System.out.println(max);
}
}
练习3: 数组元素的反转(要求,不能创建新数组,就在原来的数组里面操作)
package method.demo1;
public class Demo1 {
public static void main(String[] args) {
int[] arrayA = {1,2,3,4,5,6,7,8,9,10,0};
for(int i =0;i<(arrayA.length)/2 -1;i++){
int temp = arrayA[i];
arrayA[i] = arrayA[arrayA.length - i - 1];
arrayA[arrayA.length - i -1] = temp;
}
for(int i =0;i<arrayA.length;i++){
System.out.println(arrayA[i]);
}
}
}
教程的解法:我觉得更好,但是思路是一样的
package method.demo1;
public class Demo1 {
public static void main(String[] args) {
int[] arrayA = {1,2,3,4,5,6,7,8,9,10,0};
for(int min = 0,max = arrayA.length - 1;min<max;min++,max--){
int temp = arrayA[min];
arrayA[min] = arrayA[max];
arrayA[max] = temp;
}
for(int i =0;i<arrayA.length;i++){
System.out.println(arrayA[i]);
}
}
}
2.9 数组作为返回值
代码如下:
package method.demo1;
public class Demo1 {
public static void main(String[] args) {
int[] qwq = calculate(2,3,3);
}
public static int[] calculate(int a , int b, int c){
int[] hhh = {a,b,c};
return hhh;
}
}
p = arrayA[min];
arrayA[min] = arrayA[max];
arrayA[max] = temp;
}
for(int i =0;i<arrayA.length;i++){
System.out.println(arrayA[i]);
}
}
}
## 2.9 数组作为返回值
代码如下:
```java
package method.demo1;
public class Demo1 {
public static void main(String[] args) {
int[] qwq = calculate(2,3,3);
}
public static int[] calculate(int a , int b, int c){
int[] hhh = {a,b,c};
return hhh;
}
}
标签：Java,int,void,static,数组,arrayA,方法,public 来源： https://blog.csdn.net/m0_47652477/article/details/114419561