java知识点复习

JDK JRE JVM

JDK:
Java标准开发包，它提供了编译、运⾏Java程序所需的各种⼯具和资源，包括Java编译器、Java运⾏时环境，以及常⽤的Java类库等。

JRE:
Java运⾏环境，⽤于解释执⾏Java的字节码⽂件。

JVM
Java虚拟机，是JRE的⼀部分。负责解释执⾏字节码⽂件，是可运⾏java字节码⽂件的虚拟计算机

区别联系:(问答题会考可能)

JDK包含JRE，JDK 和 JRE 中都包含 JVM。JDK出了包含jre还包含⼀些常⽤开发⼯具和基础类库

JDK ⽤于开发，JRE ⽤于运⾏java程序

JVM 是 java 编程语⾔的核⼼并且具有平台独⽴性（不同的平台有不同的VM）

JVM的好处：一次编译，随处运行

javac: 编译 java源⽂件->class字节码⽂件(0,1)
java: 解释

基本语法

程序结构

一个源文件中最多只能有一个public类，其他类的个数不限，如果源文件中包含一个public类，它必须按该类名命名

Java应用程序的执行入口时main()方法。它有固定的书写格式：

public static void main(String args[]){
     …..}

命名规范

包名，包名是全小写的名词，中间可以由点分隔开，例如：java.awt.event;

类名，首字母大写，通常由多个单词合成一个类名，要求每个单词的首字母也要大写，例如class WelcomeToJava;

接口名，命名规则与类名相同，例如interface Collection;

方法名，往往由多个单词合成，第一个单词通常为动词，首字母小写，中间的每个单词的首字母都要大写，例如：balanceAccount，　isButtonPressed;

变量名，全小写，一般为名词，例如：length;

常量名，基本数据类型的常量名为全大写，如果是由多个单词构成，可以用下划线隔开，例如：int YEAR, int WEEK_OF_MONTH；如果是对象类型的常量，则是大小写混合，由大写字母把单词隔开。

标识符

不能以数字开头。
不能是Java中的关键字。
标识符不能是true，flase和null（尽管这三个不是关键字）

关键字

变量和常量

只有public, protected, private, static, final, transient 和 volatile 能修饰成员变量

常量

JAVA常量就是在程序中固定不变的值，是不能改变的数据。例如数字1、字符“a”、浮点数3.2等。在Java中，常量包括整型常量、浮点数常量、布尔常量、字符常量等。

使用 final 关键字来定义一个常量，常量一旦初始化就不可以被修改。

变量

变量是程序中最基本的存储单元，其要素包括变量名，变量类型和作用域

每一个变量使用前必须要先声明，然后必须进行赋值，才能使用

分类：
按声明位置：
局部变量：方法或语句块内部定义的变量
成员变量：方法外部、类的内部定义的变量

在类体内定义的变量称为成员变量，它的作⽤域是整个类
在⼀个⽅法或⽅法内代码块中定义的变量称为局部变量

• 注意：
  类外面（与类对应的大括号外面）不能有变量的声明
  方法体内部声明的变量（包括形参）称为局部变量：方法体内部是指与方法对应的大括号内部
  在方法体外，类体内声明的变量称为成员变量

按所属类型：
基本数据类型变量（8种）
引用数据类型变量

数据类型

boolean类型数据只允许取值true或false，不可以0或非0的整数替代true和false，这点和C语言不通

Java字符采用Unicode编码，每个字符占两个字节，因而可用十六进制编码形式表示

java中的char一定是无符号的，不允许用unsigned char修饰

基本类型转换：

boolean类型不可以转换为其他的数据类型

整型、字符型、浮点型的数据在混合运算中相互转换，转换规则：
容量小的类型自动转换为容量大的数据类型，数据类型按照容量大小排序为：
byte,short,char->int,->long->float->double
byte,short,char之间不会互相转换，三者在计算时首先转换为int型

容量大的数据类型转换为容量小的数据类型时，要加上强制转换符，但可能造成精度降低或溢出

有多种类型的数据混合运算时，系统首先自动将所有数据类型转换为容量最大的那一种数据类型，然后在进行计算

实数常量默认为double，整数常量默认为int

数组

数组初始化
动态初始化
数组定义与为数组元素分配空间和赋值的操作分开进行

静态初始化
在定义数组的同时为数组元素分配空间并赋值

Java语言中声明数组时不能指定其长度

每个数组都有一个属性length指明它的长度

