黑马程序员-基础知识梳理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]+",");
			else
				System.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;
			}
			else
				return 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'));
			else
				sb.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]);
			else
				System.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 stub
		int[][] 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;
			} 
			
	}
}