JavaSE基础学习

Java SE

一、Java SE 基础

1.变量

变量就是内存中的存储空间，空间中存储着经常发生改变的数据
定义格式：数据类型变量名 = 数据值；
int salary = 10000
使用：根据变量名进行使用

注意事项

变量在作用域范围内才可以使用
变量名不允许重复定义
一条语句可以定义多个变量
变量在使用之前一定要进行赋值

2.标识符

* 作用：给类、变量、方法等取名字的符号单词* 命名规则：可以由数字、字母、下划线(_)和美元符($)其中一种或多种组成不能以数字开头不能是关键字或特殊直接量（true，flase，null）
*      区分大小写* 注意：不需要记忆规则，使用idea自动检查即可

3.基本数据类型的分类和使用

整数型

byte：1个字节，范围-128~127
short：2个字节
int：4个字节
long：8个字节

浮点型：
- ```
float：4个字节
double：8个字节
```
字符型
- ```
char：2个字节
```

布尔型

boolean：1个字节，就两个值true和false

4.switch语句

1.格式
2.switch语句的case穿透现象
- 注意：在switch语句中，如果case控制的语句体后面不写break，将会出现穿透现象
- 现象：当case 开始穿透，后续的case就不会具有匹配效果，内部的语句都会执行，知道看见break,或者将整体switch语句执行完毕，才会结束。
- 应用场景：当发现switch语句中，多个case给出的语句出现了重复的，就可以考虑使用case穿透来优化代码

5.String

1.API:应用程序编程接口（Application Programming Interface ）
- Java API:指的就是JDK中提供的各种功能的Java类

Java概述

Java语言背景介绍

问题：
1.什么是计算机语言，学习它有什么作用？
2.java语言的创始人是谁，在哪一年发布的呢？
3.java目前分为几个平台版本，我们学习的是哪些版本？
4.JavaEE主要是用于什么方向的开发？
Java语言介绍
- 语言：人与人交流沟通的表达方式
- 计算机语言：人与计算机沟通交流的一种特殊语言
- Java语言是Sun公司（Stanford University Network）在1995年推出，1996年发布第一版开发工具包jdk1.0
- Java之父：詹姆斯·高斯林
Java语言的三个版本
- JavaSE：Java语言的标准版
  - JavaSE主要用于桌面应用的开发，是其他两个版本的基础
  - 桌面应用：用户只要打开程序，程序的界面会让用户在最短的时间内找到他们需要的功能，同时主动带领用户完成他们的工作并得到最好的体验
- JavaME：Java语言的小型版，用于嵌入式消费类电子设备
  - 已经被Android和ios取代，不是我们学习的重点
- JavaEE：Java语言的企业版，用于Web方向的网站开发
  - 网页、网站和服务器
    - 网页：通过浏览器将数据展示在用户面前，跟后台服务器没有交互
    - 网站：通过跟后台服务器的交互，将查询到的真实数据再通过网页展示出来
  - 简单理解：网站=网页+后台服务器
Java跨平台原理

问题：
1.对于跨平台，这个平台指的是什么呢？
2.java程序是如何做到能够在不同的操作系统上运行的呢？
3.不同平台上的JVM虚拟机是一样的吗？

平台与跨平台
- 平台：不同的操作系统，比如：Windows、Mac、Linux…
- 跨平台：java程序可以在任意的操作系统上运行
跨平台的原理
- Java程序本身不能在不同的系统上直接运行，但是可以每个系统安装一个匹配系统的JVM
- JVM将Java程序翻译成对应系统可以看懂并且执行的程序
总结：要想跨平台运行java程序，只需要在不同的操作系统中，安装一个与操作系统对应的Java虚拟机（JVM）即可
注意：Java虚拟机本身不允许跨平台，允许跨平台的是Java程序

JRE和JDK

问题：
1.开发一个java程序的三个步骤是什么？
2.什么是java类，有什么作用？
3.在JRE中提供核心类库，有什么意义呢？
4.JVM、JRE、JDK之间具有什么关系？

JRE：Java Runtime Environment，java运行环境，包含JVM虚拟机及Java核心类库，是java语法能够被使用的前提
- 类：java文件在代码中的集合体现（类=java文件/一个java文件/一个java类）
- 类库：存放多个java文件的仓库
- 核心类库：java已经写好的，非常核心的代码仓库。常用‘’词典“
- 核心理解：编写代码的过程中，需要用到java存放在JRE中，已经写好的java文件
JDK：Java Development Kit，java软件开发工具包，内部包含了代码的编译工具（javac.exe）和运行工具(java.exe)
- JDK=JRE+开发工具
- JRE=JVM+核心类库
开发Java程序的三个步骤
1. 编写源代码
  1. 创建文本文件
  2. 修改文件后缀名为.java
  3. 在文件中按照java的语法格式书写代码
2. 编译源代码
  - 写好的Java源文件不能直接被JVM识别和执行。需要用JDK中提供的翻译工具（javac.exe）将其翻译成字节码文件（.class文件），这个过程就是编译
3. 运行程序：利用JDK提供的运行工具（java.exe）运行字节码文件
课后练习
- 下列关于JDK、JRE、JVM关系描述正确的是（）
  - A： JDK是开发工具，JRE是运行环境，JVM是虚拟机。三者没有关联
  - B： JDK是运行环境，包含了JRE。JRE是开发工具，包含了JVM。JVM是虚拟机，保证了跨平台
  - C： JDK是开发工具，包含了JRE。JRE是运行环境，包含了JVM。JVM是虚拟机，可以保证跨平台
  - D： JRE是虚拟机，保证了跨平台。JVM是运行环境，包含了JRE。JDK是开发工具，包含了JVM

JDK的下载和安装

问题：
1.安装jdk，能否安装在中文路径的文件夹下？
2.jdk的版本这么多，我们基础班学习，选择使用哪个版本？
3.怎么判断jdk已经安装成功了？
4.jdk根目录下的bin目录中主要是存放什么文件的？
Java语言的发展史
1. 95年推出，96年发布第一个开发工具包jdk1.0
2. 2009年被Oracle收购
3. 其余版本，都是功能测试版，半年到一年更新一次
4. 基础班使用版本：14，因为有一些新特性，可以了解一下。
5. 目前官方发布的，正在用于开发的大版本有8、11，也叫LTS版本，就是长期维护的版本
6. 比如9、10、12、13、14、15、16都是维护半年的功能测试版
7. 下一个大版本官方预计今年9月份之后
JDK的下载和安装
- 下载
  1. 直接访问：https://www.oracle.com/java/
  2. 找到download java按钮，鼠标点击，进入下载页
  3. 然后就可以选择版本进行安装，一般只会展示最新版和稳定版
  4. 注意：下载之前需要注册Oracle账号，用邮箱注册即可
