JAVA 学习笔记

时间 2019-12-07

标签 java 学习笔记栏目 Java 繁體版

原文原文链接

转载：牛客吴彦祖
连接：https://www.nowcoder.com/discuss/28656
来源：牛客网java

Java笔记

第一章

Java最大的特色就是能够在不一样的平台环境上运行。
Java Write Once，Run Anywhere！
Java体系结构中立。
Java的版本分为:JSE 标准版；JEE 企业版；JME 小设备版。
Java与C++的区别：（-3+1）去掉指针，去掉多继承，去掉运算符重载；增长自动内存分配与回收机制。
Java面向对象的特色：封继多：封装、继承、多态。
Java分布式：Java的网络编程如同从文件发送和接收数据同样简单。
Java鲁棒性：异常处理机制、自动垃圾收集处理来进行内存管理。
Java安全性：不支持指针、沙箱运行模式（Java程序的代码和数据在必定的空间执行）
Java解释执行：代码被编译为JVM字节码，字节码的执行不依赖硬件配置。这是Java能够在不一样平台上运行的基础。
javac name.java name.class java name
javac是编译命令 java是解释执行命令
package 一个程序最多只能有1句，且只能放在第一句。
import无关紧要，有必须放在全部的类定义以前。
JVM是运行java字节码的一台虚拟机。

第二章

Java采用Unicode字符集，16位，，支持大部分字符集。
Java标识符不能以数字开头，名称与大小写相关。
标识符的使用习惯：1名次首字母大写；2动名词动词首字母小写，名次首字母大写；3常量全大写；4变量首字母小写其余的大写。
Java数据类型：8个基本类型：byte、short、int、long、float、double、char、boolean；3个引伸类型：class、interface、数组。
Java中逻辑类型和整数类型不能直接转换。
final修饰符号常量、其值在赋值以后不能改动。
类成员变量自动赋初值，局部变量不赋初值报错，引用做为类成员自动赋值为NULL。
Java中取消的操做符：->、*、&、sizeof、其中三个与指针相关。
基本类型赋值在栈里；引用类型赋值在堆里；引用自己位于栈。
引用直接用==比较的是地址，要比较对象的实际内容，用equal()方法。
Java中逻辑操做符&& || 有短路屏蔽，位操做符& |没有。
自动类型转换：低精度到高精度；高精度到低精度须要强制类型转换。
Java是结构化程序设计语言：顺序结构、选择结构、循环结构。
switch-case中只能用整型、字符型、枚举型、字符串。
break跳到最近的｝以后；continue跳出当前循环到下一次循环，当是while时直接判断条件，for还须要进行自加操做。
带有Lable的break和continue的区别：break跳到Lable以后跳过最近的｛｝；contine跳到Lable以后进入｛｝。
return返回结果、返回控制。

第三章

类变量实例变量类方法实例方。
类变量、类方法既能用类名，也能用实例名访问。
实力变量、实例方法只能用实例名访问。
类方法中只能访问类变量，类方法中不能有this和super指针。
访问权限：public、protected、包（默认）、private。
protected：1本身用；2子类用；3同一包中用。
不一样访问权限的访问个体有：1类；2包；3子类；4不一样包中的非子类。
构造方法是一个特殊的方法，与类名相同，无返回类型，经过new()调用。
Java中没有析构函数，系统自动回收垃圾，对于不是经过new()申请的空间，用终结处理方法finalize()
对象的声明（标识符）；实例化（用new分配空间）；初始化（赋值）。
栈：基本类型和对象引用堆：全部的Java对象，用new产生的数据。
类成员的初始化顺序：1静态成员；2组合对象成员；3类自己其余成员。
静态成员只初始化一次。
Java包有必定的层次，对应外存上的目录结构，同一包中不能有相同的类名。
程序中没有package语句时，放入默认包中。
一个编译单元只能有一个公共类public class，公共类名与文件名相同，还能够有多个支持类。
导入的两个包中有同名类时，使用时用全名来区分。
为导入包而用类库中的类时，用全名引用；自定义的包，java+类名。
java.lang 自动加载的默认包：基本数据的封装类、数学函数、字符串、线程等。
java.util 工具类库：日期、日历、堆栈、向量、集合、哈希集。
Object类：在lang包中，全部类的基类、定义全部类应有的公共函数。
System类：在lang包中，不能实例化，全部方法都可直接引用，与系统属性相关。
Math类：在lang包中，静态方法，不声明为实例，经常使用Math.PI、Math.E。
String类：在lang包中，字符常量，不用new建立时由栈中引用指向常量池（不重复）；用new建立时可重复。Substring截取中间一段，trim去掉两端空格。
StringBuilder、StringBuffer：对于常常要修改的字符串，StringBuilder效率高于StringBuffer，StringBuffer在线程上是安全的，在大多实现过程当中，StringBuilder要比StringBuffer快。
String至关于字符中的常量，只要值变化，内存空间就变化。
StringBuffer中的方法：append to追加、insert插入、delete删除、reverse反转。

