黑马程序员-基础知识梳理2

------- android培训、java培训、期待与您交流！ ----------

数组的第二种创建方式：元素类型[]  数组名 = new 元素类型[]{元素1，元素2.。。。。};

int [] arr = new int[]{1,2,3,4,5}; 

int[] arr ={1,2,3,4,5};

异常代码：

Arrary Index out of boundsException:3:操作数时，访问到了数组不存在的角标

NullPointer Exception :空指针异常：当引用没有任何指向，值为NULL的情况，该引用还用于操作实体。

选择排序：先以0角标的数与其他数比较，确定0角标的位置的数之后再以相同的方法确定1角标，2角标。。。。。

选择排序特点：内循环结束一次，最值出现在头角标位置。

冒泡排序：相邻2个元素比较，如果符合条件，换位置，一轮过后，最值出现在数组的最后一个元素上，下一轮的时候，就不用比较最后一个元素了。

public class Sort {public static  void main(String[] args){int[] arr = {9,2,4,3,5,1};int[] arr1 = {11,3,88,22,13,52,1};printarr(arr);selectSort(arr);printarr(arr);printarr(arr1);bubbleSort(arr1);printarr(arr1);}/** * 该方法实现冒泡排序 * @param arr */public static void bubbleSort(int[] arr){for(int i=0;i<arr.length-1;i++){for(int j =0;j<arr.length-i-1;j++){if(arr[j+1]<arr[j]){swap (arr,j+1,j);}}}}/** * 该方法实现选择排序，让数组升序排列 * @param arr */public static void selectSort(int [] arr){for(int i=0;i<arr.length-1;i++){for(int j=i+1;j<arr.length;j++){if(arr[i]>arr[j]){swap(arr,i,j);}}}}/** * 该方法实现对数组内2个元素之间的位置互换 * @param arr * @param i * @param j */public static void swap(int[] arr,int i,int j){int temp = arr[i];arr[i] = arr[j];arr[j] = temp;}/** * 该方法实现对数组的打印 * @param arr */public static void printarr(int[] arr){for(int i=0;i<arr.length;i++){if(i!=arr.length-1)System.out.print(arr[i]+",");elseSystem.out.println(arr[i]);}}}

希尔排序是最高效的排序。

数组元素的查找：如果要找的数不在数组内，那么就返回一个-1

折半查找的2种方式：

public class halfSearch {public static void main(String[] args){int[] arr = {1,2,9,12,18};int temp1=halfSearch1(arr,2);int temp2=halfSearch1(arr,22);int temp3=halfSearch2(arr,12);int temp4=halfSearch2(arr,22);System.out.println(temp1);System.out.println(temp2);System.out.println(temp3);System.out.println(temp4);}/** * 这是折半查找的第一种方式 * @param arr * @param key * @return */public static int halfSearch1(int[] arr,int key){int mid,min,max;max = arr.length-1;min = 0;mid=(max+min)>>1;while(key!=arr[mid]){if(key>arr[mid]){min=mid+1;}else if (key<arr[mid]){max= mid-1;}if (min>max){return -1;}mid=(max+min)>>1;}return mid;}/** * 这是折半查找的第二种方式 * @param arr * @param key * @return */public static int halfSearch2(int[] arr, int key){int min,max,mid;min=0;max=arr.length-1;mid=(max+min)>>1;while(max>=min){if(key>arr[mid]){min=mid+1;}else if(key<arr[mid]){max=mid-1;}elsereturn mid;mid=(max+min)>>1;}return -1;}}

练习：有一个有序的数组，想要将一个元素插入到该数组中，还要保证该数有序；

思路：1、先查找该数是否在该数组存在，如果找到了，就直接插在该数的位置

2、如果不存在，可以利用折半查找的方式在return -1 的地方将其改成return min；这个min就是要插入位置的角标

练习：

十进制->二进制

十进制->16进制