- 安装（电脑可以安装不同版本的jdk，但是如果安装都是同一个版本，会把之前的卸载）
  1. 双击jdk文件进行安装；
  2. 在选择安装路径的环节，选择英文路径下进行安装，不要安装在带有中文的路径下；
  3. 建议所有和开发相关的软件都安装在统一的路径下，建议在D盘下创建一个develop文件夹统一进行管理
JDK的安装目录（根目录介绍）

第一个程序

常用DOS命令

问题：
1.打开DOS命令提示符操作窗口的步骤是什么？
2.常用的DOS命令有哪些，分别具有什么功能？
3.如何快速的进入某个文件所在目录的对应DOS环境中？

学习DOS命令意义
- 为了能够使用JDK中bin目录下的java.exe和javac.exe这两个工具
- 未来学习使用Linux系统，需要提前适应命令行操作界面风格
打开DOS的方式想·
1. 按下 win+r 键，弹出运行窗口
- 在窗口中输入cmd
- 点击确定
常用DOS命令
命令补充

命令说明
mkdir 文件夹名创建一个文件夹
rmdir [/s] 文件夹名删除一个[非空]文件夹
del 文件名删除文件
cd.>要新建的文件名创建一个空白文件
rename 要重命名的文件名重命名之后的文件名修改一个文件的文件名
move 被移动的文件要移动到的位置[\移动后的文件名] 剪切一个文件到指定路径下，也可以更改剪切后的文件名
copy 被复制的文件要复制到的位置[\复制后的文件名] 复制一个文件到指定路径下，也可以更改复制后的文件名
快速进入bin目录所在的DOS命令提示符

找到jdk的bin文件夹，进入
在文件夹上方的地址栏输入cmd，回车即可

DOS命令练习
- 在桌面创建一个文件夹dos-test
- 进入dos-test文件夹
- 创建一个dos.txt文件
- 自己选择一个非C盘的路径，创建一个文件夹dos-copy
- 将dos-test中的文件复制到dos-copy中
- 回到桌面，删除dos-test文件夹
- 退回C盘根路径
- 清除屏幕
- 退出

Path环境变量的配置

问题：
1.安装jdk之后，为什么要配置Path环境变量？
2.配置环境变量时，变量JAVA_HOME的值是什么？
3.Path变量的配置，是在用户变量中还是在系统变量中？
4.如何校验jdk的path环境变量是否配置成功？
配置Path环境变量的意义
可以在任意目录下，都能访问到bin目录中的javac和java工具
Path环境变量的配置

找到桌面上计算机图标，鼠标右击，选择属性
找到高级系统设置，一般在左上方
选择高级、环境变量
在系统变量中新建一个变量
变量名是：JAVA_HOME，变量值是jdk的根目录地址，点击确定
再到系统变量框里找到path变量，编辑它
在path变量的编辑框中，点击新建，然后输入：%JAVA_HOME%\bin
需要注意的是，如果path变量框是上面的样式，是不需要加分号结束的
但如果是下方的样式，那么输入%JAVA_HOME%\bin;是需要带分号结束
设置好之后，需要一直点击确定结束
验证path环境变量是否配置成功，需要重新打开一个dos命令行窗口界面验证，不能使用原有的窗口
在dos命令行窗口分别输入java -version，java，javac三个命令验证

HelloWorld案例详解

问题：
1.书写Java代码时，class这个单词是用来干什么的？
2.一个Java程序能不能没有main主方法？
3.代码System.out.println(“学习Java的人不是帅哥，就是美女！”);的作用是什么？
4.class前面的public这个单词，有什么作用？
一个java程序，有且仅有一个main方法，属于固定写法
- 一个java程序可以有很多个类，所以类是java程序的最基本组成单位
- 如果Java程序有很多个类，运行这个程序，从有main方法的类中开始
类名必须和文件名保持一致，因为类名前面有public修饰
HelloWorld程序说明：

java在基础班没有丰富的视觉界面显示，只能通过控制台这种简单的界面去呈现内容。你现在打印的这个内容，以后真正的显式地方，是网页上
基础班暂时不学习网页内容，这个要到就业班才会学习

IDEA的安装和使用

IDEA的概述和安装
概述
IDEA全程是IntelliJ IDEA，是用于Java语言开发的集成环境，它是业界公认的目前用于Java程序开发最好的工具。
集成环境：把代码编写、编译、运行、调试等多种功能综合到一起的开发工具
下载和安装
下载：https://www.jetbrains.com/idea/download/other.html
安装：双击下一步即可，注意不要安装在中文路径下
IDEA中的项目结构
Idea项目结构介绍
1. project：项目、工程
2. module：模块
3. package：包
4. class：类
小结
- project中可以创建多个module
- module中可以创建多个package
- package中可以创建多个class
- 这样的结构划分，是为了方便管理类文件的
  - 如果不用这些层级去管理类文件，全部放在同一个文件夹中，以后的项目有大量java类文件，不容易找
  - 同一个文件夹下不能出现同名的java类，这样给类取名字就很麻烦了
  - java类文件不做分类管理，就好比沃尔玛的商品不做分类，堆在一块
IDEA中的第一个代码

操作步骤（2021版）：

创建Project（项目）
创建Module（模块）

project创建好之后，会自动弹出创建module的窗口

如果不通过自动弹出的创建module窗口创建，也可以在project的界面中操作

配置Module

创建Package（包）
创建class（类）
编写代码，运行程序
IDEA常用快捷键

//psvm: 一键生成主方法
//sout: 生成输出语句
//ctrl+alt+L: 格式化代码
//alt+Enter: 代码修正提示

//ctrl+/: 添加(取消)单行注释
//ctrl+shift+/ : 添加(取消)多行注释

//ctrl+D : 复制当前行的代码
//ctrl+X : 剪切
//ctrl+V : 粘贴

//alt+1: 打开/隐藏项目结构
//alt+4: 打开/隐藏控制台

//fori ： 10次的for循环
IDEA操作模块
删除模块
导入模块

直接通过project界面导入已存在的module

通过Project structure设置导入module

最后就是一直选择next下一步即可

IDEA打开、关闭项目-类名、包名修改
关闭项目
打开项目

如果列表中要打开的项目已被移除：

修改类名
修改包名

基础语法

注释

问题：
1.什么是注释，程序当中的注释有什么作用？
2.java中注释分为几类，分别是什么？
3.注释会不会影响程序的编译和运行？