a.length的值为数组a的长度（元素个数）

输入输出

输⼊
 Scanner s=new Scanner(System.in);
 s.nextInt()
 s.nextLine()
 s.nextFloat()
 scanner.next()
 输出
System.out.println("XX"）

运算符与语句

运算符

左移<<
"a<

带符号右移
"a>>b; "将二进制形式的a逐位右移b位，最高位空出的b位补原来的符号位

无符号右移
"a>>>b;"将二进制形式的a逐位右移b位，最高位空出的b位补0

优先顺序：

语句

条件分支语句

1. if
   else if
   else

2. switch

switch(XX){
      //java特有 枚举 short byte C语⾔:字符,int
case 1 : XX ;break;
case 2: XX ;break;
default(可有可⽆): XX break;
}

switch表达式的返回值必须是下述几种类型之一：int, byte, char, short；

case子句中的值必须是常量，且所有case子句中的值应是不同的；

循环语句

1. while
2. for
3. do while
4. for each

修饰符

访问控制修饰符

Java中，可以使用访问控制符来保护对类、变量、方法和构造方法的访问。Java 支持 4 种不同的访问权限。

default (即默认，什么也不写）: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。

private : 在同一类内可见。使用对象：变量、方法。 注意：不能修饰类（外部类）

public : 对所有类可见。使用对象：类、接口、变量、方法

protected : 对同一包内的类和所有子类可见。使用对象：变量、方法。 注意：不能修饰类（外部类）。

非访问修饰符

为了实现一些其他的功能，Java 也提供了许多非访问修饰符。

static 修饰符，用来修饰类方法和类变量。

final 修饰符，用来修饰类、方法和变量，final 修饰的类不能够被继承，修饰的方法不能被继承类重新定义，修饰的变量为常量，是不可修改的。

abstract 修饰符，用来创建抽象类和抽象方法。

synchronized 和 volatile 修饰符，主要用于线程的编程。

synchronized 关键字声明的方法同一时间只能被一个线程访问。synchronized 修饰符可以应用于四个访问修饰符。

volatile 修饰符
volatile 修饰的成员变量在每次被线程访问时，都强制从共享内存中重新读取该成员变量的值

类与对象

面对对象三⼤特征：封装、继承、多态

1. 封装
   通过 private、default 、protected、 public 关键字实现属性或⽅法的封装, 仅对外提供公共访问⽅式。
   “⾼内聚，低耦合”
2. 继承
   实现数据项和⽅法的隐藏
   实现隐藏隔离，允许外部对类做有限的访问,开发者可以⾃由的改变类的内部实现
   提⾼了代码的重⽤性
3. 多态
   ⼀个对象变量可以指向多种实际类型对象的现象被称为“多态”
   三个必要条件:继承、⽅法的重写、⽗类⼸|⽤指向⼦类对象
   多态的好处:
   提⾼了代码的维护性（继承保证）；提⾼了代码的扩展性
   Java中多态的实现⽅式:接⼝实现，继承⽗类进⾏⽅法重写，同个类中进⾏⽅法重载。⽗类⼸|⽤指向⼦类对象

类

类是用于描述同一类型的对象的一个抽象的概念，类中定义了这一类对象所应具有的静态和动态属性

类的定义包括：类声明，类体

类可以看成一类对象的模板，对象可以看成该类的一个具体实例

对象可以看成是静态属性（成员变量）和动态属性（方法）的封装体

对象的创建和使用

• 必须使用new关键字创建对象
• 使用对象（引用）.成员变量或来引用对象的成员变量
• 使用对象（引用）.方法（参数列表）来调用对象的方法
• 同一类的每个对象有不同的成员变量存储空间
• 同一类的每个对象共享该类的方法

构造方法

作用：主要⽤来在创建对象时初始化对象， 即为对象成员变量赋初始值，总与new运算符⼀起使⽤在创建对象的语句中。

注意 ：

• ⼀个类可以有多个构造函数 ，可根据其参数个数的不同或参数类型的不同来区分它们,即构造函数的重载

• 使用new+构造方法创建一个新的对象

• 构造函数的名字必须和所在类名字完全相同

• 构造函数与类同名且没有返回值

• 如果没有编写指定构造函数时，编译会自动添加无参数的构造函数

• 特别： 构造函数不能用final，static，abstract修饰
  为什么？
  1.final修饰函数的主要目的是避免函数被重写，构造器不是通过继承得到的，所以没有必要把它声明为final的。
  2.同理，一个抽象的构造器将永远不会被实现，所以它也不能声明为abstract的。
  3.构造器总是关联一个对象而被调用，所以把它声明为static是没有意义的。

重载与重写

方法的重载是指一个类中可以定义有相同的名字，但参数不同的多个方法。
调用时，系统会根据不同的参数表选择对应的方法

重载：

1. 必须载同⼀个类中
2. ⽅法名相同
3. ⽅法的参数的个数、顺序或类型不同
4. 与⽅法的修饰符和或返回值没有关系
5. 可以有同的返回类型，只要参数列表不同就可以了；
6. 可以有不同的访问修饰符；

3、可以有不同的访问修饰符；

重写：
6. 重写的⽅法必须要和⽗类⼀模⼀样(包括返回值类型,⽅法名,参数列表)
7. 重写的⽅法可以使⽤@Override注解来标识
8. ⼦类中重写的⽅法的访问权限不能低于⽗类中⽅法的访问权限
权限修饰符 : private < 默认(什么都不写) < protected < public

常用关键字

this

Java中为解决变量的命名冲突和不确定性问题，引⼊关键字this代表其所在⽅法的当前对象的引⽤,使用this可以处理方法中成员变量和参数重名的情况

1. 构造⽅法中指该构造器所创建的新对象；

public class B{
     
 	A a; //A是⼀个类
  	public B(A a){
     
 		this.a = a;
 	}
}

2. ⽅法中指调⽤该⽅法的对象；

 public class Baby{
     
 	public void wakeUp(){
     
 		System.out.println("宝宝醒啦");
 	}
 	public void eat(){
     
 		this.wakeUp();
 		System.out.println("吃东⻄");
 	}
 }

3. 在类本身的⽅法或构造器中引⽤该类的实例变量（全局变量）和⽅法

 public void setName(String name){
     
 	this.name=name
}

this只能在类中的⾮静态⽅法中使⽤，静态⽅法和静态的代码块中绝对不能出现this
原因:static⽅法在类加载时就已经存在了，但是对象是在创建时才在内存中⽣成

static 关键字

在类中，用static声明的成员变量为静态成员变量，它是该类的公用变量，在第一次使用时被初始化，对应该类的所有对象来说，static成员变量只有一份

• 在类的定义体中、方法的外部可包含static语句块

• static语句块仅在其所属的类被载入时执行一次

• 用static声明的方法为静态方法，在调用方法时，不会将对象的引用传递给它，所以在static方法中不可访问非static的成员。
  静态方法不再是针对某个对象调用，所以不能访问非静态成员

• 被static修饰的变量属于类变量，可以通过类名.变量名直接引⽤，⽽不需要new出⼀个类来

• 被static修饰的⽅法属于类⽅法，可以通过类名.⽅法名直接引⽤，⽽不需要new出⼀个类来

类的成员变量包括实例变量和类变量，实例变量在不同对象互不相同，类变量被所用对象共享。

包

package语句作为java源文件的第一条语句，指明该文件中定义的类所在的包（若缺省该语句，则指定为无名包）

JDK包介绍
java.lang——包含一些java语言的核心类，如String、Math、Integer、System和Thread，提供常用功能

java.awt——包含了构成抽象窗口工具包（abstract window toolkits）的多个类，这些类被用来构建和管理应用程序的图形用户界面（GUI）

java.applet——包含applet运行所需的一些类

java.net——包含执行与网络相关的操作的类

java.io——包含能提供多种输入/输出功能的类

java.util——包含一些使用工具类，如定义系统特性，使用与日期日历相关的函数

打包命令：jar –cvf xx.jar .

访问控制

子类和继承

java中使用extends关键字实现类的继承机制

通过继承，子类自动拥有了基类（superclass）的所有成员（成员变量和方法）

Object类是所有Java类的最高层父类

java只支持单继承，不允许多继承

一个子类只能有一个基类，一个基类可以派生出多个子类

子类继承的方法只能操作子类继承和隐藏的成员变量。

子类重写或新增的方法可以操作子类继承和新声明的成员变量，但是不能直接操作隐藏的成员变量

子类的继承性

如果子类和父类在同一个包，那么子类可以继承父类中的所有的非private变量和方法。

如果不在同一个包，那么父类中的private和友好访问权限的成员变量和方法不会被子类继承。

继承中的构造方法

子类的构造的过程必须调用其基类的构造方法

子类可以在自己的构造方法中使用super调用基类的构造方法，使用this调用本类的另外的构造方法

使用super，必须写在子类构造方法的第一行

如果子类的构造方法没有显示地调用基类构造方法，则系统默认调用基类无参数的构造方法

如果子类构造方法中既没有显式调用基类构造方法，而基类中又没有无参的构造方法，则编译出错

对象转型

• 一个基类的引用类型变量可以“指向”其子类的对象

• 一个基类的引用不可以访问其子类对象新增加的成员（属性和方法）

• 可以使用引用变量instanceof类名来判断该引用型变量所“指向”的对象是否属于该类或该类的子类

• 子类的对象可以当做基类的对象来使用称作向上转型（upcasting)，反之称为向下转型（downcasting）

向上转型:

class A {
     
 public void print() {
     
 System.out.println("A:print");
 }
}
class B extends A {
     
 public void print() {
      
 System.out.println("B:print");
 }
}
public class Test{
     
 public static void main(String args[])
 {
     
 A a = new B(); //通过⼦类去实例化⽗类
 a.print();
 }
}

向下转型:

class A {
     
 public void print() {
     
 System.out.println("A:print");
 }
}
class B extends A {
     
 public void print() {
      
 System.out.println("B:print");
 }
 public void funcB(){
     System.out.println("funcB");
 }
}
public class Test{
     
 public static void main(String args[])
 {
     
 B b = (B)a; //向下转型,通过⽗类实例化⼦类
 b.funcB(); //调⽤B类独有的⽅法
 }
}

• 无继承关系的引用类型间的转换是非法的

多态

定义：多态是同⼀个⾏为具有多个不同表现形式或形态的能⼒。

一个对象只能有一种确定数据类型
一个引用类型变量可能指向（引用）多种不同类型的对象

实现继承
方法重写
父类引用指向子类对象

抽象类

public abstract class Action {
     
 
 public abstract void doSomething(); //抽象⽅法
 
 public void test(){
     
 };
 }

• 用abstract关键字来修饰一个类时，这个类叫做抽象类，用abstract来修饰一个方法时，该方法叫做抽象方法
• 含有抽象方法的类必须被声明为抽象类，抽象类必须被继承，抽象方法必须被重写
• 抽象类不能被实例化
  抽象方法只需声明，而不需实现

常用关键字

super关键字

1. super关键字主要存在于⼦类⽅法中，⽤于指向⼦类对象中的⽗类对象；可以访问⽗类的属性、函数以及构造函数。

2. ⼦⽗类存在着同名的成员（包括变量和⽅法）时，在⼦类中默认是访问⼦类的成员，可以通过super关键字指定访问⽗类的成员；

3. 默认会先调⽤⽗类⽆参的构造⽅法，可以通过super关键字指定调⽤⽗类的构造⽅法。

final

可以修饰：类，成员变量和方法中的局部变量

final的变量的值不能够被改变

final修饰类：不能被继承

Final修饰⽅法： 不能被重写，但是⼦类可以⽤⽗类中final修饰的⽅法

final修饰变量：

1. 基本类型变量使⽤final修饰了就不可变了，成员变量或局部变量被修饰为final就是常量，声明常量时必须指定常量的值

2. 对于引⽤类型变量被final修饰了:引⽤变量引⽤不可变，但是引⽤对象的内容可以改变。

接口

• 接口中只能有常量和abstract方法
• 多个无关的类可以实现同一个接口
• 一个类可以实现多个无关的接口
• 与继承关系类似，接口与实现类之间存在多态性
  语法格式：
  < modifier > class < name > [ extends< superclass > ] [ implements < interface > ,< interface > ]

public interface UserService {
     
 //接⼝中的所有定义的⽅法中其实都是抽象的 public abstract
 //变量只能为 public static final 类型的
 //public abstract void add();
 //等效于 void add();
 //int age = 99; 等效于
 //public static final int age = 99;
 int age = 99;
 void add(String name);
 void delete(String name);
 void update(String name);
 void query(String name);
 }

• 接口中声明属性默认为public static final的；也只能是public static final的；
• 接口中只能定义抽象方法，而且这些方法默认为public的、也只能是public的
• 接口可以继承其他的接口，并添加新的属性和抽象方法

接口和类的比较

• 接口与类相似点：
  一个接口可以有多个方法。
  接口文件保存在 .java 结尾的文件中，文件名使用接口名。
  接口的字节码文件保存在 .class 结尾的文件中。
  接口相应的字节码文件必须在与包名称相匹配的目录结构中。
• 接口与类的区别：
  接口不能用于实例化对象。
  接口没有构造方法。
  接口中所有的方法必须是抽象方法。
  接口不能包含成员变量，除了 static 和 final 变量。
  接口不是被类继承了，而是要被类实现。
  接口支持多继承。

实体类	抽象类	接口
常量	常量	常量
变量	变量	抽象方法
方法	方法
	抽象方法

异常类

异常是在运行期出现的错误

• Java异常是Java提供的用于处理程序中错误的一种机制
• 所谓错误是指在程序运行的过程中发生的一些异常事件（如：除0溢出，数组下标越界，所要读取的文件不存在）
• 设计良好的程序应该在异常发生时提供处理这些错误的地方，使得程序不会因为异常的发生而阻断或产生不可预见的结果
• Java程序的执行过程中如出现异常事件，可以生成一个异常类对象，该异常对象封装了异常事件的信息并将被提交给Java运行时系统，这个过程称为抛出（throw）异常
• 当Java运行时系统接收到异常对象时，会寻求能处理这一异常的代码并把当前异常对象交给其处理，这一过程称为捕获（catch）异常
  
  异常和错误的区别是：异常能被程序本身可以处理，错误是⽆法处理。

异常的分类

• Error：称为错误，由Java虚拟机生成并抛出，包括动态链接失败、虚拟机错误等，程序对其不做处理

• Exception：所有异常类的父类，其子类对应了各种各样可能出现的异常事件，一般需要用户显式的声明或捕获
  Exception（异常）分两⼤类：运⾏时异常和⾮运⾏时异常(编译异常)。
  运⾏时异常：
  如NullPointerException(空指针异常)、 IndexOutOfBoundsException(下标越界异常)
  等，这些异常是不检查异常，程序中可以选择捕获处理，也可以不处理
  ⾮运⾏时异常 （编译异常）：
  是RuntimeException以外的异常，类型上都属于Exception类及其⼦类。从程序语法⻆度讲是必须进⾏ 处理的异常，如果不处理，程序就不能编译通过。如IOException、SQLException等以及⽤户⾃定义的Exception异常.

• Runtime Exception：一类特殊的异常，如被0除、数组下标越界等，其产生比较频繁，处理麻烦，如果显式的声明或捕获将会对程序可读性和运行效率影响很大，因此由系统自动检测并将它们交给缺省的异常处理程序（用户可不必对其处理）

代码

try{
     
//可能抛出异常的语句
}catch(SomeException1 e){
     
……
}catch(SomeException2 e){
     
......
}finally{
     
……
}

• try代码块包含可能产生异常的代码

• try代码段后跟有一个或多个catch代码段

• 每个catch代码段声明其能处理的一种特定类型的异常并提供处理的方法

• 当异常发生时，程序会中止当前的流程，根据获取异常的类型去执行相应的catch代码段

• finally代码段无论是否发生异常都要执行

java中的常用类

String 类

string类是不可以变序列

String不变的性质是因为每次都从String 池⾥⾯取，如果有则直接⽤，否则创建新的放⼊

静态重载方法
public static String valueOf(…)可以将基本类型数据转换为字符串

String类初始化

String str1 = “HelloWorld”;
Sting str2 = new String();
str2="HelloWorld"
String str3 = new String(“HelloWorld”);

String 类的常见操作

1 char charAt(int index)
返回指定索引处的 char 值。
String concat(String str)
将指定字符串连接到此字符串的结尾。
int indexOf(char ch)
返回指定字符在此字符串中第⼀次出现处的索引
boolean equals(Object anObject)
将此字符串与指定的对象⽐较。
 String replace(char oldChar, char newChar)
返回⼀个新的字符串，它是通过⽤ newChar 替换此字符串中出现的所有 oldChar 得到的。
String replaceAll(String regex, String replacement)
使⽤给定的 replacement 替换此字符串所有匹配给定的正则表达式的⼦字符串。
int compareTo( NumberSubClass referenceName )
如果指定的数与参数相等返回0。
如果指定的数小于参数返回 -1。
如果指定的数大于参数返回 1。

基本数据类型包装类

• ⾃动装箱
  ⾃动装箱即⾃动将基本数据类型转换成包装类型

//早期基本数据类型->包装类型
Integer i1 = new Integer(8); //int->Integer
Integer i2 = Integer.valueOf(8); //int->Integer
//现在是⾃动装箱(⾃动基本数据类型->包装类型转换)
Integer i3 = 8;//8是int类型

• ⾃动拆箱
  ⾃动拆箱即⾃动将包装类型转换成基本数据类型，与⾃动装箱相反
  //早期包装数据类型->基本类型转换

Float i=3.3;
float i5 = i.floatValue();
Integer i2=3;
int m=i2.intValue();
// ⾃动拆箱(⾃动包装数据类型->基本类型转换)
Integer i=3;
int i4 = i;

多线程

线程和进程的区别

• 每个进程都有独立的代码和数据空间（进程上下文），进程间的切换会有较大的开销
• 线程可以看成是轻量级的进程，同一类线程共享代码和数据空间，每个线程都有独立的运行栈和程序计数器（PC），线程切换开销小

多进程：在操作系统中能同时运行多个任务（程序）
多线程：在同一应用程序中有多个顺序流同时执行

线程的基本概念

• Java的线程通过java.lang.Thread类来实现的

• VM启动时，会有一个由主方法（public static void main())定义的线程

