JavaSe学习笔记

userJayChou

已于 2023-08-25 09:42:53 修改

阅读量163

点赞数

文章标签：学习

于 2023-07-17 08:50:44 首次发布

本文链接：https://blog.csdn.net/UserJayChou/article/details/131080471

版权

Java运行环境的部署（JDK）

我们想要在任意的目录下都可以打开指定的软件，就可以把软件的路径配置到环境变量中。

Javac是JDK提供的编译工具，可以把.java文件编译成.class文件。

Java程序的开发步骤：编写（.Java）>通过Javac.exe编译生成字节码文件（.class）>通过Java.exe对字节码文件进行运行（输出）

JDK（Java开发工具包）5.0/8.0/11.0/17.0 LTS 长期使用版本

JRE（Java运行时环境)

JVM（Java虚拟机）

JavaSE标准类库（API ：预先定义好可以直接调用的函数）

他们之间的关系如下：

JDK=JRE+开发工具

JRE=JVM+JavaSE标准类库+运行工具

跨平台中平台的意思就是操作系统（Linux、MocOS、Window）

跨平台的原理是Java不是直接运行在操作系统中的，而是运行在虚拟机中的，我们只需要针对不同的操作系统给出不同的虚拟机就可以了。

Java数据类型

声明long类型变量时需要提供后缀，后缀为“l”或“L”

声明float类型变量时需要提供后缀，后缀为“f”或“F”

boolean类型只有两个数值：true、false 常使用在流程控制语句中

取值范围：

byte<short<int<long<float<double

字符集

制表符'\t'强制延伸至8个空格（补1-8空格）

\ 转义字符

char字符类型''单引号中有且仅有一个字符，字符集ASCLL码 a=97 A=65 48=0

Scanner键盘录入

//1.导包,找到Scanner类在哪，要写在类定义的上面
import java.util.Scanner;

class ScannerDemo{
   public static void main(String[] args){
       //2.创建对象，表示我现在准备要用这个类
       Scanner sc = new Scanner(System.in);
       //3.接受数据
       System.out.print("请输入第一个数：");
       int i = sc.nextInt();
   }
}

体系一：nextint();nextdouble();next(); 遇到空格、制表符、回车、就停止接收后面录入的数据。

体系二：nextLine()可以接受空格、制表符、只有遇到回车才停止接收数据。

占位符：%s System.out.printf("你好啊%s","张三");//你好啊张三

IDEA

IDEA使用教程

项目(project) module(模块) ackage(包) class(类)

快捷键

Ctrl+Alt+M 抽取方法的快捷键

Shift+f6 改全部变量的快捷键

Ctrl+Alt+T 包裹代码选择语句

Ctrl+Alt+L 格式化代码

Ctrl+Alt+V 自动生成左边

Ctrl+Alt+方向键返回/跳转

Ctrl+D 复制到下一行

Ctrl+B 查看类源码

Ctrl+N+f12 搜索

Alt+回车可以选择相对应的提示

Ctrl+Shift+U 小写字母变大写字母

Ctrl+Shift+方向键移动一行代码

Alt+Fn+Insert Constructor快速生成有参构造方法 Getter and Setter快速生成getset方法

三元运算符
格式：关系表达式？表达式1：表达式2

如：

int a = 10;
int b = 20;
int max = a>b?a:b;
System.out.println(max);

原码、反码、补码

原码：十进制数据的二进制表现形式，最左边是符号位，0为正，1为负。

利用原码对正数计算是不会有问题的。正数的原、反、补都是一样的。

如：0000 0100（4）+ 0000 0001（1） = 0000 0101 （5）

但如果是负数计算，结果就出错，实际运算的结果，跟我们预期的结果是相反的。

如：1000 0100（-4）+ 0000 0001（1） = 1000 0101（-5）跟正确答案1是相反的。

原因是：二进制后面数字先表示完，最后再由最左边的符号位决定正负的。有两个0[+0（0000 0000）和-0（1000 0000）]也是因此而导致。所以为了解决原码不能计算负数的问题，发明了反码。

反码：正数的反码不变，负数的反码在原码的基础上，符号位不变。数值取反，0变1，1变0。

如： 1000 0100（-4）+ 0000 0001（1） = 1000 0101（-5）

1111 1011 （-4反码）+ 0000 0001 （1） = 1111 1100（再转原码）=1000 0011（-3）

转码运算再转码的意义在于：运算完之后再决定符号位的正负。

但因为符号位导致了有+0和-0的存在，所以

1000 0001（-1）反码1111 1110 +0000 0001（1）= 1111 1111（-0）

-1+1=-0=0 好像也没问题，但是---

当1000 0000（-0）反码1111 111 + 0000 0001（1）= 0000 0000（+0）

-0+1=0，误差为1，继续：

当1000 0101（-5）反码 1111 1010 + 0000 0110（6）= 0000 0000（+0）

-5+6=0，误差为1，继续：

当1000 0100（-4）反码 1111 1011 + 0000 0110（6）= 0000 0001（1）

-4+6=1，误差为1，继续：

当1000 0100（-4）反码1111 1011 + 0000 0111（7）= 0000 0010（2）

-4+7=2，误差还是为1，为什么呢？

还是因为符号位的问题导致在二进制中，有两种表现形式0，一个0000 0000（0），一个1111 1111（-0），所以导致最后运算的结果有1的误差。为了解决原码不能计算负数的问题，又有了补码。

补码：负数的补码=反码+1，因为有两个0，所以把11111111这个原本的-0作为-1的反码的补码，

-4的反码+1=1000 1100 + 0000 0010（2）= 1000 1110（-2补码）

-4的反码+1=1000 1100 + 0000 0101（5）= 0000 0001（1）

