项目中，用到过的Java知识梳理（自己的百科全书）

在项目中已经使用过的知识梳理

一、8种数据类型

基本逻辑类型 boolean
字符 char
整型 byte short int long 1 2 4 8
浮点型 float double 4 8


char 类型
字符类型事实上是一个16位无符号整数，这个值是对应字符的编码，Java字符类型采用Unicode字符集编码。Unicode是世界通用的定长字符集，所有的字符都是16位。

强制转换：从大类型到小类型需要强制转换符：
格式：（需要转换成的类型）变量

强制转换有可能会造成精度损失或者溢出。
byte、char、short、三种类型实际存储的数据都是整数。
二、类 、成员变量、方法

类 --类不但定义了抽象数据类型的组成（成员变量），同时还定义了可以对该类型实施的操作（方法）。
类的定义包括“成员变量”的定义和“方法”的定义，
其中**“成员变量**”用于描述该类型对象共同的数据结构。
成员变量的类型分（1）8中基础类型；（2）引用类型，引用类型初始值为null。
成员变量根据定义的位置不同，分为全局变量和局部变量（定义在方法里）。
类中的所有方法里都可以使用全局变量。
局部变量在方法里有效。

栈用于存放方法中的局部变量

一个运行的Java程序从开始到结束会有多次方法的调用。JVM会为每一个方法的调用在栈中分配一个对应的空间，这个空间称为该方法的栈帧。
一个栈帧对应一个正在调用中的方法，栈帧中存储了该方法的参数、局部变量等数据。当某一方法调用完成后，其对应的栈帧将被移除，局部变量失效。


方法重载及意义
在Java语言中，允许许多方法的名称相同，但参数列表不同，称之为方法的重载（overload）

构造方法语法结构

构造方法是在类中定义的方法，不同于其他的方法，构造方法的定义有如下两点规则：
构造方法的名称必须与类名相同。
构造方法没有返回值，但也不能写void。

构造方法的重载：
为了使用方便，可以对一个类定义多个构造方法，这些构造方法都有相同的名称（类名），方法的参数不同，称之为构造方法的重载。

Java 访问控制符private、protected、 public、default
private:修饰的成员变量和方法， 访问权限仅限于类的内部，是一种封装的体现.
protected: 修饰的成员变量和方法可以被子类以及同一个包中的类使用，主要的作用就是用来保护子类的。它的含义在于子类可以用它修饰的成员，其他的不可以，它相当于传递给子类的一种继承的东西.
public: 修饰的成员变量和方法 具有最大的访问权限，可以访问任何一个在classpath下的类、接口、异常等。它往往用于对外的情况，也就是对象或类对外的一种接口的形式。

static修饰成员变量

用static修饰的成员变量不属于对象的数据结构；
static变量是属于类的变量，通常可以通过类名来引用static成员；
static成员变量和类的信息一起存储在方法区，而不是在堆中，**一个类的static成员变量只有“一份”，无论该类创建了多少对象。**

static修饰方法
通常的方法都会涉及到对具体对象的操作，这些方法在调用时，需要隐式的传递对象的引用（this）
static修饰的方法则不需要针对某些对象进行操作，其运行结果仅仅与输入的参数有关，调用时直接用类名引用。
由于static 在调用时没有具体的对象，因此在static方法中不能对非static成员（对象成员）进行访问。static方法的作用在于提供一些“工具方法”和“工厂方法”等。
static块
static块：属于类的代码块，在类加载期间执行的代码块，只执行一次，可以用来在软件中加载静态资源。

final修饰变量

final 关键字修饰成员变量，意为不可改变。

final 修饰成员变量，两种方式初始化：
1、声明同时初始化
2、构造函数中初始化
final 关键字也可以修饰局部变量，使用之前初始化即可。
final修饰方法
final关键字修饰的方法不可以被重写。
使一个方法不能被重写的意义在于：防止子类在定义新方法时造成的“不经意”重写。
final修饰类
final关键字修饰的类不可以被继承。
static final 常量
static final 修饰的成员变量称为常量，必须声明同时初始化，不可被改变。
在java中，经常希望某个常量可以在一个类中的多个方法中使用，通常将这些常量称为类常量。可以使用关键字static final设置一个类常量。

