JavaSE笔记总结

一、Java简介

1、三大平台

Java SE：Java标准版，用于桌面应用开发，为今后从事Java EE开发打基础（C语言和C++语言占有优势）。 Java ME：小型版的Java语言，用于嵌入式电子设备或者小型移动设备。 Java EE：企业版，web方向的网站开发和服务器开发，这个领域Java第一。

2、Java能做什么？

桌面应用开发 企业级应用开发 移动应用开发 科学计算 大数据开发 游戏开发

3、Java的特性

面向对象 安全性 多线程 简单应用 开源 跨平台（指操作系统：Windows，Mac，Linux）

4、JDK、JRE 和JVM

JDK：Java开发工具包（JVM、核心类库、开发工具）。 JRE：Java运行环境（JVM、核心类库、运行工具）。

包含关系：JDK > JRE > JVM

4.1、JVM、核心类库、开发工具

JVM虚拟机：Java程序运行的地方。 核心类库：可直接使用。 开发工具：Javac、java、jdb、jhat.......

---

二、基础概念

1、注释

单行注释：//单行 多行注释：/* 多行 */ 文档注释：/** 文档 */

2、关键字简介

在Java中被赋予特殊意义的英文单词 字母全部小写

3、字面量

3.1、基础类型

整数类型：不带小数点的数字 小数类型：带小数点的数字 字符串类型：用双引号括起来的内容 字符类型：用单引号括起来的内容 布尔类型：布尔值，表示真假 空类型：一个特殊值，空值NULL/null

 public class VaiueDDemo1{
     public static  void main(String[] args){
         System.out.println{666};         //整数
         System.out.println{6.6};         //小数
         System.out.println{"这是字符串"};  //字符串
         System.out.println{'男'};        //字符
         System.out.println{true};        //布尔
         System.out.println{null};        //空
     }
 }

3.2、特殊字符（转义字符）

转义字符（ASCII码值【十进制】）	意义
\b（008）	退格（BS），将当前位置移到前一列
\f（012）	换页（FF），将当前位置一道下页开头
\n（010）	换行（LF），将当前位置移到下一行开头
\r（013）	回车（CR），将当前位置移到本行开头
\t（009）	水平制表（HT）（跳到下一个TAB位置）八个空格长度
\（092）	代表一个反斜字符\
'（039）	代表一个单引号（撤号字符）
"（034）	代表一个双引号字符
\?（063）	代表一个双引号字符
\0（000）	空字符（NULL）
\ddd（三位八进制）	1到3位八进制数所代表的任意字符
\xhh（十六进制）	十六进制所代表的任意字符

4、变量

4.1定义格式：

数据类型 变量名 = 数据值;

int a = 10;

4.2注意事项：

只能存一个值 变量名不允许重复定义 一条语句可以定义多个变量 变量在使用前需要赋值 变量的作用域范围

5、储存规则

计算机中，任意数据都是以二进制的形式进行储存的 常见的进制：二进制0b、十进制、八进制0、十六进制0x (JDK7以上版本)

进制转换：

5.1其他进制转十进制

公式：系数*基数的权次幂 相加

系数：每一位上的数 技术：当前进制数 权：从右往左，依次为012345......

例：二转十：101 = 1 * 2^2+0 * 2^1+1 * 0^0 = 5

5.2十进制转其他进制

初基取余法：不断地除以进制数得到的余数，直到商为0，再将余数拼接起来

例:十进制的11 11%2=1 5%2=1 2%2=0 1%2=1 二进制为1011

光学三原色：红绿蓝（RGB）（255，255，255）（FFF，FFF，FFF）

6、数据类型

6.1基本数据类型

关键字	取值范围	默认值	内存占用	位数
byte	-128 ~ 127 (-2^7 ~ 2^7-1)	0	1byte	8bit
short	-32768 ~ 32767 (-2^15 ~ 2^15-1)	0	2byte	16bit
int	-2,147,483,648 ~ 2,147,483,647 (-2^31 ~ 2^31-1)	0	4byte	32bit
long	-9,233,372,036,854,775,808 ~ 9,223,372,036,854,775,807 (-2^63 ~ 2^63-1)	0	8byte	64bit
float	-2,147,483,648 ~ 2,147,483,647 (-2^31 ~ 2^31-1)	0.0f	4byte	32bit
double	-9,233,372,036,854,775,808 ~ 9,223,372,036,854,775,807 (-2^63 ~ 2^63-1)	0.0d	8byte	64bit
char	\u0000 ~ \uffff (0 ~ 65,535)	空	2byte	16bit
boolean	true和false	false	1byte	-