第四章

toString()函数，每一个非基本类型中都有，未重写时默认输出为对象的内存地址。
组合：黑盒复用，依赖关系少，高效、动态。
继承：白盒复用，黏度高，易维护，破坏封装。
优先用组合。
super出如今构造方法中必须在第一行。
重写：子类修改父类已有的方法（覆盖），重写的方法名、返回类型、参数类型必须彻底相同，且被重写的方法不能有更严格的访问权限，发生在多态中，无新受检异常。
重载：同一类中方法名相同参数列表不一样，只能经过参数列表重载，不能经过访问权限、返回类型、抛出异常重载；重载能够有不一样的返回类型、访问权限、异常，可是不做为重载的标志。
抽象类abstract抽象类不能实例化，类中有抽象方法，abstract class a1｛abstract void test()；｝函数声明以后有｛｝就算实现。
构造方法、静态方法、final方法不能使用abstract修饰。
接口默认为抽象类，实际上接口是抽象抽象类。
final类不能被继承，所以final类中的成员函数没有机会被覆盖，默认都是final的。
final方法：若是一个类不容许其子类覆盖某个方法，将这个方法声明为final。
将类方法声明为final更加高效，编译时绑定，静态绑定。
final变量常量，修饰的成员的值一旦给定就没法改变：静态变量、实例变量、局部变量。
static和final变量可以自动赋值为默认值。
this()本类的构造函数 this.本类的变量或方法
Super()超类的构造函数 super.超类的变量或方法
子类和超类有重名变量时，用this和super区分。
向上转型：子类转型为超类；超类的引用指向子类的对象。
超类的引用不能调用：1子类中定义而超类中没有定义的方法；2子类重写的方法。
只能将子类类型的引用赋值给超类类型的引用。
每一个类实例对象都自带一个虚函数表，这个表中存储的是指向虚函数的指针。
超类和子类中都有的方法，才有多态的动态绑定问题。
重写的重要特征：除了函数的实现之外其余部分都相同；覆盖：均相同才能覆盖。
Java中全部的成员方法都包含在虚表中，而C++中只有声明为virtual才是虚函数。
动态绑定和静态绑定的适用条件：静态：private、static、final、构造函数。
动态绑定的过程当中，先在对象的实际类型的虚表中匹配，找不到的话再上溯到它的基类的虚表中找。
this指针始终指的都是实际类型。
动态绑定指的是成员方法，成员变量始终都是静态绑定。
想要动态的调用变量成员，将变量成员封装在方法中返回。
重写是覆盖，同名的方法仅有一个；重载是并列，哪一个参数匹配调用哪一个。
多态的三种实现方式：1继承实现；2抽象类实现；3接口实现。
接口中只有常量和抽象方法。
Java接口中的成员变量默认都是public static final类型的，这些关键字均可以省略，可是必须初始化。
Java接口中的方法默认都是public abstract类型，不能有方法体，不能实现。
抽象类和接口的区别：抽象类中能够有写实的方法，但至少要有一个方法是抽象的；接口中全部的方法都必须是抽象的。
Java接口中只能包含public static final成员变量和public abstract成员方法。
接口继承接口，类实现接口，类继承类。
Java接口必须经过类来实现。
类实现接口时，当全部的方法没有所有被写实时，类应该声明为抽象类。
不容许建立接口实例，可是容许定义接口的引用指向实现了该接口的类实例对象。（相似于向上转型）
抽象类只能在继承体系中实现，而接口能够任意实现。
接口中的常量能够是不定常量，其值会在第一次访问是创建，而后保持不变。
内部类的访问权限控制符有：public、default、protected、private，嵌套内部类static。
建立非静态内部类时，必定要先建立其相应的外部类对象。
outerclass.innnerclass innerobject=outerobject.new innerclass()
建立嵌套类对象时，不须要建立其外部类对象。
outerclass.innnerclass innerobject=outerclass.new innerclass()
静态内部类不能访问外部类的非静态成员。
局部内部类：定义在一个方法或一个语句块中。
局部内部类访问外部类的局部变量时，只能访问final类型的。
局部内部类的访问优先级：内部类>外部类>局部final变量。
内部类的做用：容许protected和private权限，实现更小层次的封装。
内部类通常与接口联合使用，更好的实现多重继承。
匿名内部类：new 接口名(){} new 超类名(){}
内部类编译时生成的.class文件outerclassname$innerclassname.class 匿名内部类outerclassname$#.class #为数字，从1开始，每生成一个，数字递增1。
在内部类中调用this和new返回一个外部类时的不一样，this获得的是建立该内部类的外部类对象的引用；而new建立一个新的引用。
有内部类的实例做为外部类的成员时，构造该外部类时，先建立内部类的成员实例，再建立外部类实例的其余成员。（至关于组合关系）
一个外部类的内部类被另外一个类继承时，在该子类的构造方法中用外部类的一个实例调用超类的构造函数。Outerobject.super()。
通常的super()调用默认的都是extends类名中的构造函数。
class son extends father{super();}
class son extends father.innerclass{fatherobject.super();}

