java高级知识点

1.数据结构

程序=数据结构+算法

• 栈:后进先出,线性结构 入栈：push 出栈：pop
  假如已知入栈顺序是abcd,那么他的出栈顺序可能有很多种abcd(马上进马上出)
• 队列：先进先出，线性结构
• 树：有且只有一个根节点，每个节点也仅有一个父节点，每个节点可以有多个子节点( 链式结构)
  树的分类：
  有序数树 无序数树
  二叉树：每个节点最大有两个子节点的有序数树
  满二叉树：如果一个二叉树层级是K，树的节点数是2^K-1
  完全二叉树：
  二叉树的遍历：
  1)先序遍历（深度遍历）：根节点，左子树，右子树
  2)中序遍历： 左子树，根节点，右子树
  3)后序遍历： 左子树，右子树，根节点
  任何已知先中序或中后序就可以确定二叉树的结构。
  例子：二叉树的中序遍历为：BADC，先序遍历为ABCD。求后序遍历结果？ BDCA
• 图

2.ajax(Asynchronous JavaScript and XML)

异步的JavaScript and XML技术
不刷新整个页面，仅仅局部刷新 让客户端与服务器端进行通信
它不是一个新技术，只是几种技术的结合

1)ajax 的核心对象是XMLHttpRequest

XMLHttpRequest存在浏览器端，不同的浏览器 创建方式不同
目前比较主流浏览器内核：v/p

火狐内核 ：火狐 google..
window.XMLHttpRequest
IE内核 ： IE6 -IE11 360 遨游
Window.ActiveXObject

2)XMLHttpRequest 对象中的方法

a: 客户端与服务器端建立连接
open("请求方式[get|post]","请求路径",是否异步 [true|false]);
b: 监听服务器状态onreadystatechange，指定回调函数（当状态只要发生变化，就调用这个回调函数）

状态 readyState(属性)
0 连接还未建立完成
1 已经建立连接 请求未加载
2 正在加载
3 请求已经加载完成 正在交互中
4 完成交互

c: send();发送请求
d: 完成交互 服务器响应状态 status(属性):

200 服务器端成功处理了请求
400 服务器端处理失败
404 服务器端找不到处理请求的地址
500 服务器端内部错误

e:服务器回调回来的值:
XMLHttpRequest对象的属性responseText

3)ajax的操作步骤

1. 创建 XMLHttpRequest 对象
2. 建立连接 对象.open()
3. 指派监听函数 对象.onreadystatechange=回调函数名
4. 发送请求 对象.send()
5. 写监听函数 回调函数()
   判断服务器连接的状态xhr.readyState
   判断服务器响应状态 xhr.status

3.query 轻量级 javaScript 框架

写的少做的多,良好的兼容性
强大的选择器 dom 操作

1)用法：

• 1:引入 jquery.xxxx.js
  jquery.1.xx.js 良好的兼容性
  jquery.2.xx.js 支持IE8以上的版本 firefox2.0
• 2：初始化方法

       $(document).ready(function(){
       }); 

可以简写 $(function(){}); 与 window.load=function(){}类似

2)选择器

a. id 选择器
         $("#id名")  
b. 类选择器
          $(".类名")   
          <p class="p">a1 </p>  
          <p class="p">a2 </p>  
          <p class="p">a3 </p> 
           $(".p").each(function(){
           });  
 c:标签选择器   
           $("标签名")    $("div") 

4.javai/o

1)名词解释

• I/o : Input/OutPut 输入/输出
• 流 : 具有产生数据的数据源对象 或者具有接收数据的客户端对象
• I/O流 : 站在程序的角度
  用来产生数据的数据源对象 输入流;
  有接收数据的客户端对象 输出流
• 为什么要使用 I/O流
  因为计算机cpu 不能直接读取硬盘的上的数据
  计算机要进行读写数据必须要通过I/o流来操作
• java中的I/O ->java.Io
• java中的文件操作
• InputStream 抽象的类 输入流
  OutputStream 抽象的类 输出流

2）java.io.File 类

File 构造方法

       File f=new File("文件绝对路径");
       File f=new File("文件父级文件夹路径","文件名");
       File f=new File(File dir,"文件名");
       File f=new File(URL url);

     f.exists();判断文件是否存在      
     f.createNewFile(); 创建文件
     f.mkdir();  创建文件夹
     
     listFiles();
      listFiles(FileFilter filter)  

3) I/O流分类

1. 根据方向划分 : 输入、输出流
2. 根据操作字节数来分:
   字节流 按照一个字节一个字节操作 只操作一个字节(8bit)

输入字节流 InputStream 用于读取字节流的抽象类 常见子类 FileInputStream 输出字节流 OutputStream 写入字节流的抽象类 常见子类 FileOutputStream

字符流 按照两个字节操作(16bit)

输入字符流 Reader用于读取字符流的抽象类
常见子类 InputStreamReader,FileReader
输出字符流 Writer写入字符流的抽象类
常见子类 OutputStreamWriter,FileWriter

3. 可以操作Java的数据类型，是与机器无关的操作流
   DataInputStream , DataOutputStream
4. 包装流 对基本流进行添加缓存功能的流

BufferedInputStream
BufferedOutputStream
BufferedReader
BufferedWriter

5. 序列化与反序列化

持久化：把内存中的对象 数据 保存在介质[文件，数据库] 中去
序列化: 把java对象 存在文件 中 但不是任意对象都可以序列化
如果一个对象要能够序列化 那么这个对象的类 必须可序列化
可序列化 的类 必须要实现一个 Serializable 接口

序列化->ObjectOutputStream 对象存储到文件中
反序列化->ObjectInputStream 文件去读出来变成对象
静态属性不会序列化到文件中