6.2引用数据类型

Java 中的引用数据类型除了基本数据类型的都是，包括类、数组和接口。

6.2.1类

在 Java 中，类是一种引用数据类型。我们可以使用关键字 class 来创建一个类。例如：

 public class MyClass {
     // 类的成员变量和方法
 }

6.2.2数组

在 Java 中，数组也是一种引用数据类型。我们可以使用关键字 new 来创建一个数组。例如：

int[] myArray = new int[10];
 这段代码创建了一个长度为 10 的整型数组。

6.2.3接口

在 Java 中，接口也是一种引用数据类型。我们可以使用关键字 interface 来创建一个接口。例如：

public interface MyInterface {
     // 接口的方法
 }
  MyInterface 的接口。

6.2.4字符串

String str = {"abc"};

3、数据类型转换

3.1自动转换类型（隐式类型转换）

自动类型转换即：代码不需要经过任何处理，在代码编译时，编译器会自动进行处理 特点：数据范围小的转为数据范围大的时会自动进行。

3.2强制转换类型（显式类型转换）

*注：大类型转为小类型需要强制类型转换,可能会导致数据精度丢失(数据溢出或部分数据丢失)

强制类型转换：当进行操作时，代码需要经过一定的格式处理，不能自动完成 特点：数据范围大的转为数据范围小的 格式：目标数据类型 变量名 = （目标数据类型）被强制转换的数据;

7、标识符（阿里巴巴命名规范为标准）

1.必须以字母（a-zA-Z）、下划线（_）、美元符号（$）开头；

2.其余部分可以是字母、下划线、美元符、数字的随意组合；

3.区分大小写，长度不限；例如变量Man和变量MAn代表不同的变量

4.不可以使用Java关键字；如下图中单词不为java关键字，不能作为标识符使用

---

三、关键字、修饰限定符

一）、关键字

1、private关键字

private关键字用于类中，作用是保护类中的成员变量或者成员方法的数据安全。凡是被private修饰过后的成员变量或成员方法都不能直接被外界调用。需要先在类中进行数值的修饰才可以被外界调用.

针对private修饰后的变量的获取和修饰，被private修饰后的变量在类中也不能够直接被赋值，需要进行如下操作 1.public 返回值类型 get变量名() 用于获取在类中被private修饰后的变量 该操作有返回值 2.public set变量名(参数) 用于设置在类中被private修饰后的变量的方法

当一个被private修饰的变量在类中被使用get和set方法定义完之后，就可以被外部调用了.

 //创建student类
 public class student{
  
     String name;//创建成员变量name
     private int age;//创建了一个age的成员变量 使用private修饰 
  
  
     public int getAge(){//使用get方法获取被private修饰后的age变量
         return age;
     }
  
     public void setAge(int a ){
 //使用set方法对age变量进行方法的定义 这样它被外界调用赋值的时候就会执行该方法下对应的操作
         if(a<0 || a>120){
             System.out.println("数值有误");
         }
         else{
              age=a;
         }
 }
  
     //创建成员方法
     public void st(){
         System.out.println(name+age);
     }
  
 }
 //测试类
 public class test{
 public static void main(String [] args){
     student s = new Student();//创建一个student类的对象 对象名为s        
     
  
     //给成员变量赋值
     s.name="张三";// 成员变量name没有被private修饰 所以可以直接被调用
     s.setAge(20);
 /*成员变量age被private修饰了，所以不能直接调用 而是调用age在类中被定义的set方法，并给出一个参数进行传参*/
  
 //调用成员方法
     s.st();
  
     }
  
 }
  
 // 输出结果 张三20

2、this关键字

本质：所在方法调用者的地址值

可以区分局部变量和成员变量

this.成员变量 没有用this修饰的变量会遵循就近原则

需要注意，this 关键字只能在非静态方法内部使用，因为静态方法不属于任何特定的对象实例。如果在静态方法中使用 this，编译器会报错。

