1.本质：规定占用内存空间的大小,限制数据的格式类型
2.分类：基本类型
数值型
整数型
byte,short,int,long
浮点型
float,double
布尔型
boolean
字符型
char
引用类型
类,数组,接口
3.默认值
整数：int；小数：double;字符型/u0000;布尔型：false;引用数据类型：null
4.类型转换
Java中，八种基本类型，除了布尔型，其他均可以进行类型转换
自动类型转换：低精度到高精度
byte->short->char->int->long->float->double
强制类型转换：高精度到低精度
5.混合运算
混合运算：结果的类型是当前运算中最大的类型
注意：byte,short,int,long四种类型中,任意一种或多种进行运算，结果是int。
1.定义：可变的量,由于空间设置了名字,更加方便的对空间中的数据进行操作,重复使用。
2.声明：数据类型 变量名 = 值;
3.分类：
局部变量 : 在方法中声明的变量是局部变量,没有默认值,作用域只能在当前方法中使用
方法不调用不执行,调用才执行,并且执行完栈帧销毁,所以方法在栈内存是临时性的,所以局部变量也是具有临时性的,不适合长期存储
静态变量 : 类中使用static修饰的变量,属于类级别变量,该类所有对象,值共享,有默认值
成员变量 : 类中没有使用static修饰的变量,属于对象级别,对象之间变量值不共享，有默认值
如果局部变量和静态变量/成员变量同名,则局部变量优先级大于静态和成员
在方法中,可以使用类名区分同名的静态变量和局部变量
在成员方法中,可以使用this.区分同名的局部变量和成员变量
1.算术运算符 + - * / %
i++ 先赋值，再自身+1
++i 先自身+1，再赋值
2.关系运算符 > >= < <= == !=
运算结果：布尔：true/false
3.位运算符
负数：内存中取得是补码。
& 位与,两边都是真,结果才是真
| 位或,两边一个为真,结果就为真
！位非,取反
^ 位异或,两边不一样,结果是true
~ 按位非 (按位取反)
&&：短路与,两边都是真,结果才是真
||：短路或,两边一个为真,结果就为真
&& || & |的区别
&& : 短路与,如果第一个条件为false,则第二个条件不执行
& : 不管第一个条件是否为false,第二个条件依然会执行
|| : 短路或 , 如果第一个条件就为true,则第二个条件不再执行
| : 不管第一个条件为false还是true,第二个条件都执行
4.赋值运算符 = += -= *= /= %= 右结合
5.字符串拼接符
6.三目运算符
布尔类型？真：假
1.顺序结构
从上往下从左到右执行
2.分支结构
单分支,双分支,多分支
多分支中一个分支结束，整个多分支结束。
if…else…和 switch
在switch中只能传入int和字符串，每一个分支都要加break,防止出现case穿透
case合并：利用case穿透，可以完成合并。==||
3.循环结构 for while do…while
重复执行代码多次
循环三要素：起始值 终止条件 步长
4.break和continue
break:打断
1.switch中：结束case分支,防止case穿透
2.循环中，结束当前循环
continue:跳过当前次循环，继续下一次循环
1.定义： 一堆代码的集合
2.优点 : 代码复用,程序简洁清晰,易维护,易扩展,灵活度更高
3.声明 : 修饰符列表 返回值类型 方法名(参数列表) {方法体}
4.分类
静态方法 : 使用static修饰
成员方法 : 没有使用static修饰
构造方法：实例化对象使用,创建对象时会自动调用构造方法
5.调用
静态方法 : 类名.方法名(参数);
成员方法 : 对象.方法名(参数);
构造方法：类型 方法名=new 类型();
方法不调用不执行,调用才执行,并把结果返回到调用处
六、方法重载
1.定义：overload
方法名相同,参数列表不同
列表不同分为 : 类型不同或个数不同
七、内存划分
Java Runtime Data Area : java运行时区域,一般叫JVM内存。
程序计数器 :当前程序执行的位置指示器
静态区/方法区 : 保存程序文件(class文件) 以及静态数据,方法被调用之前,也保存在静态区,内部还有运行时常量池
VM栈 : 又叫栈内存 栈 : 是一种数据结构,先进后出,像弹夹
栈的构成因素
栈空间 : 栈内存就是栈空间
栈帧 : 栈空间中的每一个栈元素 就叫栈帧
栈底元素 : 第一个放进去的栈帧
栈顶元素 : 最后一个放进去的栈帧
栈操作
压栈 : 就是指把元素放入栈空间的过程
弹栈 : 就是把元素弹出去的过程
栈内存,是用来执行方法的,所有方法的执行,必须在栈内存进行
本地方法栈 : 用来执行一些本地方法
堆内存 : 用来保存对象
java采用动态加载机制
在方法中对当前方法进行调用,**注意终止条件**
常见异常 : 栈内存溢出 java.lang.StackOverFlowError
九、数组
1.定义
1引用数据类型,2源自底层的数据结构3保存和处理相同类型的数据的集合
2.数据结构 : 计算机存储和组织数据的一种方式,合理选择数据结构会提升执行效率和存储效率
3.数组特性
1数组存储方式是连续存储,并且每个元素有独一无二的下标来标识
2数组长度一旦确定不能更改
3所以数组在查询和更改的情况,效率极高,但是添加和删除效率较低
4因为长度不能更改,想要添加或者删除数据,必须先创建一个新数组,然后把原数组中数据复制进去,在复制的过程中进行添加和删除操作
5数组还有一个length属性 保存数组的长度
4.应用场景
用来保存多个数据,并且查询和更改操作较多的情况下,推荐使用数组
5.数组声明
静态声明 : 已知数组中每个元素的时候使用静态声明
数据类型[] 变量名 = {值,值,…} | 数据类型[] 变量名 = new 数据类型[]{值,值,…}
动态声明 : 不知道数组中每个元素的时候使用动态声明
数据类型[] 变量名 = new 数据类型[长度];
6.数组使用
查询 : 数组[下标]
更改 : 数组[下标]=值
遍历
For(int i = 0; i<数组.length; i++){
数组[i]
}
增强for循环
for(数据类型 变量名：数组){}
7.数组排序
API : Arrays.sort(数组);
int[] arr={1,7,2,4,9,5};
//api
Arrays.sort(arr);
冒泡 : 相邻的元素进行比较,如果前面大于后面,就交换位置比较一轮之后 最后一个一定是最大的,对以上步骤重复操作.
public static void bubbleSort(int[] arr){
for(int i=0;i
for(int j=0;j
if(arr[j]>arr[j+1]){//升序
int temp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
}
}
选择 : 假设当前这个是最小的,用该数据依次和后面所有数据进行比较,如果发现比当前元素小,就交换下标,比较一轮结束后,当前保存的一定是最小元素的下标
public static void selectSort(int[] arr){
for(int current=0;current
int min=current;
for(int i=current+1;i
if(arr[min]>arr[i]){
min=i;
}
}
if(current!=min){
int temp=arr[min];
arr[min]=arr[current];
arr[current]=temp;
}
}
}
8.二分法查找
1 确定开始和结束还要中间数据
* 2 用目标数据 和 中间数据进行比较
* 3 如果目标数据等于中间数据,返回中间数据的索引即可
* 4 如果目标数据大于中间数据的话,则在后半截继续查找,起始=中间+1,结束不变,再生成中间数据
* 5 如果目标数据小于中间数据的话,则取前半截,起始不变,结束=中间-1,再生成中间数据
* 6 重复执行以上步骤,如果起始 大于 结束 说明未找到,返回-1
public static int erfenSearch(int[] arr,int target){
int start=0;
int end=arr.length-1;
int middle=(start+end)/2;
while(start<=end){
if(arr[middle]==target)
return middle;
if(target>arr[middle]){
start=middle+1;
}else{
end=middle-1;
}
middle=(start+end)/2;
}
return -1;
}
9.数组复制
1替换复制
2插入复制
0 创建一个新数组,长度为 dest.length + length
* 1 目标数组中 从0开始 到 起始位置结束(包含),复制到新数组中
* 2 源数组中 从起始位置开始(包含) 复制 length个 到 新数组中
* 3 目标数组中 从起始位置+1开始(包含) 到最后 所有的数据 复制到新数组中
public static int[] copy(int[] src,int srcIndex,int[] target,int targetIndex,int length){
int[] newTarget=new int[target.length+length];
int index=0;
for(int i=0;i<=targetIndex;i++){
newTarget[index]=target[i];
index++;
}
for(int i=srcIndex;i
index++;
}
for(int i=targetIndex+1;i
index++;
}
return newTarget;
}
1.数组声明
静态声明 : 已知数组中每个元素的时候使用静态声明
数据类型[][] 变量名 = {{值1，值2}，{值3，值4} … } | 数据类型[] 变量名 = new 数据类型[][] {{值1，值2}，{值3，值4} … }
动态声明 : 不知道数组中每个元素的时候使用动态声明
数据类型[][] 变量名 = new 数据类型[长度][长度];
2.存储方式
3.使用方式
查询 : 数组[下标][下标]
更改 : 数组[下标][下标]=值
遍历
二维表
int[][] arr1=new int[2][3];
for(int i=0;i
for(int j=0;j
System.out.print(arr1[i][j]);
}
System.out.println();
}
}
锯齿状
int[][] arr1=new int[2][];
for(int i=0;i
arr1[i]=new int[i+1];
}
for(int i=0;i
for(int j=0;j
System.out.print(arr1[i][j]);
}
System.out.println();
}
1.面向对象
面向对象是一种对现实世界理解和抽象的方法，是相对于面向过程来讲的，把相关的数据和方法组织成一个整体来看。
2.面向对象和面向过程
面向过程 : 侧重分步骤 面向对象 : 侧重分模块
面向有对象优势 : 可扩展性,可维护性,灵活性,使程序耦合度降低
缺点 : 性能比面向过程相对较差
3.类和对象
类 定义属性模板,只定义有什么属性什么功能
对象 具体的个体,封装了属性的值
4.构造方法
实例化对象使用,创建对象时会自动调用构造方法
构造方法是每个类都有的，而且用来创建该类的对象
如果没有编写构造方法，编译器会自动帮忙生成一个无参构造。
如果编写了构造方法，不管写的是否有参，默认的无参构造都不会再自动生成。
所以当我们在编写有参构造的时候，可以手动编写一个无参构造。
构造方法语法：修饰符 方法名/类名 (参数列表) {方法体}
构造方法的修饰符，只使用权限控制，不能使用static修饰
构造方法没有返回值，连void都没有
构造方法的方法名必须和类名一致
5.如何确定使用静态属性和成员属性：
静态变量：对象之间共有的属性和值
成员变量：对象之间共有的属性不同的值，但值也可相等
静态方法：方法中不需要使用成员属性的时候，定义为静态方法
成员方法：方法中需要使用成员属性的时候，定义为成员方法
6.getter/setter方法
private int age;
//通过set和get方法给age赋值或获取
public void setAge(int age){
if(age<1)
this.age=1;
else
this.age=age;
}
public int getAge(){
return age;
}
7.实例化对象
加载类到静态区
堆内存创建对象空间
执行构造方法
返回堆内存地址
8.对象使用
对象.成员变量
对象.成员方法(参数)
9.bean
一个公共的类，私有化的属性，公共的获取属性的方法(getter/setter)，公共的无参构造
POJO：简单的JAVA对象，普通的javabeans
//性别
private boolean sex;
public boolean isSex() {
return sex;
}
public void setSex(boolean sex) {
this.sex = sex;
}
10.常见异常
空指针异常：当使用null值访问成员属性的时候，出现空指针异常。
Exception in thread “main” java.lang.NullPointerException
对象调用静态属性
静态属性使用类名调用，也可以使用对象调用，在编译阶段，会把对象转换为类名调用，所以该变量是不是null没有关系。
静态方法中无法直接使用非静态属性，需要使用对象调用才可以
成员方法中可以直接使用非静态属性，静态属性。
this
表示当前对象内存地址
区分成员和局部
重载调用构造方法
链式调用
static
修饰静态关键字
静态变量
静态方法
静态语句块
封装
包机制
导包
权限控制修饰符
继承 extends表示
super 表示父类型特征
覆写 父类功能无法满足子类需求的时候,需要进行方法覆写
必须有继承关系
方法名,返回值,参数列表必须一致
不能有更低的访问权限
不能有更宽泛的异常