三、参数传递
**参数传递**需谨慎考虑，深入了解数据传递的范围、位置（涉及 变量 （静态、全局、局部、私有、公有） 、引用（对象） ）

值传递
参数类型是8中基础类型的，参数传递的过程采用值拷贝的方式。也就是说传递后就互不相关了。
引用传递
参数类型为引用类型，参数传递的过程采用拷贝引用的方式。

在java里面除去基本数据类型的其它类型都是引用数据类型，自己定义的class类都是引用类型，可以像基本类型一样使用。
按值传递，不会改变原来的值，引用传递，会改变引用对象的值。“在Java里面参数传递都是按值传递”这句话的意思是：按值传递是传递的值的拷贝，按引用传递其实传递的是引用的地址值，所以统称按值传递。

四、集合（ map list queue）
在实际开发中，需要将使用的对象存储于特定数据结构的容器中，JDK提供了这样的容器–集合（Collection）。Collection是一个接口，定义了集合相关的操作方法，其有两个子接口：List与Set
（注：还未使用过Set）list可重复集，Set不可重复集，元素是否重复，取决于元素的equals()比较的结果。
集合持有对象的引用

add方法–用于向集合中添加新元素。
contains方法–该方法用于判断给定的元素是否包含在集合中。若包含则返回true，否则返回false。集合在判断元素是否被包含在集合中是根据每个元素的equals()方法进行比较后的结果。
size clear isEmpty
遍历集合
迭代器Iterator是一个接口，提供了统一的遍历集合元素的方式，其提供了用于遍历集合的两个方法：
hasNext方法，判断集合是否还有元素可以遍历。
next方法返回迭代的下一个元素。

1、线性表 list
List接口的两个常见实现类为**ArrayList和LinkedList**，分别用动态数组和链表的方式实现了List接口。两者在方法逻辑上完全一样，只是性能上有差别。
ArrayList更适合于随机访问，LinkedList更适合于插入和删除。

get和set
get（int index）–获取集合中指定下标对应的元素，下标从0开始。
set（int index，elment）–将给定元素存入给定的位置，并将原位置的元素返回。
add（）插入，remove（）删除
subList 获取子list
list转换为数组–toArray方法用于将集合转换为数组。
数组转换为List–Arrays类中提供了一个静态方法alist。使用该方法我们可以将一个数组转换为对应的List集合。
Comparable

对集合元素进行自然排序

2、Queue 队列
队列（Queue）是常用的数据结构，可以将队列看成特殊的线性表，只能从线性表的一端添加（offer）元素，从另一端取出（poll）元素。
队列遵循先进先出（FIFO First Input First Output）的原则。


add 增加一个元索 如果队列已满，则抛出一个IIIegaISlabEepeplian异常
remove 移除并返回队列头部的元素 如果队列为空，则抛出一个NoSuchElementException异常
element 返回队列头部的元素 如果队列为空，则抛出一个NoSuchElementException异常
offer 添加一个元素并返回true 如果队列已满，则返回false
　　poll 移除并返问队列头部的元素 如果队列为空，则返回null 不抛异常
　　peek 返回队列头部的元素 如果队列为空，则返回null
　　put 添加一个元素 如果队列满，则阻塞
　　take 移除并返回队列头部的元素 如果队列为空，则阻塞
　　
1、add()和offer()区别:

add()和offer()都是向队列中添加一个元素。一些队列有大小限制，因此如果想在一个满的队列中加入一个新项，调用 add() 方法就会抛出一个 unchecked 异常，而调用 offer() 方法会返回 false。因此就可以在程序中进行有效的判断！

2、poll()和remove()区别：

remove() 和 poll() 方法都是从队列中删除第一个元素。如果队列元素为空，调用remove() 的行为与 Collection 接口的版本相似会抛出异常，但是新的 poll() 方法在用空集合调用时只是返回 null。因此新的方法更适合容易出现异常条件的情况。

3、element() 和 peek() 区别：

element() 和 peek() 用于在队列的头部查询元素。与 remove() 方法类似，在队列为空时， element() 抛出一个异常，而 peek() 返回 null。

LinkedBlockingQueue
LinkedBlockingQueue ：一个由链接节点支持的可选有界队列。

