Java基础学习day9【谷】

Java基础学习day9 理解“万事万物皆对象”

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

Scanner,String等
文件：Fi1e
网铬资源：URL
涉及到JaVa语言与前端utm、后端的数据库交互时，前后端的结构在JaVa层面交互时，都体现为类、对象。

匿名对象的使用

理解：我们创建的对象，没有显式的赋给一个变量名。即为匿名对象
特征：匿名对象只能调用一次。

封装数组工具类

utils类

public class ArrayUtils {
    //求数组的最大
    public int getMax(int[] array) {
        int max = array[0];
        for (int i = 1; i < array.length; i++) {
            if (max < array[i]) {
                max = array[i];
            }
        }
        return max;
    }

    //求数组的最小
    public int getMin(int[] array) {
        int min = array[0];
        for (int i = 1; i < array.length; i++) {
            if (min > array[i]) {
                min = array[i];
            }
        }
        return min;
    }

    //求数组的总和
    public int getSum(int[] array) {
        int sum = 0;
        for (int i = 0; i < array.length; i++) {
            sum = sum + array[i];
        }
        return sum;
    }

    //求数组的平均
    public int getAvg(int[] array) {
        int avg = getSum(array) / array.length;
        return avg;
    }

    //反转数组
    public void getReserve(int[] array) {
        for (int i = 0; i < array.length/2; i++) {
            int temp=array[i];
            array[i] =  array[array.length-1-i];
            array[array.length-1-i]=temp;
        }
    }
    //复制数组
    public int[] getCopy(int[] array) {
        int[] newArray = new int[array.length];
        for (int i = 0; i < array.length; i++) {
            newArray[i] =  array[i];
        }
        return newArray;
    }
    //数组排序
    public void sort(int[] array){
        for (int i = 0; i < array.length-1; i++) {
            for (int j = 0; j < array.length-1-i; j++) {
                if(array[j]>array[j+1]){
                    int temp=array[j];
                    array[j]=array[j+1];
                    array[j+1]=temp;

                }
            }
        }
    }
    //遍历数组
    public void toString(int[] array) {
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i]+"t");
        }
        System.out.println();
    }
    //查找指定元素
    public int findIndex(int[] array,int a) {
        for (int i = 0; i < array.length; i++) {
            if(array[i]==a){
                return i;
            }

        }
        return -1;
    }
}

测试类

public class ArrayTest {
    public static void main(String[] args) {
        int[] arr = new int[]{1,88,99,45,71,-21,7,-9,0};
        ArrayUtils arrayUtils = new ArrayUtils();
        arrayUtils.toString(arr);
        System.out.println(arrayUtils.getMax(arr));
        System.out.println(arrayUtils.getMin(arr));
        System.out.println(arrayUtils.getAvg(arr));
        System.out.println(arrayUtils.getSum(arr));
        int[] copy = arrayUtils.getCopy(arr);
        arrayUtils.toString(copy);
        int index = arrayUtils.findIndex(arr, 7);
        if(index>=0){
            System.out.println("找到了，位置在："+index);
        }else {
            System.out.println("找不到哦！！！！");
        }
        arrayUtils.getReserve(arr);
        arrayUtils.toString(arr);
        arrayUtils.sort(copy);
        arrayUtils.toString(copy);

    }
}

方法的重载

定义：在同一个类中，方法名相同，只要他们的参数个数、参数属性、参数属性顺序不同即可

记忆：两同一不同

类相同方法名相同

参数列表不同：参数个数、参数属性

判断是否重载与方法权限修饰符、返回值类型、方法体、参数属性顺序以及形参变量名均无关系

在调用对象是如何调用一个指定的方法

方法名-----》形参列表

可变个输形参的方法