第五章

AWT：重量级控件：靠本地方法实现其功能，不一样的平台上不统一。
Swing：轻量级控件：提供了AWT的全部功能，并大幅扩充。
Swing中除了JFrame、JApplet、JDialog、JWindow以外都是轻量级控件。
Button在AWT中，JButton在Swing中；其余的名称相似。
Java采用向容器中添加组件的方式构建图形界面，一般用顶级容器做为全部组件的承载物。
容器之间能够彻底嵌套。
GUI组件分为：容器类、控件类、辅助类。
经常使用的组件及相关函数
JFrame（窗口）：setsize、setvisible、setlocation、setdefaultcloseoperation、getcontentpane
JButton（按钮）：settext、seticon、setbounds、addactionlistener
JLable（标签）：settext、seticon、settooltiptext、sethorizontextposition
JTextField（文本框）：addactionlistener、setcolums、settext
JRadioButton（单选框）；JDialog（对话框）；JFileChooser（文件对话框）；JComboBox（组合框）：JTextField（文本域）、JMenu（菜单）。
布局管理：Container中有一个方法交setLayout()
不一样的布局方式有：1BorderLayout；2FlowLayout；3GridLayout
BorderLayout是JFrame的默认布局，组件分为5个区域，东西南北中。
add(位置，组件)
FlowLayout顺序布局：从左到右、从上到下、
GridLayout网格布局：组件在网格中从左到右、从上到下。
事件处理：1事件；2源事件；3事件处理者。
事件处理的步骤：1注册事件监听器；2外部做用于事件源；3生成事件对象；4将事件对象传给事件处理器；5事件处理器进行处理。
定义监听器：actionPerformed、new建立监听器对象、注册监听器add***actionlistener()
监听器的三种实现方式：1实现注册写实；2内部类；3匿名内部类的实现。
GUI编程中要用的三个包：import java.awt.；import javax.swing.；import java.awt.event.*。
适配器：Adapter：适配器产生的必要性：接口中有不少抽象函数未写实，当要用到其中的某个功能时，须要所有写实，带来不便；适配器实现了全部方法却不作任何事情，可被继承而后只需写实要用到的那个方法而不用管其余方法。
适配器是处于接口和类之间的一个过渡性产物，省去不少实现的麻烦。

第六章

