Java方法
设计原则 : 一个方法只完成一个功能 , 这样利于我们后期的扩展—原子性
main()方法要尽量保持整洁干净
Java方法类似于其他语言的函数
一个方法需要包含以下语法 :
- 修饰符 : 可选
- 返回值类型 : void或其他
- 方法名 : 驼峰命名
- 参数类型 : 可选
- 方法体 : 包含的具体的功能
public static void main(String[] args) {
int sum = add(1, 2); //实参
System.out.println("sum = " + sum);
}
/*
修饰符 返回值类型 方法名(参数类型 参数名){
方法体
return 返回值;
}
*/
public static int add(int a,int b){ //形参
return a+b;
}
**实参 : **实际调用传递的参数
**形参 : **用来定义的
调用方法 :
对象名.方法名(实参列表)
当方法返回一个值时 , 方法调用通常被当做一个值
如果方法返回值是void , 方法调用一定是一条语句
重载方法
名称必须相同 , 参数列表必须不相同 (个数不同 , 或类型不同, 或排列顺序不同) , 返回值类型不能是重载的判断条件
方法相同时 , JVM会自己判断
public static int add(int a,int b,int c){
return a+b+c;
}
public static int add(int a,int b){
return a+b;
}
命令行传参
java Test this is YYY
使用cmd时可以给main方法传递参数
可变参数
不定项参数 , 不规定传多少个参数 , 在方法声明中 , 在指定参数类型后加一个省略号(…)
一个方法中只能指定一个可变参数 , 它必须是方法的最后一个参数 , 任何普通的参数必须在它之前声明
public static void main(String[] args) {
Demo04 t = new Demo04();
t.test(1,5,6,8,7);
}
public void test(int... i){
System.out.println(i[0]);
System.out.println(i[2]);
System.out.println(i[3]);
System.out.println(i[4]);
}
本质上就是数组
递归
就是A方法调用A方法 , 自己调用自己
递归结构的两个部分 :
递归头 : 什么时候不调用自身方法。如果没有头,将陷入死循环。
递归体:什么时候需要调用自身方法。
递归并不是个优秀的算法,能不用递归就不用递归
Java数组
数组 : 相同类型数据的有序集合
要使用数组得先声明
int[] nums; //声明
int num[]; //不推荐
nums=new int[10]; //使用new创建数组 , 可以存放10个int类型的数字
//赋值
nums[0] = 1;
nums[1] = 2;
nums[2] = 3;
nums[3] = 4;
nums[4] = 5;
nums[5] = 6;
nums[6] = 7;
nums[7] = 8;
nums[8] = 9;
nums[9] = 10;
//不赋值会有默认值
System.out.println(nums[0]);
Java内存分析
声明数组并不存在 , 只有创建了才存在 , 一旦创建了就不能改变
- 堆
存放new的对象和数组
- 栈
存放基本变量类型(会包含这个基本类型的具体数值)
引用对象的变量(会存放这个引用在堆里面的具体地址)
数组特点
- 长度是固定的 , 一旦创建大小就不能改变
- 其中的元素必须是相同类型
- 可以是引用类型数组,也可以是基本类型数组
- 数组变量属于引用类型
- 数组本身就是对象 , Java中对象是在堆中的 , 因此数组对象本身就是在堆中的
数组使用
- for-each循环 : 一般用来打印结果
//遍历
int[] a={1,2,3,4,5,6,7};
for (int i = 0; i < a.length; i++) {
System.out.println(a[i]);
}
//计算和
int sum=0;
for (int i = 0; i < a.length; i++) {
sum+=a[i];
}
System.out.println("sum = " + sum);
System.out.println("========");
//JDK1.5 , 没有下标
for (int i : a){
System.out.println(i);
}
- 数组作为参数传入方法
多维数组
数组中嵌套数组
int[][] a={{1,2,3},{4,5,6},{7,8,9}};
for (int i = 0; i < a.length; i++) {
for (int j = 0; j < a[i].length; j++) {
System.out.print(a[i][j]+" ");
}
System.out.println();
}
Arrays类
java.util.Arrays
- 输出数组
int[] a = {45,78,56,12,35,8,15,98,25};
System.out.println(Arrays.toString(a));
- 排序
sort
- 二分查找
binarySearch
- 填充
fill
冒泡排序
外层表示轮数 , 里层依次比较
-
比较数组中两个相邻的元素
-
每次比较都会产生一个最大或最小的数组
-
下一轮则可以少一次排序
public static int[] mySort(int[] a){
int temp;
//外层 , 判断要走多少次
for (int i = 0; i < a.length-1; i++) {
//内层 , 判断比较两个数 , 如果第一个数比第二个数大 , 交换位置
for (int j = 0; j < a.length-1-i; j++) {
if(a[j]>a[j+1]){
temp=a[j];
a[j]=a[j+1];
a[j+1]=temp;
}
}
}
return a;
}
稀疏数组
当一个数组中大部分元素为0 , 或者为同一值的数组时 , 可以使用稀疏数组来保存该数组
记录原始数组的有效的值生成一个新的数组
public static void main(String[] args) {
int[][] a=new int[11][11];
a[1][2]=1;
a[2][3]=2;
System.out.println("原始的数组 : ");
for (int[] i : a){
for (int j : i){
System.out.print(j+"\t");
}
System.out.println();
}
//获取有效值的个数
int sum=0;
for (int i = 0; i < a.length; i++) {
for (int j = 0; j < a[i].length; j++) {
if (a[i][j] != 0){
sum++;
}
}
}
System.out.println("有效的个数 : "+sum);
System.out.println("转换为稀疏数组 : ");
//创建一个稀疏数组的数组
int[][] a2=new int[sum+1][3];
a2[0][0]=a.length;
a2[0][1]=a.length;
a2[0][2]=sum;
int count=0; //计数器
for (int i = 0; i < a.length; i++) {
for (int j = 0; j < a.length; j++) {
if(a[i][j]!=0){
count++;
a2[count][0]=i;
a2[count][1]=j;
a2[count][2]=a[i][j];
}
}
}
for (int i = 0; i < a2.length; i++) {
for (int j = 0; j < a2.length; j++) {
System.out.print(a2[i][j]+"\t");
}
System.out.println();
}
//还原稀疏数组
//先读取稀疏数组的值
int[][] a3=new int[a2[0][0]][a2[0][1]];
//还原值
for (int i = 1; i < a2.length; i++) {
a3[a2[i][0]][a2[i][1]]=a2[i][2];
}
//打印
System.out.println("还原的数组 : ");
for (int[] i : a3){
for (int j : i){
System.out.print(j+"\t");
}
System.out.println();
}
}