JavaSE---00基础

118 阅读 0 评论 78 点赞

我是靠谱客的博主炙热柚子，这篇文章主要介绍JavaSE---00基础，现在分享给大家，希望可以做个参考。

JavaSE---00基础

- 1 JVM JRE和JDK区别与联系
- - 1.1 什么是JVM
  - 1.2 什么是JRE
  - 1.3 什么是JDK
- 2 JAVA八种基本类型
- - `2.1 类型转换`
  - 2.2 代码示例
- 3 命名规则
- 4 final
- 5 运算符
- - 5.1 算数运算符
  - 5.2 关系操作符
  - 5.3 逻辑运算符
  - 5.4 位运算符
  - 5.5 赋值运算符
  - 5.6 三元运算符
- 6 控制流程
- - 6.1 if语句
  - 6.2 switch-case语句
  - 6.2 循环语句
- 7 数组
- - 7.1 数组的创建方式
  - 7.2 数组的遍历

1 JVM JRE和JDK区别与联系

以下图片来自均来源于网络，侵删

复制代码

1
2
3
4
首先三者之间存在包含关系
JVM + 核心类库 = JRE
JRE + java开发工具（javac.exe/jar.exe) = JDK

在这里插入图片描述

1.1 什么是JVM

复制代码

1
2
Java Virtual Machine（Java虚拟机）

它是整个java实现跨平台的最核心的部分。所有的java程序会首先被编译为.class的类文件，这种类文件可以在虚拟机上执行。也就是说class并不直接与机器的操作系统相对应，而是经过虚拟机间接与操作系统交互，由虚拟机将程序解释给本地系统执行。 JVM屏蔽了与具体操作系统平台相关的信息，使得Java程序只需生成在Java虚拟机上运行的目标代码（字节码），就可以在多种平台上不加修改地运行。

那么只有JVM还能不能让class的执行?
不能，因为在解释class的时候JVM需要调用解释所需要的类库lib，而jre包含lib类库。
JVM运行图

1.2 什么是JRE

复制代码

1
2
Java runtime environment(Java运行环境)

JRE是运行基于Java语言编写的程序所不可缺少的运行环境。
JRE中包含了Java virtual machine(JVM)，runtime class libraries和Java application launcher。这些是运行Java程序的必要组件。与大家熟知的JDK不同，JRE是Java运行环境，并不是一个开发环境，所以没有包含任何开发工具（如编译器和调试器），只是针对于使用Java程序的用户
JRE

1.3 什么是JDK

复制代码

1
2
Java Development Kit (Java开发工具包)

JDK是Sun Microsystems公司针对Java开发员的产品。
JDK中包含JRE，在JDK的安装目录下有一个名为jre的目录，里面有两个文件夹bin和lib，在这里可以认为bin里的就是jvm，lib中则是jvm工作所需要的类库，而jvm和 lib和起来就称为jre。
JDK是整个JAVA的核心，包括了Java运行环境JRE（Java Runtime Envirnment）、一堆Java工具（javac/java/jdb等）和Java基础的类库（即Java API 包括rt.jar）。

2 JAVA八种基本类型

复制代码

1
2
其中整型 (4种)、字符型 (1种)、浮点型 (2种)、布尔型(1种)

类型	缺省值	长度(bit)	范围
byte [字节]	0	8	-2⁷ ~ 2⁷-1
short [短整数]	0	16	-2¹⁵ ~ 2¹⁵-1
int [整数]	0	32	-2³¹ ~ 2³¹-1
long [长整数]	0	64	-2⁶³ ~ 2⁶³-1
float单精度浮点数]	0.0	32	-2¹²⁸ ~ 2¹²⁷
float单精度浮点数]	0.0	64	-2¹⁰²⁴ ~ 2¹⁰²³
char[字符型]	空	16	0 ~ 2¹⁶-1
boolean[布尔]	false	-	false、true

这些基本类型都有对应的包装类
byte(Byte)、short(Short)、int(Integer)、long(Long)、float(Float)、double(Double)、char(Character)、boolean(Boolean)既然这些基本类型对应包装类都是类，所以他们的默认值全是null
关于boolean的长度，请看这个大佬的http://www.spring4all.com/article/19154

