java基础上

1.JDK、JRE、JVM

JDK = JRE + 开发工具集

JRE = JVM + Java SE标准类库

2.变量的定义

byte、char、short --> int --> long —> float --> double

3.区分&与&&

相同点：运算结果相同  当符号左边是true时，都会执行符号右边的操作

不同点：当符号左边是false时，&继续执行右边的运算，&&不再执行符号右边的运算

4.switch-case

凡是可以使用三元运算符的地方，都可以改写为if-else语句，反之不行。

凡是可以使用switch-case的结构，都可以转换位if-else，反之不行。

switch结构中的表达式，只能是如下的6种数据类型之一：byte、short、char、int、枚举类型（JDK5.0新增）、String类型（JDK7.0新增）

5.获取字符串和整型

import java.util.Scanner;

Scanner scan = new scanner（System.in）；

String name = scan.next（）；

Int id = scan.nextInt（）;

System.out.printIn（name）；

6.break和continue的区别

break ：用于switch-case 和循环（结束当前循环）

continue ：用于循环（结束当次循环）


外层循环控制行数，内层循环控制列数

7.数组的特点

1）数组是有序排列的。

2）数组属于引用数据类型的变量。数组的元素，既可以是基本数据类型，也可以是引用数据类型。

3）创建数组对象会在内存中开辟一整块连续的空间。

4）数组的长度一旦确定，就不能修改。

8.java数组元素的默认初始化值

1）一维数组

数组元素是整型               0

数组元素是浮点型             0.0

数组元素是char型           0 非‘0’

数组元素是boolean          false

数组元素是引用数据类型        null

2）二维数组

针对于初始化方式一：比如 int [] [] arr = new int [4] [3];

		外层元素的初始化值为：地址值

		内层元素的初始化值为：与一维数组初始化情况相同

针对于初始化方式二：比如 int [] [] arr = new int [4] [];

		外层元素的初始化值为：null

		内层元素的初始化值为：不能调用，否则报错

9.数据结构

1）数据与数据之间的逻辑关系：集合、一对一、一对多、多对多

2）数据的存储结构：

线性表：顺序表（比如数组）、链表、栈、队列

树形结构：二叉树

图形结构：有向图、无向图

10.如何理解二维数组？

1）数组属于引用数据类型

2）数组的元素也可以是引用数据类型

3）一个一维数组A的元素如果还是一个一维的数组类型的，则此数组A称为二维数组

11.杨辉三角

public class YangHuiTest {
		public static void main(String[] args){
			//1.声明二维数组
			int[][] yangHui = new int[10][] ;
			//2.给数组元素赋值
			for(int i = 0;i < yangHui.length;i++){
				yangHui[i] = new int[i+1];
				//给首末元素赋值
				yangHui[i][0] = 1;
				yangHui[i][i] = 1;
				//给每行的非首末元素赋值
				if(i > 1){
					for(int j = 1;j < yangHui[i].length - 1;j++){
						yangHui[i][j] = yangHui[i-1][j-1] + yangHui[i-1][j];
					}
				}
			}
			//3.遍历二维数组
			for(int i = 0;i < yangHui.length;i++){
				for(int j = 0;j < yangHui[i].length;j++){
					System.out.print(yangHui[i][j] + " ");
				}
				System.out.println();
			}
		}
}

1 
1 1 
1 2 1 
1 3 3 1 
1 4 6 4 1 
1 5 10 10 5 1 
1 6 15 20 15 6 1 
1 7 21 35 35 21 7 1 
1 8 28 56 70 56 28 8 1 
1 9 36 84 126 126 84 36 9 1 

12.排序算法的优劣

1）时间复杂度：分析关键字的比较次数和记录的移动次数。

2）空间复杂度：分析排序算法中需要多少辅助内存。

3）稳定性：若两个记录A和B的关键字值相等，但排序后A、B的先后次序保持不变，则称这种排序算法是稳定的。

13.数组冒泡排序的实现

public class BubbleSortTest {
	public static void main(String[] args){
		int[] arr = new int[]{43,32,76,-98,0,64,33,-21,32,99};
		
		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[j+1];
					arr[j+1] = temp;
				}
			}
		}
		
		for(int i = 0;i < arr.length;i++){
			System.out.print(arr[i] + "\t");
		}
	}
}

-98	-21	0	32	32	33	43	64	76	99

14.Arrays数组类的使用

boolean equals(int[] a,int[] b)  判断两个数组是否相等

String toString(int[] a)   输出数组信息

void fill(int[] a,int val)   将指定值填充到数组之中

void sort(int[] a)   对数组进行排序

int binarySearch(int[] a,int key)   对排序后的数组进行二分法检索指定的值

15.数组中的常见异常

1)数组角标越界的异常：ArrayIndexOutOfBoundsException

2）空指针异常：NullPointerException

16.Java面向对象学习的三条主线

1）Java类及类的成员：属性、方法、构造器；代码块、内部块

2）面向对象的三大特征：封装性、继承性、多态性

3）其他关键字：this、super、static、final、abstract、interface、package、import等

17.类

类：对一类事物的描述，是抽象的、概念上的定义。

创建类的对象 = 类的实例化 = 实例化类

例如：Person p1 = new Person（）；

对象.属性   对象.方法

如果创建了一个类的多个对象，则每个对象都独立的拥有一套类的属性。

18.属性（成员变量） vs 局部变量

相同点

1）定义变量的格式：数据类型 变量名 = 变量值

2）先声明，后使用

3）变量都有其对应的作用域

不同点

1）在类中声明的位置的不同

属性：直接定义在类的一对{}内

局部变量：声明在方法内、方法形参、代码块内、构造器形参、构造器内部的变量

2）关于权限修饰符的不同

属性：可以在声明属性时，指明其权限，使用权限修饰符。

常用的权限修饰符：private、public、缺省、protected

局部变量：不可以使用权限修饰符。

3）默认初始化值的情况

属性：类的属性，根据其类型，都有默认初始值。

​		整型： 0

​		浮点型： 0.0

​       字符型： 0

​		布尔型： false

​		引用数据类型（类、数组、接口）：null

局部变量：没有默认初始化值。

​		意味着，我们在调用局部变量之前，一定要显式赋值。

​		特别地：形参在调用时赋值即可。

4）在内存中加载的位置

属性：加载到堆空间中（非static）

局部变量：加载到栈空间

19.返回值类型

1）如果方法有返回值，则必须在方法声明时，指定返回值的类型。同时方法中，需要使用return关键字

来返回指定类型的变量或常量：“return数据”。

2）如果方法没有返回值，则方法声