异常的分类：1Exception通过处理能恢复正常，不中断现有程序；2Error没法恢复必须中断现行程序退出。
常见的异常：ArithmeticExption数学异常、OutofMemory内存溢出异常、NullPointerExption空指针异常、IndexOutofMemoryExption下标边界异常。
错误由JVM抛出。
异常分为受检异常和不受检异常：1不受检异常（编译器可处理）：不要求程序员处理，最终可从main()抛出并用printStackTrace()通常是逻辑错误，包括RuntimeException和Error及其子类；2受检异常：强制程序员检测和处理。
异常的处理方法：1用try-catch-finally结构捕获和处理；2将异常层层向上抛直至转交给JVM处理。
多个catch块时只会匹配其中一个异常类并执行catch的代码，catch匹配的顺序是从上到下。
不管try语句块是否发生异常，finally语句块都是要执行的。
try-catch-finally三个语句块不能单独使用，可组成try-catch-finally、try-catch、try-finally三种结构，catch块能够有多个，finally块只能有一个。
try-catch-finally块中的变量的做用域为语句块内部，分别独立不能相互访问。
catch块的参数有父子关系时，子类在前，父类在后。
返回类型+函数名称+形参列表+throws Exception{}
异常传递链：不处理不执行，方法在抛出异常的地方退出，不想终止方法就用try来捕获异常。
自定义异常在构造函数中super()来调用Exception类的构造函数。
throws方法声明时放在方法中，throw在方法体中，在一个具体的动做。
若是抛出的异常一直未被处理，沿函数一直往上抛，从主函数中抛出以后由JVM处理，此时能够调用printStackTrace()打印这一异常所在的位置、类型等信息。

第七章

Java中数组的下标从0开始编号，数组中除了元素以外还存在惟一的可被访问的属性length。
数组声明：类型[]数组名类型数组名[] []表示数组类型
数组的初始化：静态初始化、动态初始化。
静态初始化：[]中没有数字，各个元素的值显性给出。
动态初始化：[]中有数字或变量，用关键字new，数组中各个元素能够自动赋值。
new申请空间时在堆上，在堆上都可自动赋值。
对象数组的初始化：类型[]数组名=new 类型{new 构造方法()…}
对于大型的数组或对象数组，通常结合循环语句来赋值。
多维数组：n维数组中存放着n-1维数组的引用。
不规则数组：数组元素引用的数组长度不等：a.length指的是第一维数组长度；a[i].length指的是对应维数数组的长度。
数组是一个特殊的对象，数组名存放一个对象的引用。
数组名实质是一个引用，因此能够做为参数。
数组工具类：Arrays，类函数：copyof数组中的值拷贝；sort升序排序；binarysearch查找特定值；equals判断两个数组是否相等。
对象比较接口：java.lang.comparable int compareTo(Object o)
java.util.comparator int compare(Object o1, Object o2)
一个类用sort比较大小时，自动调用compareTo方法比较大小。
枚举：有限的、不变的值的集合。
enum类型变量只能保存声明时给定的枚举值。
数组：静态容量，容量的一开始就定了。
类集Collection，是动态容量：有两个子集：1List对象有顺序，容许重复；2Set无序，不能重复。
Map映射：键值对，键是惟一的，值能够重复。
List：(有顺序，靠下标索引)ArrayList LinkedList
List l=new ArrayList()，改变集合类型时代码不用变化，相似于接口引用一个实现了它的类，当使用类特有的方法时，不能用接口定义，而应该使用具体的类。
ArrayList数组内部维护了一个Object类型的数组；LinkedList内部维护了一个有头结点的双向链表。
使用LinkedList能够很简单的构造堆栈、队列，addFirst、addLast、getFirst、getLast、removeFirst。
泛型，C++中的模版，声明泛型时，使用尖括号指定类型参数，应用时用具体的类型填入类型参数。
泛型：类模版、函数模版。
声明 class 类名 <类型参数列表> {}
应用类名 <具体的类型列表> 变量名=new类名 <具体的类型列表> (构造函数的参数列表)。
类、接口、方法都能使用泛型。
集合Set：不容许重复，无下标索引，经常使用的集合HashSet、TreeSet、LinkedHashSet。
system.out.println(set)用结合做为参数能直接输出结合中的元素，输出形式为[…,…,…]
迭代器：Iterator设计模式、对象，特别为遍历无索引的集合而准备。
Iterator中的函数：next()首次使用时，返回序列的第一个元素，以后得到序列中的下一个元素并向后移；hasnext()判断是否有下一个。
迭代器的使用：判断it.hasnext();取出类型=it.next()
for-each遍历，对迭代器进行了包装，代码更加简洁，只能遍历两种类型：1数组；2实现了Iterator接口的实例。
哈希集：HashSet：用哈希表和哈希算法实现快速查找，折中了数组和链表，内部维护了一个链表数组，拥有常数查找时间，要求对象重写hashCode、和equal方法。
哈希表相似于邻接表，散列、Cache映射寻址中的组相连。
哈希表工做的两大步骤：1得到哈希码，算出该插入哪一个链表；2在链表上比较。
容量：链表数组的大小，载入因子，重构的条件；当元素数目>容量*载入因子时，重构翻倍。
HashSet中没有相同的元素，因此内容equals的对象，hashcode必定也相等，hashcode不相等的两个对象必定不equals。
hashcode默认返回的是内存地址，equals默认比较的也是内存地址。
哈希集中通常选一个不重复的关键词做为哈希码。
TreeSet元素间有序但不能重复，，自平衡二叉树，必须实现comparable和compator接口来比较，写实equal保证惟一性，查找效率为。
LinkedHashSet哈希集+链表，在HashSet基础上将元素串起来，元素有序。
输入同一组数据，用不一样的集输出，HashSet元素存放无序，LinkedHashSet保持添加顺序，TreeSet按排序存放。
key-value关系对的无序容器，键值均为对象，键值对也为对象。
一个映射Map中不能有相同的key，每一个key只能有一个value
Map不能用迭代器，无序，没法索引。
遍历Map时，经过将映射转换为键或值来进行遍历。
List Set Map为接口，不能实例化。
泛型<>的位置，函数：在访问控制符以后，类，接口在名称以后。理解：必须在可能出现类型的地方以前
collection是list和set的父类，collection工具类，静态类，有经常使用的操做。