• 可以通过创建Thread类的实例来创建线程

• 每个线程都是通过某个特定Thread对象所对应的方法run()来完成其操作的，方法run()称为线程体

• 通过调用Thread类的start()方法来启动一个线程

线程的创建

Java中线程的创建常⻅有如2种基本形式
1.继承Thread类，重写该类的run()⽅法

class MyThread extends Thread {
     
	private int i = 0;
	 @Override
 	public void run() {
     
 		for (i = 0; i < 100; i++) {
     
 			System.out.println(Thread.currentThread().getName() + " " + i);
		}
 	}
}

2、实现Runnable接⼝，并重写该接⼝的run()⽅法，该run()⽅法同样是线程执⾏体，创建Runnable实现类的实例，并以此实例作为Thread类的target来创建Thread对象，该Thread对象才是真正的线程对象

class MyRunnable implements Runnable {
     
	private int i = 0;
 	@Override
 	public void run() {
     
	 	for (i = 0; i < 100; i++) {
     
	 		System.out.println(Thread.currentThread().getName() + " " + i);
	 	}
 	}
 }

Thread myThread=new Thread(target);//target为Runnable接口类型
Runnabel接口中只有一个方法
public void run();//用以定义线程运行体
使用Runnable接口可以为多个线程提供共享的数据
在实现Runnable接口的类的run方法定义中可以使用Thread的静态方法
public static Thread currentThread()获取当前线程的引用

