哈哈，黄猿大大来了，吐槽，真的是干货满满，慢慢提升，多敲多练！
方法重组(overloading)和数组
1.方法重载
1.在同一个类中
2.方法名称相同
3.形参，参数列表不同（参数的个数，类型，顺序有一个 不相同都属于不同），只有满足这三个不同之一，我们才可以确保每一个方法的唯一性。
4.跟返回值无关
5.跟访问修饰符无关
优点：
代码的整体性结构更加清晰明了，提高可阅读性
代码的灵活性提高
package com.qfedu.test1;
/**
* 我们现在使用程序模拟实现一个计算器
* 方法重载：
* 1.在同一个类中
* 2.方法名称相同
* 3.形参，参数列表不同(参数的个数，类型，顺序有一个不相同都属于不同)
* 只有满足这三个不同之一 我们才可以确保每一个方法的唯一性
* 4.跟返回值无关
* 5.跟访问修饰符无关
*
* 经过方法重载改造以后优点：
* 1.代码的整体结构更加的清晰明了
* 2.阅读性更好
*
*
* @author WHD
*
*/
public class Test1 {
public static int add(int a , int b) {
return a + b;
}
public static int add(int a, int b , int c) {
return a + b + c;
}
public static int add(int a,int b,int c,int d) {
return a + b + c + d;
}
public static double add(double a,double b) {
return a + b;
}
public static double add(double a, double b ,double c) {
return a + b + c;
}
public static double add(double a,double b,double c,double d) {
return a + b + c + d;
}
public static int add(String operation,int a,int b) {
// 代码业务逻辑
return 20;
}
public static int add(int a, int b,String operation) {
return 0;
}
public static void main(String[] args) {
// alt + /
int result1 = add(20, 30);
System.out.println(result1);
// System.out.println(addtion(10, 20, 30));
// System.out.println(sum(10, 20, 30));
System.out.println(add(21.2, 22.3));
System.out.println(add(10, 20, 30));
}
}
2.数组
2.1数组的概念
数组是在内存中开辟一块长度固定的，连续的空间，用于存储相同类型数据类型的内容
2.2数组的定义
数组的定义分为四种方式
1.先声明再 分配空间
int [] num;
num = new int[5];
2.声明并且分配空间
int [] num = new int[10];
3.声明并且赋值（繁琐）
String [] strs = new Sting[] {“a”,“b”,“c”,“d”}
4.声明并且辅助（简洁）
double [] num = {1,2,3,4,5,6}
package com.qfedu.test2;
/**
* 数组 是指在内存中开辟一块连续、长度固定的空间，用于存储数据类型相同的内容
* 连续
* 固定
* 相同
* @author WHD
*
*/
public class Test1 {
public static void main(String[] args) {
// 方式1 先声明 再分配空间
int [] nums1;
nums1 = new int[5];
// 方式2 声明并且分配空间
int [] nums2 = new int[10];
// 方式3 声明并且赋值(繁琐)
String [] strs = new String[] {"a","b","c","d"};
// 方式4 声明并且赋值(简洁)
double [] nums3 = {1, 2.3 , 3.5 , 20.5 ,22};
}
}各种类型数组的定义和使用
package com.qfedu.test2;
/**
* 其他类型的数组 使用 访问
* @author WHD
*
*/
public class Test3 {
public static void main(String[] args) {
byte [] bytes = new byte[2];
bytes[0] = 12;
bytes[1] = 22;
short [] shorts = {11,22,33};
long ls[] = {22,562,458,895};
float [] fs = new float[3];
fs[0] = 20F;
fs[1] = 22F;
double [] dbs = {11,22,33};
boolean [] flags = {true,false,true,true};
char [] chars = new char[2];
chars[0] = 'A';
chars[0] = 'B';
chars[1] = 'C';
String [] strs = new String[2];
strs[0] = "abc";
strs[1] = "def";
}2.3数组的下标和访问
数组的下标（索引）从0开始
给数组中的元素赋值：数组名[index] = value;
获取数组中的元素：数组名[index]
在我们访问数组的时候，如果使用不存在的下标，将会报数组下标越界异常
ArrayindexOutOfBoudsException
package com.qfedu.test2;
/**
* 数组的访问
* 我们可以通过下标来访问数组中的每一个元素
* 数组中的下标(索引)从0开始 以后的元素 依次+ 1
* 比如数组长度为5 那么下标为 0~ 4
* 语法格式 数组名[下标]
* @author WHD
*
*/
public class Test2 {
public static void main(String[] args) {
int [] nums1 = new int[5];
// 赋值
nums1[0] = 20;
nums1[1] = 21;
nums1[2] = 55;
nums1[3] = 66;
nums1[4] = 77;
// 取值
System.out.println("数组中的第一个元素是" + nums1[0]);
System.out.println("数组中的第二个元素是" + nums1[1]);
System.out.println("数组中的第三个元素是" + nums1[2]);
System.out.println("数组中的第四个元素是" + nums1[3]);
System.out.println("数组中的第五个元素是" + nums1[4]);
// 以上代码严格按照有效的下标来访问数据 如果是否不存在的下标访问数据 会 怎样呢？
// 将会报异常 数组下标越界异常 ArrayIndexOutOfBoundsException
// nums1[5] = 55;
System.out.println(nums1[10]);
}
}2.4数组的遍历
遍历，是指将数组中的元素逐一访问，包括取值和设定值
package com.qfedu.test3;
/**
* 数组的遍历
* 遍历：将数组中的元素逐一进行访问
* 数组的属性：length 长度
* 使用方式：数组名.length来使用 得到的是一个int类型的值 表示数组的长度
* @author WHD
*
*/
public class Test1 {
public static void main(String[] args) {
int [] nums = {11,45,78,89,56,44,55,77,88,99,66,11,55};
System.out.println("使用数组的length属性获取数组的长度" + nums.length);
for(int i = 0;i < nums.length;i++) {
System.out.println(nums[i]);
}
}
}
package com.qfedu.test3;
import java.util.Scanner;
/**
* 让用户输入，将5个学生成绩存放到一个double类型的数组中
* @author WHD
*
*/
public class Test2 {
public static void main(String[] args) {
double [] scores = new double[5]; // index 0 ~ 4
Scanner input = new Scanner(System.in);
for(int i = 0; i < scores.length;i++) {
System.out.println("请输入第"+ (i + 1) +"个学生的成绩");
scores[i] = input.nextDouble();
}
// 将数组中的成绩打印出来
System.out.println("================================");
for(int i = 0;i < scores.length;i++) {
System.out.println("第" + (i + 1) + "个学生的成绩是" + scores[i]);
}
}
}2.5数组的默认值
数组作为引用数据类型，栈中存放的是数组的名字，指向的是堆中的地址，堆中存放的是数组的内容
package com.qfedu.test4;
/**
* 数组的默认值
* 不同于我们之前所使用的局部变量 数组声明并且开辟空间以后 就有默认值
* 整数：0
* 小数：0.0
* 字符：\u0000
* 布尔：false
* 其他：String null
* @author WHD
*
*/
public class Test1 {
public static void main(String[] args) {
// int a = 20;
// System.out.println(a);
int [] nums = new int[5];
for(int i = 0;i < nums.length;i++) {
System.out.print(nums[i] + "\t");
}
System.out.println();
double [] nums1 = new double[6];
for (int i = 0; i < nums1.length; i++) {
System.out.print(nums1[i] + "\t");
}
System.out.println();
char [] chars = new char[5];
for (int i = 0; i < chars.length; i++) {
System.out.print(chars[i] + "|\t");
}
System.out.println();
boolean [] bls = new boolean[10];
for (int i = 0; i < bls.length; i++) {
System.out.print(bls[i] + "\t");
}
System.out.println();
String [] strs = new String[11];
for (int i = 0; i < strs.length; i++) {
System.out.print(strs[i] + "\t");
}
}
}
此处有图片
2.6数组的扩容
数组扩容，定义一个长度为原数组两倍的新数组，遍历原数组将数组中元素逐一赋值到新数组中
package com.qfedu.test4;
/**
* 数组的扩容
* 思路：
* 1.创建大于原数组长度的新数组
* 2.将原数组的内容 依次 添加到新的数组中
* @author WHD
*
*/
public class Test2 {
public static void main(String[] args) {
int [] oldArray = {11,22,33,44,55};
int [] newArray = new int[oldArray.length * 2];
for (int i = 0; i < oldArray.length; i++) {
newArray[i] = oldArray[i];
}
System.out.println("扩容以后新数组的内容");
for (int i = 0; i < newArray.length; i++) {
System.out.print(newArray[i] + "\t");
}
}
}求数组中的元素的元素的和，求平均值
package com.qfedu.test4;
/**
* 求数组中元素的总和 / 平均值
* @author WHD
*
*/
public class Test3 {
public static void main(String[] args) {
int [] nums = {11,32,33,55,88,99};
int sum = 0;
for (int i = 0; i < nums.length; i++) {
sum += nums[i];
}
System.out.println("总和是" + sum);
System.out.println("平均值是" + sum / nums.length);
}
}求数组中最大值和最小值
package com.qfedu.test4;
/**
* 求数组中的最大值和最小值
* 分析：
* 1.最大值肯定属于数组的其中一个元素
* 2.我们先假设一个最大 ，依次与其他元素比较，如果遇到比当前假设值更大的 那么交换 "头衔"
* @author WHD
*
*/
public class Test4 {
public static void main(String[] args) {
int [] nums = {1,2,45,78,88,99};
// 假设一个最大值
int max = nums[0];
// int min = nums[0];
for(int i = 1;i < nums.length;i++) {
if(max < nums[i]) {
max = nums[i];
}
}
System.out.println("最大是值是" + max);
}
}2.7复制数组
复制数组的三种方式：
1.我们自己编写代码将原数组的内容逐一复制到 新数组中
2.JDK提供的System.arraycopy(原数组,原数组起始,新数组,新数组起始,长度)方法
3.JDK提供java.util包下Arrays提供的copyOf(原数组,新长度)方法，此方法会返回一个新的数组给我们
package com.qfedu.test5;
import java.util.Arrays;
/**
* JDK提供两种复制数组的方法
* System.arraycopy(原数组,原数组起始,新数组,新数组起始,长度); 没有返回值的
* Arrays.copyOf(原数组，新长度); 返回新的数组
* Arrays属于一个工具类 提供的有一些方法
* copyOf()复制数组
* toString() 将数组中的内容转换为字符串
* sort()排序 只能升序 不能降序
* @author WHD
*
*/
public class Test1 {
public static void main(String[] args) {
int [] nums1 = {11,22,33,44,55};
int newNums[] = Arrays.copyOf(nums1, 2);
System.out.println(Arrays.toString(newNums));
System.out.println("========================");
for (int i = 0; i < newNums.length; i++) {
System.out.print(newNums[i] + "\t");
}
int [] nums2 = {11,22,33,44,55};
int [] nums3 = new int[10];
System.arraycopy(nums2, 1, nums3, 0, 2); //
System.out.println(Arrays.toString(nums3));
System.out.println();
}
}2.8地址的替换
引用数据类型，变量中存放的是地址，直接将数组赋值给另外一个数组，赋值的是地址，此时，两个引用，也就是两个变量同时指向同一块空间，所以我们打印数组中的内容是一样的。
package com.qfedu.test6;
import java.util.Arrays;
/**
* 地址的替换
* 数组作为引用数据类型 变量中存放的是地址 指向堆中的空间 而堆中真正存放的是数组的内容
* 我们根据下标来找到对应的元素
* @author WHD
*
*/
public class Test1 {
public static void main(String[] args) {
int [] nums1 = {11,22,33,44,55};
int [] nums2 = new int[10];
for(int i = 0;i< nums1.length;i++) {
nums2[i] = nums1[i];
}
System.out.println(Arrays.toString(nums2));
System.out.println(Arrays.toString(nums1));
int a = 20;
nums1 = nums2;
System.out.println("将nums2的地址赋值给nums1，那么此时两个变量将指向同一块空间");
System.out.println(Arrays.toString(nums1));
}
}2.9值传递和引用
值的传递 基本数据类型 都属于 值的传递，值得传递只是一个值的副本 值的拷贝 不会对原来的值产生影响
和
引用传递
引用数据类型作为参数传值的时候，传递的是地址，将会改变原来的值
String类型除外，String类型属于一个特殊的引用数据类型
package com.qfedu.test6;
import java.util.Arrays;
/**
* 值传递 基本数据类型 都属于 值传递 ，值传递的只是一个值的副本 值的拷贝 不会对原来的值产生影响
* 和
* 引用传递
* 引用数据类型作为参数传值的时候，传递的是地址，将会改变原来的值
* String类型除外，String类型属于一个特殊的引用数据类型
* @author WHD
*
*/
public class Test2 {
public static void main(String[] args) {
int a = 10;
m1(a);
System.out.println(a);
int [] nums = {1,2,3,4,5};
m2(nums);
System.out.println(Arrays.toString(nums));
String str = "world";
m3(str);
System.out.println(str);
}
public static void m1(int a) {
a += 10;
}
public static void m2(int [] a) {
for (int i = 0; i < a.length; i++) {
a[i] += 1;
}
}
public static void m3(String str) {
str += "hello";
}
}3.0数组作为形参和数组作为返回值
数组作为形参，跟我们之前的其他的类型的参数规则一致，依然规定了参数，类型，顺序数组作为返回值，同样也跟我们之前讲的返回值要求一致，必须要跟方法声明时要求的返回值类型要匹配
package com.qfedu.test6;
import java.util.Scanner;
/**
* 数组类型的参数 和 数组作为返回值
* 1.要求传入一个成绩数组，然后每个数组中的元素在原有的值基础上 + 2
* 2.编写一个方法用于统计每个人的成绩，统计完成以后将成绩信息返回
* @author WHD
*
*/
public class Test3 {
public static void main(String[] args) {
double [] scores = {55,66,77,88};
m1(scores);
}
public static void m1(double [] scores ) {
for (int i = 0; i < scores.length; i++) {
scores[i] += 2;
}
}
public static double[] m2() {
Scanner input = new Scanner(System.in);
System.out.println("请输入班级人数");
int count = input.nextInt();
double scores[] = new double[count];
for (int i = 0; i < scores.length; i++) {
System.out.println("请输入第" + (i + 1) + "个人的成绩");
scores[i] = input.nextDouble();
}
return scores;
}
}
3.1可变长参数
可变长参数，表示可以接受0个或者N个相同类型的参数，使用方法跟数组一致
1.形象列表只能出现一次，否则编译出错，容易产生歧义
2.只能在形参列表的末尾
package com.qfedu.test6;
/**
* 可变长参数
* 形参列表中只能出现一个 可变长参数 并且只能在形参列表的最后一个
* @author WHD
*
*/
public class Test4 {
public static void main(String[] args) {
m1(11,22,33,44,55,66);
}
public static void m1(int a,int... nums) {
for (int i = 0; i < nums.length; i++) {
System.out.println(nums[i]);
}
}
}
扫一扫
1198
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