因为反码+1=补码，所以补码到-128有一个补码1000 0000，没有原码也没有反码。

补码解决了负数计算时跨0的问题，也正因如此，数字的存储和计算都是以补码的形式来进行的。

扩展知识：

在不同的数据类型下有不同的字节占用，如：

byte类型的10 1个字节 0000 1010

short字节的10 2个字节 0000 0000 0000 1010

int类型的10 4个字节 0000 0000 0000 0000 0000 0000 0000 1010

long字节的10 8个字节 0000000000000000000000000000000·· 1010

进而解释了隐式转换和强制转换：

byte a = 10;//0000 0010

int b = a;//0000 0000 0000 0000 0000 0000 0000 1010

隐式转换=前面补0

int a = 300;//0000 0000 0000 0000 0000 0001 0010 1100

byte b = (byte)a;//0010 1100

强制转换=截断

public class test08 {
public static void main(String[] args) {
int a = 200;//0000 0000 0000 0000 0000 0000 1100 1000
byte b =(byte)a;//1100 1000//最左边的1是符号位，11001000是补码形式，补码-1=11000111，再转原码是00111000
System.out.println(a);//=200
System.out.println(b);//00111000//-56

int c = 12;
int d = 2 ;
System.out.println(c&d);//逻辑与 0为false 1为true 把两个数都转为二进制，只有两个都是1，才有1，再转成十进制。=0
System.out.println(c|d);//逻辑或 0为false 1为true 把两个数都转为二进制，只要其中一个是1，才是1，再转成十进制。=14
System.out.println(c<<2);//左移向左移动，低位补0 转2进制整体左移2bit，每左移1次就是×2，然后再转十进制。=48
System.out.println(c>>2);//右转向右移动，高位补0或1（与右移前原符号位相等）转2进制整体右移2bit，每右移1次就是除2，然后再转十进制。=3
System.out.println(c>>>2);//右转向右移动，高位补0 转2进制整体右移2bit，每右移1次就是/2，然后再转十进制。=3
}}

流程控制语句

顺序结构：

Java默认的执行结构，从上往下，依次执行。

分支结构：

if语句

if（a>b）{}{} 如果表达式不成立，则语句体不再执行。

if（a>b）{}else{} 不会都执行也不会都不执行。二者选其一。

if（a>b）{}else if(){}else{};n者选其一。

如果对一个boolean类型的变量进行判断，不要用==号，直接把变量写在判断语句中。因为boolean类型的值本身就是判断的结果。而其他判断语句要用==号，因为=是赋值，==才是判断。

补充：

if （flag）相当于 if （flag == true）

if （！flag）相当于 if （flag == false）

if判断语句中使用布尔值作为判断式，只有在布尔值为true时才会执行，为false则跳过，不执行。

switch语句

switch（a）{case 值1：语句体1；break；case 值2：语句体2；break；default: break；}

如：int a = 10 switch(a){case 10: a;}//case 10 ->{a};

case具有穿透性。当输出语句重复时可以不写break；让case穿透输出。

jdk12之后优化了switch语句：case 1 ->{}//如果大括号里只有一行代码，{}可以省略。

switch语句中ab取值为byte、short、int、char、JDK5以后可以是枚举，JDK7以后是String。

default可以省略不写，且位置没有上下顺序。

综上所述，if适用于范围判断，swich适用于有限个列举。

循环结构：

for循环

for(int i = 1;i <= 10;i++){System.out.println("helloworld");}s

for( 初始语句; 执行条件; 增量 ){循环体}

for循环嵌套的处理逻辑：

只要内循环满足执行条件，是先内循环的，如果内循环不满足执行条件了再跳出内循环到外循环。

while循环

while（a >1）{}

while(条件判断语句){循环体语句；条件控制语句；}循环下面的语句

for和while的区别：

for循环中：知道循环次数或者循环的范围。

while循环：不知道循环的次数和范围，只知道循环的结束条件。

do...while循环

do{循环体语句；条件控制语句；}while（条件判断语句）；

先执行后判断。

无限循环：

for（；；）{}

while（true）{}

do{}while（true）；

跳转控制语句：

for (int i = 1; i <= 5; i++) {if (i == 3) { continue;}System.out.println(i);}//1245//

continue：跳过本次循环，继续执行下次循环。

for (int i = 1; i <= 5; i++) {if (i == 3) { break;}System.out.println(i);}//12

break：结束整个循环。

当内外循环嵌套时，假设break是在内循环，这样是无法停止整个循环的，我们可以在外循环格式前输入“xxx:”给外循环命名，这样break xxx就可以跳出指定命名的那个循环了。或在结束整个循环的语句中写：System.exit(0);该输出语句为：停止虚拟机运行。

Random生成随机数：

//1.导包,找到Random类在哪，要写在类定义的上面

import java.util.Random;

class RandomDemo{
   public static void main(String[] args){
       //2.创建对象，表示我现在准备要用这个类
       Random r = new Random();
        int num =r.nextInt();
       //3.接受数据
       System.out.print("请输入一个数：");
       int i = sc.nextInt(100);//包左不包右，0~99
   }
}

生成固定范围随机数：int num = r.nextInt((范围最大值-最小值)+1)+最小值;

如：生成5~15随机数

数组

数组的定义：

格式1：数据类型[]数组名，如int[]arr【常用】

格式2：数据类型数组名[]，如int arr []

数组的静态初始化：

完整格式：数据类型[]数组名=new 数据类型[]{元素1，2，3};如:int[]arr = new int[]{11,22,33};

简化格式：数据类型[]数组名={11,22,33};如：int[]arr = {11,22,33};【常用】

int[]arr1 = new int[]{11,22,33};System.out.println(arr1);//[I@4eec7777

地址值：[I@4eec7777

[：表示当前是一个数组