3、static静态

3.1、静态变量

static变量也称为静态变量，静态变量和非静态变量的区别： 1、静态变量被所有对象共享，在内存中只有一个副本，在类初次加载的时候才会初始化（静态变量是随着类的加载而加载的，优先于对象出现） 2、非静态变量是对象所拥有的，在创建对象的时候被初始化，存在多个副本，各个对象拥有的副本互不影响

3.2静态方法

成员方法的分类： 静态成员方法（有static修饰，归属于类），建议用类名访问，也可以用对象访问。 实例成员方法（无static修饰，归属于对象），只能用对象触发访问。

static访问注意事项： 静态方法只能访问静态的成员，不可以直接访问实例成员。 实例方法可以访问静态的成员，也可以访问实例成员。 静态方法中是不可以出现this关键字的。

代码块是类的5大成分之一（成员变量、构造器，方法，代码块（静态代码块、构造代码块），内部类）

3.3静态的内存

JDK8之前静态区在方法区中
JDK8之后静态区在堆空间里

4、super

super：代表父类存储空间

5、final

1、 final修饰类

当final关键字修饰一个类，则该类会成为最终类，即该类不能被继承（俗称“断子绝孙类”），但是该类可以有父类

2、final修饰变量（成员变量和局部变量） 变量分为成员变量和局部变量（成员变量和局部变量介绍传送门），他们被final修饰时有不同的注意事项。 （1） final修饰成员变量：该成员变量必须在其所在类对象创建之前被初始化（且只能被初始化一次）。 这句话的意思是： 被final修饰的成员变量，一定要被赋值且只能被赋值一次，且必须是在这个成员变量所在的类对象创建之前被赋值（2） final修饰局部变量：该变量必须在使用之前赋值，且只能被赋值一次！

注*：2.1、当final修饰基本数据类型的变量，则意味着这个变量只能被赋值一次； 2.2当final修饰引用数据类型（类、接口、数组）的变量，则引用变量所指向的对象（即该变量所存放的地址值）不能更改，但是该对象的内容（即地址值上存储的内容）可以更改！！**不能改变被final修饰的引用变量所指向的对象，但是可以改变其指向对象的内容：

3、final修饰成员方法 当final关键字修饰了成员方法，则意味着这个方法不能被重写，但是可以被继承（注意，这里final修饰的是方法而不是类）。

二）、权限修饰符

范围	private	default	protected	public
同一包中的同一类	√	√	√	√
同一包中的不同类		√	√	√
不同包中的子类			√	√
不同包中的非子类				√

三）、常用API

常用API

四、运算符

1、算术运算符

符号	作用
＋	加
-	减
*	乘
/	除
%	取余、取模

*注：

1、整数参与计算结果只能是整数。 2、小数参与计算，结果可能不精确， 3、byte、short、char在进行计算时会先提升为int再进行计算。 4、字符串的＋操作是字符串连接符，会将＋前后两个数据进行拼接。如："123" + 123 = "123123"; 。 5、字符＋字符和字符＋数字会对字符的ASCII码值进行计算。如：1 + 'a' = 98; 。

2、自增自减运算符

符号		作用
++a		先赋加再进行赋值（先加再用）
a++		是先赋值再加（先用再加）
--a		先赋减再进行赋值（先减再用）
a--		是先赋值再减（先用再减）

3、赋值运算符

符号	作用	说明
=	赋值	int a =1; 将1赋值给a
+=	加后赋值	a+=b; 将a + b的值赋值给a
-=	减后赋值	a-=b; 将a - b的值赋值给a
*=	乘后赋值	a*=b; 将a * b的值赋值给a
/=	除后赋值	a/=b; 将a / b的值赋值给a
%=	取余后赋值	a%=b; 将a / b的余数赋值给a

4、关系运算符

符号	说明
==	a == b,判断a和b是否相等，成立为true，不成立为false
！=	a != b,判断a和b是否不相等，成立为true，不成立为false
>	a > b,判断a是否大于b，成立为true，不成立为false
>=	a >= b,判断a是否大于等于b，成立为true，不成立为false
<	a < b,判断a是否小于b，成立为true，不成立为false
<=	a <= b,判断a是否小于等于b，成立为true，不成立为false

