JAVA SE

JAVA SE 知识点浓缩总结

一. java的发展史

java之父 詹姆斯*高斯林
oak–>java1.0
Oracle 公司拥有java的版权
机器语言 --> 汇编语言 --> 高级语言

二. java体系

JAVAEE 企业版
JAVASE 标准班
JAVAME 微型版

三. java特点

支持分布式
安全
健壮
可以跨平台（因为每个系统都有相应的jvm，从而实现一次编译 到处运行。）

四dos命令

cd / 回到根目录

D(盘符)： 切换盘符
dir： 展示当前文教家内酥油的文件和文件夹
文件夹会显示

文件会显示文件大小
cd 文件夹名： 进入文件夹
cd … 返回上一级目录
方向上下键 历史命令
cls 清屏
md 文件夹名 新建文件夹
rd 文件夹名 删除文件夹（彻底删除）
del 文件名.后缀 删除文件（彻底删除）
del 文件名.* 删除所有同名文件（彻底删除）
del *.后缀名 删除所有同类型文件（彻底删除）
del . 删除所有文件（彻底删除）

五. jdk的安装与卸载

​
安装：默认安装即可
jdk>jre>jvm
可以将 公共的jre 不可用

卸载：
1.控制面板 安全管理软件
2.卸载后删除环境变量

六. 配置环境变量

6.1 配置path
目的是在任意目录下 都可以使用 javac java命令
​
将jdk安装目录到 bin 放到
C:\Program Files\Java\jdk1.8.0_172\bin
配置JAVA_HOME HOU 可以 %JAVA_HOME%\bin
​
我的电脑 —> 右键 —> 属性 —> 高级系统设置 —> 环境变量 —> 系统变量 —> path
—> 将 bin目录放进去
​
6.2 配置JAVA_HOME
为了给其他软件使用java提供一个接口(访问方式)
我的电脑 —> 右键- —> 属性 —> 高级系统设置 —> 环境变量 —> 新建变量
变量名：JAVA_HOME
变量值：C:\Program Files\Java\jdk1.8.0_172

七. 第一个程序