3、Map接口
Map接口定义的集合又称查找表，用于存储所谓“Key-Value”映射对。Key可以看成是Value的索引，作为Key的对象在集合中不可以重复。
根据内部数据结构的不同，Map接口有多种实现类，其中常用的有内部为hash表和内部为排序二叉树实现的TreeMap。
put()方法 向map中存放元素的put方法 ，将Key-Value对存入Map，如果在集合中已经包含该Key，则操作将替换该Key所对应的Value，返回值为该Key原来所对应的Value（如果没有则返回null）。
get()方法从Map中获取元素的get方法。返回参数Key所对应的Value对象，如果不存在则返回null。get(Object key)
containKey()方法判断某个key是否在map中存在

  boolean containKey(Object key)

LinkedHashMap 实现有序Map

使用Map接口的哈希表和链表实现，具有可预知的迭代顺序。此实现与HashMap的不同之处在于：
LinkedHashMap维护着一个双向循环链表。此链表定义了迭代顺序，该迭代顺序通常就是存放元素的顺序。
需要注意的是，如果在Map中重新存入已有的key，那么key的位置不会发生改变，只是将value值替换。

foreach 在遍历数组、集合方面，foreach为开发人员提供了极大的方便。

   for(元素类型t 元素变量x : 遍历对象obj){ 
     引用了x的java语句; 
} 

根据map中某列数据（数值、字符串）排序

                        mlist.sort(new Comparator<Map<String, String>>(){
                        //Collections.sort(list, new Comparator<Map<String, String>>() {
                        @Override
                        public int compare(Map<String, String> o1, Map<String, String> o2) {
                            int l1=Integer.parseInt(o1.get("SEQUNCENUMBER"));//.substring(1,4)
                            int l2=Integer.parseInt(o2.get("SEQUNCENUMBER")) ;//.substring(1,4)
                            return l1-l2;
                         }
                        });

五、基本IO操作
File的listFiles方法用于返回一个抽象路径名数组，这些路径名表示此抽象路径名表示的目录中的子项（文件或目录）
FileFilter接口 ，此接口的实例可传递给File类的listFiles（FileFilter）方法。用于返回满足该过滤器要求的子项。
节点流：可以从或向一个特定的地方（节点）读写数据。
处理流：是对一个已存在的流的连接和封装，通过所封装的流的功能调用实现数据读写。
处理流的构造方法总是要带一个其他的流对象做参数。一个流对象经过其他流的多次包装，称为流的链接。

InputStream是所有字节输入流的父类。

--int read()    读取一个字节，以int形式返回，该int值得“低八位”有效，若返回值为-1则表示EOF

--int read(byte[] d)  尝试最多读取给定数组的length个字节并存入该数组，返回值为实际读取到的字节量。

OutputStream是所有字节输出流的父类。

--void writer(int d)  写出一个字节，写的是给定的int的“低八位”
--void write(byte[] d)  将给定的字节数组中的所有字节全部写出

以字节为单位向将数据写入文件 FileOutputStream
FileOutputStream是文件的字节输出流，我们使用该流可以以字节为单位将数据写入文件。

构造方法：

--FileOutputStream(File file):
创建一个向指定File对象表示的文件中写出数据的文件输出流。

--FileOutputStream（String filename）：
创建一个向具体有指定名称的文件中写出数据的文件输出流。

追加模式
执行此模式需先打开原表（如果不存在，需创建表头），然后再追加文件，最后关闭。

--FileOutputStream（File file，boolean append）：
创建一个向指定File对象表示的文件中写出数据的文件输出流。

--FileOutputStream（String filename，boolean append）：
创建一个向具有指定名称的文件中写出数据的文件输出流。

第二参数若为true，那么通过该方法写出的数据都是在文件末尾追加的。

以字节为单位从文件读取数据 FileInputStream
构造方法：

FileOutputStream(File file): 创建一个向指定File对象表示的文件中读取数据的文件输入流。

FileInputStream（String name）：创建用于读取给定文件系统中的路径名name所指定的文件的文件输入流。

FileInputStream继承自InputSream，其提供了以字节为单位读取文件数据的方法read。

 --int read()   从此输入流中读取一个数据字节，若返回-1则表示EOF（End of File）

