黑马程序员 3 Java基础语法拾遗二

浏览数：18 / 时间：2015年06月08日

1、函数

（1）无法从静态上下文中引用非静态方法。

（2）函数命名，习惯多个单词第一个小写后头都首字母大写，驼峰命名。

（3）提高代码重用性。

（4）函数内部可以调用函数但是不能定义函数。

（5）思考清楚函数需求，思路。

（6）内存加载过程：a、Javac 启动编译器，编译成JVM识别的字节码；b、Java 启动JVM。

内存分类：栈，存储变量，对象引用；

堆，存储new的元素；

静态域，static；

常量池，存放常量。

（7）重载：同名函数，参数个数或者类型相同即可，与返回值类型无关，与参数类型有关。如果函数出现不确定性，出错。

*绘画矩形函数：

    public static void draw(int w, int h){
        for(int i= w;i>0;i--) 
            System.out.print(‘*‘);
        System.out.println();
        for(int i= h-2;i>0;i--){
            System.out.print(‘*‘);
            for(int j=w-2;j>0;j) 
            System.out.print(‘*‘);
        System.out.println();
    }

*重载加法函数，整数，浮点数，字符串都可以：

    public static void add(int a ,int b){
        System.out.println(a+"+"+b+"="+(a+b));
    }
    public static void add(double a ,double b){
        System.out.println(a+"+"+b+"="+(a+b));
    }
    public static void add(String a ,String b){
        System.out.println(a+"+"+b+"="+(a+b));
    }

2、数组

（1）同一类型数据，长度必须确定。声明数组：元素类型[] 数组名 = new 元素类型[长度]。

（2）内存划分：

a 寄存器

b 本地方法区

c方法区

d 栈内存（储存局部变量，所属作用域结束自动释放）

e 堆内存（存储对象包括数组，new建立堆中。）

1）每个实体都有首地址值

2 ）堆对数组默认赋值，数值0, 0.0, 0.0f boolean false， char ‘\u0000‘

3 ）垃圾回收机制

（3）第二种定义格式：

元素类型[] 数组名 = new 元素类型[]{元素，元素，……};（int[] arr = {x,x,x,……}）

（4）数组操作：

a 遍历：

    //遍历数组
    public static void printArray(int[] arr){
        //遍历数组输出
        for(int i=0;i<arr.length;i++){
            System.out.print(arr[i]+" ");
        }
        System.out.println();
    }

b 排序：

1）改进的选择排序：

在交换过程中只交换角标，最后一步交换值，从而提高效率。

        //改进的选择排序
        for(int i=0;i<arr.length-1;i++){
            int index = i;
            int num = arr[i];
            for(int j=i+1;j<arr.length;j++){
                if(num <arr[j]){
                    num = arr[j];
                    index = j;
                }
            }
            if(index != i){
                int temp = arr[index];
                arr[index] = arr[i];
                arr[i] = temp;
            }
        }

2）冒泡排序（内循环，-1为了避免角标越界，-x，为了让外循环增加一次内循环与比较的个数递减）：

    public static void bubbleSort(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[i];
                    arr[i] = temp;
                    */
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
    }

* Arrays.sort()可以给数组排序。
c、查找：

    //查找
    public static int getIndex(int[] arr,int key){
        for(int i=0;i<arr.length;i++){
            if(arr[i]==key){
                return i;
            }
        }
            return -1;
    }

折半查找（只能在数组有序时）：

    //折半查找
    public static int binarySearch(int[] arr,int key){
        int upper = arr.length-1;
        int lower = 0;
        int mid;
        while(upper>=lower){
            mid = (upper+lower)>>1;
            if(arr[mid]>key)
                upper = mid-1;
            else if(arr[mid]<key)  //这里丢了else，导致查找失败时异常
                lower = mid+1;
            else return mid;
            //输出查找过程
            //System.out.print("["+mid+"]");
        }
        return -1;
    }

* 工程中，java.util.* 中有Arrays.bianrySearch(arr,key);//如果不存在，返回插入点，-index-1；
*面试题：给定一个数组，如果存住一个元素，保证还是有序的，那么其角标如何获取。

    public static int insertIndex(int[] arr,int key){
        int upper = arr.length-1;
        int lower = 0;
        int mid;
        while(lower<=upper){
            mid = (upper+lower)>>1;
            if(arr[mid]>key)
                upper = mid-1;
            else if(arr[mid]<key)
                lower = mid+1;
            else return mid;
        }