第八章

建立好的输入输出系统是艰难的工做：1与不一样的源和目的端进行交互；2以不一样的方式进行通讯；3大多数I/O须要异常处理。
Java经过各类封装的流类完成输入输出工做。
流：想象中无限长的数据序列1输入流输出流；2字符流字节流；3节点流处理流。
字节输入：InputStream、字节输出OutputStream、字符输入Reader、字符输出Writer。
ByteArrayInputStream：将内存的缓冲区来看成InputStream使用。
StringBufferInputStream：将String转换成InputStream。
FileInputStream：从文件中读取信息。
PipedInputStream：产生用于写入相关数据，实现管道化。
ObjectInputStream：对象序列化输入流。
SequenceInputStream：将两个或多个InputStream对象转换成单一的InputStream。
DataInputStream：从流中读取基本的数据类型(int char long…)
BufferedInputStream：使用缓冲区读入，防止每次读取都要进行操做破坏硬盘。
LineNumberInputStream：跟踪输入流的行号。
节点流：从特殊位置读写的基本功能。
处理流：结合其余流的基础上，修改管理数据并提供额外功能。
常见的处理流：1缓冲Buffered；2过滤：Filter；3转换InputStreamReader；4对象序列化ObjectInputStream；5打印PrintStream。
缓冲流：不直接读写，对硬盘损害小，嵌套在其余节点流之上，提升效率。
缓冲流在构造时，通常有两个参数：1要包装的流类；2要缓冲的数据的大小。
mark标记流中当前的位置；reset定位到最近的标记点；readline读一行；flush刷新。
打印流，不抛异常，自动刷新。
数据流：支持基本类型的输入输出，继承自InputStream、OutputStream。
流的难点在于：搞清格流之间的关系，流之间如何嵌套，如何用一个流若为参数来构造另外一个流。
处理流须要在节点流的基础上封装构造，因此识别基本的节点流和处理流是一项基本功。
处理流在使用完毕以后要调用close函数，处理流是动态的，不关一直起做用。
标准I/O流，System.in键盘输入；System.out屏幕输出；System.err错误输出。
各类流类的嵌套定义和初始化时遵循一个原则，简单的被复杂的嵌套，简单的做为复杂的参数。
Scanner类：扫描输入文本，除了可用正则表达式以外，还可分析字符串和基本类型。
Scanner的使用： Scanner s=new Scanner(System.in) int ss=s.nextInt()
使用输入输出时导入一个包import java.io.*;
使用Scanner是import java.util.*;
文件输入输出流：FileInputStream、FileOutputStream 、FileReader、FileWriter。
File类的构造：public File(String pathname)相对路径、绝对路径、父路径、子路径。
mkdir建立文件夹 mkdirs在不存在为文件中建立文件夹
有关文件的输入输出：int b=0，while((b=in.reader()!=-1)){}
随机访问文件：适用于大小已知的记录组成的文件，seek到指定位置，getFilePointer获得当前指针位置。
length判断文件大小。
RandomAccessFile生成随机访问文件。

