java知识总结

1、Java 数据类型

八种基本类型。六种数字类型（四个整数型，两个浮点型），一种字符类型，还有一种布尔型。

• 基本类型：整型、浮点型、字符型、布尔型
• 引用类型：所有class对象，变量指向某个对象，
• 包装类型：把基本类型包装为class，基本类型—>引用类型，int–integer, char–character

数组： int[] ns={1,2,3,4} for(int n :ns) int[][] ns={{1,2,3,4},{5,6,7,8}}

2、Java 变量类型

• 局部变量：在方法、构造方法或者语句块中定义的变量被称为局部变量。变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁。
• 成员变量：成员变量是定义在类中，方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中方法、构造方法和特定类的语句块访问。
• 类变量：类变量也声明在类中，方法体之外，但必须声明为static类型。静态成员属于整个类，可通过对象名或类名来调用。

	成员变量	局部变量	静态变量
定义位置	在类中,方法外	方法中,或者方法的形式参数	在类中,方法外
初始化值	有默认初始化值	无,先定义,赋值后才能使用	有默认初始化值
调用方式	对象调用	—	对象调用，类名调用
存储位置	堆中	栈中	方法区
生命周期	与对象共存亡	与方法共存亡	与类共存亡
别名	实例变量	—	类变量

2、Java面向对象编程

OOP: object -oriented-proramming

• 类(class)：数据类型，是一个模板，它描述一类对象的行为和状态。
• 对象：对象是类的一个实例，有状态和行为。
• 实例（instance）:数据
• 属性（field）：变量名.字段名，访问field

---

---

• 封装：一个class包含多个field，用private修饰field，可以拒绝外部访问
• 继承：一个class使用extends继承父类，可获得父类的所有功能，只需编写新增功能
• 多态：方法的调用，总是作用于对象的实际类型

---

---

• 构造方法：方法名为类名，参数无限制，无返回值，用于初始化实例，可定义多个构造方法，未定义时编译器创建默认构造方法，
• 方法重载：同一类中，多个方法的方法名与返回值类型相同，但参数（个数、类型、位置）不同，目的在于相同功能的方法使用一个名字，便于调用。
• 方法重写：@override，子类重写父类的方法，方法签名（方法名称、参数和返回类型）要 一样，重写必须要有继承

在同一类中重载方法，在子类中重写方法，都可以用相同的方法名来实现不同的功能。

---

---

• 抽象方法： class定义了方法，但没有具体的执行代码，那么这个方法为抽象方法，用abstract 修饰，定义了子类必须实现的接口规范，实现代码的重用
• 抽象类（abstract class）：包含抽象方法的类，也可以有非抽象方法。定义接口规范，不允许被实例化，只能使用一次继承关系
• 接口（interface）：一个抽象类没有实例字段，所有的方法都是抽象方法，

一个类却可以实现多个接口，但只能继承一个抽象类

• JavaBean:是一种符合命名规范的class，方便IDE工具读写属性，传递数据，枚举属性
• 内部类：定义在一个class内部的class，可访问外部类私有属性，破坏原有类的程序结构（属性、构造方法、普通方法、内部类）。

3、Java 修饰符

类（外部类），有 2 种访问权限：public、default。
方法和变量，有 4 种访问权限：public、default、protected、private。

• public 意味着任何地方的其他类都能访问。
• default 则是同一个包的类可以访问。
• protected 表示同一个包的类可以访问，其他的包的该类的子类也可以访问。
• private 表示只有自己类能访问。

访问权限	类	方法	字段
Public 公有访问	可访问	可访问	可访问
Private私有访问	不能修饰类、接口（内部类除外）	内部代码可访问 外部不可访问	内部代码可访问外部不可访问	不可被子类访问
Protected 受保护访问	不能修饰类、接口（内部类除外）	可被子类访问 内部代码可访问外部不可访问	可被子类访问 内部代码可访问 外部不可访问	用于继承关系，可被子类访问

修饰符：abstract、static、final

• abstract: 表示是抽象类。 使用对象：类、接口、方法
• static: 可以当做普通类使用，而不用先实例化一个外部类。（用他修饰后，就成了静态内部类了）。 使用对象：类、变量、方法、初始化函数（注意：修饰类时只能修饰 内部类 ）
• final: 表示类不可以被继承。 使用对象：类、变量、方法

修饰符	类	方法	字段
final	阻止被继承	阻止被重写	阻止被重写赋值
Static	无	静态方法	静态变量
Abstract	抽象类	抽象方法	无

java 程序是从一个 public 类的 main 函数开始执行的， (其实是main线程)，就像 C 程序 是从 main() 函数开始执行一样。

只能有一个 public 类是为了给类装载器提供方便。一个 public 类只能定义在以它的类名为文件名的文件中。
this 指向对象本身的指针，形参与成员名字重名，用 this 来区分。

super 超（父）类对象的一个指针。

4、Java 运算符

算术运算符、关系运算符、位运算符、逻辑运算符、赋值运算符、其他运算符

5、Java 循环结构

for, while 及 do…while

6、Java math与String类

