数组和封装方法

方法的封装

• 一个类中可以定义N个方法，但只有main方法是程序的入口
• 类中可以没有main方法
• 方法体现的是代码的封装性，将重复的逻辑封装到一个方法中，下次是使用的时候直接调用方法即可
• 方法必须写在类中
• 方法在程序中代表能做什么、能返回什么、需要什么
• 编写方法的语法

	返回值类型	方法名（参数类型，变量名）{
		能做什么...
	}
	返回值就是java中返回的数据类型，如果没有返回值就用void标识

数组

• 数组的长度一经创建不可改变
• 数组中存放的数据类型必须一致
• 数组中通过length获取数组的长度
• 数据通过索引获取数组中的元素

数组默认值

byte、short、int、long数组默认值为0；
boolean数据类型的默认值为false
char数组对应的默认值是0对应的字符
浮点数组的默认值为0.0
引用数组的默认类型为null

• 定义方法

int[] array=new int[3] //定义一个长度为3的数组，里面的值默认为0
int[] array={1,3,4,5}//长度为4,
int[] array=new int[] {12,3,4,}
int[] array ; array = {1, 2, 3} `错误写法

数组的遍历

• 普通的for循环遍历

public static void main(String[] args){
	int[] array={1,3,4,1};
	for(int i=0;i<array.length;i++){
		System.out.println(array[i]);
	}
}

• 增强版for循环遍历

public static void main(String[] args){
	int[] array={1,3,4,1};
	//中间用：前面i代表的是数组里元素，后面是数组的变量名
	for(int i:array){
		System.out.println(i);
	}
}

数组的封装

package com.qikux.utils;

public class MyUtils {
    //封装一个求取数组中最大值的方法
    public static int max(int[] array) {
        int max = array[0];
        for (int i = 1; i < array.length; i++) {
            if (max < array[i]) {
                max = array[i];
            }
        }
        return max;
    }

    //封装一个求取数组中最小值的方法
    public static int min(int[] array) {
        int min = array[0];
        for (int i = 1; i < array.length; i++) {
            if (min > array[i]) {
                min = array[i];
            }
        }
        return min;
    }

    //封装一个求取数组中指定元素第一次所在的位置
    public static int indexOf(int b, int[] array) {
        for (int i = 0; i < array.length; i++) {
            if (b == array[i]) {
                return i;
            }
        }
        return -1;
    }

    //封装一个求取数组中指定元素最后一次次所在的位置；
    public static int lastIndexOf(int b, int[] array) {
        int lastindexof = array.length - 1;
        for (int i = array.length - 1; i >= 0; i--) {
            if (b == array[i]) {
                return i;
            }
        }
        return -1;
    }

    /*封装一个求取元素是否在数组中*/
    public static boolean has(int b, int[] array) {
        return indexOf(b, array) != -1;
    }



    /**
     * 三元运算符定义最大值
     */
    public static int max(int a, int b) {
        int c = a > b ? a : b;
        return c;
    }

    /**
     * 三元运算符定义最小值
     */
    public static int min(int a, int b) {
        int c = a < b ? a : b;
        return c;
    }

    /**
     *定义一个方法 greatestCommonDivisor ，计算两个整数的 最大公约数
     */
    public static int greatestCommomDivisor(int a,int b){
        while(true){
           /* if(a>b){
                a=a-b;
            }else{
                a=a^b;
                b=a^b;
                a=a^b;
                a=a-b;
            }
            if(a==b){
                return a;
            }
        }*/
            if(a>b){
                a=a%b;
            }else{
                a=a^b;
                b=a^b;
                a=a^b;
                a=a%b;
            }
            if (a%b==0){
                return b;
            }
        }
    }
    /**
     * 定义一个方法 leastCommonMultiple, 计算两个整数的 最小 公倍数
     */
    public static int leastCommonMultiple(int a,int b){
        int c=a,d=b;
        while(true){
            if(a>b){
                a=a-b;
            }else{
                a=a^b;
                b=a^b;
                a=a^b;
                a=a-b;
            }
            if(a==b){
                return c*d/a;
            }
        }
    }
    /**
     * 封装一个 avg 方法， 用来 计算 int[] 数组的所有元素的平均值
     */
    public static double avg(int[] array){
        int sum=0;
        for (int i = 0; i < array.length; i++) {
            sum+=array[i];
        }
        return sum/array.length;
    }
    /**
     * 封装一个 isLeapYear 方法， 判断 对应的年份是否是闰年
     */
    public static boolean isLeapYear(int a){
        if (a%4==0&&a%100!=0||a%400==0){
            return true;
        }
        return false;
    }
    /**
     * 封装一个 isOdd 方法，判断一个数字是否是 奇数
     */
    public static boolean isOdd(int a){
        if(a%2==0){
            return false;
        }
        return true;
    }
    /**
     * 封装一个 isEven 方法，判断一个数字是否是 偶数
     */
    public static boolean isEven(int a){
        if (a%2==0){
            return true;
        }
        return false;
    }
    /**
     * 封装一个 isPrimes 方法， 判断一个数字是否是 素数
     */
    public static boolean isPrimes(int a){
        for(int i=2;i<=Math.sqrt(a);i++){
            if(a%i==0){
                return false;
            }
        }
        return true;
    }
    /**
     *
     * 封装一个 bubbleSort 方法、实现 int[] 数组的冒泡排序
     */
    public static void bubbleShort(int[] array) {
        //第一个for循环用来控制循环几趟
        for (int i = 1; i < array.length; i++) {
            //第二个for循环用来控制一趟循环几次
            for (int j = 0; j < array.length - i; j++) {
                if (array[j] > array[j + 1]) {
                    //通过异或实现两个数字的交换
                    array[j] = array[j] ^ array[j + 1];
                    array[j + 1] = array[j] ^ array[j + 1];
                    array[j] = array[j] ^ array[j + 1];
                }
            }
        }
    }
    public static void printArray(int[] array){
        for (int i : array) {
            System.out.println(i);
        }
    }

}