JavaSE
2021-07-22 23:02:12 0 举报AI智能生成
JavaSE知识内容总结
作者其他创作
大纲/内容
add(E e)：添加到当前集合中。
clear():清空集合中所有的元素。
remove(E e):删除当前集合中的对象。
contains(E e):判断当前集合中是否包含给定的对象。
isEmpty():判断当前集合是否为空。
size():返回集合中元素的个数。
toArray():把集合中的元素，存储到数组中。
常用功能
shuffle(): 乱序
sort(List<T>list):将集合中元素按照默认规则排序。
sort(List<T>list，Comparator<?superT>):将集合中元素按照指定规则排序
Collections
自然排序，类的compareTo方法被称为它的自然比较方法。只能在类中实现compareTo()一次，不能经常修改类的代码实现自己想要的排序。实现接口的对象列表（和数组）可以通过Collections.sort（和Arrays.sort）进行自动排序，对象可以用作有序映射中的键或有序集合中的元素，无需指定比较器。
Comparable
强行对某个对象进行整体排序。可以将Comparator传递给sort方法（如Collections.sort或Arrays.sort），从而允许在排序顺序上实现精确控制。还可以使用Comparator来控制某些数据结构（如有序set或有序映射）的顺序，或者为那些没有自然顺序的对象collection提供排序。
Comparator
Comparable和Comparator两个接口的区别
底层数据结构为线性表，增删慢，查询快，线程非安全
List list = new ArrayList(); list.add(1);
add(Object)
list.size()
size()
返回集合中指定位置的元素。
get(index)
移除列表中指定位置的元素
remove(index)
contains(Object)
返回E[]
toArray() E[]
返回Iterator<E>
iterator() Iterator<E>
ArrayList
底层数据为双向链表，增删快，查询慢，线程非安全
addFirst(Ee):将指定元素插入此列表的开头。
addLast(E e):将指定元素添加到此列表的结尾。
getFirst():返回此列表的第一个元素。
getLast():返回此列表的最后一个元素。
removeFirst():移除并返回此列表的第一个元素。
removeLast():移除并返回此列表的最后一个元素。
pop():从此列表所表示的堆栈处弹出一个元素。
push(E e):将元素推入此列表所表示的堆栈。
isEmpty()：如果列表不包含元素，则返回true。
LinkedList
线程安全，效率低，不经常用
Vector
List
add()
存储的元素是不可重复的，无序的
需要重写对象中的hashCode和equals方法，才能保证HashSet集合中的对象唯一
HashSet<Object>
存储的元素是不可重复的，有序的
LinkedHashSet
TreeSet
Set
元素的存取顺序不能保证一致
key唯一性，不能重复
需要重写键的hashCode()方法、equals()方法。
HashMap
HashMap的子类
存储数据采用的哈希表结构+链表结构。通过链表结构可以保证元素的存取顺序一致
LikedHashMap
remove(Object key):把指定的键所对应的键值对元素在Map集合中删除，返回被删除元素的值。
get(Object key)根据指定的键，在Map集合中获取对应的值。
Set<K> keySet():获取Map集合中所有的键，存储到Set集合中。
常用方法
Map
List、Set同属于Collection接口
List添加有序，Set添加无序
List、Set可以使用Iteration遍历，而Map不行
List里面的元素可以重复，Set里面的元素不可以重复
List、Set、Map的区别
Collection（集合）
严重错误Error，无法通过处理的错误。
Error
表示异常，异常产生后程序员可以通过代码的方式纠正，使程序继续运行，是必须要处理的。
Exception
编译时期异常:checked异常。
运行时期异常:runtime异常
异常分类
printStackTrace():打印异常的详细信息。
getMessage():获取发生异常的原因。
toString():获取异常的类型和异常描述信息(不用)。
子主题
异常处理的五个关键字：try、catch、finally、throw、throws
throw用在方法内，用来抛出一个异常对象，将这个异常对象传递到调用者处，并结束当前方法的执行。
throw new 异常类名 (参数);
抛出异常throw
：将问题标识出来，报告给调用者
声明异常throws
：Java中对异常有针对性的语句进行捕获，可以对出现的异常进行指定方式的处理
try：该代码块中编写可能产生异常的代码。
catch：用来进行某种异常的捕获，实现对捕获到的异常进行处理。
finally：无论异常是否发生，都会执行
因为异常会引发程序跳转，导致有些语句执行不到。而finally就是解决这个问题的，在finally中一定会被执行的。
finally代码块
捕获异常try…catch
运行时异常被抛出可以不处理。即不捕获也不声明抛出。
父类方法没有抛出异常，子类重写父类该方法时也不可抛出异常。此时子类产生该异常，只能捕获处理，不能声明抛出
异常注意事项
异常处理
在开发中根据自己业务的异常情况来定义异常类.自定义一个业务逻辑异常:RegisterException。一个注册异常类。
自定义一个业务逻辑异常:RegisterException。一个注册异常类。
自定义一个运行时期的异常类:自定义类并继承于java.lang.RuntimeException。
自定义异常
Throwable （异常）
可以在类或方法中预支地使用未知的类型
程序发生转换异常时，需要用到泛型
Collection虽然可以存储各种对象，但实际上通常Collection只存储同一类型对象。否则需要内部的转换
在JDK5之后，新增了泛型(Generic)语法
在创建对象的时候确定泛型
地将数据类型应用到不同的类、方法、接口当中。将数据类型作为参数进行传递
类型名称<?extends类>对象名称
只能接收该类型及其子类
上线
类型名称<?super类>对象名称
只能接收该类型及其父类型
下线
通配符
泛型
继承Thread类，重写run（）
实现Runnable接口
指两个或多个事件在同一个时间段内发生。
并发
指两个或多个事件在同一时刻发生（同时发生）。
并行
并发与并行
是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多个进程；进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创建、运行到消亡的过程。
进程
线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。
分时调度（平均分配）
抢占式调度（优先级高的先行）
线程调度
所有的线程对象都必须是Thread类或其子类的实例
Java中通过继承Thread类来创建并启动多线程
1、定义Thread类的子类，并重写该类的run()方法，span style=\"font-size: inherit;\
2、创建Thread子类的实例，即创建了线程对象
3、调用线程对象的start()方法来启动该线程
Thread():分配一个新的线程对象。
Thread(String name):分配一个指定名字的新的线程对象。
Thread(Runnable target):分配一个带有指定目标新的线程对象。
getName():获取当前线程名称
start():导致此线程开始执行;Java虚拟机调用此线程的run方法。
run():此线程要执行的任务在此处定义代码。
sleep(longmillis):使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行）。
currentThread():返回对当前正在执行的线程对象的引用。
Thread类
1、定义Runnable接口的实现类，并重写该接口的run()方法，run()方法是该线程的线程执行体
2、创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象。
3、调用线程对象的start()方法来启动线程。
Runnable
如果一个类继承Thread，则不适合资源共享。如果实现了Runable接口的话，则很容易的实现资源共享。
1.适合多个相同的程序代码的线程去共享同一个资源。
2.可以避免java中的单继承的局限性。
3.增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立。
4.线程池只能放入实现Runable或Callable类线程，不能直接放入继承Thread的类。
实现Runnable接口比继承Thread类所具有的优势：
Thread和Runnable区别
创建线程
要解决上述多线程并发访问一个资源的安全性问题：使用同步机制(synchronized)来解决。
1. 同步代码块。
2. 同步方法。
3. 锁机制。
线程同步
synchronized 关键字可以用于方法中的某个区块中
synchronized( 同步锁 ){ 需要同步操作的代码 }
1. 锁对象 可以是任意类型
2. 多个线程对象 要使用同一把锁。
同步锁:
同步代码块
public synchronized void method ( ) {可能会产生线程安全问题的代码}
同步方法
lock() :加同步锁。
unlock() :释放同步锁。
Lock锁
线程安全
一个线程正在等待被另一个线程执唤醒动作的这一状态
Timed Waiting（计时等待）
一个正在阻塞等待一个监视器锁（锁对象）的线程处于这一状态。
BLOCKED（锁阻塞）
一个正在无限期等待另一个线程执行一个特别的（唤醒）动作的线程处于这一状态。
Waiting（无限等待）
唤醒此对象监视器上等待的单个线程
notify ( )
唤醒此对象监视器上等待的所有线程
notifyAll ( )
在其他线程调用此对象的notify（）或notifyAll（）方法前，导致当前线程等待。
wait ( )
在其他线程调用此对象的notify（）或notifyAll（），或者超过指定的时间量前，导致当前线程等待。
wati（Long timeout）
线程状态
就是一个容纳多个线程的容器，其中的线程可以反复使用，无需反复创建线程而消耗过多资源。
1. 降低资源消耗。
2. 提高响应速度。
3. 提高线程的可管理性
好处：
newFixedThreadPool ( int nThreads) ：返回线程池对象
submit( Runnable task) :获取线程池中的某一个线程对象，并执行
方法
1. 创建线程池对象。
2. 创建Runnable接口子类对象。(task)
3. 提交Runnable接口子类对象。(take task)
4. shutdown ( ) 销毁线程池(一般不做)。
、步骤
线程池
线程
多线程
把数据从其他设备上读取到内存中的流。
input 输入流
把数据从内存中写出到其他设备上的流。
output 输出流
以字节为单位，读写数据的流。
abstract int read() ： 从输入流读取数据的下一个字节。
close( ) : 关闭并释放资源
read(byte[] b) ： 从输入流中读取一些字节数，并将它们存储到字节数组 b中 。
FileInputStream(File file) ： 通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件系统中的 File对象 file命名。
FileInputStream(String name) ： 通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件系统中的路径名 name命名。
FileInputStream
输入流InputStream
close() ：关闭并释放资源
flush() ：刷新此输出流并强制任何缓冲的输出字节被写出。
write(int b) ：将指定的字节输出流。
write(byte[] b) ：将 b.length字节从指定的字节数组写入此输出流。
FileOutputStream(File file) ：创建文件输出流以写入由指定的 File对象表示的文件。
FileOutputStream(String name) ： 创建文件并写入文件。
FileOutputStream
输出流OutputStream
字节流
以字符为单位，读写数据的流。
read() ： 从输入流读取一个字符。
read(char [] arr) ： 从输入流中读取一些字符存储到数组中 。
FileReader(File file) ： 创建一个新的 FileReader ，给定要读取的File对象
FileReader(String fileName) ： 创建一个新的 FileReader ，给定要读取的文件的名称。
FileReader
输入流Reader
write(int c) 写入单个字符。
write(char[] cbuf) 写入字符数组
write(String str) 写入字符串。
flush() 刷新该流的缓冲。
close() 关闭此流，但要先刷新它。
FileWriter(File file) ： 创建一个新的 FileWriter，给定要读取的File对象。
FileWriter(String fileName) ： 创建一个新的 FileWriter，给定要读取的文件的名称
FileWriter
输出流Writer
字符流
对字节流和字符流的增强
BufferedInputStream 字节输入流
BufferedOutputStream 字节输出流
字节缓冲流
BufferedReader 字符输入流
BufferedWriter 字符输出流
字符缓冲流
缓冲流
InputStreamReader
OutputStreamWriter
转换流
ObjectOutputStream(OutputStream out) ： 创建一个指定OutputStream的ObjectOutputStream。
ObjectOutputStream 对象的序列化流
ObjectInputStream(InputStream in) ： 创建一个指定InputStream的ObjectInputStream。
ObjectInputStream 对象的反序列化流
序列化流
IO流
print
println
PrintStream
打印流
元素是特定类型的对象，形成一个队列
数据源： 流的来源。 可以是集合，数组 等。
Pipelining: 中间操作都会返回流对象本身。
内部迭代：Stream流可以直接调用遍历方法。
Stream（流）是一个来自数据源的元素队列
属于管道流，只能被（消费）使用一次
逐一处理：forEach
过滤：filter
映射：map
统计个数：count
取用前几个：limit
跳过前几个：skip
将2个合并为1个：concat
Stream流
流
0~arr.length-1
i:第一个元素的位置
i+1~arr.length
j：后面那个元素的位置
每一个元素与第一个元素比较，如果小，则交换
选择排序
i：比较的轮数
0~arr.length-i-1
j：比较的位置
a[j] a[j+1]
两两比较，如果后面的小，交换
冒泡排序
快速排序*
其他排序
底层实现使用的排序算法中的快速排序
Arrays.sort(arr[]
JDK提供的排序方法
递归头
递归循环体
在方法体内调用自身的方法
递归算法
排序算法
Java语言是美国Sun公司（Stanford University Network），在1995年推出的高级的编程语言。所谓编程语言，是计算机的语言，人们可以使用编程语言对计算机下达命令，让计算机完成人们需要的功能。
什么是java
Java语言主要应用在互联网程序的开发领域。常见的互联网程序比如天猫、京东、物流系统、网银系统等，以及服务器后台处理大数据的存储、查询、数据挖掘等也有很多应用。
能干什么
了解java
所谓跨平台性，是指java语言编写的程序，一次编译后，可以在多个系统平台上运行。
实现原理：Java程序是通过java虚拟机在系统平台上运行的，只要该系统可以安装相应的java虚拟机，该系统就可以运行java程序。（注意不是能在所有的平台上运行，关键是该平台是否能安装相应的虚拟机）。
跨平台
核心优势
是Java程序开发工具，包含 JRE 和开发人员使用的工具。
JDK
是Java程序的运行时环境，包含 JVM 和运行时所需要的核心类库 。
JRE
Java虚拟机，我们编写的Java代码，都运行在 JVM 之上。
JVM
JDK/JRE/JVM
常量：是指在Java程序中固定不变的数据。
概述
分类
常量
概述：常量是固定不变的数据，那么在程序中可以变化的量称为变量。
-128~127
byte（1个字节）
65535
-2^15~2^15-1
short（2个字节）
+-2.1GB
-2^31~2^31-1
int（4个字节）
-2^63~2^63-1
long（8个字节）
整形
1.4013E-45~3.4028E+38
float（4个字节）
4.9E-324~1.7977E+308
double（8个字节）
浮点型
true
false
boolean
布尔类型
0~65535
char
字符类型
基本数据类型
的内部封装了成员变量、构造方法和成员方法
类
数组有固定的长度，长度一旦指定，不可更改。
数组就是存储数据长度固定的容器，保证多个数据的数据类型要一致。
数组
的内部主要就是封装了方法
可以继承，可以重写，二选一，但是只能通过实现类的对象来调用。
不能创建对象，但是可以被实现（ implements ，类似于被继承）。
接口
引用类型
数据类型
long a =10;
小转大
自动转化（隐藏转化）
byte b =(byte) 129;//会溢出，损失精度
大转小
数据类型 变量名 = （数据类型）被转数据值；
转换格式
浮点转成整数，直接取消小数点，可能造成数据损失精度。
int 强制转成 short 砍掉2个字节，可能造成数据丢失。
注意点
强制数据类型转化（显示转化）
数据类型的转化
就是将人类的文字和一个十进制数进行对应起来组成一张表格。
ASCII编码表
变量 前++ ：先自加在赋值变量 后++ ：先赋值在自加
算数运算符
=、+=、-=、*=、/=、%=
赋值运算符
比较运算符
逻辑运算符，是用来连接两个布尔类型结果的运算符，运算结果都是布尔值 true 或者 false
逻辑运算符
数据类型 变量名 = 布尔类型表达式？结果1：结果
布尔类型表达式结果是true，三元运算符整体结果为结果1，赋值给变量。布尔类型表达式结果是false，三元运算符整体结果为结果2，赋值给变量。
三目运算符
>>、<<、>>>
移位运算符
运算符
算数>比较>逻辑>赋值
运算符的优先级
变量
就是将一个功能抽取出来，把代码单独定义在一个大括号内，形成一个单独的功能。当我们需要这个功能的时候，就可以去调用。这样即实现了代码的复用性，也解决了代码冗余的现象。
指在同一个类中，方法名相同，参数列表不同即可，与修饰符和返回值类型无关。
参数列表：个数不同，数据类型不同，顺序不同
重载方法调用：JVM通过方法的参数列表，调用不同的方法。
方法的重载规则（背）
程序的流程对运行结果有直接的影响。所以，我们必须清楚每条语句的执行流程。而且，很多时候我们要通过控制语句的执行顺序来实现我们要完成的功能。
顺序流程
if（关系表达式）{ 语句体；}
if（关系表达式）{ 语句体1；}else{ 语句体2；}
if (判断条件1) {执行语句1;} else if (判断条件2) {执行语句2;} else {执行语句n+1;}
判断语句
支持的有：char、byte、short、int 和 Character、Byte、Short、Integer 和 String，枚举表达式的值不能是null，否则会在运行时抛出NullPointerException。在case子句中也不能使用null，否则会出现编译错误。JAVA中switch为什么不能使用long的根本原因是long转化成int会丢失精度，导致数据不准确，
switch(int、自动转化为int、枚举类型、字符串)
switch(表达式) {case 常量值1:语句体1;break;case 常量值2:语句体2;break;...default:语句体n+1;break;}
选择语句
int i=1;while(i<=10){ 输出（\"123\"）; i++;}
while
跳出并结束语句块
break
跳出本次循环，继续执行后面的语句
continue
for
控制条件语句所控制的那个变量，在for循环结束后，就不能再被访问到了，而while循环结束还可以继续使用，如果你想继续使用，就用while，否则推荐使用for。原因是for循环结束，该变量就从内存中消失，能够提高内存的使用效率。在已知循环次数的时候使用推荐使用for，循环次数未知的时推荐使用while。
for 和 while 的小区别：
初始化表达式①do{循环体③步进表达式④}while(布尔表达式②);
do...while
不是代码错误，是一种循环结构
也就是循环中的条件永远为true，死循环的是永不结束的循环。例如：while(true){}。
死循环
是指一个循环的循环体是另一个循环。比如for循环里面还有一个for循环，就是嵌套循环。总共的循环次数=外循环次数*内循环次数
循环嵌套
循环流程
流程控制
概念：数组就是存储数据长度固定的容器，保证多个数据的数据类型要一致
数据类型相同的数组
长度一旦指定，不可更改。
数组的特点
静态初始化
动态初始化
数组的初始化
arr.length
每个数组都具有长度，而且是固定的
数组的长度
就是将数组中的每个元素分别获取出来，就是遍历。遍历也是数组操作中的基石。
数组的遍历
Java语言是面向对象的程序语言，面向对象思想是一种程序设计思想。
将复杂的事情简单化，并将我们从执行者变成了指挥者。面向对象的语言中，包含了三大基本特征，即封装、继承和多态。
特点
内部方法外部调用，外部无需关心内部实现
封装
子类方法属性使用父类，不需要自己定义，扩展自己的个性化
继承
外部调用同一个方法，实际执行的逻辑不同。父类引用指向子类对象
多态
三大特征
OOP
将一个类A定义在另一个类B里面，里面的那个类A就称为内部类，B则称为外部类。
内部类可以直接访问外部类的成员，包括私有成员
外部类要访问内部类的成员，必须要建立内部类的对象。
匿名内部类必须继承一个父类或者实现一个父接口。
接口名称 对象名=new 接口名称（）{ }；
匿名内部类
内部类
Java基础入门
abs(double a) ：返回 double 值的绝对值。
ceil(double a) ：返回大于等于参数的最小的整数。
floor(double a) ：返回小于等于参数最大的整数。
round(double a) ：四舍五入。(float时返回int值，double时返回long值)
rint() : 四舍五入，（.5的时候返回偶数）
sqrt(num) : num的平方根
cbrt(x) : 开立方
random() : 随机去0~1的数
Math
length () ：返回此字符串的长度。
concat (\"string\") ：将指定的字符串连接到该字符串的末尾。
A-Z 65-90a-z 97-122'0'-'9' 48-57
charAt ( 1 ) ：返回指定索引处的 char值。
indexOf (\"a\") ：返回第一次出现在该字符串的索引。
返回字符最后出现的下标
lastIndexOf（ char）：int
substring ( 1 ) ：返回一个子字符串，从 xx 开始截取字符串到字符串结尾。
toCharArray () ：将此字符串转换为新的字符数组。
去首尾空格
trim（）：String
getBytes () ：转换为新的字节数组。
replace (char oldChar、 char newChar) ：字符串替换。
字符串转为整数，如果原字符串不是数字字符串，则报错
Integer.valueOf(string)
将object转化为字符串
String.valueOf（Object）
split(String regex) ：将此字符串按照给定的regex（规则）拆分为字符串数组。\"aa+bb+cc\"--------->{\"aa\
String
输出
out.print()
换行输出
out.printIn()
调用垃圾收集器
gc()
System.exit(0) 程序正常退出
System.exit(1)或者说非0表示非正常退出程序
exit()
键盘录入
in
格林威治时间的毫秒值
currentTimeMillis（）
数组的复制，底层代码是C++写的，调用底层，没有返回值（native）
System
toString方法返回该对象的字符串形式，也就是该对象的类型+@+内存地址值。
toString()
如果没有覆盖重写equals方法，那么Object类中默认进行 == 运算符的对象地址比较，只要不是同一个对象，结果必然为false。
如果覆盖重写equals方法，则进行对象的内容比较，即所有或指定的部分成员变量相同就判定两个对象相同
equals()
Object
作用一般是看两个数组是否一样
compareTo(T)
Conparable
java.lang
//获得0~9随机数Random r =new Random();int rd = r.nextInt(10);
Random
是大小可变的数组的实现，存储在内的数据称为元素。
.add() 添加
get() 取值
nextDouble()
nextLine() String类型
nextInt() intl类型
Scanner
toString（T [] arr）
数组的扩容，缩容
升序
sort(T [])
判断两个数组是否相等
Arrays（数组的工具类）
年月日时分秒（毫秒.SSS）
小写的hh代表12小时制，大写的HH代表24小时制
yyyy-MM-dd HH:mm:ss
日历类
get(int field) ：返回给定日历字段的值。
Calendar()
new Date() 当前系统时间
将日期转化为字符串
DateFormat df = new SimpleDateFormat(yyyy-MM-dd HH:mm:ss);String str= df.format(new Data() );
String str = df.format（date）
get(int field) ：返回给定日历字段的值。 cal.get(Calendar.YEAR) //当前时间的年份
getTime() ：返回毫秒值
Calendar
DateFormat df2 = new SimpleDateFormat(yyyy-MM-dd HH:mm:ss);Date d = df2.parse(str);
将字符串转化为日期
Date date = df2.parse（str）
getTime（） 1970-01-01 00:00:00.000到时间的毫秒数
Date
java.util
不能直接new（）实例，只能通过赋值多态去定义
abstract DateFormat
DateFormat df = new SingleDateFormat(\"yyyy-MM-dd HH:mm:ss\")
SimpleDateFormat
Java.text
以用来修饰的成员变量和成员方法，被修饰的成员是属于类的，而不是单单是属于某个对象的。既然属于类，就可以不靠创建对象来调用了。
可以修饰类、方法、成员变量； 不能修饰构造方法
static 修饰表示静态或全局，被修饰的属性和方法属于类，可以用类名.静态属性 / 方法名 访问
static 修饰的属性，也就是类变量，是在类加载时被创建并进行初始化，只会被创建一次
static 修饰的变量可以重新赋值
static 方法中不能用 this 和 super 关键字
static 方法必须被实现，而不能是抽象的abstract
static 方法不能被重写
static
静态属性使用 类名.静态变量名
静态方法使用 类名.静态方法
从属类
在JVM中仅初始化一次
存储于常量池
static关键字
final 修饰类，不能被子类继承
final 修饰方法，不能被子类重写，但可以被重载
final 修饰表示常量、一旦创建不可改变
修饰变量，常量，不能被二次赋值
final 标记的成员变量必须在声明的同时赋值，或在该类的构造方法中赋值，不可以重新赋值
final : 最终的，不可改变的，可以用于修饰类、方法和变量。
final
关键字
常用API
JVM有一个默认的构造方法
根据需求重载构造方法
使用new关键字创建对象
null值调用属性或者方法会出现NullPointerExption
NPE
内部细节对外部调用透明，外部调用无需修改或者关心内部实现
在编程规约中所有的非特殊成员变量不允许外部直接访问成员变量，必须将其私有，且提供对外公开的方法
访问权限修饰符
this代表所在类的当前对象的引用（地址值），即对象自己的引用。
指代当前对象的关键字
根据本类其他构造方法，必须写到第一行
this关键字
没有返回值类型
类名相同
1. 如果你不提供构造方法，系统会给出无参数构造方法。2. 如果你提供了构造方法，系统将不再提供无参数构造方法。3. 构造方法是可以重载的，既可以定义参数，也可以不定义参数。
构造方法（构造器）
子类共性的方法或者属性直接使用父类的，而不需要自己再定义，只需扩展自己个性化的
Java只支持单继承，不支持多继承。
Java支持多层继承(继承体系)。
子类和父类是一种相对的概念。
extends关键字继承父类除了构造方法以外的所有的属性和方法
子类的构造方法默认调用父类构造方法
表父类的存储空间标识(可以理解为父亲的引用)
指代当前类的直接父类
super（）必须放到构造方法的第一行，且不能与this（）并存
super关键字
父类的静态代码块
子类静态代码块
父类的普通代码块
父类的构造方法
子类的普通代码块
子类的构造方法
说明：静态方法（有静态先加载静态） > 普通代码块> 方法（其他）先加载用到的所有静态方法，然后按运行顺序加载普通代码块和方法
子类继承父类语句的执行顺序
父子类中，必须要有继承的概念
相同的方法名+参数序列
相同的签名
方法的访问权限大于等于父类权限。
方法返回值类型、函数名和参数列表都要一模一样。
重写的规则
垃圾回收机制GC*
继承（extends）
是指同一行为，具有多个不同表现形式。
Shape shape = new Circle();
赋值多态
当父类引用指向一个子类对象时，便是向上转型。父类类型 变量名 = new 子类类型();
向上转型
父类类型向子类类型向下转换的过程，这个过程是强制的。子类类型 变量名 = (子类类型) 父类变量名;
向下转型
存在于声明方法
声明：public void a(Shape n){}; Circle circle = new Circle();使用：a(circle);
传参多态
1.要有继承（直接继承）
2.要有方法的重写
3.父类的引用指向子类的对象
构成Java多态的规则
三大基本特征
如果“==”两边是基本数据类型或者字符串常量，比较的是常量池中的数值
==比较的是地址
equals（）方法在没有重写父类方法时比较的也是地址
在重写equals（）后比较的是引用类型属性的值是否相等
==和equals（）的区别
在实际应用中必须重写equals（）方法
equals（）
调用本地操作系统的C++库哈希地址
hashcode（）
由完全限定名 + “@”+十六进制的哈希地址组成
子类按需求重写父类的toString（）方法
引用类型直接输出对象名，默认调用toString（）方法
toString（）
所有类的父类
类必须实现可序列化接口
成员变量私有化
必须提供无参的构造方法
对外提供公开的方法访问和设置成员变量
必须重写toString（），equals（），hashcode（）方法
Java实体类编程规约
Object类
从基本类型转换为对应的包装类对象。
装箱
从包装类对象转换为对应的基本类型。
拆箱
从Java 5（JDK 1.5）开始，基本类型与包装类的装箱、拆箱动作可以自动完成
先把基本数据类型装箱，再用对象的toString()方法
valueOf（）
+\"\"
基本类型转换为String类
parseByte(String s) ：将字符串参数转换为对应的byte基本类型。
parseShort(String s) ：将字符串参数转换为对应的short基本类型。
parseInt(String s) ：将字符串参数转换为对应的int基本类型。
parseLong(String s) ：将字符串参数转换为对应的long基本类型。
parseFloat(String s) ：将字符串参数转换为对应的float基本类型。
parseDouble(String s) ：将字符串参数转换为对应的double基本类型
parseBoolean(String s) ：将字符串参数转换为对应的boolean基本类型。
String类转基本类型
包装类
抽象方法不可以有方法体，即不能有{}
有抽象方法的类必须定义为抽象类
抽象类中，可以有构造方法，是供子类创建对象时，初始化父类成员使用的。
抽象类中定义子类共有的属性
子类必须要重写父类中所有的抽象方法
抽象类不能创建对象
作用：让子类继承
由abstract关键字修饰的类
没有方法体的方法。
抽象方法
包含抽象方法的类就是抽象类。
抽象类
public static final int a = 10;
在接口中定义的属性全为常量
接口中的方法必须全为抽象方法
implements
类与接口的关系是实现的关系
extends
类与类之间的关系继承的关系
接口与接口的关系继承
比抽象类还抽象的抽象类 interface
如果你是。。。就必须得会。。。
定义类某些规范
1.抽象类只能单继承，接口可以多实现
2.接口中的变量全是常量，方法全是抽象方法，抽象类可以有普通变量，方法可以有非抽象方法
3.接口存在的意义就是为了定义规范，让子类去继承
与抽象类的区别
面向对象
String是final修饰的，不可变。每次操作都会生产新的String对象
经常需要改变字符串内容时优先使用StringBuilder
可变字符序列：(默认16字符空间，超过自动扩充)
append(...) ：添加任意类型数据的字符串形式
toString() ：将当前StringBuilder对象转换为String对象。
StringBuilder
多线程使用共享变量时使用StringBuffer
StringBuffer
String和StringBuilder和StringBuffer的区别（背）
1.String 不可变长
2.StringBuilder和StringBuffer可变长
3.用StringBuilder代替StringBuffer，因为效率高
4.大量字符串操作时，用StringBuilder代替String
StringBuilder线程非安全，效率较高，StringBuffer线程安全
String、StringBuilder、StringBuffer
JavaSE
0 条评论
回复 删除
下一页