1) java 创建对象的几种方式

1. new 类的构造器
2. 反序列化
   首先类必须实现 可序化接口 Serializable
   先进行 序列化 在进行 反序列化
3. 克隆 类对象要 克隆 类必须实现可克隆接口 Cloneable 接口
4. 反射

6. java多线程

程序-》计算机的指令集合 静态的概念
进程-》程序的一次运行 动态的概念，有独立的内存空间
线程-》进程的一次运行 可以分成若干条分支同时执行
每一条分支就是一个线程 , 线程是比进程更小的概念

多线程：一个进程分成多条线索同时执行 这个进程就是多线程
java程序中 main 方法 jvm会自动给他分配一个线程 通常这个线程
都叫做 主线程

1)线程和进程有什么区别？

• 进程它是程序的一次运行，所以它会有独立的内存空间
  线程是进程的一条执行的线索，该进程的所有线程都共享
  进程的内存，没有独立的内存空间
• 一个进程分成多条线程，同时执行叫做多线程

2) java怎么实现多线程

第一种方式：
a:写一个类 extends Thread
b:重写run() 方法
c:创建线程类对象，调用对象的 start()方法
第二中方式：
a:写一个类 实现Runable 接口
b:实现Runable 接口中run() 方法
c:创建该类对象
d:再创建一个 Thread类的对象，传递一个实现Runnable接口类的对象
e:再调用 Thread类的对象 的 start()方法（因为只有线程Thread有start方法）

在Thread类中可以：
this.getName()来获取线程的名称
在非Thread类中可以：
Thread.currentThread().getName() 来获取当前正在运行线程的名称

3) 线程中常见方法：

• boolean isAlive() 判断线程是否处于活动状态（就绪）
  一个线程类对象 在start()之前 没有处于活动状态
  在start()之后 run() 运行完成之前 都处于 活动状态
  run()运行完成之后 没有处于活动状态
• join() 合并线程
• yield() 让出 cpu 的使用权
• sleep(long millis) 让当前线程休眠指定的时间 毫秒数
  sleep 但不会释放cpu的使用权 也不释放占用的资源
• interrupt() 中断线程。
• 线程的优先级 默认值是 5 范围 0-9 值越大 越优先
  getPriority() 返回线程的优先级。
  setPriority(int newPriority) 更改线程的优先级。
  优先级 越高 只是越有机会获得cpu的使用权 并不是一定先运行
• stop();让线程消亡
• wait();让当前线程暂停执行，进入等待队列，需要notify()或noyifyAll()唤醒才能进入就绪状态
• notify();唤醒等待队列中的一个线程
• notifyAll();唤醒等待队列中的所有线程

4) 多线程安全问题（synchronized）

Java程序可以让多线程来同时执行，如果多线程要访问共同的数据，可能会造成数据 的不一致的问题，所以要做线程的同步问题。
线程的同步就是让同一个时间点只有一个线程可以访问共享的资源.

5) 同步的方式：

• synchronized修饰方法 同步方法
  同一时间只能有一个线程可以访问该方法
• synchronized 代码块
  Synchronized（共享资源的对象）{}
  同一时间只能有一个线程可以访问该对象
• 一个可重入的互斥锁类 ReentrantLock
  Lock();unlock();注意要用try-catch-finally来处理，避免死锁
• volatile 特殊的类型变量来达到同步的目的
• ThreadLocal

7.java反射（java.lang.reflect）

程序一般原理：Java创建对象——>知道类的源码——>调用构造、属性、方法
反射原理 ：没有源码，只有字节码——>反射类属性、方法和父类实现的接口——>调用方法、构造
反射 就是把一个类 用其他的类来表示 ;

获取类的字节码：
- 类路径(包名+类名).class     ( Class c=包名+类名.class;)
- Class.forName("类路径");
- 通过类的对象  .getClass();

获取父类：Class suoerc=c.getSupperclass();
获取实现的接口：Class[] interfaces=c.getInterfaces();

获取类的属性（Filed(java.lang.reflect)）：
Filed[] fs=c.getFilelds();获取public 属性（自身与父类继承过来的）
     Filed[] fs=c.getDeclaredFields();获取自身所有的属性

获取类的方法（Method(java.lang.reflect)）：
Method[] ms=c.getDeclaredMethods();获取自身所有的方法
Method[] ms2=c.getMethods();获取public 方法（自身与父类,父类的父类继承过来的）

获取类的构造方法（Constructor (java.lang.reflect)）：
Constructor[] crs=c.getConstructors() ;

8.设计模式之二

工厂模式：根据配置动态产生一组类中某个类的实例
通常这一组类有共同的父类或实现了相同的接口
配置：key——>value
key值保持不变，value根据实际情况改变 value=xxx(key)
父类(接口)对象= Class.forName(value).newIntance();

9.不常用知识点

1）内部类

1. 普通的内部类 （成员内部类 ）
   在一个类的类体里面申明的一个类
2. 静态内部类
   在一个类的类体里面申明的一个类 加上static 修饰符
3. 匿名内部类

2) 网络编程

目的：使网络中的计算机可以进行通信
定位网络中的一台计算机 InetAddress 数据的传输

TCP是Tranfer Control Protocol的简称， 是一种面向连接的保证可靠传输的协议
UDP是User Datagram Protocol的简称，是一种无连接的不可靠协议。
传输的数据受到限制 最大64K （QQ离线）

Socket——> 套接字
网络上的两个程序通过一个双向的通讯连接实现数据的交换，
这个双向链路的一端称为一个Socket。
Socket通常用来实现客户方和服务方的连接。
Socket是TCP/IP协议的一个十分流行的编程界面，
一个Socket由一个IP地址和一个端口号唯一确定