目录
方法
为了提高代码的复用性,可以将其定义成一个单独的功能,该功能的体现就是java中的方法。
定义格式:
修饰符 返回值类型 方法名(参数类型 形式参数1,参数类型 形式参数1,…){
执行语句;
return 返回值;
}
return的作用:结束方法。结束功能。
1、一个方法会不会执行,取决于有没有调用,调用的格式:
方法名 + 参数列表
2、方法定义的位置没有关系,执行顺序取决于main方法怎么调用
3、一个方法,可以不设置参数,也可以设置多个参数,如果没有参数,使用方法时,必须传对应类型的参数
4、如果方法的返回值类型是void,不允许有返回值
5、如果方法要返回一个值,必须设置返回值类型,并且return对应类型的结果
方法的重写
同名同参
子类可以调用父类的方法,如果对父类的方法不满意,可以重写父类的方法
原则:两同 两小 一大
两同:子类与父类的方法名和参数列表相同
两小:子类的返回值类型与父类的返回值类型相等
子类的返回值类型是父类返回值类型的子类
一大:子类的修饰符权限>=父类的修饰符权限
方法的重载
在一个类中,如果出现了两个或者两个以上的同名方法,只要它们的参数的个数,或者参数
的类型不同,即可称之为该方法重载了。
如何区分重载:当函数同名时,只看参数列表。和返回值类型没关系。
数组(Array)
数组是一种常见的数据结构,用于存储多个数据。标志是[ ] ,用于储存多个相同类型数据集合,想要获取数组中的元素值,可以通过脚标(下标)来获取。数组下标是从0开始的,下标的最大值是数组的长度减1。数组一旦初始化完成,在内存中所占的空间就固定下来,即数组的长度不可改变。数组既可以存基本类型的数据,也可以存引用类型的数据,只要类型相同即可。
数组的声明
动态初始化
int [ ] a = new int [5];
静态初始化
int [ ] b = new int [ ]{1,2,3,4,5,6 };
int [ ] c = {1,2,3,4,5,6};
数组的创建过程
1、在内存中开辟连续的空间,用来存放数据,长度是5
2、在数组完成初始化过程,给每个元素赋予默认值,int类型默认值是0
3、数组完成参数化会分配一个唯一的地址值
4、把唯一的地址值交给引用类型的变量a去保存
数组的遍历
从头到尾,以此访问数组每一个位置,获取每一个位置的元素。
int[ ] a= new int[10];
for(int i = 0;i<a.length;i++) {
a[i] = i+1;//a[i]代表的是数组中每一个具体的元素
}
//Arrays.toString(数组):把数组里的数据,用逗号连接成一个字符串[值1,值2]
System.out.println(Arrays.toString(a));
数组工具类Arrays
Arrays.sort(数组)
1、对数组进行排序,对于基本类型的数组使用的是优化后的快速排序算法,效率高。
2、对引用类型数组,使用的是优化后的合并排序算法
package cn.zero;
import java.util.Arrays;
/**数组的工具类Arrays*/
public class TestArraysSort {
public static void main(String[] args) {
//1.创建无序数组
int[] a = {21,96,75,23,25};
//底层使用的排序算法是进行优化后的快速排序算法
Arrays.sort(a);//对无序数组进行直接排序
System.out.println(Arrays.toString(a));
}
}
Arrays.copyOf(数组,新的长度)
把数组赋值成一个指定长度的新数组
新数组的长度 大于 原数组,相当于复制,并增加位置
新数组的长度 小于 原数组,相当于截取一部分数据
package cn.zero;
import java.util.Arrays;
/**数组的缩容与扩容*/
public class TestArraysCopyOf {
public static void main(String[] args) {
//1.创建数组
int[] from = {1,2,3,4,5};//数组一旦创建,长度不可改变
//2.1 数组的普通复制
/**copyOf()用于完成数组的复制,两个参数:
* 参数1:要复制哪个数组
* 参数2:新数组的长度*/
int[] to = Arrays.copyOf(from, 5);
System.out.println(Arrays.toString(to));
//2.2数组的扩容
/**扩容:给数组扩大容量,新数组的长度>原数组的长度
* 扩容思路:先创建对应长度的新数组,每个位置上都是默认值0
* 然后从原数组中将元素复制到新数组,没有被覆盖的元素还是默认值0*/
int[] to2 = Arrays.copyOf(from, 10);
System.out.println(Arrays.toString(to2));
//2.3数组的缩容
/**缩容:缩小数组的容量,新数组的长度<原数组的长度
* 缩容思路:先创建对应长度的新数组,每个位置上都是默认值0
* 然后从原数组中复制指定个数的元素到新数组中,类似于截取*/
int[] to3 = Arrays.copyOf(from, 3);
System.out.println(Arrays.toString(to3));
//2.4指定首尾截取原数组中的元素
/**copyOfRange()用于完成数组的截取,3个参数:
* 参数1:要截取哪个数组【原数组】
* 参数2:从原数组的哪个下标开始
* 参数3:到原数组的哪个下标结束
* 注意:截取的元素包含开始下标处的元素,不包含结束下标处的元素*/
int[] to4 = Arrays.copyOfRange(from, 2, 4);
System.out.println(Arrays.toString(to4));
}
}
二维数组
二维数组本质上是以数组作为数组元素的数组,即“数组的数组”。
类型说明符 数组名[常量表达式][常量表达式]。
创建二维数组
int[][] a = {{3,5},{7,9},{1,2}};
1、创建外部数组,长度是3
2、给每个外部数组的位置创建内部数组,每个内部数组的长度是2
3、给每个内部数组进行数据初始化
4、二维数组生成唯一的地址值
5、把地址值交给引用类型变量a来保存
遍历二维数组
for (int i = 0; i < a.length; i++) {//遍历外部数组
for (int j = 0; j < a[i].length; j++) {//遍历内部数组
System.out.println(a[i][j]);//依次打印二维数组中每个元素的值
}
}
打印二维数组
package cn.zero;
import java.util.Arrays;
/**打印二维数组中的数据*/
public class TestArrays2 {
public static void main(String[] args) {
//1.创建二维数组
// 3 5
//a[0][0] a[0][1]
// 7 9
//[1][0] a[1][1]
// 1 2 3
//a[2][0] a[2][1] a[2][2]
int[][] a = {{3,5},{7,9},{1,2,3}};
//2.遍历二维数组
for (int i = 0; i < a.length; i++) {
// System.out.println(Arrays.toString(a[i]));
for (int j = 0; j < a[i].length; j++) {
//a[i][j]--根据外部数组的下标和内部数组的下标定位具体的元素
System.out.print(a[i][j]);
}
System.out.println();
}
}
}
Java内存结构
1:寄存器。2:本地方法区。3:方法区。4:栈。5:堆。
栈:存储的都是局部变量 ( 函数中定义的变量,函数上的参数,语句中的变量 );
只要数据运算完成所在的区域结束,该数据就会被释放。
堆:用于存储数组和对象,也就是实体。啥是实体啊?就是用于封装多个数据的。
1:每一个实体都有内存地址值。
2:堆内存中的变量都有默认初始化值。因为数据类型不同,值也不一样。
3:垃圾回收机制。
创建对象,内存究竟经历了什么?
1、在栈内存中开辟一块空间,存放引用类型变量p,并把p压入栈底
2、在堆内存中开辟一块空间,存放phone对象
3、完成对象的初始化,并赋予默认值
4、给初始化完毕的对象赋予唯一的地址值
5、把地址值交给引用类型变量p来保存