线程控制基本方法

由于是静态方法，sleep可以由类名直接调用

sleep()⽅法和wait()⽅法：

• 相同点：⼀旦执⾏⽅法以后，都会使得当前的进程进⼊阻塞状态。
• 不同点：

1. ⽅法声明⽅式不同，sleep()⽅法在Thread类中声明，wait()⽅法在Object类中声明。
2. 调⽤的条件不同，sleep可以在任何需要的场景下调⽤，wait必须使⽤在同步代码块或者同步⽅法中。
3. 是否释放锁，sleep不会释放，wait会释放
4. sleep()⽅法 :sleep()使当前线程进⼊阻塞状态，在指定时间内不会执⾏。⾃动苏醒
   wait()⽅法: 不会主动苏醒，需要另外的线程调⽤notify()/notifyAll()⽅法唤醒。

进程状态

1、新建状态（New）：新创建了一个线程对象。
2、就绪状态（Runnable）：线程对象创建后，其他线程调用了该对象的start()方法。该状态的线程位于可运行线程池中，变得可运行，等待获取CPU的使用权。
3、运行状态（Running）：就绪状态的线程获取了CPU，执行程序代码。
4、阻塞状态（Blocked）：阻塞状态是线程因为某种原因放弃CPU使用权，暂时停止运行。直到线程进入就绪状态，才有机会转到运行状态。阻塞的情况分三种：
（一）、等待阻塞：运行的线程执行wait()方法，JVM会把该线程放入等待池中。
（二）、同步阻塞：运行的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则JVM会把该线程放入锁池中。
（三）、其他阻塞：运行的线程执行sleep()或join()方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。
5、死亡状态（Dead）：线程执行完了或者因异常退出了run()方法，该线程结束生命周期。