`2.1 类型转换`

复制代码

1
2
3
4
5
6
7
不同类型之间的数据可以互相转换，但是要满足一定的规则：
	精度高的数据类型就像容量大的杯子，可以放更大的数据
	精度低的数据类型就像容量小的杯子，只能放更小的数据
需要注意的两点是:
	虽然short和char都是16位的，长度是一样的但是彼此之间依然需要进行强制转换
	boolean类型不能与其他类型相互转换

在这里插入图片描述

2.2 代码示例

复制代码

1
2
3
4
5
6
//低精度向高精度转换
long l = 5L;
int i = 50;
//int比较小，要放进比较大的long,随便怎么样，都放的进去
l = i;

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
//高精度向低精度转换
byte b = 5;
int i1 = 10;
int i2 = 300;
          
b = (byte) i1;
//因为i1的值是在byte范围之内，所以即便进行强制转换
//最后得到的值，也是10
System.out.println(b);//10
          
//因为i2的值是在byte范围之外，所以就会按照byte的长度进行截取
//i2的值是300，其对应的二进制数是 100101100
//按照byte的长度8位进行截取后，其值为 00101100 即44
b =(byte) i2;
System.out.println(b);
         
//查看一个整数对应的二进制的方法：
System.out.println(Integer.toBinaryString(i2));

复制代码

1
2
3
4
5
6
7
8
9
//char与short之间的转换
char c = 'A';
short s = 80;        
//虽然short和char都是16位的，长度是一样的
//但是彼此之间，依然需要进行强制转换
c = (char) s;
//直接进行转换，会出现编译错误
s = c;

3 命名规则

复制代码

1
2
3
4
5
6
变量命名必须满足一系列的条件，不能随意命名
	1.变量命名只能使用字母、数字、$、_
	2.变量第一个字符只能使用字母、$、_
	3.变量第一个字符不能使用数字
注：_ 是下划线，不是-减号或者—— 破折号

4 final

复制代码

1
2
3
4
当一个变量被final修饰的时候，该变量只有一次赋值的机会；
通常final修饰的变量用来表示这是一个常量
final除了可以修饰变量，还可以修饰类，方法等

final修饰的方法表示此方法已经是“最后的、最终的”含义，亦即此方法不能被重写（可以重载多个final修饰的方法）。
此处需要注意的一点是：因为重写的前提是子类可以从父类中继承此方法，如果父类中final修饰的方法同时访问控制权限为private，将会导致子类中不能直接继承到此方法，因此，此时可以在子类中定义相同的方法名和参数，此时不再产生重写与final的矛盾，而是在子类中重新定义了新的方法。

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class B extends A {
    public static void main(String[] args) {}
    public void getName() {}//编译出错
    private final void getName() {}//子类自己的,不出错
}

class A {

    /**
     * 因为private修饰，子类中不能继承到此方法，因此，子类中的getName方法是重新定义的、
     * 属于子类本身的方法，编译正常
     */
    private final void getName() {}

    //因为 pblic修饰，子类可以继承到此方法，导致重写了父类的final方法，编译出错
    public final void getName() {}
    
}

复制代码

1
2
3
4
5
public void method1(final int j) {
        j = 5; //这个能否执行？
}
//不可以，因为在调用方法的时候，就一定会第一次赋值了，后面不能再进行多次赋值

final修饰类即表示此类已经是“最后的、最终的”含义。因此，用final修饰的类不能被继承，即不能拥有自己的子类。如果试图对一个已经用final修饰的类进行继承，在编译期间或发生错误

其中final修饰的类：String、StringBuilder、StringBuffer、Math、UUID
、Boolean、Character、Short、Integer、Long、Float、Double、Byte、Void等

5 运算符

运算符用于执行程序代码运算，会针对一个及以上操作数项目来进行运算。
运算符基本分为六类：算数运算符、赋值运算符、比较/关系运算符、逻辑运算符、位运算符、三元/三目/条件运算符。

5.1 算数运算符

算数操作符基本的有：

+ 加
- 减
* 乘
/ 除
% 去模
++ 自增
-- 自减