注释的概述
- 在程序指定位置添加的说明性信息
- 对代码进行解释说明，方便我们程序员更好的去阅读代码。
注释的分类
1. 单行注释
  格式：// 注释信息只有一行，并且在双斜线后面
2. 多行注释
  格式：/ 注释信息可以有很多行，位置被包裹住 /
3. 文档注释（目前用不上，暂不讲解）
  格式：/* 注释信息 /
//练习：给HelloWorld程序添加注释
//这是一个类，类的名字叫A
public class A{
/*
这是程序的主方法，一个java程序有且仅有一个main方法。
*/
public static void main(String[] args){
//这是一个在控制台打印输出内容的语句，小括号中是输出的内容。
//在控制台输出自己的姓名、对喜欢的人想说的话
System.out.println(“好棒哦，notepad真给力”);
}
}

基础语法

关键字

问题：
1.java中的“关键字”是什么？
2.Java中的“关键字”有哪些特点？
3.main方法中的名字“main”是不是关键字？

概念：被java赋予了特定涵义的英文单词
特点：
- 关键字的字母全部都是小写
- 常用的代码编辑器，针对关键字有特殊的颜色标记，非常直观
- main不是关键字，但是也很关键
java中有48个关键字，和2个保留关键字

字面量

问题：
1.Java中的字面量有哪几种类型？
2.'10’这个数据在Java中属于字符字面量吗？
3.能不能使用打印语句去打印空字面量？
字面量的分类：
- 字符串字面量：被双引号所包裹的内容
- 整数字面量：所有整数
- 小数字面量：所有小数
- 字符字面量：被单引号包裹的内容，里面只能存放单个字符。字符是字符串的组成部分。
- 布尔、字面量：只有两个值，分别是true和false，分别代表真和假、成立和不成立这种对立的意思（以后学习运算符和流程结构时需要用到）
- 空字面量：null。代表不存在的，空的。不能被输出打印。
变量

3.1 变量概述

概念：在程序运行期间，其值可以发生改变的量。
理解：变量就是内存中的存储空间，空间中存储着经常发生改变的数据
定义格式
变量的使用（变量名进行使用）

//练习
//定义一个int类型的变量，并且赋值为18

//使用变量，将变量中的数据打印出来

//再次给变量赋值，替换之前的数据

//再次打印该变量
内存图变化

第一步：
第二步：

3.2 变量的注意事项

变量的作用域：
- 从变量声明的那一行开始，到它所在的大括号结束的区域有效
注意事项：
- 在变量的作用域内，变量名不允许重复定义
- 一条语句可以定义多个变量，但需要用逗号进行分割
- 变量在使用前一定要进行赋值

数据类型

问题：
1.Java中的数据类型有几种？
2.Java中数据类型的转换方式有几种？

4.1 类型分类

Java的数据类型
- 基本数据类型（4类8种）
- 引用数据类型（类、接口、数组，比如String）
基本数据类型分类
案例

//练习：在下面输出语句的后面添加注释，标明打印内容分别属于什么数据类型
System.out.println(‘1’);//
System.out.println(520);//
System.out.println(3.14);//
System.out.println(0.618F);//
System.out.println(5201314L);//
System.out.println(false);//

4.2 类型转换

隐式转换

概念：将数据类型中取值范围小的数值或变量，给取值范围大的类型赋值。直接赋值。

int xiao=10;
//int的取值范围比double小，所以可以给double类型直接赋值
double da=xiao;
//总结：小的给大的，天经地义
1.总结：
//举例：200ml的可乐导入1L的瓶子，直接倒水，不会‘溢出’。所谓的数据类型转换就是不同类型的杯子中装水，怎么装更合适。
2.举例：
数据类型范围从小到大排序

隐式转换的细节
- 不同数据类型进行运算，小的数据类型会提升为大的之后，再参与运算
  //买早餐案例
  //买包子，2元，int类型收
  int baoZi = 2;
  //买了个鸡蛋，1.5元，double类型接收
  double egg = 1.5;
  //小类型的baoZi和大类型的鸡蛋相加，包子提升成double类型参与运算：double+double
  double zaoCan=baoZi+egg;
- 特殊关注：byte、short、char（比int类型范围小的）三种数据进行运算的时候，不管是否有更高的数据类型，都会提升为int，再参与运算
//案例1：byte+short
byte b=10;
short s=29;
//分析：byte+short -> int +int -> int
int num1=m+s;

//自案例
//案例2：byte+char
char c=‘a’;
//分析：byte+char -> int+int -> int
int num2=b+c;
//案例3：byte+short+double
double d=3.14;
//分析：byte+short+double -> int+int+double -> double+double+double -> double
double num3=b+s+d;

强制转换

概念：把一个表示数据范围大的数值或变量赋值给另一个表示数据范围小的变量
格式：目标数据类型变量名 = (目标数据类型) 值或变量;

//案例1：
int a=10;
//byte b=a; //编译报错：错误，不兼容的类型，从int转换到byte可能会有损失（精度损失）
//利用强转格式解决
byte b=(byte)a;
精度损失

//案例1：浮点数强转成整数
//给定一个变量为double类型
double d=520.1314;
//给定一个变量为int类型，比double类型范围小，强制数据类型转换
int i=(int)d;
System.out.println(a);//结果：520
//思考：是否遵循四舍五入？
//double类型变量重新复制
d=0.618;
//再次强转
i=(int)d;
System.out.println(a);//结果：0
//结论：小数强转成整数，会直接舍掉小数部分

//案例2：大整数强转成小数
//给定一个变量为int类型
int num1=520;
//强转byte类型，注意byte取值范围：-128~127
byte num2=(byte)num1;
System.out.println(num2);//结果：8
//思考：byte类型最大值为127，为什么结果是8？
精度损失的原因

标识符

问题：
1.什么是标识符，有什么作用？
2.标识符的定义规则是什么？
3.标识符常见的命名规定有哪些？
概述：给类、变量、方法等起名字的符号
硬性规则（必须得遵守，不遵守，程序就报错）：
1. 由数字、字母、下划线（_）和美元符（$）其中一种或多种组成（也可以由汉字、π组成）；
2. 不能以数字开头；
3. 不能和关键字相同；
4. 区分大小写
//合法标识符
age
L_ni3
$get

//非法标识符
7shang8xia //不能以数字开头
&abc //&不属于标识符的组成
class //不能是关键字
常见命名规定（软性规则）
- 小驼峰命名法：给变量、方法命名
  - 标识符是一个单词的时候，首字母小写。比如：name
  - 标识符由多个单词组成，首个单词全部小写，其余单词首字母大写。比如：firstName