问答题

• 面向对象的特征有哪些方面 ？
  答：主要有以下四方面：
  1.抽象：
  抽象就是忽略一个主题中与当前目标无关的那些方面，以便更充分地注意与当前目标有关的方面。抽象并不打算了解全部问题，而只是选择其中的一部分，暂时不用部分细节。抽象包括两个方面，一是过程抽象，二是数据抽象。
  2.继承：
  继承是一种联结类的层次模型，并且允许和鼓励类的重用，它提供了一种明确表述共性的方法。对象的一个新类可以从现有的类中派生，这个过程称为类继承。新类继承了原始类的特性，新类称为原始类的派生类（子类），而原始类称为新类的基类（父类）。派生类可以从它的基类那里继承方法和实例变量，并且类可以修改或增加新的方法使之更适合特殊的需要。
  3.封装：
  封装是把过程和数据包围起来，对数据的访问只能通过已定义的界面。面向对象计算始于这个基本概念，即现实世界可以被描绘成一系列完全自治、封装的对象，这些对象通过一个受保护的接口访问其他对象。

4. 多态性：
   多态性是指允许不同类的对象对同一消息作出响应。多态性包括参数化多态性和包含多态性。多态性语言具有灵活、抽象、行为共享、代码共享的优势，很好的解决了应用程序函数同名问题。