i++; 先取值，再运算
++i; 先运算，再取值
-- 操作同++操作

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
int i = 10;
int j = 5;
int a = i+j;
int b = i - j;
int c = i*j;
int d = i /j;
/*******************************/
int i = 5;
System.out.println(i++); //输出5
System.out.println(i);   //输出6
     
int j = 5;
System.out.println(++j); //输出6
System.out.println(j);   //输出6

5.2 关系操作符

比较两个变量之间的关系

> 大于
>= 大于或等于
< 小于
<= 小于或等于
== 是否相等
!= 是否不等

复制代码

1
2
3
4
5
6
7
8
9
10
int a = 5;
int b = 6;
int c = 5;
 
System.out.println(a>b);  //返回 false
System.out.println(a>=c);  //返回 true
     
System.out.println(a==b); //返回false
System.out.println(a!=b);//返回true

5.3 逻辑运算符

& 长路与(无论第一个表达式的值是true或者false,第二个的值，都会被运算)
&& 短路与 (只要第一个表达式的值是false的，第二个表达式的值，就不需要进行运算了)

复制代码

1
2
3
4
5
6
7
8
9
10
//长路与 与 短路与
//长路与  无论第一个表达式的值是true或者false,第二个的值，都会被运算
int i = 2;
System.out.println( i== 1 & i++ ==2  ); //无论如何i++都会被执行，所以i的值变成了3
System.out.println(i);
//短路与 只要第一个表达式的值是false的，第二个表达式的值，就不需要进行运算了
int j = 2;
System.out.println( j== 1 && j++ ==2  ); //因为j==1返回false,所以右边的j++就没有执行了，所以j的值，还是2
System.out.println(j);

| 长路或 (无论第一个表达式的值是true或者false,第二个的值，都会被运算)
|| 短路或 (只要第一个表达式的值是true的，第二个表达式的值，就不需要进行运算了)

复制代码

1
2
3
4
5
6
7
8
9
//长路或  无论第一个表达式的值是true或者false,第二个的值，都会被运算
int i = 2;
System.out.println( i== 1 | i++ ==2  ); //无论如何i++都会被执行，所以i的值变成了3
System.out.println(i);
//短路或 只要第一个表达式的值是true的，第二个表达式的值，就不需要进行运算了
int j = 2;
System.out.println( j== 2 || j++ ==2  );  //因为j==2返回true,所以右边的j++就没有执行了，所以j的值，还是2
System.out.println(j);

! 取反

复制代码

1
2
3
4
5
//取反 !
boolean b = true;
System.out.println(b); //输出true
System.out.println(!b);//输出false

^ 异或^ (不同返回真,相同返回假)

复制代码

1
2
3
4
5
6
//异或^
boolean a = true;
boolean b = false;
System.out.println(a^b); //不同返回真
System.out.println(a^!b); //相同返回假

5.4 位运算符

| 位或

复制代码

1
2
3
4
5
6
7
int i  =5;
int j = 6;
         
System.out.println(Integer.toBinaryString(i)); //5的二进制是101      
System.out.println(Integer.toBinaryString(j)); //6的二进制是110         
System.out.println(i|j); //所以 5|6 对每一位进行或运算，得到 111->7

& 位与

复制代码

1
2
3
4
5
6
7
int i  =5;
int j = 6;
		
System.out.println(Integer.toBinaryString(i)); //5的二进制是101
System.out.println(Integer.toBinaryString(j)); //6的二进制是110
System.out.println(i&j); //所以 5&6 对每一位进行与运算，得到 100->4

^ 异或 (任何数和自己进行异或都等于 0、任何数和0 进行异或都等于自己)

复制代码

1
2
3
4
5
6
7
8
9
int i  =5;
int j = 6;
System.out.println(Integer.toBinaryString(i)); //5的二进制是 101
System.out.println(Integer.toBinaryString(j)); //6的二进制是110
System.out.println(i^j); //所以 5^6 对每一位进行或运算，得到 011->3
         
System.out.println(i^0);
System.out.println(i^i);

~ 取非

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
byte i  =5;
         