注意：当需要多次判断时，不能连着写，比如：3 < a < 5，Java程序与数学中是有区别的

 public class Test {
     public static void main(String[] args) {
         int a = 1;
         int b = 2;
         if(a 
  
注*：我们会发现，这段代码无法正常的编译，这是因为编译器会先进行a 
  
5、逻辑运算符
 
  
 
   
 
    
 
     
符号
 
     
作用
 
     
说明
 
    
 
   
 
   
 
    
 
     
&
 
     
逻辑与（且）
 
     
并且，两边都为真，结果才为真
 
    
 
    
 
     
|
 
     
逻辑或
 
     
或者，两边都为假，结果才为假
 
    
 
    
 
     
^
 
     
逻辑异或
 
     
相同为false，不同为true
 
    
 
    
 
     
!
 
     
逻辑非
 
     
取反，例：！true = false
 
    
 
    
 
     
&&
 
     
短路与
 
     
两侧要求都成立
 
    
 
    
 
     
||
 
     
短路或
 
     
左侧为真时，不再判断右侧。左侧为假时，才会判断右侧
 
    
 
   
 
  
 
  
6、三元运算符
 
  
格式： 关系表达式？表达式1：表达式2; 关系表达式为真，输出表达式1否则输出表达式2
 
  
7、运算符优先级
 
  
 
   
 
    
 
     
优先级
 
     
运算符
 
    
 
   
 
   
 
    
 
     
1
 
     
. () {}
 
    
 
    
 
     
2
 
     
! ~ ++ --
 
    
 
    
 
     
3
 
     
* / %
 
    
 
    
 
     
4
 
     
= -
 
    
 
    
 
     
5
 
     
<< >> >>>
 
    
 
    
 
     
6
 
     
< <= > >= instanceof
 
    
 
    
 
     
7
 
     
== !=
 
    
 
    
 
     
8
 
     
&
 
    
 
    
 
     
9
 
     
^
 
    
 
    
 
     
10
 
     
|
 
    
 
    
 
     
11
 
     
&&
 
    
 
    
 
     
12
 
     
||
 
    
 
    
 
     
13
 
     
? :
 
    
 
    
 
     
14
 
     
= += -= *= /= %= &=
 
    
 
   
 
  
 
  
8、原码、反码、补码
 
  
原码：十进制数据的二进制表现形式就是原码，原码最左边的一个数字就是符号位，0为正，1为负。 反码：正数的反码是其本身（等于原码），负数的反码是符号位保持不变，其余位取反。 补码：正数的补码是其本身，负数的补码等于其反码 +1。
 
  
9、其他运算符
 
  
 
   
 
    
 
     
运算符
 
     
含义
 
     
运算规则
 
    
 
   
 
   
 
    
 
     
<<
 
     
左移
 
     
向左移动，低位补0
 
    
 
    
 
     
>>
 
     
右移
 
     
向右移动，高位补0或1
 
    
 
    
 
     
<<<
 
     
无符号右移
 
     
向右移动，高位补0
 
    
 
   
 
  
 
  
 
  
 
  
五、判断和循环
 
  
1、if语句
 
  
//第一种：
 if（布尔表达式）{
 Java语句；
 }
 ​
 //第二种：
 if（布尔表达式）{
 Java语句；
 }else{
 Java语句；
 }
 ​
 //第三种：
 if（布尔表达式）{
 Java语句；
 } else if（布尔表达式）{
 Java语句；
 }
 ​
 //第四种：
 if（布尔表达式）{
 Java语句；
 } else if（布尔表达式）{
 Java语句；
 }else{
 Java语句
 }
 
  
注*： 1、对于Java中的if语句来说，只要有一个分支执行，整个if语句全部结束。 2、以上的第二种编写方式和第四种编写方式都带有else分支，这两种方式可以保证百分比百的会有分支执行 3、if语句的分支中只有语句Java语句的话，大括号可以省略不写。如下
 
  
 if（true/false）
     一条Java语句：
 //这种方式不推荐使用，别人这么写看懂就行。
 
  
2、switch语句
 
  
//格式
 switch (表达式) {
     case 值1:
         // 执行代码块1
         break;
     case 值2:
         // 执行代码块2
         break;
     // 可以有更多的 case
     default:
         // 如果没有匹配的值，则执行默认代码块
 }


 //例子
 int dayOfWeek = 3;
 String day;
 switch (dayOfWeek) {
     case 1:
         day = "星期一";
         break;
     case 2:
         day = "星期二";
         break;
     case 3:
         day = "星期三";
         break;
     case 4:
         day = "星期四";
         break;
     case 5:
         day = "星期五";
         break;
     default:
         day = "周末";
         break;
 }
 System.out.println("今天是" + day);
 
  
在上面的例子中，根据 dayOfWeek 的值，选择执行相应的 case 语句。 在这种情况下，dayOfWeek的值为 3 33，因此执行第三个 case 语句，将day赋值为 “星期三”。 最后，输出结果为 “今天是星期三”。
 
  
2.1case击穿现象
 
  
case穿透：在switch语句中，如果case控制的语句体后面不写break，会一直向下运行，直到遇到break，或者整体switch语句结束。
 
  
2.2case合并
 
  
如果有需要，例如多个case分支的值的执行操作是相同的，这种情况下，就可以去合并多个case，只写次java操作语句即可。 （多个case可以连着写，使代码更简洁）
 
  
//例
Scanner data  = new Scanner(System.in);
		System.out.print("请输入一个数字（0-5）:");
		int num = data.nextInt();
		switch(num){
		case 1:case 2:case 3:
			System.out.println("前三名");
			break;
        //case 1,2,3 -> System.out.println("前三名");
                //break;  JDK17之后的版本可以这么写
		case 4:
			System.out.println("第四名");
			break;
		case 5:
			System.out.println("第五名");
			break;
		default:
			System.out.println("有误");
		}
 
  
3、for循环
 
  
//格式：
for(条件表达式1;条件表达式2;条件表达式3) {
​​​​​​​ 语句块; 
}
 
  
 
   
 
    
 
     
表达式
 
     
形式
 
     
功能
 
     
举例
 
    
 
   
 
   
 
    
 
     
条件表达式 1
 
     
赋值语句
 
     
循环结构的初始部分，为循环变量赋初值
 
     
int i=1
 
    
 
    
 
     
条件表达式 2
 
     
条件语句
 
     
循环结构的循环条件
 
     
i>40
 
    
 
    
 
     
条件表达式 3
 
     
迭代语句，通常使用 ++ 或 -- 运算符
 
     
循环结构的迭代部分，通常用来修改循环 变量的值
 
     
i++
 
    
 
   
 
  
 
  
4、while语句
 
  
//格式
while (循环条件) {
     循环体;
     条件控制语句;
     }
 
  
执行流程：在执行while语句时，首先判断循环条件，如果循环条件为false，则直接执行while语句后续的代码，如果循环条件为true，则执行循环体代码，然后再判断循环条件，一直到循环条件不成立为止。
 
  
5、do...while语句
 
  
//格式
 do{
     循环体;
     条件控制语句;
     }while（循环条件）;
 
  
执行流程：当执行到do-while语句时，首先执行循环体，然后再判断循环条件，如果循环条件不成立，则循环结束，如果循环条件成立，则继续执行循环体，循环体执行完成以后再判断循环条件，依次类推。
 
  
 
  
六、数组
 
  
1、概念
 
  
数组就是存储数据长度固定的容器，保证多个数据的数据类型要一致。
 
  
格式：
 
  
1.1、静态初始化
 
  
数据类型[] 数组名 = new 数据类型[]{元素1,元素2,元素3…};
 ​
 //例如
 int[] arr = new int[]{1,2,3,4,5}; 
 // 可以拆分 
 int[] arr;
 arr = new int[]{1,2,3,4,5};
 ​
 数据类型[] 数组名 = {元素1,元素2,元素3…};//不可拆分
 ​
 //例如
 int[] arr = {1,2,3,4,5};
 
  
1.2、动态初始化
 
  
 数组存储的数据类型[ ] 数组名字 = new 数组存储的数据类型[数组长度];
 数组存储的数据类型 数组名字[ ] = new 数组存储的数据类型[数组长度];
 
  
//例如
 int[] arr = new int[3];  
 int   arr[] = new int[3];
 // 可以拆分 
 int[] arr;
 arr = new int[3];
 
  
@扩展方法： Arrays.fill快速初始化，填充一个数组
 
  
java中的数组初始值都为零，若快速填充一个其他值的数组，即将数组批量填充相同的值，可以用 Arrays.fill 方法，但只能填充一个一维数组，多维数组还得用循环。
 
  
import java.util.Arrays;
 ​
 public class HelloWorld {
     public static void main(String[] args) {
         int[] arr = new int[5];
         Arrays.fill(arr, 1);
         System.out.println(Arrays.toString(arr));  // [1, 1, 1, 1, 1]
     }
 }
 
  
2、数组的访问
 
  
索引： 每一个存储到数组的元素，都会自动的拥有一个编号，从0开始，这个自动编号称为数组索引 (index)，可以通过数组的索引访问到数组中的元素。
 
  
数组的长度属性： 每个数组都具有长度，而且是固定的，Java中赋予了数组的一个属性，可以获取到数组的长度，语句为：数组名.length ，属性length的执行结果是数组的长度，int类型结果。由次可以推断出，数组的最大索引值为数组名.length-1。
 
  
 数组名[索引] = 数值，为数组中的元素赋值
 变量 = 数组名[索引]，获取出数组中的元素
 
  
3、内存分配
 
  
栈：方法运行时使用的内存 堆：储存对象或者数组，new的都在堆内存，会有地址值 方法区：储存可以运行的class文件 本地方法栈：JVM在使用操作系统功能的时候使用，和我们开发无关 寄存器：给CPU使用，和我们开发无关
 
  
4、二维数组
 
  
3.1初始化
 
  
 int[][] array1 = new int[10][10];
 int array2[][] = new int[10][10];
 int array3[][] = { { 1, 1, 1 }, { 2, 2, 2 } };
 int array4[][] = new int[][] { { 1, 1, 1 }, { 2, 2, 2 } };
 ​
 //不定长初始化
 int[][] array = new int[3][];
 array[0] = new int[1];
 array[1] = new int[2];
 array[2] = new int[3];
 ​
 //获取二维数组的长度
 int length1 = array.length;
 int length2 = array[0].length;
 // 获取二维数组的第一维长度（3）
 System.out.println(length1);
 // 获取二维数组的第一维的第一个数组长度（1）
 System.out.println(length2);
 
  
 
  
七、方法
 
  
1、概念
 
  
方法是程序中最小的执行单元
 
  
2、方法定义和方法调用
 
  
2.1简单的方法定义和调用
 
  
 //定义
 public static void 方法名(){
     方法体;
 }
 ​
 //调用
 方法名();
 
  
2.2带参数的方法定义和调用
 
  
//定义
 public static void 方法名(数据类型 参数1,数据类型 参数2){
     方法体;
 }
 ​
 //调用
 方法名(参数1,参数2);
 
  
2.3带返回值的方法定义和调用
 
  
//定义
 public static 返回值类型 方法名(数据类型 参数1,数据类型 参数2){
     方法体;
     return 返回值类型;
 }
 ​
 //调用
 方法名(参数1,参数2);
 
  
3、方法重载
 
  
方法重载是指在一个类中定义多个同名的方法，但要求每个方法具有不同的参数的类型或参数的个数。调用重载方法时，Java编译器能通过检查调用的方法的参数类型和个数选择一个恰当的方法。（引用自百度百科）
 
  
方法重载的规则如下： 1、在同一个类中，方法名称必须相同。 2、在同一个类中，方法的参数列表必须不同，可以通过参数的个数、类型或顺序来区分重载的方法。 3、在同一个类中，方法的返回类型可以相同，也可以不同。返回类型不是决定方法重载的因素。
 
  
4、方法的内存
 
  
方法被调用后就会进入栈
 
  
4.1方法传递基本数据类型
 
  
传递基本数据类型时，传递的是真实的数据，形参的改变，不影响实际参数的值
 
  
4.2方法传递引用数据类型
 
  
传递引用数据类型时，传递的是地址值，形参的改变，影响实际参数的值
 
  
 
  
八、类和对象
 
  
1、什么是对象？
 
  
面向对象OOP-CSDN博客
 
  
2、类
 
  
类和对象（Java）-CSDN博客