每日一学Java篇

今天继续学习Java面向对象的内容，以下素材均来自B站尚硅谷。

一、理解“万事万物皆对象”

        1.在Java语言范畴中，我们都能将功能、结构等封装到类中，通过类的实例化，来调用具体的功能结构。

                >Scanner,String等

                >文件：File

                >网路资源：URL

        2.涉及到Java语言与前端Html、后端的数据库交互时，前后端的结构在Java层面交互时，都体现为类、对象。

二、内存解析的说明

引用类型的变量，只可能存储两类值：null 或 地址值（含变量的类型）

三、匿名对象的使用

1.理解：我们创建的对象，没有显示的赋给一个变量名。即为匿名对象。

2.特征：匿名对象只能调用一次。

3.使用：如下

public class InstanceTest {
    public static void main(String[] args) {
        Phone p = new Phone();
        System.out.println(p);

        p.sendEmail();
        p.playGame();

        new Phone().price = 1999;
        new Phone().showPrice();

        PhoneMall mall = new PhoneMall();
        mall.show(new Phone());
    }
}

class PhoneMall{

    public void show(Phone phone){
        phone.sendEmail();
        phone.playGame();
    }
}

class Phone{
    double price;
    public void sendEmail(){
        System.out.println("发邮件");
    }
    public void playGame(){
        System.out.println("玩游戏");
    }
    public void showPrice(){
        System.out.println("手机价格");
    }
}

 自定义数组的工具类：

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");
        }
    }

    //查找指定元素
    public int getIndex(int[] arr, int dest){
        //线性查找
        for (int i = 0;i < arr.length;i++){
            if (dest == arr[i]){
                return i;
            }
        }
        return -1;//返回一个负数，表示没有找到
    }
}

public class ArrayUtilTest {
    public static void main(String[] args){
        ArrayUtil util = new ArrayUtil();
        int[] arr = new int[]{32,24,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();
        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("未找到");
        }
    }
}

 方法的重载（overload）loading...

1.定义：在同一类中，允许存在一个以上的同名方法，只要他们的参数个数或者参数类型不同即可。

        "两同一不同"：同一个类、相同方法名

                                参数列表不同：参数个数不同，参数类型不同

2.举例：

        Arrats类中重载的sort() / binarySearch()

3.判断是否是重载：

        跟方法的权限修饰符、返回值类型、形态变量名、方法体都没有关系！

4.在通过对象调用方法时，如何确定某一个指定的方法：

        方法名 - - - > 参数列表

public class OverLoadTest {

    //如下的4跟方法构成了重载
    public void getSum(int i,int j){
        System.out.println(i + j);
    }

    public void getSum(double d1,double d2){

    }

    public void getSum(String s,int i){

    }

    public void getSum(int i,String s){

    }
}

 练习判断：

 重载的练习：

1.编写程序，定义三个重载方法并调用。方法名为mOL。
        三个方法分别接收一个int参数、两个int参数、一个字符串参数。

        分别执行平方运算并输出结果，相乘并输出结果，输出字符串信息。 

        在主类的main ( )方法中分别用参数区别调用三个方法。

2.定义三个重载方法max( ),
        第一个方法求两个int值中的最大值，
        第二个方法求两个doub1e值中的最大值，

        第三个方法求三个double值中的最大值，

        并分别调用三个方法。

public class OverloadExer {
    //1.如下的方法构成重载
    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);
    }

    //2.如下的方法构成重载
    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为了方便就没有写到main()方法中。

总结：今天学习了如何理解“万事万物皆对象”、对象数组的内存解析、匿名对象的使用、理解方法的重载、方法重载的细节说明、重载的举例和判断练习、重载的练习：编码实践。

明日计划：继续学习Java面向对象的内容。