JAVA基础： 上部分总结

面向对象

1.Java基础
数据类型：
基本数据类型（4类8种）
整型 byte short int long
小数型 float double
布尔 boolean
字符 char
引用数据类型
String 数组 类 集合
常量 变量 标识符 关键字
流程控制语句
运算符 ：
位运算符:用于操作二进制位的运算符。
& | ^
<< >> >>>(无符号右移)
练习：对两个变量的数据进行互换。不需要第三方变量。
int a = 3,b = 5;–>b = 3,a = 5;
a = a + b; a = 8;
b = a - b; b = 3;
a = a - b; a = 5;
a = a ^ b;//
b = a ^ b;//b = a ^ b ^ b = a
a = a ^ b;//a = a ^ b ^ a = b;
练习：高效的算出 2*8 = 2<<3;
流程语句：If switch do while while for
选择结构（分支结构）if switch
循环结构 for while
循环应用：for(int i=0,i<num,i++){}, while(条件语句){} 前面两个是先【判断后执行 do{} while（条件语句）先执行后判断
循环嵌套
流程跳转 break：中断循环； continue：一般用于if判断在判断条件中若有continue；
说明在这种条件执行完后会继续执行后面条件
switch：
default可以写在switch结构中的任意位置如果将default语句放在了第一行，
则不管expression与case中的value是否匹配，程序会从default开始执行直到第一个break出现。
数组 数组遍历 普通遍历、增强遍历
数组 ：索引 元素
数组算法 ：冒泡排序

