java基础-知识点

1.一个java源文件中可以有多个类，但是只能有一个public修改的类，且文件名与public类名一致

2.标识符：包括英文数字，_,$，开头不能是数字，严格区分大小写

3.常量：整数，小数，boolean，字符，字符串，null

4.严格区分""与null

5.数据类型：基本数据类型，引用数据类型

6.8大基本数据类型：byte,short,int,long,float,double,char,boolean

7.引用类型：类，接口，数组

8.float a = 1.2编译错误。小数默认的是double类型，应该改为float a = 1.2f

9.byte b = 2; b = b + 2 ; 编译出错，因为b+2之后的值是int类型，int>byte，高类型到低类型会发生精度损失。

10.int/int=int

11.A%B 结果的符号看A

12.char可以存储中文，因为它存储的是Unicode码。Unicode码中有中文。

13.+=与+ =的区别

+=是一个运算符，+ =是两个运算符。short s = 1; s += 2正确。 s +  = 2不正确。

int与short运算之后是int类型，再转为short高类型到低类型会发生精度损失，但是因为+=是一个运算符，会进行数据类型的转换，所以不会出错。+  = 是两个运算符，2是int类型的，int与short运算之后是int类型，再转为short高类型到低类型会发生精度损失。

14.位移运算符：<<左移动，左移一位是乘2。>>右移动，右移一位是除2。

15.数据取值范围

Byte short int long float double   

        Char

 1        2    4       8     4        8         字节

 8       16   32     64                          位

取值范围：

Byte ：-2⁷- (2⁷-1)   -128~127

Short：-2¹⁵- (2¹⁵-1)  -32768~32767

Int  ：-2³¹- (2³¹-1)  （-2147483648~2147483647）

Long ：-2⁶³- (2⁶³-1)  （-9223372036854774808~9223372036854774807）

Float：3.402823e+38 ~ 1.401298e-45（e+38表示是乘以10的38次方，同样，e-45表示乘以10的负45次方）

Double：1.797693e+308~ 4.9000000e-324

16.交换数据

（1）交换字符

public void swapChar(char[] x,int a,int b){
	char c;
	c = x[b];
	x[b] = x[a];
	x[a] = c;
}

（2）交换数值

方式1：
n = n + m;   
m = n – m;
n = n – m;

方式2：
n = n ^ m 
m = n ^ m
n = n^m

17.函数重载

方法名相同；参数类型不同，或者参数个数不同，或者参数顺序不同；不看参数的返回值。函数重载提高了代码的复用性，方便维护。

public static void add(int a,char b){}
public static void add(int a,char b,double c){}
//public static void add(int x,char y,double z){}//函数没有重载了
public static void add(int a,double c,char b){}

18排序

（1）选择排序

public class Test {
		//从小到大排序
		public void sortSelect(int[] arr){
			int min = 0;
			for(int i=0;i<arr.length-1;i++){
				min = i;//改变的是开始比较的位置
				for(int j = i+1;j<arr.length;j++){
					if(arr[j]<arr[min])
						min = j;
				}
				if(min != i){
					arr[min] = arr[min]^arr[i];
					arr[i]   = arr[min]^arr[i];
					arr[min] = arr[min]^arr[i];
				}
			}
		}
	public static void main(String[] args) {
		int[] a = new int[]{17,28,5,13};
		new Test().sortSelect(a);
		for(int i=0;i<a.length;i++){
			System.out.println(a[i]);
		}
	}
}

（2）冒泡排序

public class Test {
	public static void sortBubble(int[] arr){
		for(int i=0;i<arr.length-1;i++){
			for(int j = 0;j<arr.length-1-i;j++){
				if(arr[j+1]<arr[j]){
					arr[j+1] = arr[j+1]^arr[j];
					arr[j] = arr[j+1]^arr[j];;
					arr[j+1] = arr[j+1]^arr[j];
				}
			}
		}
	}
	public static void main(String[] args) {
		int[] a = new int[]{17,28,5,13};
		new Test().sortBubble(a);
		for(int i=0;i<a.length;i++){
			System.out.println(a[i]);
		}
	}
}

优化方案

冒泡排序实际上每次把最大的放在最后，下次不参与比较。一般的做法的弊端是：频繁使用内存。优化方案就是每次找到最大值的下标，与每趟最后一个数进行交换。

public class Test {
	public void sortBubble(int[] arr){
		for(int j = 0;j<arr.length-1;j++){
			int max = 0 ;//最大值的下标
			for(int i=0;i<arr.length-j;i++){
				if(arr[i]>arr[max]){
					max = i;
				}
				if(i == arr.length-1-j){
					int c;
					c = arr[i];
					arr[i] = arr[max];
					arr[max] = c;
				}
			}
		}
	}
	public static void main(String[] args) {
		int[] a = new int[]{90,28,2,45};
		new Test().sortBubble(a);
		for(int i=0;i<a.length;i++){
			System.out.println(a[i]);
		}
	}
}

19.获取中间值的普通方式和最优方式

//mid = (min+max)/2; //普通方式

mid = (min+max)>>1;//最优方式

20.理解二维数组

数组实际上是引用类型的，就是对象	
//实际上就是3个一维数组，每个一维数组的长度是4，每个一维数组开辟一个内存
int[][] arr = new int[3][4];
System.out.println(arr);//[[I@18a992f
System.out.println(arr[0]);//[I@4f1d0d 
（2）更多使用定义与内存
第二个实例
//定义了一个二维数组
//实际上就是3个一维数组，每个一维数组是未知的
int[][] arr = new int[3][];
System.out.println(arr);//[[I@18a992f 二维数组的地址
System.out.println(arr[0]);//null 打印的是一维数组的地址,