System.out.println(Integer.toBinaryString(i)); //5的二进制是00000101,所以取非即为11111010,即为-6
System.out.println(~i);
/**
二进制原码：0000 0000 0000 0000 0000 0000 0000 0101
取反操作后：1111 1111 1111 1111 1111 1111 1111 1010
而在Java中，有符号整数都是用补码来表示，而补码=反码+1
	1.先求反码：1000 0000 0000 0000 0000 0000 0000 0101
	2.再求补码：1000 0000 0000 0000 0000 0000 0000 0110
最高位代表符号位 1 表示负数，0 表示正数 所以结果是-6
**/

<< 左移
>> 有符号右移

复制代码

1
2
3
4
5
6
7
8
9
byte i  =6;

//6的二进制是110
System.out.println(Integer.toBinaryString(i));
//6向左移1位后，变成1100，对应的10进制是12 简单说就是 i*2^1
System.out.println(i<<1);
//6向右移1位后，变成11，对应的10进制是3 简单说就是  i/2^1
System.out.println(i>>1);

>>> 无符号右移

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
int i  =-10;
         
//-10的二进制是11111111111111111111111111110110
//第一位是1，即符号位，代表这是一个负数
System.out.println(Integer.toBinaryString(i));
         
//对于正数， 带符号右移 >> 会把所有的位右移，并在最前面补0
//对于负数， 带符号右移 >> 会把所有的位右移，并在最前面补1     
//-10带符号右移1位，移动后前面补齐1
//得到11111111111111111111111111111011
//因为第一位是1，所以依然是一个负数，对应的十进制是-5
int j = i>>1;
System.out.println(Integer.toBinaryString(j));
System.out.println(j);
         
//-10无符号向右移1位，符号位也会向右移，第一位就变成了0
//得到01111111111111111111111111111011，对应的十进制是2147483643
int k = i>>>1;
System.out.println(Integer.toBinaryString(k));     
System.out.println(k);

5.5 赋值运算符

= 赋值操作

复制代码

1
2
int i = 5+5;

+=即自加; i+=2等同于i=i+2; 其他的 -= , *= , /= , %= , &= , |= , ^= , >>= , >>>= 都是类似，不做赘述

复制代码

1
2
3
4
5
6
7
8
int i =3;
i+=2;
System.out.println(i);//5
         
int j=3;
j=j+2;
System.out.println(j);//5

5.6 三元运算符

?:
表达式?值1:值2
如果表达式为真返回值1
如果表达式为假返回值2

复制代码

1
2
3
4
5
6
int i = 5;
int j = 6;

int k = i < j ? 99 : 88;//5小于6为真，选第一个   
System.out.println(k);//99

6 控制流程

6.1 if语句

if(表达式1){
表达式2；
}
如果表达式1的值是true,就执行表达式2

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
//如果有多个表达式，必须用大括弧包括起来;如果只有一个表达式可以不用写括弧，看上去会简约一些
boolean b = false;
if(b){
	System.out.println("yes1");
    System.out.println("yes2");
    System.out.println("yes3");
}

int i = 2;
if (i==1)
	System.out.println(1);
else if (i==2)
    System.out.println(2);
else if (i==3)
    System.out.println(3);
else if (i==4)
    System.out.println(4);

6.2 switch-case语句

switch 语句相当于 if else的另一种表达方式
switch(表达式1){
case a: xxx; break;
case b: xxx; break;
default: xxxx
}
表达式1类型参数应该是 char, byte, short, int, Character, Byte, Short, Integer,在jdk 1.7之后，还有enum，String

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
		//如果使用switch
		int day=6
        switch(day){
            case 1:
                System.out.println("星期一");
                break;
            case 2:
                System.out.println("星期二");
                break;
            case 3:
                System.out.println("星期三");
                break;
            case 4:
                System.out.println("星期四");
                break;
            case 5:
                System.out.println("星期五");
                break;
            case 6:
                System.out.println("星期六");
                break;
            case 7:
                System.out.println("星期天");
                break;
            //都不匹配则输出这一句
            default:
                System.out.println("这个是什么鬼？");
        }

6.2 循环语句

for
break: 直接结束当前for循环
continue: 继续下一次循环

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
// 方法一：
	public void test4() {
		flag: for (int i = 1; i < 4; i++) {
			for (int j = 0; j < 4; j++) {
				if (i == 2) {
					break flag;
				} else {
					System.out.println("i=" + i + " ;j=" + j);
				}
			}
		}
	}