FileOutputStream继承自OutputStream，其提供了以字节为单位向文件写数据的方法write

  --void write(int d)   将指定字节写入此文件的输出流，这里只写给定int值得“低八位”。

FileInputStream也支持批量写出字节数据的方法：

--int read（byte [] b） 将b.length个字节的数据读入到字节数组b中

FileOutputStream也支持批量写出字节数据的方法：

--void write（byte[] d）  将b.length个字节从指定byte数组写入此文件输出流中。

--void write（byte[] d, int offset,int len） 将指定byte数组中从偏移量off开始的len个字节写入此文件输出流。

缓冲输出流与缓冲输入流BufferedOutputStream\BufferedInputStream
BufferedOutputStream 缓冲输出流内部维护着一个缓冲区，每当我们向该流写数据时，都会先将数据存入缓冲区，当缓冲区已满时，缓冲流会将数据一次性全部写出。但是存在写出数据缺乏即时性。为此可以采用flush方法

void flush() 清空缓存区，将缓存区中的数据强制写出。

BufferedInputStream是缓冲字节输入流，其内部维护着一个缓冲区（字节数组）使用该流读取一个字节时，该流会尽可能多的一次性读取若干字节并存入缓冲区，然后逐一的将字节返回，直到缓冲区中的数据被全部读取完毕。

字符流原理

Reader是字符输入流的父类
Writer是字符输出流的父类
字符流是以字符（char）为单位读写数据的，一次处理一个unicode.
字符流的底层仍然是基本的字节流。

InputStreamReader：字符输入流。

–使用该流可以设置字符集，并按照指定的字符集从流中按照该编码将字节数据转换为字符并读取。

OutputStreamWriter：字符输出流

–使用该流可以设置字符集，并按照指定的字符集将字符转换为对应字节后通过该流写出。

PrintWriter是具有自动行刷新的缓冲字符流输出。
BufferReader提供了一个可以便于读取一行字符串的方法：

--String readLine() 该方法连续读取一行字符串，直到读取到换行符为止，返回的字符串中不包含该换行符。

六、socket 通信 、modbus tcp（基于modbus4j）
Socket通常称作“套接字”，用于描述IP地址和端口，是一个通信链的句柄，在Internet上的主机一般运行了多个服务软件，同时提供了几种服务。每种服务都打开一个Socket，并绑定到一个端口上，不同的端口对应于不同的服务。
应用程序通常通过“套接字”向网络发出请求或者应答网络请求。Socket和ServerSocket类位于Java.net包中。ServerSocket用于服务端，Socket是建立网络连接时使用的。在连接成功时，应用程序两端都会产生一个Socket实例，操作这个实例，完成所需的会话。

String IP=“”;
int port；
Socket socket=new Socket（IP，port）；  //建立连接
InputStream in=socket.getInputSream();  //获取网络输入流
该方法用于返回此套接字的输入流

OutputStream out=socket.getOutStream();  //获取网络输出流
该方法用于返回此套接字的输出流

当使用Socket进行通讯完毕后，要关闭Socket以释放系统资源。

--void close()

关闭此套接字。当关闭了该套接字后也会同时关闭由此获取的输入流与输出流。

Server端ServerSocket监听
java.net.ServerSocket是运行于服务端应用程序中。通常创建ServerSocket需要指定服务器端口号，之后监听Socket的连接。

//创建ServerSocket并申请服务端口8080
ServerSocket server=new ServerSocket（8080）
/*方法会产生阻塞，直到某个Socket连接，并返回请求连接的Socket*/
Socket socket = server.accept();

Server端多线程模型
若想使一个服务端可以支持多客户端连接，我们需要解决以下问题：

–循环调用accept方法侦听客户端的连接

–使用线程来处理单一客户端的数据交互

---

socket 网络通讯的两个超时
1、创建连接时的超时（socket是否创建成功时的超时）

socket = new Socket(ip, port); 这样创建socket时，当连接无法创建时，或等待很长时间才抛出异常，对于批量创建连接时，这样是不合理的。

解决办法

socket=new Socket();
socket.connect(new InetSocketAddress(ip, port),3000);  
使用了InetSocketAddress对象，设置了超时时间3秒，当创建连接时，超过三秒抛出异常。