- 大驼峰命名法：给类命名
  - 标识符不管多少个单词，每个单词首字母大写，比如：HelloWorld
//练习1：以下哪些变量的命名是符合标识符规则的？在注释后面标注
String name=“张三”;//
int age=17;//
int do=23;//
double π=3.14;//
char dollar=′dollar='dollar=′';//
char 86RMB=‘￥’;//

//练习2：使用大驼峰或小驼峰式进行命名
//2.1 定义一个类名，该类用来表示一个学生

//2.2 定义一个变量名，用来代表人的年龄

//2.3 定义一个变量名，用来代表学生的学号

//2.4 定义一个类名，用来代表第一个变量练习的类
键盘录入

学习键盘录入的目的：
- 可以在程序运行后，将键盘录入的数据获取到程序中操作
实现键盘录入的步骤：
- 导包：需要在class的上面写
  - import java.util.Scanner;
- 创建Scanner对象，只有sc可以变，其他是固定格式
  - Scanner sc=new Scanner(System.in);
- 使用变量接收键盘录入的数据，变量名num可以变，其他固定格式
  - int num = sc.nextInt();
- 使用键盘录入的数据，这里是打印数据
  - System.out.println(num);
  //练习：利用键盘录入，在控制台录入自己的座右铭，并打印

运算符

运算符和表达式
- 概念
  - 运算符：对常量或者变量进行操作的符号
  - 表达式：用运算符把常量或变量连接起来符合java语法的式子就可以称之为表达式
案例

int a=10;
int b=20;
int c=a+b;
// + 是算数运算符，a+b 是表达式，也叫算术表达式。

算数运算符

种类
案例

//案例1：+、-、*
int a=2;
int b=3;
// + 运算
int num1=a+b;
// - 运算
int num2=a-b;
// * 运算
int num3=a*b;
System.out.println(num1);
System.out.println(num2);
System.out.println(num3);

//案例2：/
//整数除法
System.out.println(10/2);//结果：5
System.out.println(10/3);//结果：3
//分析：10/3 -> int/int -> int。所以小数部分直接省去。
//要得到小数，表达式中得有小数
System.out.println(10.0/3);
System.out.println(10/3.0);

//案例3：%
//求10除以3的余数： 10 / 3 = 3 ······ 1
System.out.println(10%3);//结果：1

//案例4：混合运算
int a=2;
byte b=3;
char c=‘a’;
System.out.println(c+a*b);
//类型分析：char+int+byte -> int+int+int -> int
//顺序分析：先乘后减
//结果：字符怎么加！！！提升成int是多少呀？
//试着编译：不报错！

字符的+操作

ASCII码表：美国信息交换标准代码
- 是计算机中，字节到字符的一套对应关系。
- 在码表中，每一个字符都有一个与之对应的数字。
为什么要有码表呀？

计算机底层所有的数据都是二进制数字，字符也不例外。我们使用电脑能看到的文字都是一个个的字符组成的。那这些字符应该用哪些二进制数字表示呢？如果每个国家都不一样，数据在互联网上就很难在国际上流通了。

所以老美就搞了这么一个标准，大家都共同遵守。

常用的字符码表对照
运算过程
- char类型在参与数学运算的时候，先查找码表中对应的数字，再参与运算
  
  char c=‘a’;
  System.out.println(c+1); //结果：98

字符串的+操作

概述：字符串的“+”操作不是算数运算，而是字符串拼接运算。
特点：在“+”操作的时候，如果出现了字符串，“+”就是连接运算符。当连续进行“+”操作时，从左往右逐个进行。

//案例1：
//做一行爱一行
System.out.println(“Java”+520+1314);
//挑几个我喜欢的数字，我喜欢高一点的女孩子，175…
System.out.println(175+120+66+103+56+“Hello”);

案例：数值拆分

需求：键盘录入一个三位数，将其拆分为个位、十位、百位后，打印在控制台
思路：
- 使用Scanner键盘录入一个三位数；
- 计算个位数：数值 % 10。比如123的个位数是3，123 % 10的结果就是3；
- 计算十位数：数值 / 10 % 10。比如123的十位数是2，123 / 10得12，12 % 10的结果就是2；
- 计算百位数：数值 / 100。比如123的百位数是1，123 / 100得1。
公式：
- 个位数：数值 / 10的0次方 % 10；
- 十位数：数值 / 10的1次方 % 10；
- 百位数：数值 / 10的2次方 % 10；
- 千位数：数值 / 10的3次方 % 10；
- …
  
  //需求：键盘录入一个三位数，将其拆分为个位、十位、百位后，打印在控制台
  //1. 使用Scanner键盘录入一个三位数
  //1.1 导入Scanner包：import java.util.Scanner;
  import java.util.Scanner;
  public class Test{
  public static void main(String[] args){
  //1.2 创建Scanner对象
  Scanner sc = new Scanner(System.in);
  //1.3 提示用户键盘录入
  System.out.println(“亲，请输入一个三位数哦：”);
  //1.4 键盘录入数字
  int num = sc.nextInt();
  //2. 计算个位数：数值 % 10
  int ge = num % 10;
  //3. 计算十位数：数值 / 10 % 10
  int shi = num / 10 % 10;
  //4. 计算百位数：数值 / 100
  int bai = num / 100;
  //5. 假设输入的数字是520，打印内容：整数520的个位为：0，十位为2，百位为：5
  //5.1 分析：字符串拼接操作
  System.out.println(“整数” + num + “的个位为：” + ge + “，十位为” + shi + “，百位为：” + bai);
  }
  }

自增自减运算符

大家都玩微信吧？如果有朋友给你发消息，如果你没看，每发一条消息，红点的消息记录就多一条。说明微信有个程序一直再计数，每次增加1。

System.out.println("女神：在吗？我有事跟你说");
//定义一个int类型的变量记录未读消息数
int count = 1;
System.out.println("---您有" + count + "条未读消息---");System.out.println("女神：我怀孕了");
count = count + 1;
System.out.println("---您有" + count + "条未读消息---");System.out.println("女神：可能不是你的，但我还是爱你的");
count = count + 1;
System.out.println("---您有" + count + "条未读消息---");System.out.println("女神：我想和你结婚，尽快");
System.out.println("开启了好友人认证，你还不是他的好友。请先发送好友申请...");
//问题：每次count都得加1再赋值给自己，特别麻烦，有没有更简单的方法呢？利用java的自增运算符就可以简化

介绍

注意事项：

