大家好，我是讯享网，很高兴认识大家。



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 ( 整型) ，取值范围：-~ 4字节

long （长整型）取值范围：-~ 8字节

浮点型（小数）

float（单精度的浮点型）1.4E-45~3.E38 4字节

double （双精度的浮点型）4.9E-324~1.23157E308 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 = L; //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();

}

java基础文字总结

条件控制语句

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默认使用==号，重写之后一般比较的是内容。