//对一维数组进行冒泡排序
int [] arrs = {5,4,3,2,1};
//冒泡排序
for(int i=0;i<arrs.length-1;i++){ //外层 行 length-1 避免重复遍历
for(int j=0;j<arrs.length-i-1;j++){ //内层 列 length-i-1
if(arrs[j] > arrs[j+1]){
//开始进行换位比较
int temp = arrs[j+1]; //把arrs[j+1]赋值给 temp
arrs[j+1] = arrs[j]; //把arrs[j] 赋值给 arrs[j+1]
arrs[j] = temp; // 把temp值赋值给arrs[j]
}
}

	    选择排序 

--------------------和冒泡差不多不多写了；------------------
逆序排列

在升序排序的基础上：
//循环3要素

• 初始值：int start=0,end =nums.length-1;
• 循环条件:start<end;
• 循环操作：start++,end –
  for(int start=0,end =nums.length-1;start<end;start++,end–){
  //交换元素值
  int temp = nums[start];
  nums[start] = nums[end];
  nums[end] = temp;
  }

---

二分查找

• 前提是升序不重复元素 的数组
• min
• max
• mid
• */
  public class HalfSearch {
  public static void main(String[] args) {
  int [] nums = {2,3,4,5,6};
  int result = halfSeac(nums,nums.length,5);//下面的方法二分查找；
  System.out.println(“元素的索引是:”+result);
  //Arrays工具类的 binarySearch 就是二分查找
  System.out.println(Arrays.binarySearch(nums,3));
  }
  //找到就返回这个元素 参数分别是 数组 数组长度 要查找的数
  public static int halfSeac(int []arrs,int n,int key){
  int min = 0; //最小值
  int max = n-1; //最大值
  int mid ;
  while(min <= max){ //最小值小于 等于最大值
  mid = (min+max)/2; //求出中间值
  if(arrs[mid] == key){ //如果比较的数是中间值
  return mid; //key 就作为中间值 返回mid
  }
  if(arrs[mid] > key){ //如果中间值比你传的数大
  max = mid-1; // 往左边移动
  }
  if(arrs[mid] < key){ //如果中间值比你传的数小
  min = mid+1; //往右边移动
  }
  }
  return -1; //不存在这个数
  }
  }

2

.类和对象 面向对象

对象是类的实例，类是具有属性（0-N）和方法(0-N)的统称（模板）
面向对象三大特性 ：封装 ：安全
继承 （子类会拥有父类非私有的属性和方法）
多态 （上 下）
方法（函数）：
实例方法
静态方法
构造方法
get Set 方法
重载方法 ：一般在同一个类里，多个同名不同参方法，和返回值无关
重写方法 ：前提有父子类关系，子Override父方法
抽象方法 --> 接口 抽象类
关键字：final static
集合 泛型
集合Collection
单列 List Set
双列 HashMap
集合遍历 for forEach Itertor
keySet entrySet
泛型和集合配合使用
5.异常可抛异常，可catch异常一般来说catch异常好一些，在出现异常时可以知道在那个代码位异常
异常体系 会 try catch 、throws
解决异常
Java把内存划分为4个部分 1. 代码区 1、栈区 3、堆区 4、静态区域

1、栈区（stacksegment）—由编译器自动分配释放,存放函数的参数值，局部变量的值等，具体方法执行结束之后，系统自动释放JVM内存资源
2、堆区（heapsegment）—一般由程序员分配释放，存放由new创建的对象和数组，jvm不定时查看这个对象，如果没有引用指向这个对象就回收
3、静态区（datasegment）—存放全局变量，静态变量和字符串常量，不释放
4、代码区（codesegment）—存放程序中方法的二进制代码，而且是多个对象共享一个代码空间区域

成员变量和局部变量的区别：
1：成员变量直接定义在类中。
局部变量定义在方法中，参数上，语句中。
2：成员变量在这个类中有效。
局部变量只在自己所属的大括号内有效，大括号结束，局部变量失去作用域。
3：成员变量存在于堆内存中，随着对象的产生而存在，消失而消失。
局部变量存在于栈内存中，随着所属区域的运行而存在，结束而释放。

构造代码块和构造函数有什么区别？
构造代码块：是给所有的对象进行初始化，也就是说，所有的对象都会调用一个代码块。只要对象一建立。就会调用这个代码块。
构造函数：是给与之对应的对象进行初始化。它具有针对性。

创建一个对象都在内存中做了什么事情？
1：先将硬盘上指定位置的Person.class文件加载进内存。
2：执行main方法时，在栈内存中开辟了main方法的空间(压栈-进栈)，然后在main方法的栈区分配了一个变量p。
3：在堆内存中开辟一个实体空间，分配了一个内存首地址值。new
4：在该实体空间中进行属性的空间分配，并进行了默认初始化。
5：对空间中的属性进行显示初始化。
6：进行实体的构造代码块初始化。
7：调用该实体对应的构造函数，进行构造函数初始化。（）
8：将首地址赋值给p ，p变量就引用了该实体。(指向了该对象)

异常：
异常处理原则：功能抛出几个异常，功能调用如果进行try处理，需要与之对应的catch处理代码块，这样的处理有针对性，抛几个就处理几个。

特殊情况：try对应多个catch时，如果有父类的catch语句块，一定要放在下面。

throw 和throws关键字的区别：
throw用于抛出异常对象，后面跟的是异常对象；throw用在函数内。
throws用于抛出异常类，后面跟的异常类名，可以跟多个，用逗号隔开。throws用在函数上。

通常情况：函数内容如果有throw，抛出异常对象，并没有进行处理，那么函数上一定要声明，否则编译失败。但是也有特殊情况。

异常分两种：
1：编译时被检查的异常，只要是Exception及其子类都是编译时被检测的异常。
2：运行时异常，其中Exception有一个特殊的子类RuntimeException，以及RuntimeException的子类是运行异常，也就说这个异常是编译时不被检查的异常。

编译时被检查的异常和运行时异常的区别：
编译被检查的异常在函数内被抛出，函数必须要声明，否编译失败。
声明的原因：是需要调用者对该异常进行处理。
运行时异常如果在函数内被抛出，在函数上不需要声明。
不声明的原因：不需要调用者处理，运行时异常发生，已经无法再让程序继续运行，所以，不让调用处理的，直接让程序停止，由调用者对代码进行修正。

定义异常处理时，什么时候定义try，什么时候定义throws呢？
功能内部如果出现异常，如果内部可以处理，就用try；
如果功能内部处理不了，就必须声明出来，让调用者处理。

自定义异常：当开发时，项目中出现了java中没有定义过的问题时，这时就需要我们按照java异常建立思想，将项目的中的特有问题也进行对象的封装。这个异常，称为自定义异常。

对于除法运算，0作为被除数是不可以的。java中对这种问题用ArithmeticException类进行描述。对于这个功能，在我们项目中，除数除了不可以为0外，还不可以为负数。可是负数的部分java并没有针对描述。所以我们就需要自定义这个异常。

自定义异常的步骤：
1：定义一个子类继承Exception或RuntimeException，让该类具备可抛性。
2：通过throw 或者throws进行操作。

异常的转换思想：当出现的异常是调用者处理不了的，就需要将此异常转换为一个调用者可以处理的异常抛出。
System.exit(0); //退出jvm，只有这种情况finally不执行。

当异常出现后，在子父类进行覆盖时，有了一些新的特点：
1：当子类覆盖父类的方法时，如果父类的方法抛出了异常，那么子类的方法要么不抛出异常要么抛出父类异常或者该异常的子类，不能抛出其他异常。
2：如果父类抛出了多个异常，那么子类在覆盖时只能抛出父类的异常的子集。

注意：
如果父类或者接口中的方法没有抛出过异常，那么子类是不可以抛出异常的，如果子类的覆盖的方法中出现了异常，只能try不能throws。
如果这个异常子类无法处理，已经影响了子类方法的具体运算，这时可以在子类方法中，通过throw抛出RuntimeException异常或者其子类，这样，子类的方法上是不需要throws声明的。