自定义一个数组的工具类
将数组中的内容封装到一个方法中
创建一个ArrayUtil类
public class ArrayUtil {
// 求数组的最大值
public int getMax(int[] arr) {
int maxValue = arr[0];
for (int i = 1; i < arr.length; i++) {
if (maxValue < arr[i]) {
maxValue = arr[i];
}
}
return maxValue;
}
// 求数组的最小值
public int getMin(int[] arr) {
int minValue = arr[0];
for (int i = 1; i < arr.length; i++) {
if (minValue > arr[i]) {
minValue = arr[i];
}
}
return minValue;
}
// 求数组的总和
public int getSum(int[] arr) {
int sum = 0;
for (int i = 0; i < arr.length; i++) {
sum += arr[i];
}
return sum;
}
// 求数组的平均值
public int getAvg(int[] arr) {
return getSum(arr) / arr.length;//方法中调用方法
}
// 反转数组
public void reverse(int[] arr) {
for (int i = 0; i < arr.length / 2; i++) {
int temp = arr[i];
arr[i] = arr[arr.length - i - 1];
arr[arr.length - i - 1] = temp;
}
}
// 复制数组
public int[] copy(int[] arr) {
int[] arr1 = new int[arr.length];
for (int i = 0; i < arr1.length; i++) {
arr1[i] = arr[i];
}
return arr1;
}
// 数组排序
public void sort(int[] arr) {
// 冒泡排序
for (int i = 0; i < arr.length - 1; i++) {
for (int j = 0; j < arr.length - 1 - i; j++) {
if (arr[j] > arr[j + 1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp
}
}
}
}
// 遍历数组
public void print(int[] arr) {
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + "\t");
}
System.out.println();
}
// 查找指定元素
public int getIndex(int[] arr, int dest) {
// 线性查找:
for (int i = 0; i < arr.length; i++) {
if (dest == arr[i]) {
return i;
}
}
return -1;//返回一个负数,表示没有找到
}
}
再创建一个ArrayUtilTest类,对ArrayUtil中的方法进行调用
public class ArrayUtilTest {
public static void main(String[] args) {
ArrayUtil util = new ArrayUtil();
int[] arr = new int[]{32,34,32,5,3,54,654,-98,0,-53,5};
int max = util.getMax(arr);
System.out.println("最大值为:" + max);
System.out.println("排序前:");
util.print(arr)
util.sort(arr);
System.out.println("排序后:");
util.print(arr);
System.out.println();
System.out.println("查找:");
int index = util.getIndex(arr, -5);//-5即为要查找的数
if(index >= 0){
System.out.println("找到了,索引地址为:" + index);
}else{
System.out.println("未找到");
}
util.reverse(arr);
}
}
方法的重载
-
重载概念:在同一个类中,允许存在一个以上的同名方法,只要他们的参数个数或者参数类型不同发即可.
两同一不同:同一个类,相同方法名。参数列表不同,参数个数不同,参数类型不同
-
重载的特点:与返回值类型无关,只看参数列表,且参数列表必须不同。(参数个数或参数类型)调用时,根据方法参数列表的不同来区别
-
在通过对象调用方法时,如何确定某一个指定的方法:
方法名------>参数列表 -
重载示例:
//返回两个整数的和
int add(int x,int y){
return x+y;
}
//返回三个整数的和
int add(int x,int y ,int z){
return x+y+z;
}
//返回两个小数之和
double add(double x,double y){
return x+y;
}
public class OverLoadTest{
public static void main(String [] args){
OverLoadTest test = new OverLoadTest();
test.getSum(1,2);//请问,此时调用的是那个方法
}//回答:调用的是第一个方法。因为参数类型为int。如果方法一不存在,则会自动进行类型提升,选择方法二
//如下的4个方法构成重载
public void getSun(int i,int j){//如果调用的是此方法则输出方法一,下面相同
System.out.println("方法一");
}
public void getSun(double d1, double d2){
System.out.println("方法二");
}
public void getSun(String s,int i){
System.out.println("方法三");
}
public void getSun(int i,Strgin s){
System.out.println("方法四");
}
//下面的这个方法不能和上面的构成重载, 他是同一个类,相同方法名,但是参数列表和第一个相同,所以不行
public int getSun(int i, int j){
return 0;
}
//下面的这个也不行,形参列表还是和第一个相同 int ,int 与形参变量名无关
public void getSun(int m,int j){
}
//下面的这个也不行,形参列表还是和第一个相同 int ,int 与方法的权限修饰符无关
private void getSun(int i,int j){
}
}
**总结:判断方法是否重载:跟方法的权限修饰符、返回值类型、形参变量名、方法体都无关
**
方法重载的练习:
要求:
1、编写一个程序,定义三个重载方法并且调用,
三个方法分为接收一个int的参数、两个int的参数、一个字符串参数
分别执行平方运算并输出结果,相乘并输出结果、输出字符串信息。
在主类的main()方法中分别用参数区别调用三个方法
2、定义三个重载方法max()
第一个方法求两个int值中的最大值
第二个方法求两个double值中的最大值
第三个方法求三个double值中的最大值
并分别调用三个方法。
public class OverloadExer{
//题一
//如下三个方法构成重载
public void mOL(int i){
System.out.println(i * i);
}
public void mOL(int i,int j){
System.out.println(i * j);
}
public void mOL(String s){
System.out.println(s);
}
//题二
//如下三个方法可以构成重载
public int max(int i ,int j){
return (i>j)? i : j;
}
public double max(double d1 ,double d2){
return (d1 > d2)? d1 : d2;
}
public double max(double d1 ,double d2,double d3){
double max = (d1 > d2)? d1 : d2;
return(max >d3)? max :d3;
}
}
可变个数形参的方法
具体使用
/*
* 可变个数形参的方法
*
* 1.jdk 5.0新增的内容
* 2.具体使用:
* 2.1 可变个数形参的格式:数据类型 ... 变量名
* 2.2 当调用可变个数形参的方法时,传入的参数个数可以是:0个,1个,2个,。。。
* 2.3 可变个数形参的方法与本类中方法名相同,形参不同的方法之间构成重载
* 2.4 可变个数形参的方法与本类中方法名相同,形参类型也相同的数组之间不构成重载。换句话说,二者不能共存。
* 2.5 可变个数形参在方法的形参中,必须声明在末尾
* 2.6 可变个数形参在方法的形参中,最多只能声明一个可变形参。
*
*/
public class MethodArgsTest {
public static void main(String[] args) {
MethodArgsTest test = new MethodArgsTest();
test.show(12);
// test.show("hello");
// test.show("hello","world");
// test.show();
test.show(new String[]{"AA","BB","CC"});
}
public void show(int i){
}
public void show(String s){
System.out.println("show(String)");
}
public void show(String ... strs){
System.out.println("show(String ... strs)");
for(int i = 0;i < strs.length;i++){
System.out.println(strs[i]);
}
}
//不能与上一个方法同时存在
// public void show(String[] strs){
//
// }
//The variable argument type String of the method
//show must be the last parameter
// public void show(String ...strs,int i){
//
// }
}
方法参数的值传递机制
1、 方法,必须由其所在类或对象调用才有意义。若方法含有参数:
形参:方法声明时的参数,方法定义时,声明的小括号内的参数
实参:方法调用时实际传给形参的参数值
2、Java中的实参值如何传入方法的?
Java里的方法参数传递方式只有一种:值传递。即将实际参数值的副本(复制品)传入方法内,而参数本身不受影响
① 形参是基本数据类型,将实参基本数据类型变量的“数据值”传递给形参
② 形参是引用数据类型,将实参引用数据类型变量的“地址值”传递给形参
public class ValueTransferTest {
public static void main(String[] args) {
System.out.println("***********基本数据类型:****************");
int m = 10;
int n = m;
System.out.println("m = " + m + ", n = " + n);
n = 20;
System.out.println("m = " + m + ", n = " + n);
System.out.println("***********引用数据类型:****************");
Order o1 = new Order();
o1.orderId = 1001;
Order o2 = o1;//赋值以后,o1和o2的地址值相同,都指向了堆空间中同一个对象实体。
System.out.println("o1.orderId = " + o1.orderId + ",o2.orderId = " +o2.orderId);
o2.orderId = 1002;//这里给新地址值赋值了1002,所以o1的也会发生改变
System.out.println("o1.orderId = " + o1.orderId + ",o2.orderId = " +o2.orderId);
}
}
class Order{
int orderId;
}