java基础知识点整理剖析Word格式文档下载.docx
《java基础知识点整理剖析Word格式文档下载.docx》由会员分享，可在线阅读，更多相关《java基础知识点整理剖析Word格式文档下载.docx（84页珍藏版）》请在冰豆网上搜索。
二：
00000000
十：
1286432168421
2、数据类型
基本数据类型：
数值型：
整型：
Byte-128--1271字节
Short-32768-327672字节
Int10位数4字节
Long20位数8字节
浮点型：
float单精度f后缀4字节
Double双精度（默认）8字节
字符型：
char0-65535字母一字节，汉子默认2字节
布尔型：
booleantrue、false一字节
引用数据类型：
类：
class
数组：
[]数组为实体，应用时要用new建立实体
接口：
interface
字符串：
String
数据类型的转换：
自动类型转换：
小的类型向大的类型转换（字节长度）
Char-int-long-float-double
当遇到浮点型时，全部转换成浮点型
强制类型转换：
将大的类型强制转换成小的类型，
可能造成精度缺失，数据丢失
用法：
（数据类型）（数据）
类型转换图例
Char类型在和数值运算时、为ASCII编码表中的数值
如：
’a’=97,‘A’=65‘i’=49
ASCII编码表是程序员为了方便，设计的一张生活中字符和二进制值的对应表，方便计算机识别生活中的字符
变量：
作用：
用来存储数据
解释：
内存中的一块存储空间
作用范围：
只在变量所在的｛｝范围内起作用
格式：
数据类型变量名=值（数据）
注意：
1.只能存储一个3.只可在同一类型内进行变化
2.存储的数据是可变的
3、运算符
包括：
算术运算符赋值运算符逻辑运算符（比较运算，逻辑运算）
位运算符位移运算符三元运算符
算术运算符：
+-*/++--%
%取余/模切关算法（除以2非1即0）符号正负只看左边
++自增--自减1.针对变量本身（作用于变量）
2.放在变量的前后都可以
3.符号和变量，谁在前面先算谁
赋值运算符：
=+=-=*=/=%=
两边运算完结果，将右边的值赋于给左边
比较运算符：
>
<
>
=<
=!
===
作为数据的连接，形成表达式：
结果为Boolean型
逻辑运算符：
&
（and）|（or）!
&
||^（异或）
用于连接条件表达式，形成更复杂的表达式
和&
的区别：
与：
两边为true时，结果为true
：
左边无论是否为true，右边都要进行运算
左边为false时，右边不进行运算提高效率
|和||：
只要一边为true即为true
同上：
左边为true，右边不运算
^和|区别：
^:
异或,不同.两边不同,结果:
true
*true^true=false
*true^false=true
*false^true=true
*false^false=false
！
事物的另一面
位运算符：
&
与运算（and）6&
3true=1，false=0；
6|3|或运算（or）
110（6）110
011（&
3）|011
————————————
010
（2）101
位移运算符：
<
左移值<
位数计算为：
值*2^位数
右移值>
值/2^位数
无符号位右移
三元运算符：
（条件表达式）？
表达式1：
表达式2;
条件表达式的结果为boolean型，true或者为false
当表达式结果为true时，最终结果为表达式1；
当表达式结果为false时，最终结果为表达式2；
4、流程控制语句
顺序结构、分支结构、循环结构
分支：
判断：
if语句（三元运算符是if-else的简写，有局限性）
选择：
switch
If（条件表达式）｛code·
｝当不加｛｝时，只控制离它最近的一句
If（条件）{code·
}else{code·
}有且只有一种情况发生
}elseif{code·
}
应用：
开发中遇到不确定的情况，出现选择性判断时，用if...else区间判断。
Switch语句
switch（表达式）｛//byteshortintcharString
case值1:
Break；
case值2:
。
。
defaulf:
//默认
｝
从第一条case开始读，由“break”“｝”结束
只要匹配到了，就不再判断（case内容不判断），执行下一句，知道结束
应用：
当对几个固定常量进行匹配时，建议用switch,提高效率
区间判断时，用if（switch能写的if都可以做）
循环：
当某一些代码（动作）需要执行多遍时，可以将这一部分代码（动作）做循环体，放到循环中，由计算机帮我们执行
1.定义循环条件，控制循环次数（跳出循环条件）
While：
while（条件表达式）｛
循环体｝
do｛循环体｝while（条件表达式）;
While和do...while的区别：
While先判断后执行
Do...while先执行一遍后判断
For:
for（初始化表达式;
条件表达式;
循环体执行后的表达式）{
code...（循环体）}
当条件表达式不写时，默认为true
For和while的区别：
（变量在结束后的存在与否）
For结束后，变量消失，内存释放
While结束后，变量可以继续参加其他运算
三种循环语句的区别
while和do-while和for的区别：
1.语法不同
2.执行顺序不同
while循环：
先判断，再执行
do-while循环：
先执行，再判断
for循环：
3.适用情况
循环次数确定的情况，通常选用for循环
循环次数不确定的情况，通常选用while和do-while循环
跳转语句：
breakcontinuereturn（用来结束函数）
Break：
应用于switch和循环语句中
跳出语句，结束循环
Continue：
只用在switch语句中
继续（结束当前循环，继续下一循环）
循环标号：
给循环起名字。
方便break在其他位置结束循环
标号：
循环
函数
：
定义在类中具有特定功能的一段独立代码区域
也称为：
方法、功能、动作、行为
结构：
1、函数声明2、函数体
好处：
提高了代码的复用性
格式：
修饰符返回值类型函数名（参数列表）｛
函数体·
Return返回值；
｝//在没有和未知返回值时，返回值类型
处为void，可省略return；
谁调用的函数返回值就返回给谁
函数只有在被调用时才会执行（对象/类名）
函数是不允许嵌套的（函数内不可定义函数）
如何去定义函数？
1.两点明确？
返回值类型，功能结果
2.未知内容。
参数列表
函数的重载：
Overload
当类中出现两个或多个同名函数时，但参数列表不同，称为这几个函数重载。
前提：
1.函数名相同
2.参数列表不同（参数的个数和类型，顺序）
（重载的函数一般功能相同或相近）
函数的重载和返回值类型无关
在调用时，注意参数列表的顺序、、、
重写：
override子类沿袭父类的声明，改变了父类的函数体
数组
一系列同类型的数据集合
1.是用来存储数据的（其地址值存在栈内存中，实体存在堆内存中。
2.数据必须是同类型的
3.是固定长度的（在被创建出来是就必须明确数组的长度，二维数组可不明确其数据一维数组的长度）
4.数组有索引（下标、角标）：
给数组中元素的编号0-----length-1，
属性：
length数组的长度应用：
数组名.length
数据类型[]数组名=new数据类型[数组长度];
（数组是以实体存在的）
二维数组：
一系列一维数组的集合
数据类型[][]数组名=new数据类型[二维数组长度][一维数组长度]
数组创建时必须有长度，没给一维数组长度时，就代表没有
二维数组的每一个角标位存储的都是一维数组的地址，如果没有指定一维数组的长度时，默认为null;
常见数组的异常：
空指针异常：
NullPointerExcetion
引用型变量不指向内存中的实体，还继续操作该实体时
（如：
arr=null;
用null操作数据时
数组角标越界异常：
ArrayIndexOutOfBoundsExcetion
访问了实体中不存在的角标
数组的copy:
System.arrayCopy（beforeArray,2,afterArray,5,5）;
//从beforeArray数组的第2角标位开始复制5个数据到after数组的第五个角标位起，before数组不变
数组的扩容：
Arr=Array.copyof（arr,arr.length*2）
//扩容2倍，
杨辉三角：
publicstaticvoidYanghui（）{
intnum=7;
inta[][]=newint[num][num];
//第一个和最后一个数字为1
for（inti=0;
i<
num;
i++）{
a[i][i]=1;
a[i][0]=1;
}
//里面的数字计算
for（inti=2;
for（intj=1;
j<
num-1;
j++）{
a[i][j]=a[i-1][j]+a[i-1][j-1];
}
//前面三角空格
for（intj=0;
a.length-i;
j++）{
System.out.print（"
"
）;
//里面的数字隔开
=i;
j++）
System.out.print（a[i][j]+"
System.out.println（）;
}
Java内存的划分：
寄存器本地方法区方法区
栈内存：
存储的是引用（方法和实体的引用）和局部变量
都是在方法范围内定义的，所以说存的都是方法
栈内存中的内容随方法的加载而加载，消失而消失
堆内存：
存放的是实体（凡是应new创建的都是实体）
1.堆中的实体都有地址值，（一般通过地址值找到实体后引用）
2.堆内存中的数据都有默认值String：
null·
3.垃圾回收机制：
实体在没有任何引用指向时，会成为垃圾，不定时的被回收机制处理
排序方式
插入排序希尔排序
快速排序冒泡排序
选择排序堆排序
基数排序
选择排序：
拿着一个角标位对应的值和其他角标位的值进行比较（一轮确定一个最值），反复length-1次、、、
for（inti=0;
i<
arr.length-1;
i++）{
for（intj=i+1;
j<
arr.length;
j++）{
if（arr[i]>
arr[j]）{
inttemp;
temp=arr[i];
arr[i]=arr[j];
arr[j]=temp;
}}}
冒泡排序：
相邻的两个角标位上的数据进行比较
for（intj=0;
arr.length-1-i;
if（arr[j]>
arr[j+1]）{
temp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
插入排序：
就像抓纸牌一样，每次抽取数组中的一个数据，用此数据和已有的数据进行比较排序，（需要保证手中的数据是有序的）
publicstaticvoidsort（int[]arr）{
intcurrent;
//当前要抓到牌的位置.（数组的角标位）
intbefore;
//当前要插入序列中key的前一个位置
intkey;
//当前current对应的值
for（current=1;
current<
current++）{
key=arr[current];
before=current-1;
while（before>
=0&
arr[before]>
key）{
arr[before+1]=arr[before];
//大值向后移动
before--;
//一直向前递减.因为插入的数据要和前面序列中的数据挨个比较
arr[before+1]=key;
//最后插入数据
面向对象
面向过程---->
面向对象：
执行者----->
指挥者
面向过程：
程序员找到所有的功能并且将功能有序的联系起来，形成一定的模块。
强调的是流程动作！
是一种思想、认知
强调的是事物本身，其实就是将面向过程的动作进行了封装
有利于整个程序结构逻辑设计，提高程序的灵活性
更好的分析问题和解决问题，将复杂的问题简单化
特征：
封装继承多态
类和对象的关系
某一种事物的描述class
对象：
被描述的具体事物new
类的成员-->
对象中的成员：
想要被使用，前面必须有引用
成员变量（属性）：
定义在类中，函数外，存储在堆内存的对象中，
有默认值，随着对象的加载而加载，消失而消失
成员函数（行为）：
成员变量和局部变量的区别：
定义的位置：
存放位置：
局部：
方法、函数中栈内存中，自动释放
成员：
定义在类中，函数外，堆内存的对象中
作用域：
赋值：
所在的｛｝中必须有初始值才能进行其他操作
函数的运用而运用
所在的整个类中有默认值，可以没有初始化
随对象实体的加载而加载
函数传递参数:
一定要传入一个具体的实体（实体名称/匿名实体）.（如：
String[]时参入参数：
newString[]名）
权限修饰符
Private：
私有化可以修饰成员
被修饰的成员只在本类中有效，外界访问不到
在Java中，将成员私有化是封装的体现之一
默认：
Protected:
保护权限，被修饰的成员只可以被子类使用
Public：
公共权限
封装:
就是将开发细节进行隐藏,
需要让外界进行访问.就提供一些间接访问方式.
如:
在本类函数间传导。
setXxx（Xxxxx）,getXxx（）没有访问需求,可以不写.
This：
代表对象的引用（谁调用this所在的那个函数，就代表谁）
当成员变量和局部变量同名时，可以this.成员表示成员变量
Super:
代表父类的空间标识符。
用法和this差不多
如：
（super（）{}:
父类构造函数）
区别：
This先访问本方法/类中的属性，如果没有再访问父类
Super之间访问父类成员
This表示对象super表示父类空间的标识符
构造函数（构造器）
1.给对象做数据的初始化（可以传参形式）
2.创建对象
在不让外界创建本类的对象时，可以将构造函数私有化
1.函数名和类名相同
2.没有返回值类型（该位置上什么都不写）
3.多个构造函数可以以重载的形式存在
4.只有在创建对象时才执行对应的构造函数
5.构造函数不可调用（建立该对象也不可以）但构造函数间可互相调用（this（参数），且要放在构造函数的第一条语句处！
）
6.够着函数的第一句处，都有默认的super（）；
但当父类中没有空参数的构造函数时，子类需手动指定构造函数
7.this（XX）和super（xx）不能同时存在
8.类中有默认的空参数构造函数，当自定义了构造函数时，默认的构造函数消失。
构造代码块:
给所有对象进行初始化,在构造函数之前执行（放在任何位置都一样，对象创建时运行）.
静态代码块:
给类做初始化的.而且只执行一次.（在类加载到内存时执行.）
静态static（静态关键字）
修饰符，可以修饰成员（保存于方法区中）
特点：
1.被修饰的成员被所有对象共享（单独存储空间，节省空间）
2.被静态的成员多了一种调用方式类名.成员名
3.随着类的加载而加载，消失而消失。
生命周期最长！
（不要随意加静态，连锁反应，会导致数据驻留时间最长）
4.优先于对象而存在
1.静态只能调用静态
2.不能和this/super同时使用
当定义一个函数时，该函数没有用到对象的特有属性时，可以把该函数定义成静态的。
当类中所有方法都是静态的.那么可以将构造函数私有化,不让外界建立对象,避免麻烦和内存浪费.
存放的位置：
类变量随着类的加载存在于方法区中
实例变量随对象建立于堆内存中
静态代码块：
Static｛｝只执行一次（在类的加载时）
给类做初始化（类被加载时应当出现的一些内容）
设计模式
为了解决某一问题，提出的一套解决方案（Java有23种）
单例设计模式：
保证内存中，只有一个对象（对象的唯一性）
如何保证对象的唯一性呢？
1.不让外界建立对象-->
将构造函数初始化
2.在本类中创建对象
3.提供间接的访问方式
单例模式分析图
饿汉式：
1.构造函数私有化
Private类名（）｛｝
2.建立本类对象
Privatestatic类名对象名=new类名（）;
3.将建立好的对象提供出去
PublicStatic类名/对象名get·
（）{
Return对象名；
懒汉式：
（延迟加载模式）
2.建立本类对象
PrivateStatic类名对象名=null;
3.将建立好的对象提供出去
PublicStatic类名get·
（）｛
Synchronized（obj）{//解决安全问题
If（对象名==null）
对象名=new类名（）；
｝
模版设计模式
在定义功能时，一部分确定，一部分不确定，且确定部分还在使用不确定部分时，可以将不确定部分抽取出来，抛到外面，让外面去指定（另建函数指定功能，让确定部分调用）
Voida（）{
确定code...
不确定code...（b（）;
）b为另一函数
确定code...}
继承extends
让类于类间产生了关系（子类和父类）
好处：
提高了代码的复用性（私有化一样继承但不可用）
类于类之间可以单继承/多重继承，不可以多继承（多继承有不确定型）
继承体系中成员的特点：
用super.父类成员可以调用父类内容
成员变量：
当成员变量和局部变量同名时，可以使用super表示父类的引用
成员函数：
重写：
override/覆盖/覆写
子类沿袭父类的声明，改变方法的方法体
（调用重写时，运行的是子类的方法体）
注意：
1.重写时，子类上的函数权限要大于等于父类方法的权限（父类私有时不可被重写）
2.静态只能覆盖静态
继承体系构造函数的特点:
任何一个构造函数的第一条语句处,都默认有super（）;
不写,系统自己加.
当父类中指定了构造函数后,没有空参数的构造函数了,
那么子类就需要手动指定一下父类的构造函数.
子类一定要先走一遍父类构造函数?
?
子类继承父类,要使用父类中内容,所以,要先看父类如何对自己的内容进行初始化的.
在一个构造函数中,this（）和super（）不能同时使用.
继承的弊端：
打破了封装性，（方法的重写，使父类中方法的功能被覆盖）
最终化：
final
关键字：
修饰符可以用来修饰类、成员
修饰类时：
该类不能被继承
1.全局常量:
publicstaticfinal
2.抽象方法:
publicabstract
修饰方法时：
该方法不能被重写（保证父类的功能不变）
修饰变量时：
该变量只能（必须）被赋值一次，而且是显示赋值
抽象：
abstract
修饰符用来修饰类、方法
抽象类：
（和正常类的区
升级会员 