JAVASE

最新推荐文章于 2024-10-08 21:30:52 发布

@XL

最新推荐文章于 2024-10-08 21:30:52 发布

阅读量598

点赞数 1

文章标签： java javase

本文链接：https://blog.csdn.net/qq_43554177/article/details/107913561

版权

JAVASE

了解发展发现历史由来

詹姆斯-高斯林；
Tiobe–语言排行
Sun-Oracle（09收购）

JAVA的技术版本

JavaSE(核心标准版）
JavaEE（企业级版本）
Javame（微型版-淘汰）

JAVA语言特点

简单性
强类型
面向对象（oo）
与平台无关的语言
健壮性和安全性
多线程

JDK安装和环境变量配置

理解JDK、JRE、JVM的区别（重点！！！）

JDK：开发工具包
JRE:提供运行时环境（提供核心的类库）
JVM：JAVA虚拟机（执行.class文件）

扩展

.class文件如何加载，解析，执行，初始化，销毁…

数据存储和处理过程：

数据输入->数据存储(内存)->处理(计算)->输出结果

8大基本数据类型(重点)

1GB = 1024MB
1MB = 1024KB
1KB = 1024B
1B(字节) = 8bit(位)
100MB 100Mb = 12.5
1个中文字符占用2个字节

类型名称占用内存大小(字节单位) 取值范围
byte 字节型 1 (8) -128~127 (-2^7 ~ 2^7-1)
short 短整型 2 (16) -32,768~32,767(-2^15 ~ 2^15-1)
int 整型(最常用) 4
long 长整型 8
float 单精度浮点型 4
double 双精度浮点型 8
char 字符型 2 ‘’
boolean 布尔型 — true | false
字符串类型：String - > “”

注意

虽然String不属于8大基本数据类型，但是在实际开发过程中使用频率非常高。

变量

可变的量，其本质就是内存中存储数据的一块内存空间。

变量名称命名

遵守标识符的规范，采用驼峰命名法方式定义。

变量的三要素

变量类型
变量名称
变量值

变量创建三步走

声明变量类型
定义变量名称
赋值

数据类型之间转换

1、自动转换

源数据类型(占用内存) 小于目标的数据类型(内存空间)
byte by = 10; //源数据类型
int a = by; //目标的数据类型

2、强制转换(容易造成精度丢失)

源数据类型(占用内存) 大于目标的数据类型(内存空间)
int a = 10; //源数据类型
byte by = (byte) a; //目标的数据类型
int <-> char
ASCII转换
0 -> 48
1->49
…
A->65
B->66
…
a ->97
z->122
参考ASCII码表

赋值运算符

Java语言使用赋值运算符“=”来给变量赋值。
如：int num = 100;
算术运算符
加法运算符 +
减法运算符 -
乘法运算符 *
除法运算符 /
取模运算符 %
总结~~~~~
一元运算符
++(递增)
–(递减)
递增++：int box = 100; ++box; // 相当于box = box + 1
递增++：int box = 100; box++; // 相当于box = box + 1
递减–：int box = 100; --box; // 相当于box = box - 1
递减–：int box = 100; box–; // 相当于box = box - 1
后置递增配合复合语句：先做其他事儿，再递增。
前置递增配合复合语句：先递增，再做其他事儿。

关系运算符

**“==”：相等运算符，只比较值，不比较类型
“!=”：不相等运算符

“!”：不全等(不恒等)
“>”：大于运算符
“>=”：大于等于运算符
“<”：小于运算符
“<=”：小于等于运算符****
（=）全等运算符

一元运算符

++（递增）
–（递减）

int a=10;
System.out.println(a++);两步操作
1.输出10，2.做递增

int a=10;
System.out.println(a++ + a++);//21(10 +11)
System.out.println(a);//12

System.out.println(a++ + ++a);//22(10+12)
后置递增配合复合语句：先做其他事儿，再递增。
前置递增配合复合语句：先递增，再做其他事儿。

& | ！

	  ***& 与 and 并且 得出结论：表达式有一个false，结果都为false；
	   | 与 or  或者 得出结论：表达式有一个为true，结果都为true；
	   ！ 相反
	   &&  短路与  错误即获得结果
	   ||	短路或   正确即获得结果**

& 与 && 的区别

	**int a=10;
	boolean bool=a>10&((a++)>10);
	System.out.println(a);
	a=11;
	boolean bool1=a>10&&((a++)>10);
	System.out.println(a);a=10;**

|与||的区别

**int a = 10;
boolean bool = a > 9 | ((a++) > 10);
System.out.println(a);
a = 11;
boolean bool1 = a > 9 || ((a++) > 10);
System.out.println(a);
a = 10;
运算符优先级
！ > () > 算术运算符 > 关系运算符 > && > || > =

	int flag =4 > 5 ? 100 : 200;
	冒号:两端的表达式类型一定要和变量类型统一；**

if

单分支if语句

**语法：
if（表达式）{
代码块
}**

双分支if语句

**语法：
语法：
if（表达式）{
代码块1
}else{
	代码块2
}
true-》代码块1 
false-》代码块2**

多分支语句

**if(条件表达式1）{
语句块1
}else if(条件表达式2){
语句块2
}else if（..){
}。。。。。
else{
语句块n
}**

执行过程

**条件表达式1为true，走语句块1
否则走表达式2，条件表达式2为true，走语句块2，
否则走表达式3......
如果所有的条件表达式都不满足走else语句块n；**

switch

执行过程中

**在switch是进行了等值比较，算术表达式的值
和case后常量值如果满足算术表达式值=case的值就走对应的
case语句块。如果都没有case对应，就走默认的default语句
块**，

注意

**1.算术表达式类型：byte，short，int,char,Strig(1.8+);
2.case后常量表达式的值，不能重复，Duplicate case；
3.算术表达式和常量表达式进行的是等值比较
4.等值比较有相同时，进入当前的case中，如果有break，直接结束
如果没有break关键字，程序会继续向下执行，直到遇到break为止。
5.case和default位置可以任意放，从上到下遍历（无循环）**

while循环

**主要处理重复且有规律的操作
while(true){//进入循环体:死循环
	循环体
}
循环结构特点：循环条件 循环操作（循环体）

while循环特点:先判断，再执行**

debug调试

调试目的：

找出原因，修正缺陷

调试主要方法

**设置断点，单步执行，观察变量
点击eclipse的debug按钮运行代码。**

do while循环

**语法：
do{
	循环体
}while(循环条件);
先执行一次循环体再判断循环条件**

for循环

**语法：
for(参数初始化;循环条件;更新循环的变量){
	循环操作	
}
	
for(;true:){
}//死循环；
Unreachable code 不可到达代码；
int i=1; ①
while(i>10){ ②
	System.out.println("i"); ③
	i--; ④
}
第一次：①->②->③->④
第二次：		②->③->④
第三次：		②->③->④
第n次：......**

continue

**结束本次循环，不是终止整个循环**

多层for循环中continue作用

**continue结束当前for循环
continue终止本次循环，继续执行下一次循环（当前循环中）**

break

**break;在switch语句体中使用，
当时它的作用是跳出switch语句体，
不再执行后面的case和default处理。
而在循环中也可以使用break关键字，
它的作用是退出当前整个循环程序。**

多层for循环中break作用

		**break结束当前for循环**

flag:

**flag：
break flag 结束指定层；**

数组

**数组是存储在一个连续的内存块中的元素集合(相同数据类型）。
int []egg		//企业推荐使用
int egg[]**

数组使用

**1.声明数组类型
2.分配数组的内存空间（设置数组的长度）
3.根据数组的下标访问数组或给数组赋值。
egg=new int []{1,2,3};
int []egg={0,0,0};//特殊：数组变量名称与{}必须在同一行**

注意

数组的类型必须是一致的。
数组默认的下标从0开始计算，最后一个元素默认的下标length-1
length//数组中求元素的个数，是采用.length属性，注意length没有括号
java.lang.ArrayIndexOutOfBoundsException数组下标越界异常。
数组一旦声明，就不能该变它的长度。如果改变，它其本质是新创建了
一块内存空间。

数组初始值

**基本数据类型               				数组中的默认值
整数类型（byte，short，int,long)       		0
浮点型（float，double）						0.0
字符型										‘’
布尔型										false
字符串										null**

for each

	**for(int i:arr){//for(数组类型 自定义变量:需要遍历的数组）	
	}**

冒泡排序

	**两个数据来比较:  
	两两比较小靠前
	外层循环n-1；
	内侧循环n-1-i；**

java.util.Arrays工具类

	**sort 排序从小到大
	fill
	copyof()
	binarySearch(float[] a, float key) 
	使用二叉搜索算法搜索指定数组的浮点数。**

初级错误！

class Test2 {
public static void main(String[] args){
boolean x= true;
boolean y=false;
short z=20;
if((xtrue) && (y=true)) z++;
if((ytrue) || (++z==22)) z++;
System. out .println( “z=”+z);
}
}
y=true是赋值
运行结果是什么？
A.Z=21
B.z=22
C.z=23
D．Z= 24
B

二维数组

int [][]arr=new int [3][3];规则
int [][]arr=new int[3][2];不规则的
[null,null,null]
int [][]arr={规则
	{1,2,3},
	{4,25,5},
	{7,8,9	}

};
a[0][0]=1;
二维数组其本质就是一维数组又存放一维数组

注意

数组中定义数组一定要指定数组的长度（内存空间大小）
如果是二维数组...多位数组也要指定长度。
int [][]arr={{},{},{}};
//遍历二维数组的方式
for(int i=0;i<arr.length;i++){//外层循环：最外层一维数组的长度
	for(int j=0;j<arr[i].length;j++){
		System.out.println(arr[i][j]);
	}

}

多维数组（了解）

在实际开发中很少用了解即可
int[][][] arr = {{{,,},{,,},{,,}},
				 {{,,},{,,},{,,}},
				 {{,,},{,,},{,,}}
				 }; 
arr[0][1][2]
int[][][] arr = new int[3][4][2];//不规则的多维数组	多少维多少个for
for (int i = 0; i < arr.length; i++) {
		for (int j = 0; j < arr[i].length; j++) {
			for (int k = 0; k < arr[i][j].length; k++) {
				System.out.println(arr[i][j][k]);
			}
		}
	}