第九章

系统级并发，单个的一段程序执行控制流称为线程。
多线程：一个程序内有多个相同或不一样的线程或执行不一样的任务。
多线程的做用：1提升UI的响应速度；2提升硬件资源的利用率；3隔离高速硬件和低速硬件；4提供程序上的隔离不一样的运行模块。
实现多线程的程序设计关键：得到Thread实例，重写run方法，调用start方法开始线程并分配资源。
从run方法中返回是退出线程惟一正确的方法。
start是线程从系统外分配资源，run是线程得到资源后要进行的工做。
线程类Thread是Object的直接子类，成员属性：PRIORITY优先级。
Thread的成员方法：sleep休眠指定的秒数，start启动线程，yield挂起暂停，run执行，notify唤醒。
isLive判断线程是否处于活动状态，getName返回线程名称，currentThread返回正在执行的线程的引用。
继承Thread：1继承Thread类；2重写run方法；3new建立新对象；4调用start启动线程。
线程的不肯定性：同一线程内执行的顺序是必定的，多个线程执行顺序有多种组合。
用继承Thread类的方式实现多线程，被Java多继承的限制不能再继承别的类。
用实现Runnable方法实现多线程：（更加通用的多线程方法），1实现Runnable方法；2重写public void run(){}；3用new来实例新对象；4调用start启动线程。
经过继承和实现两种方法造成的线程类在使用时有区别：1继承实现的线程类能直接实例化；2经过实现的线程类实例化以后做为new Thread()的参数。
线程的生命周期：出生、就绪、运行、休眠、等待、阻塞、死亡。
两个线程的依赖关系：某格线程在另外一个线程终止时才能继续执行，可调用另外一个join的方法当另外一个线程死亡时，该线程从等待态进入就绪态。
线程被建立时，从父线程中继承优先级，建立以后也能改变优先级。
优先级定义分为10级。
线程优先级的做用：方便操做系统的调度，优先级相同且不实用分时技术时，一个运行完才运行下一个，除非他本身变为其余状态。
20 两个线程同时访问一个成员，形成对共享数据的冲突，形成一致破坏，为保证数据的一致性，引入同步锁sunchronized
同步分为方法同步和语句同步，方法同步在函数类型以前加sunchronized；语句同步在{}以前加sunchronized。
协做机制：生产者消费者模型。
死锁的解决：1逻辑隔离：每一个同步区使用各自的锁；2尽快释放：使用完尽快释放锁对象；3按顺序申请：用到多格锁对象的申请一致。

第十章

数据库的组成：数据库、数据库管理系统、应用系统、数据库管理员、数据库用户。
数据类型：网状模型、层次模型、关系模型。
关系模型数据库是目前最流行的数据库。
数据库的数据有最小的冗余度和较高的数据和程序独立。
SQL语言，常见的SQL查询命令
查询：selsct…from…where
操纵：insert、updata、delete
定义：creat、alter、drop
JDBC是为了JAVA专门和数据库交互的一套接口，用于执行SQL语句的JavaAPI。
JDBC的基本功能：1加载JDBC驱动程序；2创建与数据库的联系；3使用SQL语言进行数据库操做和处理结果；4关闭相关连接。
写数据库程序要导入的包：import java.sql.*。