Math.floor 是向下取整。
Math.ceil 是向上取整。
Math.round 是四舍五入取整
装箱和拆箱的概念有点特别。
byte、int、long、double 等为 java 的基础数据类型。
所有的包装类（Integer、Long、Byte、Double、Float、Short）都是抽象类 Number 的子类。

String s1 = "abc";            // 常量池
String s2 = new String("abc");     // 堆内存中
System.out.println(s1==s2);        // false两个对象的地址值不一样。
System.out.println(s1.equals(s2)); // true

Java 中int 和 Integer 的区别

1. int ：是基本数据类型，int 变量存储的是数值。Integer 是引用类型，实际是一个对象，Integer 存储的是引用对象的地址。
   2.Integer ：是一个对象，需要存储对象的元数据，占用更多的内存。但是 int 是一个原始类型的数据，所以占用的空间更少。
2. new Integer() 生成的变量指向堆中新建的对象，非 new 生成的 Integer 变量指向的是 java 常量池中的对象，两者在内存中的地址不同。

Java中String、StringBuffer 和 StringBuilder 的区别

• String 长度大小不可变，StringBuffer 和 StringBuilder 长度可变
• StringBuffer 线程安全 StringBuilder 线程不安全
• StringBuilder 速度快
• stringbuffer 基本没有适用场景，你应该在所有的情况下选择使用 stringbuiler，除非你真的遇到了一个需要线程安全的场景

1.String：字符串常量，字符串长度不可变。Java中String 是immutable（不可变）的。用于存放字符的数组被声明为final的，因此只能赋值一次，不可再更改。

2.StringBuffer：字符串变量（Synchronized，即线程安全）。如果要频繁对字符串内容进行修改，出于效率考虑最好使用 StringBuffer，如果想转成 String 类型，可以调用 StringBuffer 的 toString() 方法。Java.lang.StringBuffer 线程安全的可变字符序列。在任意时间点上它都包含某种特定的字符序列，但通过某些方法调用可以改变该序列的长度和内容。可将字符串缓冲区安全地用于多个线程。

3.StringBuilder：字符串变量（非线程安全）。在内部 StringBuilder 对象被当作是一个包含字符序列的变长数组。
4.基本原则：
如果要操作少量的数据用 String ；单线程操作大量数据用StringBuilder ；多线程操作大量数据，用StringBuffer。

7、Java 数据结构

在Java中的数据结构主要包括以下几种接口和类：

• 枚举（Enumeration）
• 位集合（BitSet）
• 向量（Vector）
• 栈（Stack）
• 字典（Dictionary）
• 哈希表（Hashtable）
• 属性（Properties）

ArrayList 和 LinkedList 的区别

• ArrayList 是 List 接口的一种实现，它是使用数组来实现的。
• LinkedList 是 List 接口的一种实现，它是使用链表来实现的。
• ArrayList 遍历和查找元素比较快。LinkedList 遍历和查找元素比较慢。
• ArrayList 添加、删除元素比较慢。LinkedList 添加、删除元素比较快。

---

---

• 泛型方法：在调用时可以接收不同类型的参数。根据传递给泛型方法的参数类型，编译器适当地处理每一个方法调用。

• 对象序列化：一个对象被表示为一个字节序列，该字节序列包括该对象的数据、有关对象的类型的信息和存储在对象中数据的类型。用于网络传输

8、Java 网络编程

-网络编程是指：编写运行在多个设备（计算机）的程序，这些设备都通过网络连接起来。

java.net 包中提供了两种常见的网络协议的支持：

• TCP：TCP 是传输控制协议的缩写，它保障了两个应用程序之间的可靠通信。通常用于互联网协议，被称 TCP / IP。
• UDP：UDP 是用户数据报协议的缩写，一个无连接的协议。提供了应用程序之间要发送的数据的数据包。

Socket 编程：这是使用最广泛的网络概念，它已被解释地非常详细。
URL 处理：这部分会在另外的篇幅里讲，点击这里更详细地了解在 Java 语言中的 URL 处理。
套接字使用TCP提供了两台计算机之间的通信机制。 客户端程序创建一个套接字，并尝试连接服务器的套接字。
当连接建立时，服务器会创建一个 Socket 对象。客户端和服务器现在可以通过对 Socket 对象的写入和读取来进行通信。
java.net.Socket 类代表一个套接字，并且 java.net.ServerSocket 类为服务器程序提供了一种来监听客户端，并与他们建立连接的机制。

Socket的概念：上面已经解释了，不在复述。

• 同步和异步：同步和异步是针对应用程序和内核的交互而言的。同步指的是用户进程触发IO 操作并等待或者轮询的去查看IO 操作是否就绪；而异步是指用户进程触发IO 操作以后便开始做自己的事情，而当IO 操作已经完成的时候会得到IO 完成的通知。
  以银行取款为例：

  • 同步 ： 自己亲自出马持银行卡到银行取钱（使用同步 IO 时，Java 自己处理IO 读写）；
  • 异步 ： 委托一小弟拿银行卡到银行取钱，然后给你（使用异步IO 时，Java 将 IO 读写委托给OS 处理，需要将数据缓冲区地址和大小传给OS(银行卡和密码)，OS 需要支持异步IO操作API）；

