java知识点复习

Posted 中二病没有蛀牙

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了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<<b; "将二进制形式的a逐位左移b位，最低位空出的b位补0

带符号右移
"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;
  1. ⽅法中指调⽤该⽅法的对象；
 public class Baby
 	public void wakeUp()
 		System.out.println("宝宝醒啦");
 	
 	public void eat()
 		this.wakeUp();
 		System.out.println("吃东⻄");
  1. 在类本身的⽅法或构造器中引⽤该类的实例变量（全局变量）和⽅法
 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.封装：
    封装是把过程和数据包围起来，对数据的访问只能通过已定义的界面。面向对象计算始于这个基本概念，即现实世界可以被描绘成一系列完全自治、封装的对象，这些对象通过一个受保护的接口访问其他对象。
  1. 多态性：
    多态性是指允许不同类的对象对同一消息作出响应。多态性包括参数化多态性和包含多态性。多态性语言具有灵活、抽象、行为共享、代码共享的优势，很好的解决了应用程序函数同名问题。
  • String是最基本的数据类型吗？
    答：基本数据类型包括byte、int、char、long、float、double、boolean和short。（8个）
    java.lang.String类是final类型的，因此不可以继承这个类、不能修改这个类。为了提高效率节省空间，我们应该用StringBuffer类
  • int 和 Integer 有什么区别？
    答：Java 提供两种不同的类型：引用类型和原始类型（或内置类型）。Int是java的原始数据类型，Integer是java为int提供的封装类。Java为每个原始类型提供了封装类。