2、收发数据时的超时（读写数据时的超时）
（1）setSoTimeout -----------read 方法的超时时间。
这个参数通过socket.setSoTimeout(int timeout)方法设置，socket关联的InputStream的read()方法会阻塞，直到超过设置的so timeout，就会抛出SocketTimeoutException。当不设置这个参数时，默认值为无穷大，即InputStream的read方法会一直阻塞下去，除非连接断开。

（2）监测通讯管道是否畅通，设置一个心跳包，开个线程发固定消息，监测通信通断。可以设置多久没有收到回复就算超时。

七、自定义通讯协议

1、基于fastjson传json字符串

2、自定义数据包（包头、版本号。。。数据长度、数据区等）按字节传递接收

八、线程以及线程传参
概念
什么是进程
进程hi操作系统中运行的一个任务（一个应用程序运行在一个进程中）。
进程（process）是一块包含了某些资源的内存区域。操作系统利用进程把它的工作划分为一些功能单元。
进程中所包含的一个或多个执行单元称为线程（Thread）。进程还拥有一个私有的虚拟地址空间，该空间仅能被它所包含的线程访问。
线程只能归属于一个进程并且它只能访问该进程所拥有的资源，当操作系统创建一个进程后，该进程会自动申请一个名为主线程或首要线程的线程。

什么是线程
一个线程是进程的一个顺序执行流。
同类的多个线程共享一块内存空间和一组系统资源，线程本身有一个供程序执行时的堆栈。线程在切换时负荷小，因此，线程也被称为轻负荷进程。一个进程中可以包含多个线程。
进程和线程的区别
一个进程至少有一个线程。
线程的划分尺度小于进程，使得多线程程序的并发性高。另外。进程在执行过程中拥有独立的内存单元，而多线程共享内存，从而极大地提高了程序的运行效率。
线程在执行过程中与进程的区别在于每个独立的线程有一个程序运行入口，顺序执行序列和程序的出口。但是线程不能独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制。
从逻辑角度来看，多线程的意义在于一个应用程序中，有多个执行部分可以同时执行。但操作系统并没有将多个线程看做多个独立的应用来实现进程的调度和管理以及资源分配。

线程使用的场合
线程通常用于在一个程序中需要同时完成多个任务的情况。我们可以将每个任务定义为一个线程，使他们得以一同工作。
也可以用于单一线程中可以完成，但是使用多线程可以更快的情况，比如下载文件。

并发原理
多线程“同时”运行只是我们感官上的一种表现。事实上线程是并发运行的，OS（操作系统）将时间划分为很多时间片段（时间片），尽可能均匀分配给每一线程，获取时间片段的线程被CPU运行，而其他线程全部等待，所以微观上是走走停停的，宏观上都在运行。这种现象叫并发，但不是绝对意义上的“同时发生”

1、使用Thread创建并启动线程
Thread类是线程类，其每一个实例表示一个可以并发运行的线程。我们可以通过继承该类并重写run方法来定义一个具体的线程，其中重写run方法的目的是定义该线程要执行的逻辑。启动线程时调用线程的start()方法而非直接调用run()方法。start()方法会将当前线程纳入线程调度。使当前线程可以开始并发运行。当线程获取时间片段后会自动开始执行run()方法中的逻辑

2、使用Runnable创建并启动线程
实现Runnable接口并重写run方法来定义线程体，然后再创建线程的时候将Runnable的实例传入并启动线程。
这样做的好处在于可以将线程与线程要执行的任务分离开减少耦合，同时Java是单继承的，定义一个类实现Runnable接口这样的做法可以更好的去实现其他父类或接口。因为接口是多继承关系。

3、使用内部类创建线程
通常我们可以通过匿名内部类的方式创建线程，使用该方式可以简化编写代码的复杂度，当一个线程仅需要一个实例时，我们通常使用这种方式来创建。

九、Android 客户端

通信基于socket
使用xml文件画界面、加背景图片
通过流进行数据交互
Android主线程不能进行耗时操作
子界面的切换
二维码扫码功能
下拉列表

十、Swing UI界面

JFrame
Swing中的JFrame继承于原有AWT中的Frame类，Swing中几乎所有组件都是从JComponent衍生（继承Jcomponent）而来，而JFrame、JDialog、JWindow与JApplet不是。
JFrame、JDialog、JWindow与JApplet这四组件我们统称为最上层组件，因为其余的Swing组件都必须依附在此四组件之一上才能显示出来。