可以放在变量的前面，也可以放在变量的后面
如果是单独给变量使用，放前放后都一样（常用操作）
如果参与运算
- 在前：先对变量进行自增或自减，再拿变量的值参与操作
- 在后：先拿变量原本的值参与运算，然后变量自己再进行自增或自减。变化后的变量值不参与运算
只能操作变量，不能操作常量

案例演示
//案例1：单独使用
int count=0;
//在前
++count;
System.out.println(count);//结果：1
count++;
System.out.println(count);//结果：2
//无区别，都是自己的值加1

//案例2：参与运算
int num=1;
//在前：
int result=--num;//赋值也算参与运算
System.out.println(result);//结果：0
System.out.println(num);//结果：0
//在后：
result=num--;
System.out.println(result);//结果：0
System.out.println(num);//结果：-1//操作常量
++520//编译报错
520--//编译报错

总结

自增自减最后都要给自己加1或者减1，然后会给自己赋值。当然这个赋值运算省略了。说道到赋值，在java中我们已经知道了=是赋值运算符，那除了=之外，还有没有其他的赋值运算符呢？这里可以告诉大家，还有5种赋值运算符。

赋值运算符

介绍
案例演示

案例1：加后赋值
int a=24;
int b=2;
a+=b;// a=a+b;
System.out.println(a);

案例2：减后赋值
a-=b;// a=a-b;
System.out.println(a);

案例3：乘后赋值
a*=b;// a=a*b;
System.out.println(a);

案例4：除后赋值
a/=b;// a=a/b;
System.out.println(a);

案例4：取余后赋值
a/=5;// a=a%5;
System.out.println(a);
注意事项：扩展的赋值运算符隐含了强制类型转换

//案例1
int a=23;
byte b=12;
b=a+b; //编译报错
//分析：int+byte -> int+int -> int。int不能直接赋值给byte
System.out.println(b);

//案例2：扩展的赋值运算符
int a=23;
byte b=12;
b+=a;//编译通过
//分析：b+=a -> b=(b的数据类型)(b+a) -> byte=(byte)(byte+int) -> byte=byte
System.out.println(b);

关系运算符

在java中，普通的赋值运算符是用=号表示，所以以后int a=23;的实际读法，应该是把23赋值给了int类型的a。话说到这，如果我不是做赋值，就是要判断相等呢？=号都被占用了，哪个符合能用作判断相等的操作呢？

介绍

   关系运算符是用来判断两个变量（常量、表达式）之间的关系，比如相等关系、不等关系和大小关系。运算结果都是布尔值，要么是true，要么是false。

代码演示

//案例1：操作变量
int a=23;
int b=12;
System.out.println(a>b);//结果：true

//案例2：操作常量
System.out.println(3<2);//结果：false

//案例3：操作变量和常量
System.out.println(a>=3);//结果：true

//案例4：操作表达式
int num1 = 5;
System.out.println(num1 * 2 + 1 != 11);//结果：false

逻辑运算符

国家开始推新冠疫苗啦，让全民接种。但是不是所有人都能打的，在年龄上有限制。规定是只给18~59岁的人群注射。

//定义一个变量，代表要接种疫苗的人，叫小明
String name="小明";
//小明今年14岁
int age=14;
//筛选，结果是true就能打，否则不能打
boolean result= 18<=age<=59; //编译报错，不允许这么写。
//如果不能一次性写，那就得写两行代码，在java中，能不能一次判断完呢？

介绍
作用：用于连接多个比较表达式的条件，得到最终的结果是个布尔值
- 其中&、|、^三种，左右两边不管是变量、常量还是表达式都可以
- 这些变量、常量、表达式最终的结果必须t布尔类型或数字
- ！的后面放布尔值，不能放其他类型
代码案例

//案例1：操作变量
//有房
boolean fang = true;
//没车
boolean che = false;
//&：左右两边都是true，结果才是true。要求高
System.out.println(fang & che);//结果：false
//|：左右两边有一个为true，结果就是true。要求低
System.out.println(fang | che);//结果：true

//案例2：操作变量和常量
System.out.println(fang & false);//结果：false
System.out.println(fang & true);//结果：true
System.out.println(che | true );//结果：true

//案例3：操作常量
System.out.println(true & false);//结果：false
System.out.println(false | true);//结果：true
// ^：左右两边的值不一样，结果才是true
System.out.println(true ^ true);//结果：false
System.out.println(false ^ true);//结果：true

//案例4：操作表达式
//今年18岁
int age = 18;
//年龄必须在18到59岁才能打疫苗
System.out.println(age >= 18 & age <= 59);//结果：true

短路逻辑运算符

介绍
与运算：
- 逻辑与：&，无论左边真假，右边都要执行
- 短路与：&&，如果左边为true，右边就执行。如果左边为false，右边不用执行
或运算：
- 逻辑或：|，无论左边真假，右边都要执行
- 短路或：||，如果左边为false，右边执行。如果左边为true，右边不执行
代码演示

//案例1：&&的短路效果
int a=3;
int b=4;
System.out.println(a>3&&++b>4);
//分析：a>2的结果是false，所以&&后面不执行。b没有做自增运算
System.out.println(“b：”+b); //结果：4

//案例2：||的短路效果
int num1=3;
int num2=4;
System.out.println(num1>2||num2–<4);
//分析：num1>2的结果是true，所以||后不执行，num2没有做自减运算
System.out.println(“num2：”+num2); //结果：4

三元运算符

格式：关系表达式 ? 表达式1:表达式2;
执行流程：
- 首先计算关系表达式的结果
- 如果结果是true，则取表达式1的结果做最终结果
- 如果结果是false，则取表达式2的结果做最终结果
代码演示

//案例1：求两个变量中的最大值
int a=28;
int b=18;
//分析：先让看a是否大于b，如果a大于b，则a是最大值，将a的值赋值给变量max，否则就是b赋值给max
int max=a>b?a:b;
System.out.println(“最大值是：”+max);

//注意事项：表达式1和表达式2最终结果的数据类型必须一致。为什么？如果不一致，三元运算符最后的要赋值的话，拿什么数据类型接收？是不是就无法确定了？

分支语句

流程控制语句-顺序结构

介绍：java代码的默认执行流程：从上到下，从左往右
代码案例

//案例
//从上往下
System.out.println(“我是黑马程序员”);
System.out.println(“我的目标是月薪过万”);
System.out.println(“前提是要努力学习，键盘敲烂”);
//从左往右
System.out.println(“高薪就业！”+“人生巅峰！”+“迎娶白富美！”);

if分支结构

2.1 第一种格式

格式