`public class HelloWord{
   
    public static void main(String[] args){
   
        System.out.println("Hello Word！");
    }
​}

编译
javac Java源文件名.后缀名

运行
java 类名字

注意：
1.java的源文件是不区分大小写
2.类名如果被public 修饰 那么 类名必须与源文件的名字保持一致
3.如果一个java文件存在多个类 那么编译后 有几个类就会生成几个class文件
4.Java语言是一门严格区分大小写的语言不能用中文符号，标点符号使用英文半角，括号成对出现

八. 注释

//单行注释

/*
多行注释
多行注释
*/
​
注：注释内容不参与编译

九. 标识符

标识符：
在java内凡是需要自己命名的地方

规则：

1. 字母数字下划线 美元符组成
2. 数字不能开头
3. 严格区分大小写
4. 不能是java中的关键字和保留字

规范：
1.类名每一个单词的首字母都大写
2.见名之意
3.驼峰命名
方法名，变量名在命名时第一个单词的首字母小写
从第二个单词开始每一个单词的首字母要大写。 //getMaxNum();
4.对常量命名时 要求 每一个单词的字母都要大写 单词与单词之间使用下划线连接
5.包名 每一个单词的字母都要小写

十. 常量与变量

数据类型

基本类型数据：
整数型
byte 1
short 2
int 4 默认
long 8 后面加L/l
浮点型
double 8 默认
float 4 后面加F/f
字符型
char 2 [0,65535]
布尔型
boolean //值只有true/false

引用类型数据：
只要不是基本类型数据 就是引用类型数据

常量
在程序执行过程中 值不会发生改变的量

变量
在程序执行过程中 值会发生改变的量

注意：
1.变量的初始化 变量完成 赋值
2.一个方法内 不能出现同名的变量

十一. 进制

10进制 2进制 8进制 16进制

10进制转为 2进制:
除以2 取 余数 ，最后取反（逆顺序排列）。

2进制转为 10进制：
从右到左用二进制的每个数去乘以2的相应次方（第一位是0次方）。

8进制与2进制
2进制每三位一运算顺序排列成8进制
8进制每一位进行运算顺序排列成2进制

16进制与2进制
2进制每四位一运算顺序排列成16进制
16进制每一位进行运算顺序排列成2进制

java可以将不同的进制数转为10进制进行展示

二进制：前面加0b
0b101 5
8进制：前面加0
011 9
16进制：前面加0x
0x10 16

十二. 计算机的存储单位

8bit =1byte
1024byte = 1kb
1024kb = 1Mb

1024Mb = 1Gb
1024Gb = 1Tb

十三. 计算机底层存储数据的方式

计算机底层都以01二进制的方式储存数据

符号位 0 正数 1 负数

正数
源码/反码/补码：三码合一
负数
原码
反码 除了符号位 其他位 0变1 1变0
补码 反码+1

byte 8bit
[-128,127]
[-2^(n-1),2(n-1)-1]

小数的存储 //了解即可
符号位
指数位
尾数位

十四. 类型转换

自动类型提升：
小的数据类型转换成大的数据类型
强制类型转换：
大的数据类型转换成小的数据类型
公式：小的数据类型 变量名 = (小的数据类型)大的数据类型的值;

十五. 运算符

算数运算符

• • • / % ++ –
      前++：先加1后运算 //++i
      后++：先运算后加1 //i++
      前–：先减1后运算 //–i
      后–：先运算后减1 //i–
      赋值运算符
      = += -= *= /= %=
      x += y //x = x + y
      x -= y //x = x - y
      x *= y //x = x * y
      x /= y //x = x / y
      x %= y //x = x % y
      关系运算符

= < <= != ==
结果都是布尔类型

逻辑运算符
& && | || ^ !

&：有一个false，结果就是false。
&&：同 & 运算结果一致，但运算过程中一旦遇到false，后面就不在运算。
|：有一个true，结果就是true。
||：同 | 运算结果一致，但运算过程中一旦遇到true，后面就不在运算。
^：符号前后相同结果为false，附后前后不同结果为true。
!：取反。
! false —> true
! true --> false

三目运算符
X?Y:Z;//X是布尔型。
X为true 运行Y。
X为false 运行Z。

十六. 键盘输入

16.1 基本使用
16.1.1. 创建键盘输入对象
java.util.Scanner in = new java.util.Scanner(System.in);
16.1.2. 提示语句
System.out.println(“请您输入一个年龄”);
16.1.3. 对象调用方法
int age = in.nextInt();
16.2 常用方法(可以获取的类型)
java.util.Scanner in = new java.util.Scanner(System.in);

byte a = in.nextByte();
nextShort();
nextInt();
nextLong();
nextFloat();
nextDouble();
nextBoolean();
next();//获取字符串
16.3 next() & nextLine()
区别：

1. next()：读取空格前的内容。
   nextLine()：可以读取一整行内容。
2. 如果前面有其他的键盘输入语句。 (解决方案：输入两次nextLine() ) 。

十七. 分支结构

1. if分支

① if单分支

if(boolean表达式){
分支内容;
}

② if双分支

if(布尔表达式){
分支1;
}else{
分支2;
}

例：
int age = 19;
 if(age>=18){
   
  	
  	System.out.println("成年了");
  }else{
   
  	System.out.println("没有成年");
  
  }
String s = age>=18?"成年了":"没有成年";

注：判断闰年
判断闰年的标准：
1.能被400整除
2.能被4整除不能被100整除

③if多分支

1. if(b1){ 分支内容1 }else if(b2){ 分支内容2 }else if(b3){ 分支内容3 }else{
   分支内容4 }

注：
1.当所有的if都不满足 会执行else。
2.else可以省略。

2 switch-case分支

2.1switch-case分支结果
switch(表达式){
case 值：
break;
case 值：
break;
case 值：
break;
default:
break;

}
2.2 switch中表达式类型 及 使用注意

1. break作用
   防止语句块穿透
2. default:
   当所有的case 都不满足时 会执行 default
   是可以有也可以没有
3. 表达式类型
   byte
   short
   char
   int
   String（jdk1.7之后开始支持）
   枚举
4. case值唯一不能重复

十八. 循环

任何一个标准的循环：
初始化条件： 只会执行一次
循环条件： 最后执行
循环体：循环的意义
迭代条件：让初始化条件 不断向循环条件靠近

0 引入：开方及获取随机数

0.1 java中怎么开方
Math.sqrt(要开平方的数)

0.2 java中怎么获取随机数
Math.random():产生随机数[0,1)
“[” 和 “]”：包含这个数
“(” 和 “)”：不包含这个数

```java
例:在n ~ m中获取随机数
(int)(Math.random()*(m-n+1)+n);
 n     m