• 阻塞和非阻塞：阻塞和非阻塞是针对于进程在访问数据的时候，根据IO操作的就绪状态来采取的不同方式，说白了是一种读取或者写入操作方法的实现方式。阻塞方式下读取或者写入函数将一直等待；而非阻塞方式下，读取或者写入方法会立即返回一个状态值。
  以银行取款为例：

  • 阻塞 ： ATM排队取款，你只能等待（使用阻塞IO时，Java调用会一直阻塞到读写完成才返回）；
  • 非阻塞 ： 柜台取款，取个号，然后坐在椅子上做其它事，等号广播会通知你办理，没到号你就不能去，你可以不断问大堂经理排到了没有，大堂经理如果说还没到你就不能去（使用非阻塞IO时，如果不能读写Java调用会马上返回，当IO事件分发器通知可读写时再继续进行读写，不断循环直到读写完成）

9、Java 多线程编程

进程和线程的区别

• 进程：应用程序的执行实例，有独立的内存空间和系统资源
• 线程：CPU调度和分派的基本单位，进程中执行运算的最小单位，可完成一个独立的顺序控制流程

进程和线程的关系

• 1）一个线程只能属于一个进程，而一个进程可以有多个线程，但至少有一个线程。每条线程并行执行不同的任务。线程不能独立的存在，它必须是进程的一部分。线程是操作系统可识别的最小执行和调度单位。
• 2）资源分配给进程，同一进程的所有线程共享该进程的所有资源。 同一进程中的多个线程共享代码段(代码和常量)，数据段(全局变量和静态变量)，扩展段(堆存储)。但是每个线程拥有自己的栈段，栈段又叫运行时段，用来存放所有局部变量和临时变量。
• 3）处理机分给线程，即真正在处理机上运行的是线程。
• 4）线程在执行过程中，需要协作同步。不同进程的线程间要利用消息通信的办法实现同步。

多线程是多任务的一种特别的形式，多线程使用了更小的资源开销，能满足程序员编写高效率的程序来达到充分利用 CPU 的目的。

多线程原理：
相当于玩游戏机，只有一个游戏机（cpu），可是有很多人要玩，于是，start 是排队！等 CPU 选中你就是轮到你，你就 run()，当 CPU 的运行的时间片执行完，这个线程就继续排队，等待下一次的run()。
调用 start() 后，线程会被放到等待队列，等待 CPU 调度，并不一定要马上开始执行，只是将这个线程置于可动行状态。然后通过 JVM，线程 Thread 会调用 run() 方法，执行本线程的线程体。先调用 start 后调用 run，这么麻烦，为了不直接调用 run？就是为了实现多线程的优点，没这个 start 不行。
1.start() 方法来启动线程，真正实现了多线程运行。这时无需等待 run 方法体代码执行完毕，可以直接继续执行下面的代码；通过调用 Thread 类的 start() 方法来启动一个线程， 这时此线程是处于就绪状态， 并没有运行。 然后通过此 Thread 类调用方法 run() 来完成其运行操作的， 这里方法 run() 称为线程体，它包含了要执行的这个线程的内容， run 方法运行结束， 此线程终止。然后 CPU 再调度其它线程。
2.run() 方法当作普通方法的方式调用。程序还是要顺序执行，要等待 run 方法体执行完毕后，才可继续执行下面的代码； 程序中只有主线程——这一个线程， 其程序执行路径还是只有一条， 这样就没有达到写线程的目的。
记住：多线程就是分时利用 CPU，宏观上让所有线程一起执行 ，也叫并发。

• 线程池：是一个容纳多个线程的容器，其中的线程可以反复使用，省去了频繁创建线程对象的操作，无需反复创建线程而消耗过多资源。（是什么）

为什么需要用到线程池呢？
实际使用中，创建和销毁线程花费的时间和消耗的系统资源都相当大，甚至可能要比在处理实际的用户请求的时间和资源要多的多。
如果在一个jvm里创建太多的线程，可能会使系统由于过度消耗内存或“切换过度”而导致系统资源不足。

线程池主要用来解决线程生命周期开销问题和资源不足问题。通过对多个任务重复使用线程，线程创建的开销就被分摊到了多个任务上了，而且由于在请求到达时线程已经存在，所以消除了线程创建所带来的延迟。这样，就可以立即为请求服务，使用应用程序响应更快；另外，通过适当的调整线程中的线程数目可以防止出现资源不足的情况。（什么用）

3、线程池都是通过线程池工厂创建，再调用线程池中的方法获取线程，再通过线程去执行任务方法。
使用Runnable接口创建线程池的步骤：
1、创建线程池对象
2、创建 Runnable 接口子类对象
3、提交 Runnable 接口子类对象
4、关闭线程池

线程安全问题
产生原因：多个线程竞争同一资源（访问同一数据），可参考经典的生产者消费者问题。
解决方案：
run 方法内：同步代码块 synchronized {}