当您建立一个JFrame组件时，系统会为此JFrame建立Root Pane组件
使用到的组件
JPanel
JButton
JLabel（标签）
JTextField（文本框）
JFileChooser（文件选择）
JTextArea（纯文本区域）

public static void style(){

    textArea.append("\r\n");   //换行   追加在末尾一行
    textArea.paintImmediately(textArea.getX(), textArea.getY(), textArea.getWidth(), textArea.getHeight());//立即显示在文本区
    textArea.setCaretPosition(textArea.getText().length());//光标在文本区尾部
}

JScrollPane （滚动条）

  //自动出现
   scrollPane.setHorizontalScrollBarPolicy(JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED);
   scrollPane.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED);

JTextPane（可编辑文本区，类似Word），可以改变关键字的字体、大小、颜色等

    public void insert(String str, AttributeSet attributeSet){
        Document docs=textPane.getDocument();
        str=str+"\r\n";

        try{
            docs.insertString(docs.getLength(),str,attributeSet);
            textPane.setVisible(true);
            textPane.setCaretPosition(docs.getLength());
        }catch(BadLocationException ble){
            ble.printStackTrace();
        }
    }

Jtable
tableModel 刷新表格数据
创建对象

	DefaultTableModel tableModel =new DefaultTableModel(rowData,columnsName);
	JTable table=new JTable(tableModel);

对表格实时追加一行（多行）数据并刷新：
tableModel.addRow(arr);
table.setModel(tableModel);

随时可以选中列头，并根据所在的列的值，按行排序。

TableRowSorter<TableModel> sorter = new TableRowSorter<TableModel>(tableModel);
table.setRowSorter(sorter);

可以操作Jtable但是不能编辑单元格。

 this.tableModel = new DefaultTableModel(rowData,columnsName){
            public boolean isCellEditable(int row, int column)
            {
                return false;
            }
        };

事件处理总共要注意3件事，第一是Source如何，也就是什么组件要被处理，如按钮、或是CheckBox等等。第二是什么样的事件要被处理，例如按下键盘或是按下按钮。若是按下按钮的事件要被处理，在按钮组件上就要增加addActionListener的事件处理类型，就如同“注册”的效果。第三是编写处理事件的程序代码，以按下按钮为例，处理这个事件的程序代码就必须写在actionPerformanceed（）方法中。只要清楚这三件事，事件的处理将会是一件很轻松的事。


十 一、继承、接口、实现
java的四大特性：继承，抽象，封装，多态
封装我们大多只知道get、set方法，其实他主要是为了隐藏对象属性，保证有些属性只存在类内部，而不被其他类修改或这使用
多态 理解是特性与共性的关系，子类可以有父类的属性与方法，但同时他也应该有自己的属性和方法，有时子类中拥有的父类方法不是他想要的，他就可以重写这些方法，或者编写特有的方法
抽象就是把属性和方法抽出来，只声明而不实现，最常见的就是接口的使用
而继承是大家最常见的，就不多说了，但是大家需要知道的是父类转换为子类并不是类型安全的，需要强制转换，而子类转换为父类会丢失自己特有的属性和方法。
其实接口和继承都可以很好的形成一种规范，但类只能继承一个,接口可以多个实现，我认为父类主要的是他提供了一个方法，并提供了一种默认的实现代码，而接口往往只声明了方法，不存在方法的实现(java8中可以有默认方法了,但用在函数式编程中)，这么设计意在形成一种规范，同时也是为了解决java不可以以方法为参数进行传递的设计
接口和继承还能和泛型有很好的配合，给代码提供更好的规范作用，减少异常的产生

继承 extends
通过extends 关键字可以实现类的继承；
子类（Sub class）可以继承父类（Super class）的成员变量及成员方法，同时也可以定义自己的成员变量和成员方法。
Java语言不支持多重继承，一个类只能继承一个父类，但是一个父类可以有多个子类。
子类的构造方法中必须通过super关键字调用父类的构造方法，这样可以妥善的初始化继承自父类的成员变量。

方法的重写

重写中使用super关键字

