重学JavaSe后的补充

1.三元运算符：

需要三个数据才可以进行操作的运算符。
格式：数据类型变量名称 =条件判断 ? 表达式a :表达式b

        int a=10;
        int b=20;
        int max = a>b ? a:b;    //最大值的变量

2.基本数据类型转换：

实线表示自动转换时不会造成数据丢失，虚线则可能会出现数据丢失问题。

1）自动类型转换：

数字表示范围小的数据类型可以自动转换成范围大的数据类型。

2）强制类型转换：

范围大的数据类型强制转换成范围小的数据类型。（有可能发生数据溢出）

//int --> Long
//格式：范围小的类型 范围小的变量名 = (范围小的类型) 原本范围大的数据;
int num =(int) 100L;

3.if-else和switch的区别：

if-else语句更适合于对区间（范围）的判断，而switch语句更适合于对离散值的判断。
if-else的使用范围比switch更广，但执行效率没有switch高。

switch使用时的注意事项：

1）多个case后面的数值不可以重复。
2）switch小括号当中只能是下列数据类型：
基本数据类型：byte/short/char/int
引用数据类型：String、enum
3）switch语句格式可以很灵活：
前后顺序可以颠倒，而且break语句可以省略。

4.三种循环的区别：

for循环：适合循环次数是已知的操作。
while和do…while使用于循环次数未知的。

5.break关键字的常见用法：

1）switch中：
一旦执行，整个switch语句结束。
2）循环语句中：
一旦执行，整个循环语句结束，打断循环。

for(int i=1;i<=10;i++){
    if(i==4){
        break;
    }
    System.out.println("Hello"+i);
}

运行结果：
Hello1
Hello2
Hello3

6.continue关键字的用法：

一旦执行,跳过当前循环次循环剩余内容,马上开始进行下一次循环。

for(int i=1;i<=10;i++) {
    //如果当前是第四层，则跳过当前循环，开始下一层循环(第5层)
    if (i==4){
        continue;
    }
    System.out.println(i+"层到了");
}

运行结果：

Hello1
Hello2
Hello3
Hello5
Hello6
Hello7
Hello8
Hello9
Hello10

break是直接打断循环，continue是跳过。countinue<break。

7.重载和覆写的区别：

重载	覆写
发生在一个类里面	发生在继承关系里面
重载方法名称相同，参数的类型及个数不同。	方法名称，参数的类型和个数相同，方法返回值相同。
重载方法没有权限的限制。	被覆写的方法不能拥有比父类更为严格的访问控制权限。

8.数组

1）数组是什么：

一组相关变量的集合。

2）数组的特点：

是引用数据类型；数组长度不可变

3）数组的创建：

I.动态初始化（指定长度）：

数据类型[] 对象数组名称 = new 数据类型 [长度];

int[] arrayA = new int [5];

II.静态初始化（指定内容）：

标准格式：
数据类型[] 对象数组名称 = new 数据类型 []{ …, … , …}
省略格式：
数据类型[] 对象数组名称 = { …, … , …}

int [] arrayB= new int[] {11,22,33};
int [] arrayC= {44,55,66};

III.使用建议：

如果不确定数组当中的具体内容，用动态初始化；确定了具体内容，则最好使用静态。

4）获取数组元素：

格式：数组名称[索引值]
索引值从0开始，一直到"数组长度-1"为止。

动态初始化数组并循环输出：

public class Test {
	public static void main(String[] args) {
		int data [] = new int[3];
		data[0] = 10;
		data[1] = 20;
		data[2] = 30;
		for(int x=0;x<data.length;x++){
			System.out.println(data[x]);
		}
	}
}

5）数组的内存图：

根据地址[0x666]找到数组。

引用传递：同一块堆内存空间，能被不同的栈访问。

6）数组的索引越界：

索引超过了数组的长度。
ArrayIndexOutOfBoundsException异常。

int[] array = {10,20};
System.out.println(array[2]);

7）数组长度的不可变性：

xx.length即可获得数组的长度。
只用你new了，数组的长度就永远不可变。（变了的只是新数组，地址值发生改变）

8）冒泡排序

（利用java.util.Arrays.sort() 也可以完成排序）

public class Test10 {
	public static void main(String args[]){
		int data [] = new int [] {
			9,7,6,8,4,5,1,3,2,	
		};
		sort(data);
		print(data);
	}
	public static void sort(int temp[]){
		int t;
		for(int x=0;x<temp.length;x++){
			for(int y =0;y<temp.length-1;y++){
				if(temp[y]>temp[y+1]){
					t = temp[y];
					temp[y] = temp[y+1];
					temp[y+1] = t;
				}
			}
		}
	}
	public static void print(int temp2[]){
		for(int x=0;x<temp2.length;x++){
			System.out.print(temp2[x]);
		}
		System.out.println();
	}
}

9）数组反转

public class Test10 {
	public static void main(String args[]){
		int data [] = new int [] {
			1,2,3,4,5,6,7,8	
		};
		reserve(data);
		print(data);
	}
	public static void reserve(int temp[]){
			int len = temp.length /2;
			int head = 0;
			int tail = temp.length - 1;
			for(int x=0;x<len;x++){
				int a ;
				a = temp[head];
				temp[head] = temp [tail];
				temp[tail] = a;
				head ++;
				tail --;
			}
	}
	
	public static void print(int temp2[]){
		for(int i =0;i<temp2.length;i++){
			System.out.println(temp2[i]);
		}
	}
}

9.Java的内存：

Java中的内存可以划分为五个模块：

①栈内存(Stack)：

存放的都是方法中的局部变量。方法的运行一定要在栈当中运行。

②堆内存(Heap)：

凡是new出来的东西，都在堆内存中。堆内存都有地址值：16进制。

③方法区(Method Area)：

存储.class相关信息，包含方法的信息。

④本地方法栈(Native Method Stack)：

与操作系统相关。

⑤寄存器(pc Register)：

与CPU相关。

發表評論

所有評論

還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.