…
if(关系表达式){
语句体;
}
…

//执行流程
//1. 首先计算关系表达式的值，这个结果只能是布尔值
//2. 如果关系表达式的值为true，就执行语句体
//3. 如果关系表达式的值为false，就不执行语句体
//4. if语句结束，继续执行后面的代码内容
代码案例

//案例1：小明上网
System.out.println(“今天是周末，天气真好，小明出门玩耍”);
//定义一个int类型变量，代表小明的年龄
int age=19;
System.out.println(“看到了一间网吧，准备进去玩两把”);
System.out.println(“网管问：你成年了吗？”);
//使用if语句进行判断
if(age>=18){
System.out.println(“小明说：我成年了”);
System.out.println(“领卡、卡机、五连跪”);
}
System.out.println(“小明转身回家”);
注意事项
- 如果语句体只有1条语句，大括号可以不写（不推荐）
- if语句中小括号后面不能加分号，如果加分号，就代表if语句结束了

2.2 第二种格式

格式

…
if(关系表达式){
语句体1;
} else {
语句体2;
}
…

//执行流程
//1. 首先计算关系表达式的值，这个结果只能是布尔值
//2. 如果关系表达式的值为true，就执行语句体1
//3. 如果关系表达式的值为false，就不执行语句体2
//4. if语句结束，继续执行后面的代码内容
代码案例

//案例1：判断一个数是奇数还是偶数
//给定一个待判断的整数
int num=23;
//开始进行判断
//寻找奇数的规律，偶数可以被2整除，意味着偶数对2取余数的结果是0，这个就可以作为判断的条件
if(num % 2==0){
System.out.println(“偶数”);
}else{
System.out.println(“奇数”);
}

//案例2：判断两个数谁是最大值
int num1=5;
int num2=3;
//三元运算的方式
int max= num1>num2?num1:num2;
//利用if-else完成
//谁最大，需要判断num1是否大于num2，这就可以作为一个条件
if(num1>num2){
System.out.println(“最大数是：”+num1);
}else{
System.out.println(“最大数是：”+num2);
}

2.3 第三种格式

格式

…
if(关系表达式1){
语句体1;
} else if(关系表达式2) {
语句体2;
} else if
…
} else {
语句体n+1;
}
…

//执行流程
//1. 首先计算关系表达式1的值，这个结果只能是布尔值
//2. 如果关系表达式1的值为false，就执行关系表达式2
//3. 如果关系表达式2的值为false，就执行关系表达式3
//4. …
//5. 有任何关系表达式的值为true，就执行对应的语句体
//6. 如果没有任何关系表达式的值为true，就执行语句体n+1
代码案例

/**
- 案例1：根据学生成绩，程序给出对应的评价
- 90~100：优秀
- 80~89：良好
- 70~79：中等
- 60~69：及格
- 0~59：请努力！
  */
  //定义一个变量接收成绩
  int score=89;
  //需求中有5种条件，每种对应一个评价。刚好和if-else if的结构匹配
  if (score >= 90 && score <= 100) {
  System.out.println(“优秀”);
  } else if (score >= 80 && score <= 89) {
  System.out.println(“良好”);
  } else if (score >= 70 && score <= 79) {
  System.out.println(“中等”);
  } else if (score >= 60 && score <= 69) {
  System.out.println(“及格”);
  } else {
  System.out.println(“请努力加油！”);
  }

2.4 案例：考试奖励

//需求：键盘录入学生考试成绩，根据成绩，程序给出不同的奖励//思路：
//1. 考试成绩未知，需要用键盘录入，拿到考试成绩
//1.1 导入Scanner包，在代码的最上方第一行
import java.util.Scanner;//1.2 创建Scanner对象
Scanner sc=new Scanner(System.in);
//1.3 提示用户键盘录入成绩
int score=sc.nextInt();//2. 判断录入的学生成绩是否在合法范围之内
if(score>=0&&score<=100){//合法成绩//3. 在合法的if块中，判断成绩范围if(score>=95&&score<=100){//4. 为每种判断设置对应的奖励System.out.println("奖励自行车一辆");} else if(score>=90&&score<=94){System.out.println("奖励游乐场玩一次");} else if(score>=80&&score<=89){System.out.println("奖励变形金刚一个");} else {System.out.println("挨顿揍，这个城市又多了一个伤心的人");}
//注意，下面这个else是外层判断输入成绩是否合法对应if结构，不是内层的。
}else{//非法成绩System.out.println("您输入的成绩有误");
}

switch分支结构

3.1 格式和执行流程

格式

switch(表达式){
case 值1:
语句体1;
break;
case 值2:
语句体2;
break;
…
case 值n:
语句体n;
break;
default:
语句体n+1;
break;
}
/**
- 格式说明：
- 表达式：可以取值为byte、short、int、char,JDK5以后可以是枚举，JDK7以后可以是String；
- case：后面跟的值，是要和表达式进行匹配的值。如果匹配的结果是一样的，就执行对应语句体；
- break：表示中断、结束的意思，用来结束switch语句；
- default：表示所有的情况都不匹配的时候，就执行该处语句体的内容，和if语句的else相似。
  */
/**
- 执行流程：
- 1.首先计算表达式的值；
- 2.依次和case后面的值进行比较，如果有对应值的话，就会执行相应语句，在执行的过程中，遇到break就会结
- 束，其他语句体不会再执行；
- 3.如果所有的case后面的值和表达式的值都不匹配，就会执行default里面的语句体，然后程序结束掉
  */
注意事项
- case给出的值不允许重复
  case后面的
- 值只是常量，不能是变量

3.2 case穿透

注意：在switch语句中，如果case控制的语句体后面不写break，将出现穿透现象；
现象：当开始出现case穿透，后续的case就不会具有匹配效果，内部的语句不会结束，继续向下执行。直到看到break，或者将整个switch语句执行完毕，switch才会结束
应用：当发现switch语句中，多个case给出的语句体出现重复的时候，就可以考虑使用case穿透来优化代码

//案例：键盘录入1_{12，代表当前月份。其中3}5是春季，6_{8是夏季，9}11是秋季，12~2是冬季。
//1.使用Scanner键盘录入
//1.1 导包
import java.util.Scanner;
public class Test03 {
public static void main(String[] args) {
//1.2 创建Scanner对象
Scanner sc = new Scanner(System.in);
//1.3 提示用户键盘录入，防止程序要开始录入的时候，用户不知道
System.out.println(“请输入当前月份”);
//1.4 开始键盘录入选择，并用int类型的变量season接收键盘录入的数字值
int season = sc.nextInt();
//2.根据录入的数字值，匹配不同的月份
switch (choice) {
case 3:
case 4:
case 5:
System.out.println(“春天到了，这是个万物复苏的季节”);
break;
case 6:
case 7:
case 8:
System.out.println(“夏天热情似火，路边的小姐姐都很好看”);
break;
case 9:
case 10:
case 11:
System.out.println(“秋天收获劳动的过时，大地的馈赠”);
break;
case 12:
case 1:
case 2:
System.out.println(“冬天里寒风凛凛，小姐姐的身材看不到了”);
break;
default:
System.out.println(“您输入的月份有问题哦！”);
break;
}
}
}

