01标识符/关键字/基本类型（四类八种）
注释：
代码的解释，不会变jvm执行的。
- //单行
- /*
- 多行
- */
- /**
- 文档
- */
关键字
java中含有特殊含义的英文单词。 public void，关键字不用单独用作取名字。
标识符
java取名字。（相同项目不能有相同包名，相同包不能有相同类名，相同作用域不能有相同变量名）
包名：com.test.helloworld
类名：HelloWorld
方法名：main
参数名/变量名：args
规则：不能以数字开头 _$ HelloWorld 。 不要用汉字
约定：
驼峰命名法：
类名：HelloWorld 每个英文单词首字母大写
方法名/变量名： main getAge getStudentAge 除了第一个单词外其余首字母大写。
===============================================================
逻辑类型
boolean(布尔类型)，取值范围为true/false
整型（整数）
byte(字节型)，取值范围：-128~127 1字节
short(短整型)，取值范围：-32768~32767 2字节
int ( 整型) ，取值范围：-2147483648~2147483647 4字节
long （长整型）取值范围：-9223372036854775808~9223372036854775807 8字节
浮点型（小数）
float（单精度的浮点型）1.4E-45~3.4028235E38 4字节
double （双精度的浮点型）4.9E-324~1.7976931348623157E308 8字节
字符型
char(字符型)：char类型的变量，赋值的时候数据长度只能是一位，并且用’’包起来。 2字节
拥有后缀（大小写都行）：
long l = 10000L;
float f = 3.14F;
double d = 3.33D;
===============================================================
目前变量的定义必须写在main方法里面。
public class VarDemo {
public static void main(String[] args) {
//main + alt + /
//变量定义的格式：
//数据类型 变量名 = 变量的值;
boolean b1 = true;
boolean b2 = false;
//整数类型 默认类型是int
byte byte1 = 127;
short s = 130;
int x = 4;
x=5;
int y = 10;
x = y;
long l = 2147483648L; //l L表示是一个long，推荐使用大写
//浮点,浮点类型默认类型是 double
float f = 3.14F; //f F表示是一个float，推荐使用大写
double d = 3.14D; //D d表示是一个double，推荐使用大写
//字符类型
char c = ' '; //单引号之间只能有一个值
//java 大的数据类型不能直接赋值给小的数据类。
}
}
02变量/一维数组、二维数组/运算符
变量：
相同的作用域下不能有同名的变量。
基本数据类型：
存的就是具体的值。
int x = 3;
引用数据类型：
存的是一个地址值。（简单理解通过门牌号能找到楼盘）
字符串：
String s = "ABC";
数组：
数组就是一个容器（存储多个东西的器皿，抽屉）。
容器的特点：
定长、固定数据类型。
索引：
下标，从0开始
初始化就是赋值，赋值就是初始化。
一维数组的格式1：
数据类型[] 数组名 = new 数据类型[数组的长度];
int[] arr = new int[3];
一维数组的格式2：
数据类型[] 数组名 = {值1,值2,值3,值4};
int[] arr3 = {1,2,3,4,3,4,5,6,8,9,2,3};
获取长度
数组名.length;
arr.length;
取值/赋值******：
arr[0] = 10;
System.out.println(arr[0]);
二位数组的初始化格式1：
数据类型[][] 数组名 = new 数据类型[二位数组的长度][];
int[][] arr = new int[3][3];
二位数组的初始化格式2（优先掌握这一种，这种会更容易理解）********：
数据类型[][] 数组名 = {{值1，值2，}，{值1，值2}，{值1，值2}};
int[][] arr2 = {{1,2},{3,4},{5,6},{1}};
取值/赋值：
arr[0][0] = 20;
System.out.println(arr[0][0]);
异常：运行出现了错误
NullPointerException
null 值调用属性或者方法
ArrayIndexOutOfBoundsException
访问了不存在的索引
运算符
算数运算符
% 取余 取模
++ -- 自增1 自减1
单独使用时，++ 放前和放后没有区别，都是+1；
参与运算,++在后面先把变量x的值取出来赋值（运算），再自增1
参与运算,++在前面先把变量x自增1，再把值取出来赋值（运算）
关系运算符，结果boolean
== 比较相等
!= 比较不相等
逻辑运算符，结果也是boolean
& | ! && ||
& 遇false 则false
| 遇true则true
&& 短路：如果左边已经决定了整个表达式的结果，那么右边不会执行
赋值运算符
int a = 10; //把10赋值给a变量；
扩展赋值运算符 += *= /= %=; 底层包含强制类型转换
//把左边和右边的值进行运算后赋值给左边。
a +=10; //a = (int)(a+10);
三元运算符
boolean结果的表达式 ? 结果1 : 结果2;
true 返回 结果1 ， false 返回结果2;
03循环for、while、dowhile/流程控制语句if、switch
循环
1、格式
for(初始化语句 1 ;条件判断语句 2 ;循环体执行之后的语句 4) {
循环体 3 ;
}
2、执行流程
1 --> 2 --> 3 --> 4 --> 2 --> 3 --> 4 --> 2 false 结束
true true
最少
1 --> 2 false 结束 循环的右大括号
增强for循环:
for(数据类型 变量名 : 数组或者集合名) {
}
增强for和普通for的区别是：增强for不能直接拿到索引。
求和思想：
int sum = 0;
for (int i = 1; i <= 10; i++) {
sum += i;
}
System.out.println(sum);
while格式：
初始化语句 1
while(条件判断语句2) {
循环体3;
循环体执行之后的语句4;
}
执行流程 : 和for 是一样
1 --> 2 --> 3 --> 4 --> 2 --> 3 --> 4 --> 2 false 结束
true true
最少
1 --> 2 false 结束 循环的右大括号
do while 格式（了解）
初始化语句 1
do {
循环体3;
循环体执行之后的语句4;
}while(条件判断语句2);
特点：do while 至少会执行一次循环体。
循环控制语句
continue; //跳出本次循环，继续下次循环
break; //跳出全部循环
嵌套循环
for (int i = 1; i <= 4; i++) { //控制行
for (int j = 1; j <= 5; j++) { //控制列
System.out.print("*");
}
System.out.println();
}
条件控制语句
1、格式
2、执行流程
格式1：
if() {
true进入 if 语句体
}
格式2：
if() {
true进入 if 语句体
}else {
false进入 else 语句体
}
格式3：
if() {
当前true进入 if 语句体
}else if () {
当前true进入 if 语句体
}else if () {
当前true进入 if 语句体
}...
else {
所有的if或者else if 都不满足则进入 else
}
格式3和多个if的区别
格式3是分支流程，最终只会进入一个if。
多个if是只要满足条件就能进入if，不存在互斥。
switch（了解）
switch(值) {
case 值1:
语句；
break;
case 值2:
语句；
break;
case 值3:
语句；
break;
default:
语句；
break;
}
switch(值)值的类型：byte、short、int、char、String、枚举
switch什么时候结束，遇到break和}。
break穿透：没有遇到break，不会再次进行case匹配。
if和 switch 的区别：
if的第三种格式
if else if .... else
和switch执行流程是非常相似的。
switch需要匹配的值是一个范围的时候，那么很难用。
if的条件更加丰富，只要表达式结果是boolean类型就ok。
switch只是一个值的比较。
什么时候用switch:只比较值是否相等，且数量较少的时候。性能高过if。
95%都使用if。
04面向对象概念/方法、构造方法/成员变量和局部变量的区别
函数/方法：
函数就是功能实现，它是遵循了特定语法，一段具有特定功能代码。（类通过定义函数来描述类的功能）
位置：类中方法外，与main方法平级*******
***********方法不调用，不执行***********
分类：
非构造函数（普通函数）
格式：
- 按照main方法修改。
- 修饰符 函数返回值类型 函数名(参数类型 参数名...){函数体}
public int add(int a,int b){
return a+b;
}
修饰符：
- public
- protected
- 默认修饰符
- private
权限逐步降低。
public的访问权限最大。private类型的访问权限最小
函数返回值类型：
八大基本类型 / 引用类型 / 空类型（void）
函数名：
随便定义，语法要求第一个字母小写，函数名要见名知意。
参数类型：
就是一个变量的类型（八大基本类型 / 引用类型）
形参实参：（不要纠结）
- 形参：方法参数列表
- 实参：真实参数入的值，实际参与运算的值。
面向对象概念
面向对象：把事情交给对象完成（厨师、快递员），对象具备完成某件事情的人或物。
面向过程：自己一条龙完成所有事情
类于对象
模板，描述的是具有共性的一类事物，所以我们又可以把类称作模板技术，
静止的（属性用`变量`来描述）和（动态的行为用`函数`来描述）。
例子：
手机、汽车，鱼、狗
对象：类的具体化
构造函数
创建对象，兼职成员对属性就行赋值。
分类:
- 无参构造函数（默认构造函数）
public 类名() {
}
- 带参数构造函数
public 类名(参数类型 参数名) {
}
注意细节:
- 函数名必须跟类名保持一致
- 不需要声明函数返回值
- 如果在类中定义了任意构造方法，那么java不再提供默认空参构造方法
成员变量和局部变量的区别：
局部变量特点：
- 定义在函数体内
- 定义在函数参数列表里
- 代码块中{}
- 成员变量特点
- 定义在类体内
- 在函数外
- 在代码块外
- 生命周期：
- 局部变量出了包含他的{}就死亡
- 成员变量对象不消亡就一起存在
- 如何调用函数
05方法重载/继承/方法重写/super关键字和this关键字
1、方法函数重载
- 规则：方法名一样，参数不一样，与返回值无关
- 参数的个数不一样
- 参数的类型不一样
- 如果参数个数一样,类型也一样，但是顺序不一样
- 普通方法和构造方法都能重载
2、java内存（了解）
java的内存包含了栈、堆、方法区、寄存器
栈：
- 先进后出
- 局部变量、方法都在栈中
堆：
- new出来的对象就在堆
- 两个引用（变量）指向同一个对象（理解+掌握）。
Student s = new Student();
Student s2 = s;
3、封装（把代码放入方法） 三大特征都是为了少些代码少修改代码。
Encapsulation。意思是将代码通过函数的形式将一些代码细节包装起来，防止外部代码的随机访问，
要访问这些数据就必须通过调用函数来完成。
好处：
- 提高了代码的阅读性
- 提高了代码的可维护性
体现：方法、对象、private get/set
get/set和构造方法都可以对成员变量进行赋值。
4继承 inherit
生活中的继承：子承父业。
java中的继承：两个类之间通过extends关键字来描述父子关系，子类便可拥有父类的非私有成员。
解决问题
- 提高了代码复用性
- 代码的维护性更高
语法：
public class 父类 {
}
public class 子类 extends 父类 {
}
注意事项：
- 如果一个类不继承任何类，默认继承Object,Object是java中的祖宗类。
- Java是单继承（一个类只能继承于一个类），多层继承，一个父类可以有多个子类。
- 创建本类对象之前会先初始化父类对象
- 子类不能继承父类的private成员（属性，方法）
5、方法重写/覆盖
- 前提条件：继承或者实现
- 子父类中出现了一模一样的方法。修饰符、返回值、方法名、参数都必须一模一样。
- 作用：方法升级。
6、super关键字与this关键字
- super指向父类（调用父类方法或属性时候用到）
- this指向当前类（区分局部变量和成员变量同名）
- super() 调用父类构造方法
- this() 调用本类其他构造
7、修饰符
访问修饰符
- public protected 默认修饰符 private
- 权限逐步降低。
- public的访问权限最大。private类型的访问权限最小
非访问修饰符
- static 静态（共享） 后面会通过实际例子讲解
- final 常量、最终类（不能被继承，被绝育了）方法（不能被重写）
- abstract 抽象
06多态/api使用/字符串方法学习
1、多态 Polymorphism 少写代码
概念：用父类的类型来接收子类的对象
先决条件：
- 继承/接口实现
- 父类类型接收子类对象
优点：
- 扩展性强，解决了代码复用，降低类型耦合度
- 可以少定义变量，少些重复代码。
案例：一个方法接受不同的子类类型。
缺点：
- 不能使用子类特有方法
- 可以使用强转，转成对应子类类型，解决这个问题。
使用方法:
父类 变量名1 = 子类对象;
子类 变量名2 = (子类)变量名1;
多态一般伴随重写使用。
场景：
public void driverCar(Car car) {
car.run();
}
2、api使用
打开->显示->索引->输入java提供的类
3、字符串
原理:
char[] ch = {'a','b','c'};
特点：
- 方法不能改变String本身
方法
- equals：判断字符串是是否一样，大小写敏感
- split：切割
- replace：替换
- substring：字符串截取
- trim：删除字符串两端的空格
- length：获取字符串长度
- equalsIgnoreCase：判断是否一样，忽略大小写
- indexOf：获取指定内容在字符串中出现的位置
- isEmpty：判断字符串是否为空
- lastIndexOf：获取要匹配内容在字符串中最后出现的位置
构造方法：
基本不用。
4、== 和 equals 区别
- == 比较基本数据类型比较的是值，比较引用数据类型比较的是地址值。
- equals 是Object类中的方法，基本数据类型无法调用。
- equals默认使用==号，重写之后一般比较的是内容。