[22 , 33]
n:较小的数
m:较大的数

1. for循环

① for循环的格式

for(初始化条件;循环条件;迭代条件){
循环体;
}

例：（打印五次Hello World）
for(int i = 1;i<=5;i++){
   
	System.out.println("Hello World\t" + i);
}

② 变量定义及位置确定

没有变量记录结果，需要自己定义变量
记录的是循环的总变化：放到循环的外面
记录的是循环内单个个体变化： 放到循环内

例：求 1~100的所有数的和
int sum = 0;
	for(int i = 1;i<=100;i++){
   
		sum = sum + i;
		System.out.println(i);
	}
	System.out.println("总和是："+ sum);

2. while循环

① while循环的格式

初始化条件；
while(循环条件){
循环体；
迭代条件;
}

例：
int i=1；
while(i<=10){
   
	System.out.println(i);
	i++;
}

3 .do{}while

① while循环的格式

初始化条件;
do{
循环体
迭代条件;
}while(循环条件);

例：
int i =1;
do{
   
 	System.out.println(i);
	i++;
}while(i<=10);

4 .嵌套循环

嵌套循环： 把一个循环作为另一个循环的循环体;
外层循环：控制行数
内层循环：控制列数
外层循环执行一次 内层循环执行一遍

例：
/*
     **********
     **********
     **********
*/
   for(int i = 1;i<=3;i++){
    
       for(int j = 1;j<=10;j++){
   
           System.out.print("*");
       }
       System.out.println();
   }

十九 特殊的流程控制语句

1 break

1. 只能用在循环或者switch中
2. 循环中
   如果不存在标签 结束break所在层循环
   如果存在标签 结束标签所在层循环
3. switch中 防止语句块穿透