重写和重载的区别
重载是指一个类中定义多个方法名相同但参数列表不同的方法，在编译时，根据参数的个数和类型来决定绑定是那个方法。
重写是指在子类中定义和父类完全相同的方法，在程序运行时，根据对象的类型不同（而不是引用类型）而调用不同的版本。

接口 interface
接口可以看成是特殊的抽象类。即只包含有抽象方法的抽象类；

接口之间是extends(继承关系)，接口可以继承不同的接口，但是接口与接口之间不能实现。
接口的继承是多继承的机制。

实现接口 implement
与继承不同，一个类可以实现多个接口，实现的接口直接用逗号分隔。当然，该类需要实现这些接口中定义的所有方法；
一个类可以通过implement关键字”实现“接口。一个类实现了某个接口后必须实现该接口中定义的所有方法。
接口可以作为一种类型声明变量，一个接口类型的变量可以引用实现了该接口的类的对象；通过该变量可以调用该接口中定义的方法（具体的实现类提供了方法的实现）。
接口间可以存在继承关系。

十二、异常处理机制
十三、正则表达式
实际开发中，经常需要对字符串数据进行一些复杂的匹配、查找、替换等操作。通过“正则表达式”，可以方便的实现字符串的复杂操作。
正则表达式是一串特定字符，组成一个”规则字符串“这个”规则字符串“是描述文本规则的工具。正则表达式就是记录文本规则的代码。



分组
分组：（）圆括号表示分组，可以将一系列正则表达式看做一个整体，分组时可以使用”|“表示”或"关系，

“^" 和“$"

matches方法
matches(正则表达式)方法：将一个字符串与正则表达式进行匹配，如果匹配成功就返回true,否则返回false。
split方法
String的split方法可以将字符串按照特定的分隔符拆分成字符串数组。
十四、对象内存管理
编译好的Java程序需要运行在JVM中。
程序，无论代码还是数据，都需要存储在内存中。JVM为JAVA程序提供并管理所需要的内存空间。
JVM内存分为“堆”、“栈”和“方法区”三个区域，分别用于存储不同的数据。

对象存储在堆中
十五、运算、分支结构、
运算符：
1、算数运算
加（+）、减（-）、乘（*）、除（/）、取模运算（%）和自增（++）及自减（–）

取模运算符（%）意为取余数，可适用于整数、char类型以及浮点数。
2、关系运算符
判断数据之间的大小关系。包括大于（>）、小于（<）、大于等于（>=）、小于等于（<=）、等于（==）、不等于（！=）六个运算符。关系运算的结果为Boolean类型，如果关系成立为true，否则为false。
3、逻辑运算
逻辑运算建立在关系的基础之上 ，逻辑运算符包括：与（&&）、或（||）和（!）.
参与逻辑运算的变量或表达式都是Boolean类型，运算结果也为Boolean类型。逻辑运算规则如下表所示：

使用**&&**运算符：两个Boolean变量参与“&&”运算时，只有当两个变量均为true时，运算结果才为true。
使用 **“||”运算符：两个Boolean变量参与“||”运算时，当两个变量有一个为true时，结果即为true，只有当两个变量均为false时，结果为false。
使用！**运算符：变量为true时结果为false，变量为false时结果为true。

例如：判断闰年 boolean isLeapYear=(year%40&&year%100!=0)||year%4000;

分支结构
1、if语句执行逻辑
if（逻辑表达式）{
语句1；
语句2；
}
语句3；
2、if-else语句
语句0；
if（逻辑表达式）{
语句块1；
}else{
语句块2；
}
语句3；

if-else语句的嵌套

else if 语句执行逻辑
事实上，else if 结构就是if else 嵌套的简便写法。

3、 switch-case 语句执行逻辑
switch case 语句是一种特殊的分支结构，可以根据一个整数表达式的不同取值，从不同的程序入口开始执行。

通常case1、case2、。。。caseN对应完全不同的操作，可以和break语句配合使用，执行完相应语句后即退出switch块，不继续执行下面的语句。

switch-case在实现分支功能时和if-else的主要区别在于switch-case结构的效率要高、结构更清晰。

待学习的地方

一、线程中锁机制
synchronized关键字

二、泛型`

三、抽象类、抽象方法
注 ：未完，不断更新、补充