JavaSE的基础入门笔记！比较个人向，可能有些乱
前言
整理更新中
本部分 Java基础教程 正在整理编辑中，预计需要 9天 ，可能存在部分内容缺失，我在慢慢整理，会逐步放出…
以前版本的记录太朦胧，废话很多（现在的废话也多
然后就是，把教程写的美观些~，不会太单调（容易视觉疲劳）
再再再就是，很多地方写的太简单了，可能不太好理解
数组那部分全都是代码，感觉没人能看懂… 另外，面向对象部分实在是，太多了！！！！！
我还没想好是另外弄一个文档页来单独放面向对象，还是说直接就在这个页面写。毕竟面向对象必须要详细些。
可能因为懒而接着在这里写
当前进度
- Java背景知识
- 环境搭建、编译工具选择
- 基础概念
- 流程控制
- 方法的创建使用及重载
- 数组
- 面向对象
- 总结
代码资源
本教程中所有内容 均以代码形式上传到本人网盘中，免费提供下载
都是我边看边写的，甚至文章内部分内容还是我照着代码写的
直通车: MoYu-Pan | Java 密码:moyu233
Java的背景知识
上世纪C系列统治编程的时候，程序员被指针等折磨的死去活来 （现在我也被折磨的死去活来）
Java的开发，让程序员们倍感欣喜
用Java来制作软件界面有些丑 ，于是被嘲笑"只是个玩具"
后来几年，一些高端企业发现Java开发一些大型项目的三高特性
高血压，高血脂，高血糖 ，高可用、高性能、高并发
Java才逐渐开始普及。比如手机系统：安卓，就是借助Java开发
JDK、JRE、JVM
JDK： Java的开发环境
JRE： Java的运行环境
JVM： Java的一个虚拟机。相当于模拟一个CPU来处理Java相关内容。
JAVA可以跨平台使用的核心，在不同平台模拟虚拟机。
一个BUG， 一次编译，到处运行
大概了解一下三者关系就可以。
Java开发环境基础搭建
开发环境
JDK我这里安装的是JDK17。可以按照自己需求安装版本
JDK最新版下载：https://www.oracle.com/java/technologies/downloads/
开发工具
安装IDEA
IDEA官网： https://www.jetbrains.com/
分为旗舰版（收费）和社区版（免费），社区版用来个人开发Java已经够用了。
所以这里选择社区版
提示：安装时勾选记得勾选 .java选项
配置汉化
打开IDEA，左上角Fire(文件)-Setting(设置)-Plugin-搜索Chinese
下载简体中文汉化补丁。安装完毕重启即可。
注释、标识符、关键字
注释
Java中分有三种类型的注释
- 单行注释
- 多行注释
- 文档注释
具体格式如下:
//单行注释
/*多行注释
多行注释
多行注释
*/
/**
*文档注释
*文档注释
*/
标识符和关键字
关键字：
关键字不能作为命名。比如：int public ，是不允许的。
标识符：
所有标识符都应该以字母 (A-Z、a-z) ，美元符号（$），或 下滑符（_） 开头
所有标识符在首个字符之后，可以使用 字母(A-Z、a-z)，美元符号（$），或下滑符（_） 以及数字的混合。
标识符 可以使用中文（但不提倡）
例子：
-
#ABC、1ABC、*ABC…不合法。
-
A#abc、A*abc…不合法。
注意 ：标识符是大小感敏感的。int MOYU 和 int moyu 不是同一个数据
Java的数据类型及部分拓展
数据类型
Java中，所有变量都必须先定义，然后才能使用
//不定义进行使用
int a;
System.out.println(a); //输出a的值
//定义进行使用
int a = 20;
System.out.println(a); //输出a的值
变量声明格式。
type varName [=value] [{,varName[=value] }]
类型 名称 = 值 （使用,隔开，声明多个变量）
数据类型分为：基本数据类型、引用数据类型（后面会提到！）
基本数据类型
数值类型
整数型： 例如0、1、2、3的整数
byte： 8位，最大存储数据量是255，存放的数据范围是-128~127之间。
short： 16位，最大数据存储量是65536，数据范围是-32768~32767之间。
int： 32位，最大数据存储容量是2的32次方减1，数据范围是负的2的31次方到正的2的31次方减1。
long： 64位，最大数据存储容量是2的64次方减1，数据范围为负的2的63次方到正的2的63次方减1。
浮点型： 例如1.1、2.34、5.689…的小数
float： 32位，数据范围在3.4e-45~1.4e38，直接赋值时必须在数字后加上f或F。
double： 64位，数据范围在4.9e-324~1.8e308，赋值时可以加d或D也可以不加。
其他
字符类型： 可以定义 一个字符 。比如”H“
char： 16位，存储Unicode码，用单引号赋值。
布尔类型：
boolean：只有true和false两个取值。
//例子
public class MoYu {
public static void main(String[] args){
//整数型
byte a=100;
int b=10000;
long c = 100L;//long类型末尾要加L
short d =100;
//浮点型
float e= 0.35f;//float类型末尾需要加f
double f=20.45;
//字符型
char m = 'A';//char类型要用单引号，而不是双引号.
//字符串
String n="摸鱼233";//String要用双引号。并且String是类，而不是关键字
//非数值型
boolean g = true;
}
}
引用数据类型
这里只列一下，不展开讲，后面会提到
类： Class
接口：Interface
数组：Arry
类型转换
只讨论七种基本数据类型的转换！
该部分整理中
自动类型提升
一行说明白！
byte、char、short -> int -> long ->float -> double
整理中…
强制类型转换
可能导致精度损失
1.精度损失
2.精度不损失
3.精度损失(二进制)
整理中…
拓展
- 1字节(Byte)=8位(bit)
- 1KB( Kilobyte，千字节)=1024B
- 1MB( Megabyte，兆字节)=1024KB
- 1GB( Gigabyte，吉字节，千兆)=1024MB
- 1TB( Trillionbyte，万亿字节，太字节)=1024GB
#浮点数型不能直接拿来比较计算（本身数据具有约分）
double a = 1.0/10; //值为0.1
float b = 0.1f; //值为0.1
System.out.println(a);//输出为0.1
System.out.println(b);//输出为0.1
System.out.println(a==b);//输出为false
转义字符
控制字符
- ’ 单引号字符
- \ 反斜杠字符
- \r 回车
- \n 换行
- \f 走纸换页
- \t 横向跳格
- \b 退格
Unicode转义字符： \u
//例子
char a='A'
System.out.println("\u0065")； //输出得到A
System.out.println((int)A)； //输出得到65
//Unicode格式：U0000、UFFFF
变量、常量、运算符
变量、常量
变量类型：类变量、实例变量、局部变量
作用域：变量可以作用的范围
运算符
基本运算符：
| 操作符 | 描述 | 例子 |
|---|---|---|
| + | 加法 - 相加运算符两侧的值 | A + B 等于 30 |
| - | 减法 - 左操作数减去右操作数 | A – B 等于 -10 |
| * | 乘法 - 相乘操作符两侧的值 | A * B等于200 |
| / | 除法 - 左操作数除以右操作数 | B / A等于2 |
| % | 取余 - 左操作数除以右操作数的余数 | B%A等于0 |
| ++ | 自增: 操作数的值增加1 | B++ 或 ++B |
| -- | 自减: 操作数的值减少1 | B-- 或 --B |
自加自减符
public class moYu{
public static void main(String[] args){
int a = 3;//定义一个变量；
int b = ++a;//自增运算
int c = 5;
int d = --c;//自减运算
System.out.println("进行自增运算后的值等于"+b);
System.out.println("进行自减运算后的值等于"+d);
}
}
关系运算符
下表为Java支持的关系运算符
表格中的实例整数变量A的值为10，变量B的值为20：
| 运算符 | 描述 | 例子 |
|---|---|---|
| == | 检查如果两个操作数的值是否相等，如果相等则条件为真。 | （A == B）为假 |
| != | 检查如果两个操作数的值是否相等，如果值不相等则条件为真。 | (A != B) 为真 |
| > | 检查左操作数的值是否大于右操作数的值，如果是那么条件为真。 | （A> B）为假 |
| < | 检查左操作数的值是否小于右操作数的值，如果是那么条件为真。 | （A <B）为真 |
| >= | 检查左操作数的值是否大于或等于右操作数的值，如果是那么条件为真。 | (A> = B）为假 |
| <= | 检查左操作数的值是否小于或等于右操作数的值，如果是那么条件为真。 | （A <= B）为真 |
public class MoYu {
public static void main(String[] args) {
int a = 10;
int b = 20;
System.out.println("a == b = " + (a == b) );
System.out.println("a != b = " + (a != b) );
System.out.println("a > b = " + (a > b) );
System.out.println("a < b = " + (a < b) );
System.out.println("b >= a = " + (b >= a) );
System.out.println("b <= a = " + (b <= a) );
}
}
/*
输出结果如下
a == b = false
a != b = true
a > b = false
a < b = true
b >= a = true
b <= a = false
*/
位运算符
二进制运算：
A = 0011 1100
B = 0000 1101
-----------------
A&B = 0000 1100
A | B = 0011 1101
A ^ B = 0011 0001
~A= 1100 0011
假设整数变量 A 的值为 60 和变量 B 的值为 13：
| 操作符 | 描述 | 例子 |
|---|---|---|
| ＆ | 如果相对应位都是1，则结果为1，否则为0 | （A＆B），得到12，即0000 1100 |
| | | 如果相对应位都是 0，则结果为 0，否则为 1 | （A | B）得到61，即 0011 1101 |
| ^ | 如果相对应位值相同，则结果为0，否则为1 | （A ^ B）得到49，即 0011 0001 |
| 〜 | 按位取反运算符翻转操作数的每一位，即0变成1，1变成0 | （〜A）得到-61，即1100 0011 |
| << | 按位左移运算符。左操作数按位左移右操作数指定的位数 | A << 2得到240，即 1111 0000 |
| >> | 按位右移运算符。左操作数按位右移右操作数指定的位数 | A >> 2得到15即 1111 |
| >>> | 按位右移补零操作符。左操作数的值按右操作数指定的位数右移，移动得到的空位以零填充。 | A>>>2得到15即0000 1111 |
逻辑运算符
| 操作符 | 描述 | 例子 |
|---|---|---|
| && | 称为逻辑与运算符。当且仅当两个操作数都为真，条件才为真 | （A && B）为假 |
| | | | 称为逻辑或操作符。如果任何两个操作数任何一个为真，条件为真 | （A | | B）为真 |
| ！ | 称为逻辑非运算符。用来反转操作数的逻辑状态。如果条件为true，则逻辑非运算符将得到false。 | !(A && B)为真。 |
拓展
短路逻辑运算
当使用 与逻辑运算符 时，在两个操作数都为true时，结果才为true，但是当得到第一个操作为false时，其结果就必定是false，这时候就不会再判断第二个操作了。
public class moYu{
public static void main(String[] args){
int a = 5;//定义一个变量；
boolean b = (a<4)&&(a++<10);
System.out.println("使用短路逻辑运算符的结果为"+b);
System.out.println("a的结果为"+a);
}
}
/*
使用短路逻辑运算符的结果为false
a的结果为5
*/
解释： 该程序使用到了短路逻辑运算符(&&)，首先判断 a<4 的结果为 false，则 b 的结果必定是 false，所以不再执行第二个操作 a++<10 的判断，所以 a 的值为 5。
条件运算符
条件运算符也被称为 三元运算符 。该运算符有3个操作数，并且需要判断布尔表达式的值。该运算符的主要是决定哪个值应该赋值给变量。
int long = 10;
String one = (long<15)?"长度不合格":"长度合格";
运算符优先级
| 类别 | 操作符 | 关联性 |
|---|---|---|
| 后缀 | () [] . (点操作符) | 左到右 |
| 一元 | expr++ expr– | 从左到右 |
| 一元 | ++expr --expr + - ～ ！ | 从右到左 |
| 乘性 | * /％ | 左到右 |
| 加性 | + - | 左到右 |
| 移位 | >> >>> << | 左到右 |
| 关系 | > >= < <= | 左到右 |
| 相等 | == != | 左到右 |
| 按位与 | ＆ | 左到右 |
| 按位异或 | ^ | 左到右 |
| 按位或 | | | 左到右 |
| 逻辑与 | && | 左到右 |
| 逻辑或 | | | | 左到右 |
| 条件 | ？： | 从右到左 |
| 赋值 | = + = - = * = / =％= >> = << =＆= ^ = | = | 从右到左 |
| 逗号 | ， | 左到右 |
包、JavaDoc
Java的包机制就如同电脑建文件夹一样，大概理解就好。
JavaDoc是java一种文档功能，可以视为一种说明书，不详细展开
官方JavaDoc示例：直通车
流程控制
总体内容比较简单，信息量少。可以去看下我写的代码，里面有一些应用
if、if…else条件判断
普通的IF语句
条件判断句式，（如果…，则…，否则）
if(布尔表达式)
{
//如果布尔表达式为true将执行的语句
}
示例
//if势力
public class Demo {
public static void main(String args[]){
int x = 10;
if( x < 20 ){
System.out.println("摸鱼屋防伪！");
}
}
}
IF…Else语句
if 语句后面可以跟 else 语句，当 if 语句的布尔表达式值为 false 时，就会执行else内容
public class Demo {
public static void main(String args[]){
int x = 30;
if( x < 20 ){
System.out.println("这是 if 语句");
}else{
System.out.println("这是 else 语句");
}//明白区别了吧
}
}
注意：
- if 语句至多有 1 个 else 语句，else 语句在所有的 else if 语句之后。
- if 语句可以有若干个 else if 语句，它们必须在 else 语句之前。
- 一旦其中一个 else if 语句检测为 true，其他的 else if 以及 else 语句都将跳过执行。
Switch选择结构
整理中整理中！！！！
while、do…while循环
基本的While
while是最基本的循环，就像这样:
while( 布尔表达式 ) {
//循环内容
}
规则： 只要布尔表达式为 true，循环就会一直执行下去。
别写一个死循环啊喂！！(强调)
代码例子:
public class Demo {
public static void main(String[] args) {
int x = 10;
while( x < 20 ) {
System.out.print(x+"\n");
x++;
}//While结束~
}
}
Do…While语句
while是，满足条件，进入循环，然后执行语句
do…while 则是，先执行一次语句，然后判断是否进入循环。
do {
//代码语句
}while(布尔表达式);
注意： 布尔表达式在循环体的后面，所以语句块在检测布尔表达式之前已经执行了。 如果布尔表达式的值为 true，则语句块一直执行，直到布尔表达式的值为 false
For循环
for循环是一个神奇的循环，很简单的结构，很简单的循环
但是稍微那么嵌套几个for，就很容易绕进去了
所以还是建议自己写几个小应用理解理解（比如:9x9乘法表）
或者去我网盘里下载一下看看
For循环
简单！
结构如下:
for(初始化; 布尔表达式; 更新代码) {
//代码！
}
具体运行是：先初始化，然后判断布尔值，为true则结束，为false则执行代码
执行完代码后，执行更新代码。最后再判断布尔值，重复上述步骤
简单写个代码理解下
public class Demo {
public static void main(String[] args) {
//简单的for语句
int a;
for (a=1;a<10;a++) {
System.out.println(a);
}//for结束
}
}
一定一定要去看应用！
增强For循环
这个结构就比较抽象了 (我真的讨厌这个！)
for(声明语句 : 表达式)
{
//代码句子
}
是不是看不明白了。没事，写一个对比代码看一下就好
增强版可以理解为普通版的简化表达 (个人理解)
public class Demo {
public static void main(String[] args) {
//增强for循环
int[] numbers = {10,20,30,40,50};
for (int x : numbers){
System.out.println(x);
}
//等效于
for (int o=0;o<5;o++){
System.out.println(numbers[o]);
}//for结束
}
}//代码结束
到这里流程控制就结束啦，也不知道我写明白没有
一定要记得去自己写写应用!
Java方法
终于到了一个稍微稍微重头戏的内容
这部分内容比较重要，和后面的许多内容都有关联！
加油！
方法创建及使用
最好自己开个IDEA跟着一起写写
方法的创建
Java方法 是语句的集合，它们在一起执行一个功能。
举个栗子:
解方程！
解方程 的过程 是 对未知数 求解
那我们设定一个 “解方程”方法，然后把解方程的内容写进去
现在“解方程“ 就是个方法。
那么现在你就可以 解方程(式子); 来解方程了
是不是有点太抽象了，简单写个 加法 的 方法吧
//加法算法
public static int add(int a,int b){
int sum;
sum = a+b;
return sum;
}
/*
方法结构:
修饰符 返回值类型 方法名(参数类型 参数名){
...
方法体
...
return 返回值;
}
*/
你是不是疑惑！
“static是什么，public是什么，return又是什么啊，三个int分别什么意思啊?”
别急！ （我知道你很急，但你先别急）
可以看到我在代码最下面写了方法的结构
public , static 都是修饰符，return 是返回值
public
表示这个方法是公开的。谁都可以调用的
static
表示这个方法是静态的
什么叫静态呢?
简单说就是，在你这个 类(Class) 刚开始执行的时候，方法就一同被创建好了，这样直接就可以在类内调用了
不加 static的话，只有当你代码里用到这个方法的时候，才会去创建方法。
为了理解，本块内容里所有方法都是静态的。非静态到面向对象会说的！
return
是返回值，会返回一个数据，这个数据的类型就是修饰符后写的数据类型
第一个int是返回值的数据类型
void 则表示无返回值。余两个 int 则是参数
方法的使用
会创建也要会用！
看个代码来简单理解下
public class Demo {
//什么是方法
//main方法
//void表示返回空
public static void main(String[] args) {
int m=10;
int n=20;
int sum = add(m,n);//调用加法
System.out.println(sum);
}
//构建有返回值的方法
//加法
//int 表示方法的返回数值类型
//static表示是静态方法。类内可调用
public static int add(int a,int b){
return a+b;//返回add方法的值
}
可以看到，我使用了 int sum = add(m,n);
括号内的两个参数的值会传递到方法里的a和b上，然后返回a+b的值，此时sum被赋值。完成了一次方法调用
方法内的a和b只是一个符号，是作为值传递的媒介，本身无法被方法外调用的。
比如英语里的that。可以拿来替代一个句子，但没有句子前提，本身拿出来是无意义的.
切记：返回值类型和你return后面的数据类型必须相同！
方法重载及可变参数
方法重载
那么问题来了，我写了一个add加法，返回类型是int，但是我需要对double进行一次加法，怎么办呢，写一个add2吗
答案是：方法重载
下面用一个简单的比大小方法做例子(不严谨的方法)，只理解方法重载意思即可
public class Method1 {
public static void main(String[] args) {//main方法
int x = 10;
int y = 15;
double n = 22;
double m = 25;
}
//比大小方法
public static boolean bigger(int a,int b){
return a>b;
}
//return在方法中表示方法结束
//方法重载
public static boolean bigger(double a,double b) {
if (a-b<0){
return false;
}else{
return true;
}
}
可以看到我创建了两个同名方法，但是参数类型却是不同的。这便是方法重载
当我的代码参数输入为两个 double 时，方法会自动选择到 double 的比大小
当我输入两个int时，方法会自动选择到int比大小
同名不同参 ，程序执行时，会自动选择适合你输入参数的方法。
可变参数
那么如果需要三个甚至多个数之间比大小，而方法add只写了两个参数，
这时候需要用到：可变参数
抽象的东西，还是直接上代码！
//可变参数
//多个整数加减
public static int add(int... i){
int result = 0;
int a=i.length ;
for(int x=0;x<a;x++){
result = result + i[x];
}
return result;
}
int... i 表示这里可以填写多个 int 参数
而int i ，也就是可变参数，实际存储形式为数组(后面会讲)，这时候想要把所有数加到一起，就需要用for循环遍历一下数组。
不懂也没关系，知道可变参数怎么写，什么意义即可
(不可能看不懂的吧！不可能的吧？)
值传递与引用传递
[整理中]
数组
又是一个稍微重头戏的内容！
加油，米娜桑
面向对象
…
总结
…
