JAVA SE

最新推荐文章于 2023-10-25 11:41:03 发布

阿支<－biubiu－⊂(`ω´∩)

最新推荐文章于 2023-10-25 11:41:03 发布

阅读量240

点赞数

分类专栏： JAVA SE

本文链接：https://blog.csdn.net/m0_56593901/article/details/116597918

版权

JAVA SE一. java的发展史java之父詹姆斯*高斯林oak–>java1.0Oracle 公司拥有java的版权机器语言 --> 汇编语言 --> 高级语言二. java体系JAVAEE 企业版JAVASE 标准班JAVAME 微型版三. java特点支持分布式安全健壮可以跨平台（因为每个系统都有相应的jvm，从而实现一次编译到处运行。）四dos命令cd / 回到根目录D(盘符)：切换盘符dir：展示当前文教家内酥油的

摘要由CSDN通过智能技术生成

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内凡是需要自己命名的地方

规则：

字母数字下划线美元符组成
数字不能开头
严格区分大小写
不能是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()
区别：

next()：读取空格前的内容。
nextLine()：可以读取一整行内容。
如果前面有其他的键盘输入语句。 (解决方案：输入两次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多分支

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中表达式类型及使用注意

break作用
防止语句块穿透
default:
当所有的case 都不满足时会执行 default
是可以有也可以没有
表达式类型
byte
short
char
int
String（jdk1.7之后开始支持）
枚举
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

只能用在循环或者switch中
循环中
如果不存在标签结束break所在层循环
如果存在标签结束标签所在层循环
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&

最低0.47元/天解锁文章

阿支<－biubiu－⊂(`ω´∩)

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
JAVA SE

JAVA SE一. java的发展史java之父詹姆斯*高斯林oak–>java1.0Oracle 公司拥有java的版权机器语言 --> 汇编语言 --> 高级语言二. java体系JAVAEE 企业版JAVASE 标准班JAVAME 微型版三. java特点支持分布式安全健壮可以跨平台（因为每个系统都有相应的jvm，从而实现一次编译到处运行。）四dos命令cd / 回到根目录D(盘符)：切换盘符dir：展示当前文教家内酥油的
复制链接

扫一扫