1.jdk5.0新增的内容
2具体使用：
2.1可变个数形参的格式：数据类型 …
变量名
2.2当调用可变个数形参的方法时，传入的参数个数可以是：0个，1个，2个，…
2.3可变个数形参的方法与本类中方法名相同，形参不同的方法之间构成重载
2.4可变个数形参的方法与本类中方法名相同，形参类型也相同的数组之间不构成重载。换句话说，二者不能共存
2.5可变个数形参在方法的形参中，必须声明在末尾
2.6可变个数形参在方法的形参中，最多只能声明一个可变形参。

关于变量的赋值：值传递机制

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

例：

public class Demo {
    public static void main(String[] args) {
        int m=10;
        int n=20;
        System.out.println("m="+m+"n="+n);
        Demo demo = new Demo();
        demo.swap(m,n);
        System.out.println("m="+m+"n="+n);
    }
    public void swap(int m,int n){
        int temp=m;
        m=n;
        n=temp;
    }
}

结果为

出现的原因：

根本原因：局部变量在方法结束后就会自动销毁，此情况变量是基本数据类型，会直接调用数据的值

解决办法：

创建引用数据类型来辅助交换

方法一：创建一个类用类来存储

public class Demo {
    public static void main(String[] args) {
        int m=10;
        int n=20;
        System.out.println("m="+m+"n="+n);
        Demo demo = new Demo();
        Date date = new Date();
        date.m=m;
        date.n=n;
        demo.swap(date);
        System.out.println("m="+date.m+"n="+date.n);
    }
    public void swap(Date date){
        int temp=date.m;
        date.m=date.n;
        date.n=temp;
    }
}
class Date{
    int m;
    int n;
}

例二：

public class Demo1 {
    public static void main(String[] args) {
        int[] nums = new int[]{1,3,7,55,-9,-78};
        Demo1 demo1 = new Demo1();
        for (int i = 0; i < nums.length-1; i++) {
            for (int j = 0; j < nums.length-1-i; j++) {
                if(nums[j]>nums[j+1]){
                demo1.swap(nums[j],nums[j+1] );
                }
            }
        }
        for (int i = 0; i < nums.length; i++) {
            System.out.print(nums[i]+"t");
        }
    }
    public void swap(int m,int n){
        int temp=m;
        m=n;
        n=temp;
    }
}

错误原因：同理，数据类型为基本数据类型是存在栈内存中，相当于复制

解决方法：

public class Demo1 {
    public static void main(String[] args) {
        int[] nums = new int[]{1,3,7,55,-9,-78};
        Demo1 demo1 = new Demo1();
        for (int i = 0; i < nums.length-1; i++) {
            for (int j = 0; j < nums.length-1-i; j++) {
                if(nums[j]>nums[j+1]){
                demo1.swap(nums,j,j+1);
                }
            }
        }
        for (int i = 0; i < nums.length; i++) {
            System.out.print(nums[i]+"t");
        }
    }
    public void swap(int[] arr,int m,int n){
        int temp=arr[m];
        arr[m]=arr[n];
        arr[n]=temp;
    }
}

练习

代码：

Circle类

public class Circle {
    double radius;
    public double findArea(){
        return Math.PI*radius*radius;
    }
}

PassObject类

public class PassObject {
    public void printAreas(Circle c,int time){

        System.out.println("Radius"+"t"+"t"+"Area");
        for (int i = 1; i < time+1; i++) {
            c.radius=i;
            System.out.println(c.radius+"t"+"t"+"t"+c.findArea());
        }
        c.radius=time+1;
    }
}

测试类

public class Demo3 {
    public static void main(String[] args) {
        PassObject passObject = new PassObject();
        Circle circle = new Circle();
        passObject.printAreas(circle,5);
        System.out.println("now the radios is  "+circle.radius);
    }
}

递归方法

递归方法：一个方法体内调用它自身。
方法递归包含了一种隐式的循环，它会重复执行某段代码，但这种重复执行无须循环控制

递归一定要向已知方向递归，否则这种递归就变成了无穷递归，类似于死循环。

暑期编程PK赛得CSDN机械键盘等精美礼品！

Java基础学习day9【谷】

Java相关栏目本月热门文章