循环语句

循环：重复做某件事情，具有明确的开始和停止标记

for循环

1.1 格式和执行流程

格式

for(初始化语句;条件判断语句;条件控制语句){
循环体语句;
}
//执行流程
//1.执行初始化语句
//2.执行条件判断语句，看起结果是true还是false。
//3.如果是false，循环结束
//4.如果是true，继续执行循环体语句
//5.循环体语句执行结束，执行条件控制语句
//6.回到第二步继续
代码演示

1.2 案例：输出数据1_5和51

思路分析：
- 打印1~5：
- 打印5~1：
代码演示

//打印1~5
//打印的动作是重复的，所以必须把输出语句放到循环内部
//重复5次，并且是从1开始打印，那么就要控制变量在1，2，3，4，5都能取到
for(int i=1;i<=5;i++){
System.out.println(i);
}
//打印5~1
//同上，只是打印从5开始，变量的值取5，4，3，2，1，依次递减
for(int i=5;i>=1;i–){
System.out.println(i);
}

//思考：如何只利用一个循环解决？
//分析：总共循环打印10次，可以先让变量取到1~10
for(int i=1;i<=10;i++){
//如果仅仅是直接打印i的值，则无法打印5_{1，打印的是6}10
//System.out.println(i);
//所以不能直接打印i，必须加条件限制，只有当i<=5的时候可以直接打印
if(i<=5&&i>=1){
System.out.println(i);
}
//如果只有上面的条件限制，则无法阻挡6_{10的打印，思考6}10和5~1之间的关系
//11-6=5，11-7=4，11-8=3，11-9=2，11-10=1
//找到规律，可以开始判断条件，当i取6~10的时候如此操作
if(i<=10&&i>=6){
System.out.println(11-i);
}
}

1.3 案例：求1~5数据和

思路分析
代码演示

//定义一个int类型的变量，专门用来接收求和的值，一开始没有任何值，所以是0
int sum=0;
//因为是求1_{5的和，所以要保证能取到1}5这几个数字，并且求和的话是加了5次，所以循环也能控制成5次
for(int i=1;i<=5;i++){
//每次相加，都是拿累计好的值加新取到的1~5的值，累计值是由sum表示，所以是拿sum和i相加
//sum+i;
//加完之后，累计值要改变，所以还得赋值回给sum
//sum=sum+i;
//这种自己加某个值再赋值给自己的操作，可以使用扩展赋值运算符搞定
sum+=i;
}
//循环结束，可以确定i的每个值都取到了，并且加过了，这个时候的sum已经是最后的结果
System.out.println(“1-5之间的数据和是：”+sum);

1.4 案例：求1~100偶数和

思路分析
代码演示

//分析：要取到1~100的值，数字有100个，那么得循环100次
//定义一个变量，做累计相加的值的容器
int sum=0;
for(int i=1;i<=100;i++){
//这100个数字，不是所有数字都是偶数，什么样的数字才能被称为偶数？一个数被2整除，没有余数就是偶数
if(i%2==0){
//满足条件的i才会进来，此时i就是偶数，利用上一个案例的知识，可以在此处累计相加
sum+=i;
}
}
//循环结束，就可以打印sum的值
System.out.println(“1-100之间的偶数和是：”+sum);

1.5 案例：水仙花数

水仙花数
思路分析
代码演示

//1. 通过循环能获得100~999这所有的数
for(int i=100;i<=999;i++){
//针对当前i的值，i一定是三位数，所以要拆分成个位、十位、百位
//2.分别定义变量代表个位、十位、百位
int ge=i%10;
int shi=i/10%10;
int bai=i/100;
//3.水仙花数的条件就是：个位数的三次方+十位数的三次方+百位数的三次方等于原来的数
if(gegege+shishishi+baibaibai==i){
//4.满足条件的数就是水仙花数，可以打印
System.out.println(“水仙花数：”+i);
}
}

1.6 案例：每行打印2个水仙花数（统计）

需求分析
代码实现

//1. 通过循环能获得100~999这所有的数
//2. 定义一个变量，记录打印了多少个数，定义的时候还一个都没有打印，所以初始值是0
int count=0;
for(int i=100;i<=999;i++){
//针对当前i的值，i一定是三位数，所以要拆分成个位、十位、百位
//3.分别定义变量代表个位、十位、百位
int ge=i%10; 521-------1
int shi=i/10%10; 521—52—2
int bai=i/100; 521------5
//4.水仙花数的条件就是：个位数的三次方+十位数的三次方+百位数的三次方等于原来的数
if(gegege+shishishi+baibaibaii){
//5.满足条件的数就是水仙花数，打印的时候注意，第一不要换行，第二要留一个空格隔开
System.out.print(i+" ");
//6.每打印一个数字，count的值就得记录1次，值要加1
count++;
//7.此时就应该马上判断打印了多少个数字，如果是偶数，马上就要开始换行了
//8.判断一个数是否是偶数，只需要对2取余数是0就可以了
if(count%20){
//9.仅仅换行，不打印
System.out.println();
}
}
}

while循环语句

2.1 格式和执行流程

格式

//基本格式
while(条件判断语句){
循环体语句;
}

//完整格式
初始化语句;
while(条件判断语句){
循环体语句;
条件控制语句;
}

//执行流程
//1.执行初始化语句；
//2.执行条件判断语句，看结果是true还是false
//3.如果是false，循环结束。如果是true，则继续执行循环体语句
//4.执行条件控制语句
//5.若循环内部没有使用特殊关键字结束循环，则回到第2步继续
代码案例

//案例：打印999次“我爱你的第X天”
//1.有记录次数，并且循环的次数和记录的次数相关，所以初始化语句就可以定义一个int类型的变量
int count=1;
//2.开始循环，当count值一直小于等于999次的时候，就还可以打印
while(count<=999){
System.out.println(“我爱你的第”+count+“天”);
//每打印1次，count的次数就得加1
count++;
}
注意事项

