面向对象OOP（上）②

理解万事万物皆对象

1.在Java语言范畴内，我们都将功能、结构等封装到类中，通过类的实例化，来调用具体的功能结构
Scanner,String等
文件：File
网络资源：URL
2.涉及到Java语言与前端Html、后端的数据库交互时，前后端的结构在Java层面交互时，都体现为类、对象

匿名对象的使用

1.我们创建的对象，没有显式的赋给一个变量名。即为匿名对象
2.特征：匿名对象只能调用一次
3.使用：
//匿名对象
A a = new A( );
这个时候a是类A的一个对象，对象名字为a
method(A a),方法中需要传递一个对象来作为参数
方法一：
A a = new A( );
method a;
方法二：method(new A( ));

自定义数组的工具类

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;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[i] > 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类

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("查找");
  int index = util.getIndex(arr,5);
  if(index>=0)
  {
   System.out.println("找到了，索引地址为："+index);
  }else
  {
   System.out.println("没找到");
  }
 }
}

注意点：将两个类放在同一个包裹中才能相互调用

理解方法的重载

1.定义：在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。
"两同一不同"：同一个类、相同方法名
参数列表不同，参数个数不同，参数类型不同
2.举例：
Arrays类中重载的sort() /binarySearch()

public class Demo0001 {

 //以下四种方法构成重载
 public void getSum(int i,int j)
 {
  System.out.println(i+j);
 }

 public void getSum(double d1,double d2)
 {
  System.out.println(d1+d2);
 }

 public void getSum(String s,int i)
 {
  System.out.println(s+i);
 }

 public void getSum(int i,String s)
 {
  System.out.println(i+s);
 }
}

3.判断是否重载：
跟方法的权限修饰符、返回值类型、形参变量名、方法体都没有关系
4.在通过对象调用方法时，如何确定某一个指定的方法
方法名------> 参数列表

可变个数形参的方法

具体使用：
1.可变个数形参的格式：数据类型 … 变量名
2.当调用可变个数形参的方法时，传入的参数个数可以是：0个，1个，2个…

public class Demo0001 {

 public static void main(String[] args) {
  Demo0001 demo = new Demo0001();
  demo.show(12);
  demo.show("Hello"+"World");

 }
 public void show(int i)
 {
  System.out.println(i);
 }

 public void show(String...strs)  //可变个数形参
 {
  System.out.println("show(String...strs)"); 
 }

}

3.可变个数形参的方法与本类中方法名相同，形参不同的方法之间构成重载

4.可变个数形参的方法与本类中方法名相同，形参类型也相同的数组之间不构成重载。换句话说，二者不能共存

//两者不可共存 
public void show(String...strs)
 {
  System.out.println("show(String...strs)"); 
 }
 public void show(String[] strs)
 {
  System.out.println("show(String...strs)");
 }

5.可变个数形参在方法的形参中，必须声明在末尾
//错误例子
//public void show(String…strs,int i)
应为public void show(int i,String…strs)

6.可变个数形参在方法的形参中，最多只能声明一个可变形参

方法参数的值传递机制

关于变量的赋值：
如果变量是基本数据类型，此时赋值的是变量所保存的数据值
如果变量是引用数据类型，此时赋值的是变量所保存的数据的地址值

方法的形参的传递机制：值传递
形参：方法定义时，声明的小括号内的参数
实参：方法调用时，实际传递给形参的数据

值传递机制：
如果参数是基本数据类型，此时实参赋给形参的是实参真实存储的数据值。
swap()方法内，m与n发生了调换，但main方法内没有任何改变。

如果参数是引用数据类型，此时实参赋给形参的是实参存储数据的地址值

public class Demo0001 {
 public static void main(String[] args) {
  Data data = new Data();

  data.m = 10;
  data.n = 20;

  System.out.println("m = "+data.m+" n = "+data.n);

  Demo0001 test = new Demo0001();
  test.swap(data);
  System.out.println("m = "+data.m+" n = "+data.n);
  //交换m与n的值
//  int temp = data.m;
//  data.m = data.n;
//  data.n = temp;
 }

 public void swap(Data data)
 {
  int temp = data.m;
  data.m = data.n;
  data.n = temp;
 }

}
class Data
{
 int m;
 int n;
}