package cn.itcast.day2;public class decimalToBinaryAndHex {public static void main(String[] args){int num=12;toBin(num);toHex(num);}public static void toBin(int num){StringBuffer sb=new StringBuffer();while(num!=0){sb.append(num&1);num = num >>> 1;}System.out.println(sb.reverse());}public static void toHex(int num){StringBuffer sb = new StringBuffer();while(num!=0){int temp=num&15;if(temp>10)sb.append((char)(temp-10+'A'));elsesb.append(temp);num = num >>>4;}System.out.println(sb.reverse());}}

查表法 三种进制整合

package cn.itcast.day2;public class jinzhizhenghe {public static void main(String[] args){int num = 78;toBin(num);//验证二进制toHex(num);//验证16进制toOct(num);//验证8进制}//查表法将3种进制转换共同的地方抽取出来封装成一个方法public static void trans( int num ,int base,int offset){char[] chs = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};StringBuffer sb = new StringBuffer();char [] arr =new char[32];int pos =arr.length;while (num!=0){int temp = num & base;arr[--pos] = chs[temp];num=num>>>offset;}for(int i=pos;i<arr.length;i++){if(i!=arr.length-1)System.out.print(arr[i]);elseSystem.out.println(arr[i]);}}//转2进制public static void toBin(int num){trans(num ,1,1);}//转8进制public static void toOct(int num){trans(num,7,3);}//转16进制public static void toHex(int num){trans(num,15,4);}}

二维数组

int arr[][] = new int[3][4]; //定义了名为arr 的二维数组，二维数组里有三个一维数组，每个一维数组里面有4个元素。3指二维数组的长度

二维数组的应用

练习：求二维数组的所有数的和；

int

package cn.itcast.day2;public class arrayPractise {/**练习：求二维数组里所有数的和 * @param args */public static void main(String[] args) {// TODO Auto-generated method stubint[][] arr = {{1,3,5,5,2},{23,13,2},{23,1},{19,57}};int sum = 0;for(int i=0;i<arr.length;i++){for(int j=0;j<arr[i].length;j++){sum += arr[i][j];}}System.out.println(sum);}}

数组定义方式：

一位数组：int[] x; int y[];

二维数组： int [][] x;int []x[];int x[][];

习题：

1  。   int[] x,y[]; x是一位数组，y是二维数组； 拆开来分析：int[] x; int[] y[];

上面的定义作为一个大前提；

x[0]= y;错 ，二维数组赋值给一位数组的一个元素；

y[0]=x;对

y[0][0]=y; 错

x[0][0]= y;错

y[0][0]= x[0];对

x=y;错

面向对象：将功能封装进对象，强调具备了功能的对象。

类：对现实生活种事物的描述

对象：就是这类事物实实在在存在的个体

成员变量：存在堆内存中，因为对象存在，才在内存中存在；

布局变量：存在栈内存中

作用范围：成员变量作用于整个类中，布局变量作用于函数或者语句中。

匿名对象使用环境：1.当对对想的方法只调用一次，可以用匿名对象来完成，这样比较简化。如果对一个对象进行多个成员调用，必须对这个对象取名字。

2.可以将匿名对象作为实际参数进行传

new Car().num=5;

封装：是指隐藏对象的属性和实现细节，仅对外提供访问方式

构造函数：

特点 :

1函数名与类名相同

2不用定义返回值

3不可以写return语句

对象一建立，就会调用与之对应的构造函数

构造函数的作用：可以用于给对象进行初始化

构造函数的细节:

当一个类中没有定义构造函数，那么系统会默认给该类加入一个空参数的构造函数，如果有定义构造函数，默认构造函数就会消失。

构造函数在同一个类中可以有多个，只要参数列表不同就行。

构造函数和一般方法的区别：

构造函数在对象一建立就运行。给对象进行初始化；而一般方法是对象调用后才执行，是给对象添加对象具备的功能的

一个对象建立，构造函数只运行一次，而一般方法可以被该对象调用多次。

构造代码块：给对象进行初始化，而且优先于构造函数执行。

与构造函数的区别：

构造代码块是给所有对象进行统一初始化。

构造代码块中定义的是不同对象共性的初始化内容。

this 代表什么？

this 代表他所在函数所属对象的引用；

this 作用:用于区分局部变量和成员变量的同名情况；

this的应用：当定义类中功能时，该函数内容要用到调用该函数的对象时，这时用this来表示这个对象，但凡本类功能内部使用了本类对象，都用this表示。

构造函数间互相调用只能用this，构造函数只能被构造函数调用。

this（参数列表）；

不带点；this语句只能放在构造函数的第一行；因为初始化动作要先执行。

public static void main(String[] args)

主函数：是一个特殊的函数，作为程序的入口，可以被jvm调用。

主函数的定义：

public：代表这该函数访问权限是最大的。

static:代表着主函数随着类的加载就已经存在了

void：主函数没有具体的返回值

main：不是关键字，但是是一个特殊的单词，可以被JVM调用

（String[]  args）:函数的参数，参数类型是一个数组，该数组中的元素是字符串类型的数组。主函数是固定格式的JVM识别。jvm在调用时，传入的是new String[0];

静态变量的定义环境？

当对象中出现共享数据时，该数据被静态所修饰。

对象中的特有数据要定义成非静态存在于堆内存中。

静态函数的定义环境：当功能内部没用访问到飞静态数据时（对象的特有数据）没那么该功能可以定义成静态的。

将方法静态后可以方便使用，但该类还是可以被其他程序建立对象，可以通过将构造函数私有化来优化。

static关键字：

用法：是一个用来修饰成员变量，成员函数的修饰符

当用static修饰后，该成员可以直接 被类名调用，不需要new对象。

static特点：

1。随着类的加载而加载，随着类消失而小时，生命周期长。

2。优于对象存在。

3。被所有对象共享

4。被类名直接调用

静态注意事项：

1.静态方法只能访问静态成员，非静态方法可以访问静态，非静态成员。

2.静态方法中不能定义this，super关键字；

因为静态优先于对象存在。

实力变量与类变量的区别：

1、存放位置：类变量随着类的加载而存在于方法中；实例变量随着对象的建立而存在于堆内存中。

2、生命周期：类变量随着类的消失而小时，实例变量随着对象的消失而消失

帮助文档的编写

/**

功能

@author xx

@ version V1.1

*/

在成员方法前面加上

/**

实现功能

@param 参数名 功能

.......

*/

命令：javadoc -d myhelp -authot -version java名.java

*/

API: APPLY PROGRAM INTERFACE

静态代码块的执行语句：

static{

执行语句；

}

Person p =new Person("zhangsan",20);

该语句做了什么？

1.加载person.class 到内存中；

2、执行该类的static代码块，如果有的，给person.class类进行初始化；

3、在堆内存中开辟空间，分配内存地址；

4、在堆内存中建立对象的特有属性，并进行默认初始化；

5、对属性进行显示初始化；

6、对对象进行构造代码块初始化

7、对对象进行队形的构造函数初始化

8、将内存地址复制给站内存中的P变量。

设计模式：解决某一类问题最行之有效的方法

java中有23中设计模式.

单例设计模式:解决一个类在内存只有一个对象

想要保证对象唯一：

1.为了避免其他程序过多建立该类的对象，先禁止其他程序建立该类的对象；

2.为了让其他程序可以访问该类的对象，只好在本类中定义一个对象；

3.为了方便其他程序对自定义对象的访问，可以对外提供一个访问方式；

这三步的代码实现：

1.将构造函数私有化

2.在类中建立一个本类的对象

3.提供一个方法可以获取该对象

private student(){}

private static student s = new student

public static student getInstance(){

return s;

}

package cn.itcast.day2;public class lanhan_ehan {/** * @param args */public static void main(String[] args) {// TODO Auto-generated method stub}//懒汉式对象是方法被调用时，才被初始化，也叫对象的延迟加载。static class Single{private static Single s = null;private Single(){};public static Single getInstance(){if(s==null){synchronized(Single.class){s= new Single();return s;}}return s;}}//饿汉式：single 类一进内存，就已经创建好对象了。static class Single1{private Single1(){};private static Single1 s = new Single1();public static Single1 getInstance(){return s;} }}