Java SE知识点框架总结分享
2022-10-19 17:14:44 0 举报AI智能生成
登录查看完整内容
Java SE知识点框架总结分享
作者其他创作
大纲/内容
作用：创建对象，给对象赋值
构造器本身是一个方法（又称为构造方法）
构造器没有返回值，也不用写void
构造器的方法名必须和类名一致
如果没有定义带有参数的构造器，那么存在不带参数的默认构造器；
如果定义了带有参数的构造器，那么默认的构造器就会被覆盖
在定义了参数的基础上要使用无参数的构造器必须显式的将无参构造器定义出来
默认构造器的类型是protect
类中是默认有构造器的：
private/public/protect + 类名 +（参数类型 + 参数名）
构造器的语法：
构造器
this关键字和构造器放在一起使用，谁调用构造器this指的就是谁。
在重载构造器的相互调用时，this关键字必须是构造器的第一条语句
this关键字
语法： static + 数据类型+数据名
类属性的生命周期：一直存在，除非虚拟机关闭
对象属性的生命周期：主函数的结尾也即是对象属性生命的结尾
使用static修饰的属性认为是类属性；不使用static关键字修饰的属性认为是对象属性<br>
类名.类属性（推荐）
对象实例.类属性（不推荐）
访问方式：
static关键字修饰属性
void表示无返回值
返回值类型可以是基本数据类型，也可以是引用数据类型
语法：public static void[返回值类型] 方法名（参数类型 参数名）｛｝
使用static修饰的方法认为是类方法；不使用static修饰的方法认为是对象方法
类名.类方法（推荐）
对象实例.类方法（不推荐）
调用方式（访问方式）
类方法只能使用类属性
因为类方法是静态的，对象属性是非静态的。不能从静态上下文中访问非静态变量
类方法无论是类访问还是对象访问都不能直接访问对象属性
对象属性和方法只能通过"对象实例.对象属性、对象方法"来访问
类方法和类属性即可以通过"类名.类属/类方法"来访问，也可以通过"对象实例.类方法、类属性"来访问
静态方法中不可以使用this关键字
<b><font color="#c41230">不能将方法体内的局部变量声明为static</font></b>
注意：
static关键字修饰方法
static关键字
第五章：面向对象
也就是权限修饰符为private
将默认的构造器私有化
创建的对象是静态的，否则不能咋静态方法中调用非静态对象
权限修饰符为private
在单例类的内部创建一个自己本身的对象
因为这是其他类唯一可以访问的方法
权限修饰符：public
创建静态方法获得对象
创建步骤：
在类一创建完成只有，在类二中通过”引用数据类型 对象名 =类名.类方法 ”进行创建对象调用，无论创建多少个对象，返回值都是类一自己本身创建的对象
单例模式懒汉模式
懒汉模式是直接初始化
饿汉模式只是创建了对象而没有初始化，只有在用的时候才初始化对象。
和懒汉模式的区别
饿汉模式
子主题
使用情况：如果几个类有相同的方法和属性那么就可以使用继承来设计
继承关键字：extends
语法：class 子类名 extends 父类名{<br> 子类独有的属性<br> 子类独有的方法<br>}
继承后子类会获得父类的所有的属性和方法（暂时不final）
父类更通用，自雷更具体；
private:只能在本类中被访问
如果想要继承就得提供公共的set()和get()方法
子类不能继承父类权限修饰符为privte的属性或方法
单继承就是A只能继承B，不能季继承B又继承C
java只能单继承。
多级继承是指B继承了A，C也继承了A。
java可以多级继承
特点：
继承
super表示调用了父类的构造方法
所谓子类实例化就是创建子类并继承父类
子类实例化的过程中父类的构造方法先于子类的构造方法被调用
子类被调用的时候父类的默认构造器就会被调用(父类如果存在有参数的构造器，一定要把默认的无参构造器显示的表示出来)
子类在调用父类的有参构造器时使用“super(参数列表)”，这时父类的默认构造器就不会被调用了
在子类中隐藏的调用了super<br>super();
super的调用必须放在方法的第一行
可以使用super和this关键字来区分子类和父类同名的属性
在子类中访问属性和方法的顺序是先在子类中查找，子类中没有的话再去父类中查找。所以当子类和父类有相同名字的方法时访问的是子类的方法（如果在这种情况下要调用父类的方法时可以super关键字来实现。）
super可以表示父类的引用
super的其他用法
super关键字表示对父类的调用
this关键字表示谁调用我，我指的就是谁
super关键字和this关键字的关系
代表当前类的指定实例的引用
可以区分同名的属性和局部变量
调用本类里面的属性：<br>this.属性名；this.方法名();
super关键字
概念：在子类继承父类时，子类的方法和父类的方法相同（相同指的是权限修饰符、返回值类型、方法名、参数列表都相同。方法帖可以不一样），子类的方法就会在将父类的方法覆盖。<b>这种方式叫做重写</b>
重写：在父类和子类有相同的方法，唯一不同的就是方法体。一般是因为父类的方法体满足不了需求才发生重写。
重载：重载是在同一个类中，有着相同的方法名但参数的数据类型或参数个数不同的两个或几个方法就是重载。<br>重载的目的：节省类中的命名资源和提高方法的可读性。
重写和重载的区别
方法的重写
final修饰的方法不能被复写
语法： 权限修饰符 final 返回值类型 方法名 （参数列表）{方法体}；
修饰在方法上
属性名一般采用大写，多个词采用下划线来分隔。
这种常量大多定义在接口中。
语法：权限修饰符 【static】 final 数据类型 属性名 = 值 ；
修饰在属性上
语法： final class 类名{<br> 属性<br> 方法}
使用final修饰的方法是不能被继承的。
修饰在类上
final关键字：
当多个具体的实体类存在着共同的行为，但是有不同的表现，我们在父类继承过程中父类的方法具体实现不能确定，但是能确定的是他们都有这种行为。将这种行为方法叫做抽象方法。
概念：
抽象方法语法：public abstract [返回值][void] 方法名 (参数列表)；
<b><i>抽象方法没有方法体</i></b>
抽象类语法：<br>abstract class 类名{<br> 属性<br> 方法<br>}
注：<i><b>抽象类可以没有抽象方法，但是有抽象方法的的类一定是抽象类。</b></i>
如果一个类中存在一个抽象方法，那么这个类一定是抽象类。这个类以一定要有abstract关键字
语法：
抽象类不能被实例化
抽象类必须被子类继承才能使用子类实例化
继承类抽象类的非抽象类必须实现抽象类的所有抽象方法。
抽象类也可以继承抽象类，这样不需要实现父抽象类的方法。
抽象类的抽象方法不能和private、final、static共存。
特点
抽象类
第六章：类的继承
定义：如果一个抽象类中所有的方法的都是抽象的，那么就可以定义为一个接口。
语法：interface 接口名{<br> 方法的定义<br> .....<br>}
<b>接口是对行为的抽象，类是对属性和行为的抽象</b>
接口与抽象类的差别
定义
在接口里，每一个方法都是抽象的，因此可以省略abstract.
我的理解：接口就是全是抽象方法的抽象类。要使用接口的话，就得把所有的抽象方法覆盖了才能使用。
class 类名 implements 接口名1、接口名2....{<br> 接口里所有的方法<br>}
实现接口的类必须要实现接口里的每一个方法。
在接口里定义方法
在接口里定义的量都是常量。
<b><i>通过接口名来访问（推荐）</i></b>
通过接口的实现类的实例来访问
单词大写，多个单词之间用下划线来分开。例如FINAL_PATH
常量的命名规则
在接口里定义属性
jdk1.7可以实现接口的多继承、多实现和多级继承
jdk1.6及其以下版本不能实现多继承
接口可以继承接口（多继承）
接口定义的是一种标准，可以使我们的代码分层开发，分模块开发
接口降低了代码的耦合度，提高了代码的可扩展性和可维护性。
接口改进了单继承的局限。
使用接口的好处
接口里面所有的方法都是抽象的，抽象类里面的方法可能是抽象的，也可能是非抽象的。
接口和抽象类都不能实例化，接口需要类来实现后实例化实现类，抽象类需要类来继承后实例化继承类。
抽象类只能单继承；接口继承接口可以多继承、也可以单继承。接口还可以多实现(白话就是继承类继承接口可以继承多个接口)
<b>接口中的属性是final、static类型的，抽象类中的属性和普通类属性没有区别</b>
<b><i>接口中的方法默认就是抽象的，不需要加abstract;<br>抽象类中的抽象方法要加abstract关键字。</i></b>
接口和抽象类的区别
可以通过实现接口的类实例化接口
语法：接口名 对象名 = new 实现接口的类名
注：接口是不能被实例化的。
接口
行为具有多种表现功能的能力称为多态
定义：
通常使用抽象类来抽象要使用多态的方法。
必须要有继承关系，在抽象类中可以定义多态的抽象方法，通过子类来继承这个抽象类然后复写抽象类中的抽象方法以达到多态的效果。
<h3><b><i><font color="#c41230">多态子类的实例可以赋给父类的引用。</font></i></b></h3>
子类中的特有方法不能通过父类来调用。
instanceof可以判断多态引用的变量到底是什么类型。
继承多态
接口多态基本上和类的继承多态一致：不同的类的继承使用的是继承关系实现多态，接口采用实现的方式实现多态。
接口多态
必须要实现的一个业务方法
定义一个可以重写也可以不重写的方法
必须不能被重写的方法
模板方法：供其他类来使用的方法
抽象模板
具体逻辑
方法重写
具体的模板：实现具体的业务逻辑
具体模板
创建具体模板对象
主程序所在类
模板方法（23种的一个）
解释一： API是我们写代码的帮助文档
java.lang.*下的类都不需要引入，都是自动引入的。
math类的使用
API的使用
就是文件夹
作用：对类做分类管理，可以区分同名不同包的类。
语法：package 包名（不同级别以.来分隔，位置放在有效代码的第一行）
如何编译：javac -d .类文件
同一个包下的两个类可以直接的访问。
类的权限修饰符为public时才能被外部的包引用。
方式1：访问不同包的类在类的前面加上包的全路径。这种情况下必须先编译被引用的包。
语法：import 包名.类名。
这行代码放在package的下面，class的上面。
方式2：在使用某个包下的类时需要引入。<br>
不同包的使用
包的使用
包
nextInt( )方法：将输入的下一个信息扫描为一个int
scanner是一个类，先实例化一个对象，再调用int 变量名=nextInt( )的方法扫描自己输入的信息。
scanner扫描器
多态
第七章 ：接口和多态
把一个类定义到另一个类中，那个内部的类就是内部类。
<span>内部类就是类里面的类。</span>
内部类不能够直接访问
外部类.内部类 变量名 = new 外部类对象.new 内部类对象
访问内部类的语法：
内部类的方法如果想要访问内部类的方法，必须要创建内部类的对象，根据对象来访问
访问内部类
外部的类的权限修饰符只能是public或者默认(什么都不加)
私有内部类只能在外部类里面被访问。可以通过外部类的公共方法实例化内部类再被其他类调用访问内部类。（和封装有点像，只不过这里封装的是一个内部类）
私有内部类
静态类可以加static关键字，定义了为静态内部类
外部类名.内部类名 对象名 = 外部类名.内部对象
静态内部类的创建语法：
j静态内部类只能访问它的外部类的静态属性
静态内部类
方法中定义的类叫局部内部类。
局部内部类
方法中定义的匿名类叫做匿名内部类
匿名内部类
内部类
匿名类就是没有名字的类
创建了一个没有名字但是实现了接口的类的对象。
引用语法：.方法名（参数类型 参数名）；
语法1：new 接口名（）{<br> 接口里的方法的覆盖<br>}；
引用语法：对象.方法名（参数类型 参数名）；
语法2：接口名 对象 = new 接口构造方法
注意：匿名类最后的分号一定要加。
借助接口来创建匿名类。
匿名类是一次行的，用完就会被垃圾回收器回收。
通过类可以实例化一个没有名字的对象，这个对象就叫做匿名对象。
匿名对象很快就会被垃圾回收器回收。也是一次性的。
语法： new 构造方法；
也可以这么引用方法：new 构造方法.普通方法名（）；
匿名对象：
匿名类
public
protected
默认的
private
子主题（ ）
Ｙ
Ｎ
Ｙ
类（外部类）
Ｙ
Ｙ
方法
Ｙ
属性
四种权限修饰符的可用性
类的权限修饰符一般都是public
方法绝大多数都是public
属性绝大多数都是private
四种权限修饰符的一般作用范围
分支主题
权限修饰符详解
object类是类层次结构的根类，每个类都使用object类。object类作为超类，每个类都继承它的方法。
直接打印对象时是默认的在调用父类继承下来的toString
判断对象相等时不能用“==”号，因为“==”是在判断地址是否相等，而地址是永远不会相等的。
object类
第八章：内部类和Object
标出输出：输入syso然后按下alt+/
主函数：输入main然后按下alt+/
自动补全：alt+/
单行注释：ctrl+/
多行注释封装：Ctrl+shift+/
取消多行注释：Ctrl+shift+\\
对代码进行格式化：Ctrl+shift+f
向上移动选中行：alt+↑
向上下移动选中行：alt+↓
对使用了其他包中的类或接口进行自动导入，也可以消除没用的包：Ctrl+shift+o
删除选中行：ctrl+d
将选中部分的字母大写：ctrl+shift+x
将选中部分的字母小写:ctrl+shift+y
获得建议处理方式：ctrl+1
常用快捷键
快捷键的使用
错误都是以error结尾的
编译期异常必须处理，不处理就无法编译通过。
编译期异常
如果发生了运行时异常，异常点之后的代码就不会执行。
编译期没有异常，但是运行的时候出现了异常。
运行时异常
异常都是以Exception结尾的
语法： try{<br> 可能发生异常的代码<br>}catch(异常类型 变量名){<br> 处理异常的代码<br>}
如果不发生异常就不会产生异常对象（就是变量名代表的对象）也不会进入catch
如果发生了异常，这个异常会进入catch中，走catch中的代码。
如果异常通过catch得到了处理，那么catch模块后面的代码可以正常执行。
第一种方法：自行解决
try{ }catch( ){ }的快捷键：ctrl+shift+z
自动上抛的
第二种方法：向上层抛出（调用者）
在此语句中可以有多个catch
finally{ }一定会被执行而不管有没有异常
catch里的return执行后会等待finally{ }语句执行
如果catch{ } try{ }里面有return返回值被执行，那么finally{ }里是无法更改返回值的，除非finally { }里面也有一个return返回值。。
执行顺序shift最后执行finally{ }
return后面的句子不被执行
try{ }catch( )finally{ }语句
运行时异常的处理
向上抛关键字：throws
编译期异常的处理
编译期异常自行处理<br>运行时异常上抛
自定义的异常都是运行时异常
创建一个异常类继承RuntimeException
继承RuntimeException的构造器
步骤
自定义异常
错误和异常
第九章<span>Eclipse的使用和异常</span>
byte、short、int、long
整形
float、double
浮点型
数值型
char
字符型
boolean
布尔型
基本数据类型
类（class）
接口(interface)
数组( [ ] )
引用数据类型
数据类型
字符串概述
第十章
第十一章
ArrayList
Vector
List
HashSet
TreeSet
Set
Collection
集合的体系结构：
集合也叫容器，用于存储对象
<font color="#c41230"><b><i><u>通过泛型来指定这种数据类型</u></i></b></font>
集合中可以存储任何数据类型，但是在实际开发中一般只存储一种数据类型
第十二章集合上
第十三章
Map集合shift键值对的集合，Collection集合是单一出现的数据的集合
Map的键是唯一的，而Collection的子接口List集合中的元素是可以重复的，set是唯一的。
Map是夫妻对、Collection是光棍。
Map集合和Collection集合的区别
数据成对出现
数据的键是唯一的
一个键只能对应一个值
键可以重复
键可以有一个为空、值可以有多个为空
Map的特点
Map概述
Map的介绍和添加
Map的常用功能
第十四章：Map集合和文件
概述：
输入流
输出流
从输入和输出角度分类
字符流：凡是能够读懂的都是字符流
字节流：二进制文件
从数据角度分类
分类
创建文件
创建输出流对象
把流指定指向的文件
释放资源
使用字符流向一个文件输入hello world
IO流介绍
第十五章：IO流和字符流
<span>进程是一个具有独立功能的程序关于某个数据集合的一次运行活动。</span>
线程：是进程的一个单元
多线程：一个进程中有多个线程在同时运行。
线程概述
线程被new出来
新建
准备就绪
具有执行资格和具备执行的权利
运行
没有执行资格和执行权利
阻塞
线程的对象变成垃圾，释放资源。
销毁
线程的生命周期
忽略线程间的相互转换。
线程是并发执行的
<span>一种是继承Thread类，一种是实现Runnable接口</span>
实现线程的两种方式
针对线程的安全性问题，需要使用同步（就是加锁，共享资源只能有一个人进入访问）
语法：synchronized（锁对象）{<br> 操作共享资源的代码 <br>}
代码被多个线程访问
代码中有共享的数据
共享数据被多条语句操作
同步代码加在什么地方
如果是静态方法，那么锁对象就是类的类对象。
如果是对象方法，那么锁是this
synchronized也可以加在方法上
当线程的实现方式时继承Thread类时，这个对象必须是静态的。
synchronized同步代码快的锁对象可以使任意类对象，
在synchronized内部如果休眠会带着锁休眠
只有使用锁对象才能调用wait(）方法和notify(）方法。
synchronized
在做服务端的时候为了减少服务端的压力需要休眠。
如果休眠时在同步代码块中执行，休眠不会让出锁对象。
线程的休眠
第十七章：线程
<span>new关键字创建对象方法如下：</span><br><span>类名 对象名=new 类的</span><a target="_blank" rel="nofollow">构造函数</a><span>；</span>
Java SE知识点框架总结分享
0 条评论
回复 删除
下一页
