JavaSE知识内容
2020-04-16 11:05:28 2 举报AI智能生成
javase基础知识学习框架
作者其他创作
大纲/内容
课后习题注意
Question_02
Q4:int类型的sum，最大计算到12的阶乘，如果计算13的阶乘会超过int范围
拓展
获取随机数
java.util.Random random=new java.util.Random();
random.nextInt(3)//限定数字在3下，从0开始的所以注意＋1
控制台输入
程序运行中，可在控制台（终端）手动录入数据，再让程序继续运行
导包语法：import 包类.类名；//将外部class文件功能引入到自身文件中
使用顺序
导入java.util.Scanner
声明Scanner类型的变量
使用Scanner类中对应的函数（区分类型）
.nextInt();//获取整数
.nextDouble();//获得小数
.next();//获得字符串
.next().charAt(0);//获得单个字符
注：如果输入了不匹配的数据，则会产生java.util.InputMismatchException
进制的转换
什么叫进制?
逢十进一，每次到达10就往前进一位
常见的进制
10进制，2进制，16进制，8进制（程序）
String特殊性
String引用数据类型、对象类对象作比较
String引用数据类型与String对象类作比较S1.equals（S3）
String引用数据类型与String引用数据类型作比较：比较的是地址
比较字符串不相同时，可使用！
Eclipse基本使用
创建project
file>new>project>Java Project
Java文件
src下创建package，再创建Class(.Java文件)
修改字体
编辑字体
Windows>Preferences>General>Appearance>Colors And Fonts>Basic>Text Font
输出字体
Windows>Preferences>General>Appearance>Colors And Fonts>Basic>Console Font
视图板块
Window>Show View
重置窗口布局
Windows>Perspective>Reset Perspective
运行快捷键
ctrl+F11
导入外部项目
file>import>general>existing project into Woekspace>browse
格式化代码
ctrl+shift+f
附加源代码
Windows
Preferences
Java
Intstalled JERs
选中JRE——Edit JRE
rt.jar
Source Attachment
找带src.zip
使用选择对象，选择后按F3
导包
ctrl+1
悬浮选择
时间
Sysytem.currentTimeMillis();获取当前系统的毫秒值
1970.1.1 00：00：00~当前
当前系统的秒值/1000
当前系统的分钟/1000/60
当前系统的小时1000/60/60
当前系统的天1000/60/60/24
System.nanoTime();
反编译
cmd
javap -verbose 类名>类名.bytecode
JavaSE知识内容
概述与环境搭建
java的由来
java的语言特点
面向对象
简单
跨平台
计算机执行机制
编译执行
在具体环境中（windows）执行一次翻译工作（源代码—>二进制），执行时，执行的是二进制文件。执行效率高，但是不能跨平台。什么叫编译执行，先翻译，然后执行的是翻译后的文件，执行效率高，但是不能跨平台。
解释执行
在具体环境中一行一行解释并执行，不同环境都有自己的解释器。可以跨平台，执行效率低。
java的执行机制
先编译、在解释
名词解释
JVM:Java虚拟机
JRE:Java运行环境
JDK:Java开发环境
环境搭建
安装jdk
配置环境变量
用户变量中JAVA_HOME(jdk绝对路径)
系统变量中path（\\%JAVA_HOME%\\bin）
测试
第一个java程序
注意：文件扩展名，，文件显示为详细信息
Java的语言规则
编译与运行
javac xxx.java
java 类名
类的阐述
同一个源文件中可以定义多个类
编译后，每个类都会生成独立的.class文件
一个类中，只能有一个主函数，每个类都可以有自己的主函数
public修饰的类称为公开类，要求类名必须与文件名称完全相同，包括大小写
一个源文件中，只能有一个公开类
Package包
包的声明：package 包名;（全小写，不以.开头或结尾）
作用：归纳 整理 管理.class文件
为生成的字节码文件，增加一个前缀，进而加以区分可能存在的同名class，达到class文件的管理效果，区分效果。
加入了package的声明之后，可以有效的区分同名的.class文件
命名规范
类名：HelloWorld MyPack (帕斯卡命名法)
函数名、变量名：main、run、testMethod（驼峰命名法）
包名：com.qf.teach;全小写，不以.开头或结尾 （一般从大到小，这样重复时在后加位置即可）
常量：HELLOW_WORLD 全部大写
语言基础
前置内容
nodepad++的设置
菜单栏—语言—J—Java设置开发语言（自动识别语言的关键字）
编辑完文件之后，记得Ctrl+S进行保存（在编辑器的左上端，*表示当前文件未保存）
菜单栏—设置—语言格式设置—可调整字体、字体大小，注意：点击“使用全局字体、使用全局字体大小”
菜单栏—设置—首选项—新建—右侧的编码选项下，选中GB2312(中文的字符编码)
前置知识
什么是内存？
内存即是一块瞬时状态的存储空间，有一定的容量
内存与硬盘的区别?
内存的造价比较高，整个的计算机硬件资源稀缺
计算机给Java大多的内存空间？
java虚拟机（java程序），默认分配的物理内存容量是计算机1/8
计算机存储容量的基本单位?
bit(位-8位等于1字节)-byte(1字节)-KB-MB-GB-TB-PB-EB-ZB-YB-BB-NB-DB-CB-XB(1024进制关系)
变量
计算机内存中的一块存储空间，是存储数据的基本单位
组成部分
数据类型
变量名
值
声明的三种方式
先声明，再赋值
声明并赋值
多个同类型变量的声明与赋值
基本数据类型
整数
byte
1字节
-2^7~2^7-1
short
2字节
-2^15~2^15-1
int（默认）
4字节
-2^31~2^31-1
long
8字节
-2^63~2^63-1
小数(支持科学计数法2E3等)
float
f/F
double（默认）
布尔
boolean
字符
char范围0-65535
转义字符（1.可以将特殊转普通2.普通转特殊）
\\'
\\\"
\\\\
\\t
\
引用数据类型
字符串
String
数组
对象
类型的转换
自动类型转换
两种类型相互兼容，目标类型大于源类型
强制类型转换
两种类型相互兼容，目标类型小于源类型
转换规则
整数长度足够，数据完整
整数长度不够，数据截断
小数强转整数，数据截断
字符整数互转，数据完整
保证正整数转换成字符，可以正常显示
boolean不可与其他类型转换
运算符
算数运算符
+ - * / % ++ --
赋值运算符
= += -+ *= /= %=
关系运算符
> < >= <= == !=
逻辑运算符
&& || !
三元运算符
布尔表达式？结果1：结果2
选择结构与分支结构
选择结构
基本if选择结构
if else选择结构
多重if选择结构
相互排斥，有一个选项为true，其他选择不再执行，适用于区间判断
嵌套if选择结构
可以在一个选择结构当中，嵌套另一个选择结构，语法正确、格式正确的情况下，可以任意组合
分支结构
switch适用于byte short int char String（JDK7+）
注意:switch的case被选中后，不会主动退出这个结构，需要手工追加break，跳出整个switch。
多个case取值不可以相同
局部变量
概念：声明在函数内部的变量，必须先赋值，再使用。
作用范围：从定义行开始，到所在代码块结束
注意：作用域从{开始到}结束
注意:多个变量，在重合的作用范围内，不允许重名。
循环
定义:通过某个条件，是一段代码周而复始的执行
循环的概念
循环的组成部分
初始部分
循环用以判断的变量
循环条件
决定是否继续循环的依据
循环操作
单次执行的逻辑代码或任务
迭代部分
控制循环条件改变的增量
被循环条件判断的变量，才是初始部分和迭代部分！
流程控制
break：终止、跳出switc、循环结构
contiune
结束本次、进入下一次循环
三大循环结构
while循环
特点
首次既有入口条件，先判断、再执行，适用于循环次数明确的情况。
首次判断不满足，则一次都不会执行。
语法
while（布尔表达式）{}
注意:被循环条件判断的变量，才是初始部分和迭代部分
for循环
for（初始部分；循环条件；迭代部分{循环操作}
do while
应用场景：适用于循环次数不明确的情况
首次没有入口条件，先执行再判断
do{}while（布尔表达式）
循环嵌套
定义：在一个完整的循环结构中，嵌套另一个完整的循环结构
函数
概念：实现特定功能的一段代码，可反复使用
函数的定义
函数定义在类的内部，与main函数并列
public static void 函数名称（）{//函数主体}
函数的调用
在需要执行函数代码的位置，通过函数名称进行调用
函数的执行
注意:调用函数时，会优先执行函数内部代码，结束后，返回到函数调用处，继续执行向下执行。
返回值与返回值类型
原因:函数调用时，一些情况下无需返回结果；另一些情况则必须返回结果。
定义语法:public satatic 返回值类型 函数名称（形式参数列表）{//函数主题；return value；}
注意:根据需求返回一个结果，规定返回值的具体类型font color=\"#c41230\
return关键字
一个函数只能有一个返回值
当有返回值的函数存在分支结构时，必须保证每一条分子都具有正确的返回值
两种用法：
return应用在具有返回值类型的函数中
表示结束当前函数，并伴有返回值，返回到函数调用处
return应用在没有返回值类型（void）的函数中
表示结束当前函数，直接返回函数调用处
总结：
一个函数可以定义多个函数，函数之间属于并列关系，不可嵌套
一个函数只做一件事情
好处：
减少代码冗余
提高复用性
提高可读性
提高可维护性
方便分工合作
多级调用
优先执行函数内部代码，结束后，返回到调用处，继续向下执行
无穷递归
Exception in thread\"main\"java.lang.StackOverFlowError内存溢出
当函数自己调用自己时，如果没有正确的出口条件，则产生无穷递归
递归
在实际开发中，递归可以解决具有既定规律的特定问题
何时使用递归？
当需要解决的问题可以拆分成若干个小问题，大小问题的解决方法相同
有固定规律，函数中自己调用自己
递归阶乘
递进
每一次推进，计算都比上一次简单，直至简单到无需继续推进，就能获得结果。也叫到达出口
回归
基于出口的结果，逐层向上回归，依次计算每一层的结果，直至回归到最顶层
注意：所有能以递归解决的问题，循环都可以解决。当解决复杂问题时，递归更为简单。
概念
一组连续的存储空间，存储多个相同类型的值
数组的创建
先声明再分配空间
int[] a;a=new int[5]
声明并分配空间
int[] a=new int[5]
声明int数组类型变量定义变量名为a
分配长度为5的存储空间
声明并赋值(繁)
声明并赋值（简）
自动推导，不可两部来。
数组的使用
数组中的每个数据格被称为“数据元素”
对每个元素进行赋值或取值的操作被称为“元素的访问”
访问元素是，需要使用“下标”（从0开始，依次+1，自动生成）
访问的语法：数组名[下标]；
访问无效下标，会导致数组下标越界
数组的遍历
遍历:从头到尾，逐一对数组的每个元素进行访问
数值的默认值
整数：0
小数：0.0
字符：\\u0000
布尔:false
其他：null
数组的扩容
创建数组时，必须显示指定长度，并在创建之后不可更改长度
思路
创建大于原数组长度的新数组中
将原数组中的元素依次复制到新数组中
数组复制的方式
长度*2，复制到源数组遍历
java.util.Arrays.copyOf(原数组，新长度)//返回带有原数组的新数组
地址的替换
数组作为引用类型之一，其变量中存储的是数组的地址
数组类型的参数
可变长参数//用于零散数字存于数组
可接收多个同类型实参，个数不限，使用方式与数组相同
数据类型...形参名 //必须定义在形参列表的最后，且只能有一个，支持0~N个参数
补：是对数组的一种便利写法的补充(80%的场景用数组，20%的场景用可变长参数)
子主题
引用数据类型传的是地址值
引用数据类型在函数中返回类型写void类型，函数内定义的接受传过来地址的数组对数据的修改是有效的，因为地址值传过去了。
基本数据类型传的是值
一方改变，不会影响另一方
二维数组
定义:一维数组中的一维数组，数组中的元素为数组
赋值：int[][] array=new int[行][列]
高纬数组中存的低维数组的地址
创建
数据类类型[][]数组名；数组名=new 数据类型[][]
数据类型[][]数组名=new 数据类型[][]
声明并赋值（繁）
数据类型[][]数组名=new 数据类型[n][];
数组排序
冒泡排序
相邻的两个数值比较大小，互换位置
外层循环为趟数，次数为数组长度-1，当倒数第二个数字排出来后，不需比较最后一个
内层循环实现相邻两个数字比较，将最大或最小移动到最右侧，并换位置，次数为数组长度-i-1，一趟只能排出一位数字
选择排序
固定值与其他值依次比较大小，互换位置
外循环为固定的位置为数组长度-1
内层循环固定一个值，与其他位置进行比较。而固定值为外循环i确定，为固定值后一位开始比则为i+1，j=i+1，j<数组的长度，j++
JDK排序
java.util.Arraays.sort(数组名)；//升序
若想降序则颠倒位置i=0；i<nums.length/2;i++
什么是对象
一切客观存在的事物都是对象，万物皆对象
任何对象皆有自己的特征和行为
特征
称为属性，一般为名词，代表对象有什么
行为
称为方法，一般为动词，代表对象能做什么
程序中的对象
如何使用程序模拟现实世界，解决现实问题？
首先，在程序中，必须具有和现实中相同的对象，用以模拟现实世界
然后，使用程序中的对象代表现实中的对象，并执行操作，进而解决现实问题
现实中的对象多数来自于(模板+工厂)，程序的对象也应该具有模板（类）
对象的创建
Dog dog1=new Dog();//创建Dog类型的对象，并保存在dog1中
将对象保存在相同类型的Dog中，其中dog1称对象名或引用名
访问属性：对象名.属性名=值；赋值取值都如此
调用方法：对象名.方法名();
类的组成
类的抽取
在一组相同或类似的对象中，抽取出共性的特征和行为，保留所关注的部分
用类可以创造出多个对象，程序的对象的模板为类
类的定义
属性：通过变量表示，又称实例变量
语法：数据类型 属性名；
位置：类的内部，方法的外部
方法：通过函数表示，又称实例方法。
语法：public 返回值类型 方法名（形参）{}不再写static
类和对象的关系
类:定义了对象应具有的特征和行为，类是对象的模板
对象：拥有多个特征和行为的实体，对象是类的实例
实例变量与局部变量
定义位置
局部变量定义在主方法或方法内的结构当中
实例变量定义在类的内部，方法的外部
默认值
局部变量无默认值
实例变量默认值为字面值
使用范围
局部变量从定义行到包含其结构结束
实例变量本类有效
命名冲突
局部变量不允许重名
可与局部变量重名，局部变量优先
方法重载
在一个类中定义多个相同名称的方法
要求：方法名相同、参数列表不同，与访问修饰符，返回值无关
屏蔽用户差异，方便
构造方法
类中用来创建对象的特殊方法，名称与类名相同，没有返回值
特点:名称和类名相同，没有返回值类型
创造对象时（new对象时），触发构造方法的调用，不可通过句点的形式手工模式
注意：如果类中没有显示定义构造方法时，则编译器默认提供无参构造方法
this关键字
类是模板，可服务于此类所有对象；this是类中的默认引用，代表当前实例。当创建s1对象时，this指向0x0000A001，访问name属性则是0x0000A001地址里面的name
用法:
1.调用实例属性、实例方法。当实例变量和局部变量重名时，如需访问实例变量，则需要加this
2.调用本类中的其他构造方法中的已被赋值的方法类局部变量的再复用。
注意:必须在构造方法的首行，不存在普通方法中。
三种特性
封装
概念：尽可能隐藏对象的内部实现细节，控制对象的修饰及访问的权限
访问修饰符：private（将属性修饰为私有，仅本类可用）
注意：用private修饰的属性外部不能访问，外部new对象后，赋值取值都不能进行，则需要在类中定义两个方法。访问公共方法
调用方法完成赋值操作setXxx
调用方法完成取值操作getXxx
继承
程序中的继承，是类与类之间特征和行为的一种赠与获得
类与类之间必须满足“is a”的关系
父类的选择
功能越精细，重合点越多，越接近直接父类。功能越粗略，重合点越少，越接近Object类。
父类的抽象
可根据程序需要使用到的多个具体类，进行共性抽取，进而定义父类。
在一组相同或类似的类中，抽取出共性的特征和行为，定义在父类中，实现重用。
语法：class子类extends父类{}//定义子类时，显示继承父类
应用：产生继承关系之后，子类可以使用父类中的属性和方法，也可定义子类独有的属性和方法
完整的子类=父类共性+子类特性
好处：既提高代码的复用性，又提高代码的可扩展性
特点：Java为单继承，一个类只能有一个直接父类，但可以多级继承，属性和方法逐级叠加
访问修饰符
private
本类√
同包×
非同包子类×
其他×
default默认
同包√
public
非同包子类√
其他√
protected
不可继承
父类的构造方法，子类不可继承
父类的prite修饰的成员。不可继承（不可见）
父类由default修饰的成员，子类不在同包时，不可继承（不可见）
方法的覆盖
当父类提供的方法无法满足子类需求时，可以在子类中定义和父类相同的方法进行覆盖。
要求
方法名、参数名、返回值必须与父类完全相同
访问修饰符应与父类相同或比父类更宽泛
执行机制
子类覆盖父类方法后，优先执行子类覆盖后的方法版本
继承中的对象创建
在具有继承关系的对象创建中，构建子类对象会先构建父类
无参构造方法中隐式存在super()
super关键字
在子类，可直接访问从父类继承到的属性和方法，但如果父子类的属性或方法存在重名，需要加以区分，才可专项访问。
继承父类的子类的属性名与父类属性名相同时，子类方法中使用该属性时使用super.调用父类属性名
继承父类的子类的方法覆盖时，执行代码区想调用父类此方法时使用super.
访问属性：
若类中的实例变量与方法中的局部变量名相同时用this.使用实例变量。
两种方法：
super.父类属性，父类方法（）
在子类的构造方法的首行，使用super()或super(实参)
注意:
如果子类构造方法中，没有显示定义super()或super(实参)，则默认提供super（）
多态
不同人物角色看待同一对象的视角不同，关注点也不相同
生活中的多态是指“客观事物在人脑中的主观反应”
主观意识上的类别与客观存在的对象具有“is a”关系，即形成多态。
这是什么动物?
将子类对象当作父类类别看待
程序中的多态
父类引用指向子类对象，从而产生多种形态
二者具有直接或间接的继承关系时，父类引用可指向子类对象，即形成多态
父类引用仅可调用父类所声明的属性和方法，不可调用子类独有的属性和方法。
应用
使用父类作为方法形参实现多态，使方法参数的类型更为宽泛
使用父类作为方法返回值实现多态，使方法可以返回不同的子类对象
向上转型
父类引用中保存真实子类对象，称为向上转型
注意：仅可调用Animal中所声明的属性和方法
向下转型
将父类引用中的真实子类对象，强制回子类本身类型，称为向下转型
注意：只有转换回子类真实类型。才可调用子类独有的属性和方法
类型转换异常
向下转型时，如果父类引用中的子类对象类型和目标类型不匹配，则会发生类型转换异常
instanceof关键字
向下转型前，应判断引用中的对象真实类型，保证类型转换的正确性
语法：父类引用 instanceof 类型 //返回boolean类型结果
作用
屏蔽子类间的差异
灵活、隅合度低
三个修饰符
抽象
抽象类
具备某种对象的特征，但不完整
应用：
abstarct修饰类，此类不能new对象
可被子类继承，提供共性属性和方法
可声明为引用，更纯粹的使用多态
经验
抽象父类，可作为子类的组成部分依附于子类对象存在，由父类共性+子类独有组成完整的子类对象
抽象方法
只有方法声明，没有方法实现不用花括号，意为不完整的方法，必须包含在抽象类中
产生继承关系后，子类必须覆盖父类中所有的抽象方法，否则子类还是抽象类。
static
int a；
实例属性是每个对象各自持有的独立空间，对象单方面修改，不会影响其他对象
jvm（局部变量）和heap堆（对象）
static int b；
静态属性是整个类共同持有的共享空间，任何对象修改，都会影响其他对象
方法区（存储类的相关信息）1.类的信息 2.父类是谁 3.实例属性 4.静态属性 5.实例方法 6.静态方法 7.类的创建时间 8.类的编辑JDK版本 9类的加密
什么是静态
静态可以修饰属性和方法
称为静态属性（类属性）、静态方法（类方法）
静态成员是全类所有对象共享的成员
在全类中只有一份，不因创建多个对象而产生多份。
不必创建对象，可直接同通过类名.属性名以及类名.方法名来访问
静态方法
在本类中通过“静态方法名”访问
其他类中，通过类名.静态方法名访问
静态特点
静态方法允许直接访问静态成员
静态方法不能直接访问非静态成员
静态方法不允许使用this或是super关键字
静态方法可以继承，不能重写，没有多态
类加载
jvm首次使用某个类时，从过CLASSPATH查找该类的.class文件，并将.class文件中对类的描述信息加载到内存中，进行保存
加载时机
创建对象
创建子类对象
访问静态属性
调用静态方法
Class.forName(\"全限定名\")
静态代码块
类加载的执行环节，执行地位和静态属性一致，只有首次加载时，需要执行，仅一次。可为静态赋值，或程序必要的初始行为
final
final关键字
修饰类此类不能被继承
String、Math、System均为final修饰的类，不能被继承
修饰方法：此方法不能被覆盖
修饰变量：此变量值不能被改变（常量）
只能被赋值一次，不允许修改
实例变量
实例常量不再提供默认值，必须手动赋予初始值。
赋值时机：显示初始化、动态代码块、构造方法
要求：
实例常量赋值deadline，在构造方法完成之前，为实例常量赋值即可
如果在构造方法中为实例常量赋值，必须保证所有的构造方法都能对其正确赋值。
静态常量
赋值时机：显示初始化、静态代码块
静态常量赋值deadline，在类加载完成之前（通过类名调用之前），为静态常量赋值即可。
对象常量
final修饰基本类型：值不可变
final修饰引用类型：地址不可变
接口
接口的语法
接口相当于特殊的抽象类，定义方式、组成部分与抽象类类似
使用interface定义接口，没有构造方法，不能创建对象。只能定义：公开静态常量、公开抽象方法
与抽象类的异同
相同
也可以编成字节码文件
不能创建对象（接口不是类，不是模板的概念，也没有构造方法）
可以作为引用类型
具备Object类中多定义的方法
不同
所有属性都是公开静态变量
隐式使用public static final修饰
所有方法都是公开抽象方法
隐式使用public abstract修饰
没有动态代码块，没有构造方法，没有静态代码块
什么是接口（微观）
接口是一种能力和约定
接口的定义：代表了某种能力
方法的定义：能力的具体要求
Java为单继承，当父类的方法种类无法满足子类需求时，可实现接口扩充子类能力
接口支持多实现，可为类扩充多种能力
接口的规范
任何类在实现接口时，必须实现接口中所有的抽象方法，否则此类为抽象类
实现接口中的抽象方法时，访问修饰符必须是public
接口引用
同父类一样，接口也可声明为引用，并指向实现类对象
注意：
仅可调用接口中所声明的方法，不可调用实现类中独有的方法
可强转回实现类本身类型。进行独有方法调用
接口的多态
多种不同类型的引用指向同一个对象时，表示看待对象的视角不同。不同引用所能看到的对象范围不同，只能调用自身类型中所声明的部分
不同引用类型，仅可调用自身类型中所声明的方法
常见关系
类与类
单继承
extends父类名称
类与接口
多实现
implements接口名称1，接口名称2，接口名称n
接口与接口
多继承
extends父接口1，父接口2，父接口n
常量接口
将多个常用于表示状态或固定值的变量，以静态常量的形式定义在接口中统一管理，提高代码的可读性
什么是接口（宏观）
接口是一种标准
*接口回调
先有接口的使用者，后有接口的实现者
接口的好处
程序的耦合度降低
更自然的使用多态
设计与实现完全分离
更容易搭建程序框架
更容易更换具体实现
内部类与常用类
内部类
什么是内部类？
在一个类的内部再定义一个完整的类
编译之后可生成独立的字节码文件
内部类可直接访问外部类的私有成员，而不破坏封装
可为外部类提供必要的内部功能组件
四种
成员内部类
在类的内部定义，与实例变量、实例方法同级别的类
外部类的一个实例部分，创建内部类对象时，必须依赖外部类对象
在外部类、内部类存在重名属性时，会优先访问内部类属性
成员内部类不能定义静态成员
静态内部类
不依赖外部类对象，可直接创建或通过类名访问，可声明静态成员
只能直接访问外部类的静态成员
实例成员需要实例化外部类对象
局部内部类
定义在外部类方法中，作用范围和创建对象范围仅限于当前方法
局部内部类访问外部类当前方法中的局部变量时，因无法保障变量的生命周期与自身相同，变量必须修饰为final
限制类的使用范围
匿名内部类
没有类名的局部内部类（一切特征都与局部内部类相同）
必须继承一个父类或者实现一个接口
定义类、实现类、创建对象的语法合并，只能创建一个该类的对象
优缺点：
优点：减少代码量
缺点：可读性较差
Object类
超类、基类，所有类的直接或间接父类，位于继承树的最顶层
任何类，如没有书写extends显示继承某个类，都默认直接继承Object类，否则为间接继承
Object类中所定义的方法，是所有对象都具有的方法
Object类型可以存储任何对象
作为参数，可以接受任何对象
作为返回值，可返回任何对象
getClass()方法
public final Class<?> getClass(){}
返回引用中存储的实际对象类型
应用:通常用于判断两个引用中实际存储对象类型是否一致
hashCode（）
public int hashCode（）{}
返回该对象的十进制的哈希码值
哈希算法根据对象的地址或字符串或数字计算出来的int类型的数值
哈希码并不唯一，可保证相同对象返回相同哈希码，尽量保证不同对象返回不同哈希码
toString
public String toString(){}
返回该对象的字符串表示（表现形式）
可以根据程序需求覆盖该方法，如：展示对象各个属性值
equals（）
public boolean equals(Object obj){}
默认实现为（this==obj），比较两个对象地址值是否相同
可进行覆盖，比较两个对象的内容是否相同
比较两个引用是否指向同一对象
finalize（）
当对象被判为垃圾对象时，由JVM自动给调用此方法，用以标记垃圾对象，进入回收队列。
垃圾对象：没有有效引用指向此对象时，为垃圾对象
垃圾回收：由GC销毁垃圾对象，释放数据存储空间。
自动回收机制：JVM的内存耗尽，一次性回收所有垃圾对象。
手动回收机制：使用System.gc();通知JVM执行垃圾回收。
包装类
什么是包装类?
基本数据类型所对应的引用数据类型
Object可统一所有数据，包装类的默认值null
包装类中实际上就是持有了一个基本类型的属性，作为数据的存储空间（Byte中有一个byte属性），还提供了常用的转型方法，以及常量，既可以存储值，又具备了一系列的转型方法和常用常量，比直接使用基本类型的功能更强大
包装类中提供了若干转型的方法，可以让自身类型与其他包装类型、基本类型、字符串相互之间进行转换
包装类对应
byte short int long float double boolean char
包装类型
Byte Short Integer Long Float Double Boolean Character
转换方法
8种包装类型中，有6种是数字型，继承来自java.lang.Number父类
byteValue()
shortValue()
intValue()
flaotValue()
doubleValue()
java.lang.Number父类为所有子类分别提供了6个转型方法，将自身类型转换为其他数字型
parseXxx（String s）静态转型方法：7种包装类型都有，除了Character，都可以通过String进行构建
valueOf（基本类型）、valueOf（字符串类型），静态转型方式，8种包装类型都有
装箱、拆箱
JDK5之后，提供自动装箱、拆箱，简化使用包装类的编程过程
自动装箱，将基本类型直接赋值给包装类型
自动拆箱，将包装类型的值，直接赋值给基本类型
整数缓冲区
Java预先创建了256个常用的整数包装类型对象
在实际应用当中，对已创建的对象进行复用
String类
字符串是常量，创建之后不可改变
字符串字面存储在字符串池中，可以共享
String s = new String（“hello”）；//产生两个对象，堆、池各存储一个
String s = “hello”，产生一个对象，字符串池中存储
常用方法
public char charAt(int index)//获取下标值
public boolean contains(String str)//判断当前字符串中是否包含str
public char[] toCharArray()//将字符串转换成数组
public int indexOf(String str)//查找str首次出现的下标，存在，则返回该下标；不存在，则返回-1
public int lastIndexOf(String str)//查找字符串在当前字符串中最后一次出现的下标索引
public int length()//返回字符串的长度
public String trim()//去掉字符串前后的空格
pulic String toUpperCase()//将小写转成大写
public boolean endWith(String str)//判断字符串是否以str结尾
public String replace（char oldChar，char newChar）//将就字符串替换成新字符串
public String[] split(String str)//根据str做拆分
BigDecemal类
很多实际应用中需要精准运算，而double是近似值存储，不在符合要求，需要借助BigDecimal
位置：java.math包中
作用：精准计算浮点数
创建方式：BigDecimal bbd = new BigDecimal（“1.0”）;
方法：
BigDecimal add(BigDecimal bd)加
BigDecimal subtract(BigDecimal bd)减
BigDecimal multiply(BigDecimal bd)乘
BigDecimal divide(BigDecimal bd)除//进行除法运算时，如果不能准确的计算出结果时需要指定保留的位数和取舍方式
集合
概念：对象的容器，存储对象的对象，可代替数组
特点：容器的工具类，定义了对多个对象进行操作和常用方法
位置：java.util.*
Collection体系集合
Interface Collection 该体系结构的根接口，代表一组对象，称为“集合”。一些集合允许重复元素，有一些有序有一些无序。JDK不提供此接口的任何直接实现：它提供了更具体的子接口的实现，如Set和List。
List接口：有序、有下标、元素可重复
Set接口：无序、无下标、元素不能重复
特点：代表一组任意类型的对象，无序无下标。
boolean add（Object obj）//添加一个对象。 boolean addAll（Collection c）//将一个集合中的所有对象添加到此集合中。 void clear()//清空此集合中的所有对象。 boolean contain（Object o）//检查此集合中是否包含o对象 boolean equals（Object o）//比较此集合是否与指定对象相等。 boolean isEmpty（）//判断此集合是否为空 boolean remove（Object o）//在此集合中移除o对象 int size（）//返回此集合中的元素个数。 Object[] toArray() //将此集合转换成数组。
List接口与实现类
List集合
特点：有序、有下标、元素可以重复。可继承父接口提供的共性方法。同时定义了一些独有的与下标相关的操作方法。
List实现类
ArrayList【重点】：
数组结构实现，查询快、增删慢；
JDK1.2版本，运行效率快、线程不安全。
1. JDK8的ArrayList，实际初始长度是0 2. 首次添加元素时，需要实际分配数组空间，执行数组扩容操作 3. 真正向数组中插入数据，用的时候再创建，或再加载，有效的减低无用内存的空间。
Vector：
数组结构实现，查询快、增删慢；
JDK1.0版本，运行效率慢、线程安全。
LinkedList：
链表结构实现，增删快，查询慢。
- 链表结构存储 - Queue接口：队列、双端队列 - 栈结构后进先出，队列结构先进先出
Set接口与实现类
Set子接口
无序、无下标、元素不可重复（当插入新元素时，如果新元素与已有元素进行equals比较，结果为true时，则拒绝新元素的插入）
Set实现类
HashSet
基于HashCode实现元素不重复
当存入元素的哈希码相同时，会调用equals进行确认
LinkedHashSet
链表实现的HashSet，按照链表进行存储，即可保留元素插入的顺序。
TreeSet
基于排列顺序实现元素不重复。
实现了SortedSet接口，对集合元素自动排序。
元素对象的类型必须实现Comparable接口，指定排序规则。
通过ComparaTo方式确定是否为重复元素。
Map接口与实现类
Map接口的特点：
用于存储任意键值对（Key—Value）
键：无序、无下标、不允许重复（唯一）
值：无序、无下标、允许重复
Map父接口
特点:存储一对数据（Key—Value），无序、无下标，键不可重复，值可重复。
Map集合的实现类
HashMap【重点】：
-JDK1.2版本，线程不安全，运行效率快，允许用null作为key或value
`HashMap算法:拿到任何一个对象，通过hash（key）做运算，key>>>16(除以16)，只可能得到0~15之间的一个数组，作为插入数组的下标`
HashSet中的存储便是用了HashMap存储，利用了其key，Value值则为null。
TreeMap：
实现了SortedMap接口（是Map的子接口），可以对key自动排序。
TreeSet的底层，因为需要存入到TreeMap中所以需要实现Comparabble接口并去重
Hashtable
JDK1.0版本，线程安全，运行效率慢；不允许null作为key或是value
子类：Properities
Hashtable的子类，要求key和value都是String。通常用于配置文件的读取。在读取配置文件之后，保存文件中的键值对。反射，JDBC`
getPropetry();
setPropetry();
Hashtable作为Map的实现类，里面应该有put方法，Properities是Hashtable的子类。需要实现类中有put方法，所以参数是Object类型但又非得要求key和value是String。（所以它不适合做Map的实现类，也不适合做Hashtable子类）它有着不该拥有的put方法，定位不准确的集合
Collections工具类
概念：集合工具类，定义了除了存取以外的集合常用方法
public static void reverse（List<?> list）//反转集合中元素的顺序 public static void shuffle（List<?> list）//随机重置集合元素的顺序 public static void sort（List<T> list）//升序排序（元素类型必须实现Comparable接口）
泛型类型
编译时即可检查，而非运行时抛出异常。
访问时，不必类型转换（拆箱）。
不用泛型之间引用不能相互赋值，泛型不存在多态
类型
实例泛型
类:创建对象时，为类所定义的泛型，进行参数化赋值
\t接口:实现接口时，为接口所定义的泛型，进行参数化赋值
静态泛型
可应用在新参列表、返回值两种场景上，不单单可以规范泛型，还可以语义化返回值
只能应用在新参列表上，规范泛型
foreach循环
for(数据类型 变量名：容器名称){ \t//可遍历集合或数组（常用在无序集合上） }
异常
异常的概念
程序在运行过程中出现的特殊情况。
异常处理的必要性
任何程序都可能存在大量的未知问题、错误；如果不对这些问题进行正确处理，则可能导致程序的中断，造成不必要的损失。
异常的分类
Throwable：可抛出的，一切错误或异常的父类，位于java.lang包中。
Error:JVM、硬件、执行逻辑错误，不能手动处理。
Exception：程序在运行和配置中产生的问题，可处理。
RuntimeException：运行时异常，可处理，可不处理（不管可由java虚拟机处理，打印堆栈跟踪信息）。
CheckedException：受查异常，必须处理。
异常的产生
自动抛出异常：当程序在运行时遇到不符合规范的代码或结果时，会产生异常。
手动抛出异常：语法：throw new 异常类型(\"实际参数\");
产生异常结果：相当于遇到return语句，导致程序因异常而终止。
异常的传递
异常的传递：按照方法的调用链反向传递，如始终没有异常处理，最后会由JVM进行默认异常处理（打印堆栈跟踪信息）
受查异常：throws声明异常，修饰在方法参数列表后端。throws称为消极的处理方式
运行时异常：因可处理，可不处理，无需声明异常
异常的处理
try{ \t\t\t**可能出现异常的代码** }catch（Exception e）{\t\t\t**异常处理的相关代码，如：getMessage（）、printStackTrance（）**}finally{\t\t\t**无论是否出现异常，都需要执行的代码结构，常用于释放资源。**}
常见异常处理结构
try{} catch{}
try{} catch{}catch{}
try{} catch{}finally{}
try{} catch{}catch{}finally{}
try{} finally{}
注：多重catch，遵循从子（小）到父（大）的顺序，父类异常在最后
自定义异常
需继承自Exception或Exception的子类，常用于RuntimeException。
必须提供的构造方法：
无参数构造方法
String message参数的构造方法
方法覆盖
带有异常声明的方法覆盖
方法名、参数列表、返回值类型必须和父类相同。
子类的访问修饰符和父类相同或是比父类更宽。
子类中的方法，不能抛出比父类更宽的异常，但可以比父类抛出更多的异常（前提是抛出的异常小于或等于父类异常级别）。
扩充：方法执行字节中字节码操作指令
反编译：
javap -verbose 类名>反编译类名.bytecode
多线程
线程
线程，又称为轻量级进程（Light Weight Process）程序中的一个顺序控制流程，同时也是CPU的基本调度单位。
进程由多个线程组成，彼此间完成不同的工作，交替执行，称为多线程。
线程的组成
任何一个线程都具有基本的组成部分
CUP时间片：操作系统（OS）会为每个线程分配执行时间。
运行数据
堆空间:存储线程需要使用的对象，多个线程可以共享堆中的对象
栈空间:存储线程需使用的局部变量，每个线程都拥有独立的栈
线程的逻辑代码
创建线程（1）
继承Thread类
覆盖run()方法
调用start方法
创建线程（2）
实现Runable接口
创建线程对象
线程的状态
常见方法
休眠： \tpublic static void sleep(long millis) \tthrows InterruptedException \t当前线程主动休眠millis毫秒
放弃： \tpublic static void yield() \t当前线程主动放弃时间片，回到就绪状态，竞争下一次时间片。
结合： \t\tpublic final void join(long millis) \t\tthrows InterruptedException \t\t允许其他线程加入到当前线程。
等待
线程安全
线程不安全：
当多线程并发访问临界资源时，如果破坏原子操作，可能会造成数据不一致。
临界资源：共享资源（同一对象），一次仅允许一个线程使用，才可保证其正确性。
原子操作：不可分割的多部操作，被视作一个整体，其顺序和步骤不可打乱或缺省。
同步代码块
synchronized（临界资源对象）{//对临界资源对象加锁 //代码 （原子操作）}
同步方法
synchronized 返回值类型 方法名称(形参列表0){//对当前对象(this)加锁\t//代码(原子操作)}
同步规则
只有在调用包含同步代码块的方法，或者同步方法时，才需要对象的锁标记。
如调用不包含同步代码块的方法，或普通方法时，则不需要锁标记，可直接调用。
已知JDK中线程安全的类
StringBuffer\t Vector\t Hashtable
经典问题
死锁
当第一个线程拥有A对象锁标记，并等待B对象锁标记，同时第二个线程拥有B对象锁标记，并等待A对象锁标记时，产生死锁。
一个线程可以同时拥有多个对象的锁标记，当线程阻塞时，不会释放已经拥有的锁标记，由此可能造成死锁。
生产者、消费者
若干个生产者在生产产品，这些产品将提供给若干消费者去消费，为了使生产者和消费者能并发执行，\t在两者之间设置一个能存储多个产品的缓冲区，生产者将生产的产品放入缓冲区中，消费者从缓冲区中取走产品进行消费，\t显然生产者和消费者之间必须保持同步，即不允许消费者到一个空的缓冲区中取出产品，也不允许生产者向一个满的缓冲区中放入产品。
线程通信
必须在对obj加锁的同步代码块中。在一个线程中，调用obj.wait()时，此线程会释放其拥有的所有锁标记。\t\t同时此线程阻塞在os的等待队列中。释放锁，进入等待队列
public final void wait()
通知
必须在对obj加锁的同步代码块中。从obj的Waiting中释放一个或全部线程。对自身没有任何影响。
public final void notify()
public final void notifyAll()
synchronized
线程的状态（阻塞）
线程的通信
wait（）
通知（唤醒）
notify（）
notifyAll（）
线程池
线程容器，可以设定线程分配的数量上限
预先创建线程对象，存入池中，并实现重用池中的线程对象
避免频繁的创建、销毁
Executor顶级接口
ExecutorService线程池接口
Executors工厂类
Callable<V>接口
public V call() throws Exception{}
jdk5加入，与Runnable类似，都代表了一个线程任务
call方法，具有泛型返回值，可以声明异常
Future接口
Lock锁
JDK5加入，与synchronized比较。显示定义，结构更灵活
ReentrantLock
重入锁
2147483648锁
ReadWriteLock
ReentrantReadWriteLock
一种支持一写多读的同步锁，读写分离，可分配读锁，写锁
多次分配读锁，多个读操作可以并发执行
互斥规则
线程安全集合
Collections中的工具方法
Collections工具类提供了多个可以获得线程安全集合的方法
JDK1.2提供，接口统一、维护性高，但性能没有提升，均以synchronized实现。
CopyOnWriteArrayList
线程安全的ArrayList，加强版读写分离
写有锁，读无锁，读写之间不阻塞，优于读写锁
写入时，先copy一个容器副本、再添加新元素，最后替换引用
CopyOnWriteArraySet
线程安全的Set，底层使用CopyOnWriteArrayList实现
唯一不同在于，使用addIfAbsent()添加元素，会遍历数组
如存在元素，则不添加(扔掉副本)
ConcurrentHashMap
初始容量默认为16段（Segment），使用分段锁设计。
不对整个Map加锁，而是为每个Segment加锁。
当多个对象存入同一个Segment时，才需要互斥。
最理想状态为16个对象分别存入16个Segment，并行数量16。
使用方式与HashMap无异。
Queue接口（队列）
FIFO
抛出异常
返回特殊值
ConcurrentLinkedQueue
线程安全、可高效读写的队列，高并发下性能最好的队列。
BlockingQueue接口
\tvoid put(E e)//将指定元素插入此队列中，如果没有可用空间，则等待。
E take()//获取并移除此队列头部元素，如果没有可用元素，则等待。
可用于解决生产者、消费者问题
ArrayBlockingQueue
数组结构实现，有界队列。（手工固定上限）
LinkedBlockingQueue
链表结构实现，无界队列。（默认上限Integer.MAX_VALUE）
I/O框架
流
内存与设备之间传输数据的通道
流的分类
按方向
输入流
将存储设备中的内容读入到内存中
输出流
将内存中的内容写入到存储设备中
按单位
字节流
以字节为单位，可以读写所有的数据
字符流
以字符为单位。只能读写文本数据
按功能
节点流
具有实际传输数据的读写功能
过滤流
在节点流的基础之上增强功能
InputStream字节输入流
OutputStream字节输出流
字节节点流
FileInputStream
FileOutputStream
字节过滤流
BufferedOutputStream
BufferedInputStream
对象字节流
ObjectOutputStream
ObjectInputStream
使用对象字节流传输对象的过程，称为对象序列化，反序列化
必须实现Serializable接口
必须保持其所有属性均可序列化transient修饰为临时属性，不参与序列化读取到文件尾部的标志：java.io.EOFException
字符编码
UTF-8
针对Unicode可变长度字符的编码
GB23112
简体中文
GBK
简体中文、扩展
当编码方式与解码方式不一致时，出现乱码
Reader
Writer
字符节点流
FileWriter
FileReader
字符过滤流
BufferedWriter
BufferedReader
PrintWriter
桥转换流
InputStreamReader
OutputStreamReader
可将字节流转换为字符流
可设置字符的编码方式
File类
代表了物理盘符中的一个文件或文件夹
FileFilter接口
对获取文件进行过滤，满足条件的文件或文件夹才能保存下来
网络编程
网络
由点和线构成的，标识诸多对象间的相互联系
计算机网络
为实现资源共享和信息传递，通过通信线路连接起来的若干主机（Host）
互联网：点与点相连
万维网：端与端相连
物联网：物与物相连
网络编程:让计算机与计算机之间建立连接，进行通信
网络模型：OIS（Oper System Interconnection）开放式系统互联
第一层：物理层（双绞线，光导纤维）
第二层：链路层（MAC）
第三层：网络层（IP地址）
第四层：传输层：（TCP\\UDP）
第五层：会话层（断点续传）
第六层：表示层：（对数据转换以及加密）
第七层:应用层（HTTP、FTP、SMTP）
TCP/IP 模型
一组用于实现网络互连的通信协议，将协议分为四层。
第一层：网络接口层（以太网、ADSL）
第二层：网络层（分配地址、传送数据、IP协议）
第三层：传输层（文本数据，协议是TCP、UDP协议）
第四层：应用层（负责传送最终形态的数据，协议为HTTP、FTP）
TCP/UDP
TCP协议：Transmission Control Protocol 传输控制协议
是一种面向连接的、可靠的、基于字节流的传输层通信协议。数据大小无限制。建立连接的过程中需要三次握手，断开连接的过程需要四次挥手
UDP协议：User Datagram Protocol用户数据报协议
是一种无连接的传输层协议，提供面向事务的简单不可靠信息传送服务，每个包的大小64KB
IP
Inernet Protocol Address 互联网协议地址/网际协议地址分配给互联网设备的数字标识（唯一标识）
IPV4：4字节32位整数，并分成4段8位的二进制数，每8位之间用圆点隔开，每8位整数可以转换为一个0~255的十进制整数格式：D.D.D.D 例如：255.255.255.255
IPV6:16字节128位整数，并分成8段十六进制，每16位之间用圆点隔开，每16位整数可以转换为一个0~65535的十进制整数.=格式：X.X.X.X.X.X.X.X 例如：FFFF.FFFF.FFFFF.FFFF.FFFF.FFFF.FFFF.FFFF
回环地址
127.0.0.1，指本机，一般用于测试使用
Port端口
在通信实体上进行网络通讯的程序的唯一标识
公认端口：0~1023注册端口：1024~49151动态或私有端口：49152~65535
常用端口
MySql：3306Oracle：1521Tomcat：8080SMTP:25Web服务器：80FTP服务器：21
InetAddress类
标识互联网协议（IP）地址对象，封装了与该IP地址相关的所以信息，并提供获取信息的常用方法。
无法直接创建对象，构造方法私有化，需要通过getXXX方法来获得
基于TCP的网络编程
Scocket编程
Socket（套接字）是网络中的一个通信节点分为客户端Socket与服务器ServerSocket通信要求：IP地址+端口号
反射
类的对象
基于某个类new出来的对象，也成为实例对象
类对象
类加载的产物
封装了一个类的所有信息[类名、父类、接口、属性、方法、构造方法]
一个类.class文件就代表一个类对象
获取类对象
通过类的对象，获取类对象
Student s = new Student();Class c = s.getClass();
通过类名获取类对象
Class c = 类名.class
通过静态方法获取类对象
Class c = Class.forName(“包名.类名”);
常用方法：
public String getName()public Package getPackage()public Class<? super T>getSuperclass()public Class<?>[] getInterfaces()public Filed[] getFieldspublic Methods[] getMethods()public Constructor<?>[] getConstructors()public T newInstance()
工厂设计模式
开发中有一个非常重要的原则“开闭原则”，对拓展开放、对修改关闭
工厂模式主要负责对象创建的问题
可通过反射进行工厂模式的设计，完成动态的对象创建
通用编程
单例模式
只允许创建一个该类的对象
方式1：饿汉式[类加载时创建，天生线程安全]
方式2：懒汉式[使用时创建，线程不安全，加同步]
方式3：懒汉式（使用时创建，线程安全）
JDK8
Lambda表达式
允许把函数作为一个方法的参数。（函数作为参数传递到方法中）
<函数式接口><变量名> = （参数1，参数2...）->{//方法体}
注意事项
形参列表的数据类型会自动推断
如果形参列表为空，只需保留（）
如果形参只有1个，（）可以省略，只要参数名字即可
如果执行语句只有1句，且无返回值，{}可以省略
若有返回值。仍想省略{}，return也省略。保证执行语句只有1句
Lambda表达式不会生成单独的内部类文件
Lambda访问局部变量时，变量要修饰final，如果没加，会自动添加
函数式接口
如果一个接口只有一个抽象方法，则该接口称为函数式接口
为了确保接口达到要求，可以添加@FunctionalInterface注解提示
内置四个核心函数式接口：
Consumer<T>消费型接口 void accept(T t);
Supplier<T> 供给型接口 T get();
Predicate<T>断言型接口 boolean test(T t)
方法引用
方法引用是Lambda表达式的一种间写形式，如果Lambda表达式方法体中只是调用一个特点的已存在的方法，则可以使用方法引用
使用：：操作符将对象或方法名的名字分隔开来
对象：：实例方法
类：：静态方法
类：：实例方法
类：：new
注意：调用的方法参数列表与返回值类型，要与函数型接口中的方法参数列表与返回值类型一致
Stream API
Stream是Java8中处理数组和集合的抽象概念。
可以执行非常复杂的查找、过滤、映射等操作
中间操作
终止操作
串行
stream():
并行
parallelStream();
0 条评论
回复 删除
下一页