//1.while后面的小括号后，千万不要写分号，例如
int count=1;
//1.1小括号后面马上接分号，代表没有循环体语句，后面的大括号部分就不属于while循环的范围
//1.2这就会导致count的值一直无法执行到自加操作，会一直满足count<=999，而出现程序卡死的情况
while(count<=999);
{
System.out.println(“我爱你的第”+count+“天”);
//每打印1次，count的次数就得加1
count++;
}

2.2 案例：珠穆朗玛峰

需求分析
代码实现

//1.需要求次数，那就说明每次循环需要计数一次，那就得在循环外定义一个变量去接收折叠的次数
//循环开始前，没有折叠，所以初始化值是0。注意不能放到循环内去定义变量
int count=0;
//2.要判断停止循环的条件是什么，就是纸张的厚度大于等于珠峰高度的时候
//纸张的高度是随着折叠而变化的，属于变化的量，那就定义一个变量代表纸张厚度
double paper=0.1;
//3.反复折叠属于重复操作，并且不知道折多少次，使用while循环比较合适
while(paper<=8844430){
//4.当纸张厚度小于珠峰的时候就要折叠，折叠的动作是重复的，折叠的后果是纸张厚度要乘以2
paper*=2;
//5.折叠一次，计数器要加1次
count++;
}
//通过不断的循环，paper的厚度一直增加，知道大于等于珠峰高度的时候，条件判断的结果为false，结束循环
//此时就可以打印折叠次数
System.out.println(“折叠”+count+“次，达到珠峰高度”);

do…while循环

格式

//基本格式
do{
循环体语句;
}while(条件判断语句);

//完整格式
初始化语句;
do{
循环体语句;
条件控制语句;
}while(条件判断语句);

//执行流程
//1.执行初始化语句
//2.执行循环体语句
//3.执行条件控制语句
//4.执行条件判断语句，看结果是true还是false
//5.如果是false，循环结束。如果是true，继续执行
//6.回到第2步继续
代码案例

//案例：在控制台输出3次：代码练习了X遍（X代表次数）
//定义一个变量用来记录打印的次数
int count=0;
do{
//进入循环就练习一遍代码，所以次数要加1次
count++;
System.out.println(“代码练习了”+count+“遍”);
//这里不能是<=，因为练了5次，就可以结束了，不能再循环练习
}while(count<5);
特点

do…while循环，无论条件是否满足，都会执行一次循环体语句
很少用，了解即可
三种循环的区别

三种循环的区别
- for、while循环: 必须满足条件才执行（先判断再执行）
- do…while:：不管条件是否成立，循环语句体至少执行一次（先执行再判断）
三种循环的场景
- 循环开始前，知道次数，使用for循环
- 循环开始前，不知道次数，使用while循环
- do…while一般不用
  
  //案例1：for循环外尝试使用变量
  //循环开始，可以知道循环3次
  for(int i=1;i<=3;i++){
  //for循环内部使用for循环中定义的变量，没有问题
  System.out.println(“i：”+i);
  }
  //编译报错，因为变量i是for循环中定义，只能在循环中使用，循环结束，i也从内存中消失
  System.out.println(“i：”+i);
  
  //案例2：将上面的for循环，替换成while循环
  //1.将变量i的声明和初始化提取到循环外操作
  int i=1;
  //2.条件判断保留
  while(i<=3){
  //可以打印
  System.out.println(“i：”+i);
  }
  //循环外打印循环外定义的变量，可以打印
  System.out.println(“i：”+i);

死循环

格式

//1.while死循环
while(true){
循环体语句;
}

//2.for死循环
for(;

JavaSE基础学习相关推荐
1. JavaSE基础学习(四)—Java核心类库（下）
  目录思维导图快速预览全文内容一.异常机制(重点) 1.基本概念 2.异常分类 3.异常的避免 4.异常的捕获 5.异常的抛出 6.自定义异常二.File类(重点) 1. 基本概念 2.常用方法 ...
2. JavaSE基础学习——内部类
  1. 内部类概述内部类就是定义在一个类里面的类,里面的类可以理解成(寄生),外部类可以理解成(宿主). 1.1 内部类的使用场景.作用当一个事物的内部,还有一个部分需要一个完整的结构进行描述,而这 ...
3. JavaSE基础学习——集合
  1. 集合的概述集合是Java中存储对象的一种容器. 集合的大小不固定,启动后可以动态变化,类型也可以选择不固定.集合更像气球, 集合非常适合做元素的增删操作. 注意:集合中只能存储引用类型数据,如 ...
4. JavaSE基础阶段学习笔记
  MarkDown学习标题三级标题四级标题字体 hello,word! hello,word! hello,word! hello,word! 引用选择狂神说Java,走向人生巅峰分割线图 ...
5. java学习之路之javaSE基础1
  <h2>java学习之路之javaSE基础1</h2> <div> ###01.01_计算机基础知识(计算机概述)(了解) * A:什么是计算机?计算机在生活中的应 ...
6. 【Java学习笔记】JavaSE基础全程笔记
  前言该文章为Java自学笔记:JavaSE基础全程笔记,导航部分学习视频为https://www.bilibili.com/video/av250694651 Java基础语法 Java面向对象基 ...
7. 动力节点『lol版』Java学习路线图（二）JavaSE基础阶段
  先上干货,再讲故事.召唤师,准备好你的键盘了吗?开战吧! 二.北地禁魔 Java零基础需要掌握的技术背景故事: 世界被同化之后,符文之地有些地区发生了变化.首当其中的便是德邦与北地.两地边界渐融, ...
8. JavaSE基础加强-学习黑马程序员Java基础视频教程（P93开始）
  目录 P0:写在前面的小知识 P93:下阶段:JavaSE基础加强简介 P95:static:修饰成员变量.内存机制 P96:static:修饰成员方法.内存机制 P97:static:访问的注意事项 ...
9. javase基础socket编程之局域网聊天，局域网文件共享
  2017年06月04日 23点25分 javase基础学完可以做什么,javase实现局域网聊天室包含内容:基础语法,面向对象,多线程,IO流,GUI编程,网络编程(udp) 实现功能:局域网群聊 ...
10. 【已完结！】Java基础--学习笔记(零起点打开java世界的大门)--博客汇总表【附：视频、工程源码、资料、详细笔记】
  java零基础入门到精通(2019版)[黑马程序员] 视频+资料(工程源码.笔记)[链接:https://pan.baidu.com/s/1MdFNUADVSFf-lVw3SJRvtg 提取码:z ...
最新文章
热门文章

JavaSE基础学习

JavaSE基础学习相关推荐

最新文章

热门文章