-----------------------------java基础篇------------------------------------------
------java发展史
诞生时间：在1995年由SUN发布。
------java优势
简单、纯面向对象，开源，且可跨平台
------java环境准备工作
第一步：安装JDK（最低安装8.0版本）【ps：网传，8.0yyds】
第二步：配置JDK（环境变量）【共计三个变量】
1：java_HOME：jdk的安装目录【作用：告知计算机JDK的位置】
2：path：jdk的bin目录【作用：告知计算机其他软件JDK命令所在位置】
3：CLASSPATH：【作用：告知计算机编译生成的字节码文件的位置】
PS:.代表当前目录
第三步：名词解释
1：JDK：java工具包【ps:由类库、JRE、调试工具和编译器总成】
2：JRE：java的运行环境【ps:JVM、解释器】
3：JVM：java虚拟机【ps:可以屏蔽操作系统之间的底层差异，为跨平台提供支持】
------JAVA的运行机制
源代码-->编译器-->编译成字节码文件（平台通用文件）-->解释器-->解释执行
【PS：先编译，后执行】
------第一个JAVA程序
目标：使用java代码输出hello world语句；准备：新建后缀名为java的源文件
一：基础知识梳理
1：class：类
【1:是盛放代码的容器；2:是程序的基本组成部分】
2：类名 ：随便起【要求：在语法允许的范围内】
【1:作用为区分各个类；2:同一源文件下的类不可以重名】
3：{}：划分类的边界
4：主函数：程序的入口
【1:写法固定；2一个类中只能存在0-1个主函数；3:所有想要运行的内容必须在主函数内】
5：输出语句：将某个内容展示到空值台查看
【1:写法固定；2:加ln:输出内容独占一行，可以输出空值；3:不加ln:输出内容不会独占一行，无法输入空值】
6：运行【代码演示】
//编译
javac 源文件名.java
//执行
Java.类名【1:每个类都会在编译完成后生成一个对应的字节码文件；2:字节码文件的文件名必须与对应的 类保持一致；3:执行时，执行的就是字节码文件】
【代码演示】
class hello1{
public static void main(String[]args){
System.out.Println("helloworld");
System.out.Println("helloworld");
}
}二：编码规范
硬性规范
1:严格区分大小写
2:命名不能以数字开头
3:命名只能由字母、数字以及下划线（_）和（$）组成【空格也属于符号】
4:命名不能使用关键字和保留字
软性规范
1:不能以汉字命名
2:类名采用大驼峰命名法【所有组成部分首字母大写】（如：StudentClass）
3:变量、方法名采用小驼峰命名法【从第二个组成部分开始大写】（如：studentAge）
4:常量命名全大写，多个组成部分之间下划线（_）链接（如：STUDENT_NUMBER）
5:做到望名知意
6:注意代码之间的层次缩进
------公开类-piblic class
所有位置都能访问的类就是公开类
代码演示：
public class 类名{
}使用要求
1:公开类名必须与源文件名保持一致
2:一个源文件中至多存在一个公开类
------注释
不参与运行，能帮助程序员添加代码解释备注的说明就是注释【分为三种】
第一种：单行注释
代码演示：
//只能注释一行内容
//int a = 10;第二种：多行注释
代码演示：
/*
我是一行被注释的内容
我是一行被注释的内容
我是一行被注释的内容
我是一行被注释的内容
我是一行被注释的内容
我是一行被注释的内容
*/第三种：文档注释
代码演示：
/**
我是很多行，但是被注释了
当你能给公开类或者方法添加说明时记得来找我，我可以帮你的
*/
------包-package
可以帮助你整理归纳字节码文件
代码演示：
package 包名1，包名2，包名3，包名n;包的使用说明
1:命名应该全小写
2:必须写在源文件有效代码第一行
3:书写package后必须带包编译和运行
【补充：接下来是带包编译和运行的代码演示】
//带包编译：
javac -d .源文件名.java
//带包运行
java 包名.类名4:一个源文件可以存在0-1个package语句
------变量和运算符
可以利用逻辑操作数据的过程可以称呼为程序
操作数据就是增、删、改、查以及存
------变量的概念
变量是计算机内存中的一块存储空间，作用为存储一个数据，是存储数据的基本单元
------变量的组成
变量由数据类型、变量名以及值组成的
1:数据类型：声明内部存放的数据是什么类型的数据（数据类型分为基本数据类型和引用数据类型）【补充：基本数据类型：byte、short、int、long、float、double、char、boolean】
2:变量名：为了更好的区分变量
3:值：内部存放的数据
------变量的创建
【变量的创建共分为四种】
第一种：先声明，后赋值【代码演示】
数据类型 变量名;//声明
变量名=值;//赋值
//eg：
int age;//先声明
age=22;//后赋值【注意：变量赋值之后才可以使用】
第二种：声明的同时直接赋值【代码演示】
//数据类型 变量名=值;
//eg
int age = 23;第三种：同时声明多个变量，再一一赋值【代码演示】
数据类型 变量名1,变量名2,变量名3,变量名n,//声明多个
变量名1=值1
变量名2=值2
变量名3=值3
变量名n=值n
【代码举例】
int score1,score2,score3;//声明多个
score1=90;
score2=88;
System.out.println(score1);
System.out.println(score2);
// System.out.println(score3);错误
score3=60;
System.out.println(score3);【注意：1:多个变量的数据类型必定一致；2:未赋值前变量仍然不可使用】
第四种：同时声明多个变量并直接赋值【代码演示】
数据类型 变量名1=值1,变量名2=值2,变量名n=值n
代码举例：
//同时声明多个并直接赋值
int score4=70,score5=68,score5=67,score6=99;
【总结：第三种写法和第四种写法可以共存】
------数据类型
java是强类型的语言，每个数据都有自己对应的数据类型，同时，每个容器也必须声明自身的数据类型
【数据类型大体分为两种：第一种：基本数据类型，第二种：引用数据类型】
第一种：基本数据类型
根据数据的不同表现形式分为了
1：整数类型；2：小数类型（浮点数）；3：字符类型；4：布尔类型
1：整数类型
| 数据类型 | 字节长度 | 取值范围（十进制） |
| byte | 1B | -128~127 |
| short | 2B | -32768~32767 |
| int | 4B | |
| long | 8B |
【注意：1：int为整数的默认类型；2：long类型的值超出int的取值范围时必须在末尾添加L或者l】
【建议：这里为了方便记忆，可以记住加L】
2：小数类型（浮点数）
| 数据类型 | 字节长度 | 取值范围 |
| float（单精度浮点数} | 4B | |
| double（双精度浮点数 | 8B |
【注意：1：double为小数类型的默认类型；2：float类型在赋值时末尾必须添加F或者f】
3：字符
| 数据类型 | 字节长度 | 取值范围 |
| char | 2B | 0~65535 |
【注意：1：单引号赋值：值内部只能由一个组成部分】
char 变量名='值'【2：数值的赋值，每个数字都有一个自己对应的字符，数字不能超出取值范围】
| 大小写字母 | 对应数字大小 |
| A~Z | 65~90 |
| a~z | 97~122 |
char 变量名=数字;【char类型进行教学运算时会先统一换算为数值状态】
【3：unicode ：编码赋值——了解就好】
char 变量名='\u0041';4：布尔类型
| 数据类型 | 取值 | 应用场景 |
| boolean | true(真) false(假) | 条件判断 |
【注意：布尔类型无法进行数学运算】
第二种：引用数据类型
【特别注意：只要不是八大基本数据类型，就一定是引用类型】
【目前只学习了一个】
String：字符串，可以存放多个字母
【代码演示：】
String 变量名="值";
【注意：1:String类型的值必须写进双引号，不做其他特殊要求】
------数据类型转换
类型自小至大排序为：
byte-->short(char)-->int-->long-->float-->double
【提示：数据类型转换分为以下几种：自动类型转换、强制类型转换和自动类型提升】
一：自动类型转换
发生在小类型给大类型赋值时（一定不存在风险）
代码演示：
大类型=小类型二：强制类型转换
发生在强制将大类型的值赋值给小类型时【注意：这样会存在风险】
代码演示：
小类型=(小类型)大类型;【注意；】
【1:大类型的值在小类型的取值范围内，不会出现数据异常；】
【2:大类型的值不在小类型的范围内，会出现数据异常；】
【3:小数转成整数时，会舍去小数位，既有可能出现数据丢失；】
【4:由于char类型没有负数取值，所以其他类型转为chae时，都需要类型强转；】
【5:boolean类型不参与数据类型转换；】
【6:任意数据加上双引号或者拼接双引号都会变成String类型】
------自动类型提升
自动类型提升只发生在数学运算时，当有大类型参与时，会触发类型提升，最终结果将会被提升为大类型
【注意：自动数据类型提升最低提升为int类型，最高提升为double类型】
------表达式
由一个或多个变量或者值通过运算符进行连接，最终可以得到一个结果，该通过运算符链接起来的式子称之为表达式。
------运算符
运算符分为为：
数学运算符
【+（加）、-（减）、*（乘）、/（除）、%（取余）】
赋值运算符
【=(等于)、+=（加等于）、-=（减等于）、*=（乘等于）、/=（除等于）、%=（取余等于）】
比较运算符
【<(小于)、>（大于）、<=（小于等于）、>=（大于等于）、==（等于）、! =（不等于）】
【注意：比较运算符结果一定为boolean类型】
逻辑运算符
| 运算符 | 含义 | 运行原理 |
| && | 逻辑与 | 表示并且，多方同时满足才会为true，有一方为false，结果就为false |
| || | 逻辑或 | 表示或者，一方为true则为true，权威false才为false |
| ！ | 逻辑非 | 表示取反 |
【注意：衔接的必须是布尔表达式（结果为boolean类型的表达式）】
【特别注意：短路机制问题：只会存在逻辑运算符中】
【短路机制原理：当运算到可以奠定最终结果的表达式时，后续表达式将不再判断】
【短路运算符：&&和||，注意注意注意：&和|不是短路运算符】
一元运算符
| 运算符 | 写法 | 含义 |
| ++ | 变量名++或者++变量名 | 数值+1相当于n+=1 |
| == | 变量名--或者--变量名 | 数值-1相当于n-=1 |
【注意：无论运算符在前还是在后，变量本身的值一定会进行发生变化】
【运算符在前，表达式的结果为变量计算之后的值】
【运算符在后，表达式的结果为变量计算之前的值】
三元运算符
代码演示：
布尔表达式 ？ 结果1:结果2
【注意：执行流程：当布尔表达式结果为true时，执行结果1，否则执行结果2】
【结果1和结果2可以是一个值也可以是表达式】
------扫描器-Scanner
【提示：类库中提供了Scanner工具类，可以辅助实现接收用户输入的数据】
使用步骤：
第一步：创建扫描器【代码演示】
java.util.Scanner 扫描器名=new java.util.Scanner(System.in);第二步：提示用户输入内容【代码演示】
System.out.println("请输入查找内容");第三步：创建变量接收用户输入的内容【代码演示】
数据类型 变量名=扫描器名.next数据类型();
String: 扫描器名.next();
int: 扫描器名.nextInt();
double: 扫描器名.nextDouble();
//注意：char:扫描器名.next().charAt(0);
【注意：扫描器对象创建之后可以反复使用】
----导包-import
导包的作用是一次性在源文件中指明某个或某些类的来源
【代码演示】
import 包名.类名使用规则：
1：所在位置：第一个类的上方，package语句的下方
2：一次性导入某个或某些类之后，源文件中的类无需再代码中再次声明包（界面更简洁明了）
3：可以使用*（通配符）一次性引入某个包下所有的类
improt 包名.*;4：*通配符只能引入直属的类，呜啊引入子包中的类
5：一个导包语句中*通配符只能存在一次
6：导包语句一个源文件中可以存在多个
------转义字符
转义字符的作用：
1：将特殊字符普通化
2：将普通字符特殊化
掌握的字符有：\n表示换行，\t表示一段制表符的距离，相当于tab键的效果
必须写双引号
--------分支和循环
程序执行过程中，有可能需要根据不同的结果执行不同的操作，该现象称之为分支结构
【每一次新的选择，都会有新的结果】
分支有以下几种
第一种：if分支
【代码演示】
if(布尔表达式){
//操作语句
}第二种：if-else分支
【代码演示】
if(布尔表达式){
//if中的操作语句
}else{
//else中的操作语句
}【注意：if-else分支：一定且只会执行一个操作语句】
第三种：多重if分支
【代码演示：】
if(布尔表达式1){
//操作语句1
}else if(布尔表达式2){
//操作语句2
}else{
//else中的操作语句
}【注意：】
【1：自上而下执行，】
【2：当执行到某个满足的分支时，剩余分支将不再执行】
【3：至多执行一个操作语句】
【4：只要逻辑完整，else-if的数量不做具体要求】
【5：else部分可以省略（但是为了保证分支的完整性，通常不会省略）】
第四种：嵌套分支
【代码演示：】
if(外层布尔表达式){
if(内层布尔表达式1){
//内层if操作语句
}
}else{
if(内层布尔表达式2){
//内层if操作语句
}
}
【注意：只要逻辑完整，对嵌套位置，嵌套类型，嵌套层数不做具体要求】
第五种：switch分支
switch分支适用于等值判断
【代码演示：】
switch(一个值或者一个具有具体值的表达式){
case：值1；
//操作语句
break;
case：值2；
//操作语句
break;
case：值3；
//操作语句
break;
default:
//default操作语句
}【注意：】
【1：case自上而下判断】
【2：当所有的case都不满足时，才会执行default】
【3：break的作用为强制结束分支剩余内容的执行】
【4：当某个case满足条件之后，剩余case将不再判断，但是代码块会继续执行】
【5：最后一个语句块不需要添加break，因为执行结束，switch会自然停止】
【6：多个case可以共用同一个操作语句(这是因为break的穿透效果)】
【7：所有switch分支能够实现的操作if分支一定可以，反之不行】
【【最重要的一点：switch只能判断byte，char，short，int，string(JDK7)这些数据类型】】
------局部变量
局部变量是定义在方法内部的变量
作用范围：从定义行开始，到直属代码块{}结束
命名冲突：在同一作用域下不可重名
------循环
循环的特点：可以使操作语句再满足某个条件的前提下同时执行多次，解决代码冗余问题
for循环
【代码演示：】
for(循环初始值;循环条件;迭代语句){
//操作语句
}基础知识讲解：
循环初始值：从几开始的循环
循环条件：在那个范围内可以继续循环
迭代语句：对循环初始值做有规律的变化
while循环
【代码演示：】
while(循环条件-布尔表达式){
//操作语句
}while循环特点：
先判断，再执行，执行次数为0~n次；
while和for的区别
1：for循环更适用于循环次数和烦诶确定的情况
2：while更适用于循环次数和范围不确定的情况
------流程控制
流程控制关键字可以在循环执行的过程中改变循环的执行流程
burak
作用：跳出所有循环，是当前循环停止
continue
作用：跳过本次循环，开始下一次
死循环：当循环条件永远满足，操作语句永远可以执行时，就会形成死循环，
死循环+break(条件跳出)时while循环中很常见的一种思路
区别：
1：作用不同：break停止所有循环，continue时停止本次开始下次循环
2：应用场景不同：break可以作用与swich分支和循环，continue只能作用域循环
do-while循环
【代码演示：】
do{
//操作语句
}while(循环条件)执行特点：
先执行，再做判断，，执行次数为1~n次
whils和do-while的区别
1：while先判断再执行，执行次数为0~n次
2：do-while先执行，再判断，执行次数为1~n次
循环嵌套：
在图形输出中，外层循环代表行，内层循环代表列
执行流程：外层循环执行一次，内层循环执行一遍
break和continue只能作用于直属的循环层次
只要逻辑完整，镶嵌层数不做要求，但是通常不超过两层(镶嵌太多会导致性能受到影响)
------函数
函数：就是一段具有特定功能的代码块，特点时可以在不同的位置多次调用和执行，可以解决代码冗余问题
函数语法：
【代码演示：】
访问修饰符 返回值类型 函数名(形参列表){
//操作语句
}
//完整的函数方法
public static void 函数名(){
操作语句
}函数方法所在位置：类的内部，其他函数的外部，与主函数平级
调用方式：
自定义函数想要执行，必须经过调用
【代码演示：】
函数名(实参列表);
函数名();调用和执行的位置：
想在哪里执行就在哪里调用，【哪里不会点哪里】
参数
表示函数中不确定的因素
分为：1：形参，2：实参
形参：
形式上的参数，特点是没有具体值，只有声明部分，写在函数的声明处的小括号内
实参：
实际上的参数，特点是一个具有具体值或者拥有具体结果的表达式，写在函数调用处的小括号里
一个参数
【代码演示：】
形参:
public static void 函数名(数据类型，参数名){
//操作语句
}
实参:
函数名(值);
【注意：当存在形参时，必须使用实参给形参赋值】
多个参数
【代码演示：】
public static void 函数名(数据类型1 参数名1;数据类型2 参数名2;数据类型n 参数名n){
//操作语句
}
调用：函数名(值1,值2,值n,)实参列表必须于形参列表保持一致
【【参数列表：数据类型、个数、顺序】】
形参不可同时声明
------返回值
返回值是一个具体值，特点为可以向上(调用者)返回
【代码演示：】
public static 返回值类型 函数名(形参列表){
//操作语句
return 值;
}
【注意：】
1：void没有返回值，无需向上返回数
2：如果函数声明的有返回值，则内部必须通过return语句降至向上返回
3：当调用一个拥有返回值的函数时，调用者必须做出后续处理，否则返回值没有意义
定义变量接收返回值，在操作变量
【代码演示：】
数据类型 变量名 =函数名(实参列表);变量的数据类型应与函数声明的返回值类型保持一致，
直接操作返回值
4：同一直属作用范围内，return语句下方不可存在其他有效语句否则将会无法执行
5：如果函数中存在分支，则比徐保证每种情况下都有可被执行的return语句
6：当分支情况较多时为了方便书写和阅读，建议使用"三部曲"；
1：在函数最上方定义用来返回的变量，并赋予初始值
2：在函数操作语句中根据不同的情况为变量重新赋值
3：在函数的最下方return该变量
------函数高级
函数的嵌套调用
1:函数嵌套调用时，调用顺序与执行结束的顺序相反
2:当调用的函数执行结束，调用者才有可能执行结束
3:只要逻辑完整，嵌套层数不做要求
JVM内存结构
1:JVM内存主要有栈和堆组成【注意：除了栈和堆，还有其他元素，我还没有学到】
2:栈的特点：先进后出(FILO)，永远操作栈顶元素
3:每当函数调用时，都会生成一条对应的栈帧，栈帧的执行特点决定了函数嵌套调用时的执行特点
------递归
1：自己调用自己，或者函数之间循环调用
2：当进行递归调用时，会持续生成栈帧，如果没有跳出条件，则最终栈帧会将内存撑满，程序则会强制终止
3：return;可以强制停止程序剩余内容的执行
可以作用与递归，在递归过程中满足某个条件时，通过return:截止递归
4：能够使用递归实现的操作都可以用循环代替
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