---

• String是最基本的数据类型吗？
  答：基本数据类型包括byte、int、char、long、float、double、boolean和short。（8个）
  java.lang.String类是final类型的，因此不可以继承这个类、不能修改这个类。为了提高效率节省空间，我们应该用StringBuffer类

---

• int 和 Integer 有什么区别？
  答：Java 提供两种不同的类型：引用类型和原始类型（或内置类型）。Int是java的原始数据类型，Integer是java为int提供的封装类。Java为每个原始类型提供了封装类。

---

• 一个".java"源文件中是否可以包括多个类（不是内部类）？有什么限制？
  答：可以。必须只有一个类名与文件名相同。

---

• 阐述实体类、抽象类和接口的区别
  1、类只能继承类，接口只能继承接口，类可以实现接口，其它都不行。
  2、java中支持单继承，多实现规则。
  抽象类与接口都用于抽象，但是抽象类(JAVA中)可以有自己的部分实现，而接口则完全是一个标识(同时有多重继承的功能)。

---

• 重载和重写的区别
  方法的重写Overriding和重载Overloading是Java多态性的不同表现。
  重写Overriding是父类与子类之间多态性的一种表现，重载Overloading是一个类中多态性的一种表现。如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写 (Overriding)。子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被"屏蔽"了。如果在一个类中定义了多个同名的方法，它们或有不同的参数个数或有不同的参数类型，则称为方法的重载(Overloading)。Overloaded的方法是可以改变返回值的类型