/**
i=1 ;j=0
i=1 ;j=1
i=1 ;j=2
i=1 ;j=3
*/
// 方法二：推荐使用
@Test
	public void test5() {
		boolean flag = false;
		for (int i = 1; i < 4; i++) {
			for (int j = 0; j < 4; j++) {
				if(i==2) {
					flag = true;
				}else {
					System.out.println("i=" + i + " ;j=" + j);
				}
			}
			if (flag) {
				break;
			}
		}
	}
/**
i=1 ;j=0
i=1 ;j=1
i=1 ;j=2
i=1 ;j=3
*/

while
跟for一样，先判断再执行

复制代码

1
2
3
4
5
6
7
//打印0到4    
int i = 0;
while(i<5){
	System.out.println(i);
	i++;
}

do-while
跟while一样，不过会先执行一次，先执行再判断

复制代码

1
2
3
4
5
6
7
8
//打印0到4
//与while的区别是，无论是否成立，先执行一次，再进行判断
int i = 0;
do{
	System.out.println(i);
	i++;           
} while(i<5);

7 数组

数组是一个固定长度的，包含了相同类型数据的容器
int[] a; 声明了一个数组变量。[]表示该变量是一个数组；int 表示数组里的每一个元素都是一个整数；a 是变量名
但是，仅仅是这一句声明，不会创建数组

7.1 数组的创建方式

复制代码

1
2
3
4
5
6
7
8
9
10
11
//声明一个引用,创建一个长度是3的数组，并且使用引用a指向该数组
int[] a;
a = new int[3];

//声明的同时，指向一个数组
int[] b = new int[3];

//分配空间同时赋值
int[] c = new int[]{1, 2, 3};
int[] d = {1, 2, 3};//省略了new int[],效果一样

7.2 数组的遍历

可以使用for、foreach;
foreach是增强for循环只能用来取值，却不能用来修改数组里的值；for可以修改数组里面的值

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
int values [] = new int[]{18,62,68,82,65,9};
//常规遍历
for (int i = 0; i < values.length; i++) {
	int each = values[i];
	System.out.println(each);
}
         
//增强型for循环遍历; each为临时变量，类型为数组的类型，执行过程同上面
for (int each : values) {
    System.out.println(each);
}

最后

以上就是炙热柚子最近收集整理的关于JavaSE---00基础的全部内容，更多相关JavaSE---00基础内容请搜索靠谱客的其他文章。

本图文内容来源于网友提供，作为学习参考使用，或来自网络收集整理，版权属于原作者所有。

本文分类：JavaSE
浏览次数：118 次浏览
发布日期：2023-09-03 06:30:23
本文链接：https://www.kaopuke.com/article/k-p-k_14_uzo_10_fx_12__7__26_x.html

JavaSE---00基础

JavaSE---00基础

1 JVM JRE和JDK区别与联系

1.1 什么是JVM

1.2 什么是JRE

1.3 什么是JDK

2 JAVA八种基本类型

`2.1 类型转换`

2.2 代码示例

3 命名规则

4 final

5 运算符

5.1 算数运算符

5.2 关系操作符

5.3 逻辑运算符

5.4 位运算符

5.5 赋值运算符

5.6 三元运算符

6 控制流程

6.1 if语句

6.2 switch-case语句

6.2 循环语句

7 数组

7.1 数组的创建方式

7.2 数组的遍历

最后

评论列表共有 0 条评论

发表评论取消回复

JavaSE---00基础

JavaSE---00基础

1 JVM JRE和JDK区别与联系

1.1 什么是JVM

1.2 什么是JRE

1.3 什么是JDK

2 JAVA八种基本类型

2.1 类型转换

2.2 代码示例

3 命名规则

4 final

5 运算符

5.1 算数运算符

5.2 关系操作符

5.3 逻辑运算符

5.4 位运算符

5.5 赋值运算符

5.6 三元运算符

6 控制流程

6.1 if语句

6.2 switch-case语句

6.2 循环语句

7 数组

7.1 数组的创建方式

7.2 数组的遍历

最后

相关文章

评论列表共有 0 条评论

发表评论 取消回复

微信扫一扫：分享

`2.1 类型转换`

发表评论取消回复