//例：存在标签
a:	for(int i = 1;i<=10;i++){
   
			/*
			i = 1 时 j=1 2 3 4 5
			i = 2 时 j=1 2 3 4 5
			i = 3 时 j=1 2 3 4 5
			*/
			for(int j =1;j<=10;j++){
   
				if(j==6){
   
                    //当j==6时结束标签a：for(int i = 1;i<=10;i++){}循环
					break a;
				}
			
				System.out.print(j+" ");
			}
			System.out.println();
结果：
1 2 3 4 5
1 2 3 4 5
1 2 3 4 5

2 .continue

1.只能用在循环中
2.如果不存在标签 结束的是continue所在层这一次循环 继续下一次循环
3.如果存在标签 结束的是continue所在层这一次循环 继续的是 标签所在层循环

//例：存在标签
l:	for(int i = 1;i<=2;i++){
   
		for(int j = 1;j<=10;j++){
   
            /*
            i=1 时 j=1 2 3 4 5
            i=2 时 j=1 2 3 4 5
            i=3 时 j=1 2 3 4 5
            */
			if(j==6){
   
			continue l;
			}
			System.out.print(j+" ");
		}
		System.out.println();
}
结果：
1 2 3 4 5
1 2 3 4 5
1 2 3 4 5

3. return

结束方法

//例：	
for(int i = 1;i<=10;i++){
   
	for(int j = 1;j<=6;j++){
   
    	/*
    	i = 1 时 j = 1 2
    	遇见return语句直接结束方法。
    	*/
		if(j==3){
   		
			return;
		}	
		System.out.print(j+" ");
	}
	System.out.println();
}
结果：
1 2 

• [ ]

二十 数组

1 数组的概念

数组：存储【相同类型】数据的有序集合。

2 一维数组

①一 维数组的初始化

注：数组在初始化时存在默认

1.静态初始化：写完数组时，就知道数组的内容(数组存储的元素)

方式一：声明和赋值写到一起
    数据类型[] 数组名 = {
   元素1,元素2,......};
    数据类型 数组名[] = {
   元素1,元素2,......};
    
例：
    int[] arr = {
   10,20,30};
    int arr[] = {
   10,20,30};

方式二：声明和赋值可以分开
    数据类型[] 数组名 = new 数据类型[]{
   值1,值2,......};
    
    数据类型 数组名[] = new 数据类型[]{
   值1,值2,......};
例：    
    String[] sArr = new String[]{
   "李白","杜甫"};
    String sArr[] = new String[]{
   "李白","杜甫"};
    
2.动态初始化：写完数组时，只知道长度，不知道内容
    数据类型 数组名 = new 数据类型[数字];
例：    
    int[] arr = new int[6];

3.二维数组

① 二维数组的初始化

二维数组：数组元素是一维数组的数组称之为二维数组。
1.二维数组的长度 = 数组内一维数组的个数
2.访问二维数组元素
数组名[第几个一维数组][一维数组第几个元素]
arr[0][0];(二维数组中第一个一维数组中的第一个元素)

1.静态初始化：完成初始化后就知道数组的内容
    方式一：声明和赋值不可以分开
        数据类型 [][] 数组名 = {
   {
   值1},{
   值1},{
   值1}};
例：        
        int[][] arr = {
   {
   1,2,3},{
   10,20,30},{
   4,5},{
   50,60}};
    方式二： 声明和赋值可以分开
        数据类型[][] 数组名 = new 数据类型[][]{
   {
   值1},{
   值1},{
   值1}};
例：        
        String[][] sArr= new String[][]{
   {
   "李","杜"},{
   "安","嬴"}};

2.动态初始化
    方式一：
        数据类型[][] 数组名 = new 数据类型[3][4];
    方式二：
        数据类型[][] 数组名 = new 数据类型[3][];     

二十一 数据类型对应的默认值

整型：
	byte  0
	short 0
	int   0
	long  0L
浮点型：    
	float  0.0F
	double 0.0	
布尔型：    
	boolean  false	
字符型：   
	char \u0000  空格
引用数据类型：
    String null
    所有的引用数据类型的默认值都是null

二十二 数组的遍历

1 普通for

需要下标时使用

普通for  根据下标获取 数组元素
    for(int i = 0;i<arr.length;i++){
   
        System.out.println(arr[i] + " ---> " + i);
	}

2. 增强for

不需要下标时使用

增强for 直接获取数组元素
    for(数组元素类型 变量名：数组名){
   
        System.out.print(变量名);
    }
例：
    double dArr[] = {
   3.14,6.28,9.13,5.34};
    for(double ele : dArr){
   
        System.out.println(ele);
	}

3 用String字符串直接接收数组元素；

直接输出数组中元素情况

用String字符串直接接收数组元素遍历输出；
    String 变量名 = java.util.Arrays.toString(数组名);
	System.out.pring(变量名);
例：
    int[] arr = {
   1,6,9,8,4,2,9}
    String result = java.util.Arrays.toString(arr);
	System.out.pring(result);

二十三 内存

jvm虚拟机内存划分:

第一步 会进行class的加载 

第二步加载到内存后会将不同的数据存贮到不同的区域

方法区：jdk1.7含之前 叫方法区   ******
    jdk1.8含之后 叫元空间 使用物理内存		
    类的信息 方法的信息  静态资源信息 常量信息
		
虚拟机栈：  ******
    在调用方法时 存储 局部变量 对象的引用  
    当方法执行结束后 销毁
		
本地方法栈：
    native方法：
    java不是万能的，在需要和计算机底层硬件沟通时能力不足 
    需要借助于其他语言C等其他语言在执行时 产生的信息 存储在本地方法栈
		 
堆： ******
	对象的信息
	数组
	new 出来的内容1
		
程序计数器：
	存储下一条线程要执行的指令

GC垃圾回收器：
	无用内存即垃圾；

二十四 冒泡排序

将数组中的数从前到后两两比较
如果前一个数大于后一个数将两个数的值交换
数组经过数组长度-1次比较排序后即可有序

每一次排序后都会将数组分为两部分：一部分有序，一部分无序
在下一次排序是只需要专注于无序部分即可，每次都会活得无序部分的最大值

1 普通冒泡排序

int[] arr = {
   10,20,30,40,70,60,50};
    //遍历数组中元素
    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;
            }		
         }
 }
 System.out.println(java.util.Arrays.toString(arr));

2 优化冒泡排序

如果数组不是极端数据，则不需要数组长度-1次排序即可有序
当数组有序， 就可以结束排序操作，不需要做无用功
考虑：是否存在 前一个数大于后一个数

int[] arr = {
   40,30,10,10,50,60,70};
    //遍历数组中元素
    for(int i = 0;i<arr.length-1;i++){
   
        //假设此次排序 数组已经有序
        boolean flag = true;
        //比较元素大小，开始对排序
        for(int j = 0;j<arr.length-1-i;j++){
   
            if(arr[j]>arr[j+1