---

• throws 关键字和 throw 关键字有什么区别和联系？
  throw⽤来在⽅法体内抛出异常，⽽throws⽤来在⽅法声明处声明异常。
  这两个关键字有着⼀定的联系。如果⼀个⽅法中使⽤了throw关键字抛出了异常，那么要么⽴即⽤try/catch语句进⾏捕获，要么就是⽤throws进⾏声明，否则将出现编译错误。
  然⽽， 并不是只有使⽤了throw关键字之后才能使⽤throws关键字，语法上来说，任何⼀个⽅法都可以直接使⽤throws关键字，抽象⽅法也可以使⽤。

---

• 什么是多态？如何实现多态？
  多态性(Polymorphism)是指在基类中定义的属性或⽅法被派⽣类继承后，可以具有不同的数据类型，或表现出不同的⾏为，从⽽使得同⼀个属性或⽅法在基类及其各个派⽣类中具有不同的语义。
  Java的多态性体现在两个⽅⾯：(1) ⽅法重载实现的静态多态性，⼜称为编译时多态；(2) ⽅法覆盖/重写实现的动态多态性，⼜称为运⾏时多态。

---

• error和exception有什么区别
  error 表示恢复不是不可能但很困难的情况下的一种严重问题。比如说内存溢出。不可能指望程序能处理这样的情况
  exception 表示一种设计或实现问题。也就是说，它表示如果程序运行正常，从不会发生的情况

---

• 接口是否可继承接口? 抽象类是否可实现(implements)接口? 抽象类是否可继承实体类(concrete class)
  接口可以继承接口。抽象类可以实现(implements)接口，抽象类是否可继承实体类，但前提是实体类必须有明确的构造函数