1、JVM、JRE和JDK的差异：
JVM(Java Virtual Machine):java虚拟机，用于担保java的跨平台的特性。
java措辞是跨平台，jvm不是跨平台的。
JRE(Java Runtime Environment):java的运行环境,包括jvm+java的核心类库。
JDK(Java Development Kit):java的开拓工具,包括jre+开拓工具
2、环境变量path和classpath的浸染是什么？
(1)path是配置Windows可实行文件的搜索路径，即扩展名为.exe的程序文件所在的目录，
用于指定DOS窗口命令的路径。
(2)Classpath是配置class文件所在的目录，用于指定类搜索路径，JVM便是通过它来探求该类的class类文件的。
3、变量有什么用？为什么要定义变量？什么时候用？
答：变量的浸染：用来存储数据。
为什么要定义变量：用来不断的存放同一类型的常量，并可以重复利用
4、&和&&的差异?
答：（1）&&会涌现短路，如果可以通过第一个表达式判断出全体表达式的结果，则不连续后面表达式的运算；
只能操作boolean类型数据；
（2）&不会涌现短路，将全体表达式都运算。既可以操作boolean数据还可以操作数。
5、标示符命名规则：
由数字(0-9)，大小写英笔墨母，以及_和$组成。
不能以数字开头。
不能利用关键字来自定义命名。
6、数据类型：
(1)基本数据类型(4类8种)：
整数类型：byte、short、int、long
浮点数类型：float、double
字符类型：char
布尔类型：boolean(ture false)
(2)引用数据类型：
类
接口
数组
7、类型转换
精度从高到低 double float long int short(char) byte
(1)自动类型转换 将一个低精度—高精度
(2)逼迫类型转换 将一个高精度—低精度(精度会低落)
8、java措辞的三种技能架构
J2EE：企业版
是为开拓企业环境下的运用程序供应的一套办理方案。
该技能体系中包含的技能如 Servlet、Jsp等，紧张针对付Web运用程序开拓。
J2SE：标准版
是为开拓普通桌面和商务运用程序供应的办理方案。
该技能体系是其他两者的根本，可以完成一些桌面运用程序的开拓。
比如Java版的扫雷。
J2ME：小型版
是为开拓电子消费产品和嵌入式设备供应的办理方案。
该技能体系紧张运用于小型电子消费类产品，如手机中的运用程序等。
9、java的跨平台性：
通过Java措辞编写的运用程序在不同的系统平台上都可以运行。
跨平台的缘故原由：
只要在须要运行java运用程序的操作系统上，先安装一个Java虚拟机(JVM Java Virtual Machine)即可。
由JVM来卖力Java程序在该系统中的运行。
10、有符号数据的表示法(次重点)
原码，反码(原码取反)，补码(反码+1)。
11、函数
定义：函数便是定义在类中的具有特定功能的一段独立小程序。
特点：
定义函数可以将功能代码进行封装
便于对该功能进行复用
函数只有被调用才会被实行
函数的涌现提高了代码的复用性
对付函数没有详细返回值的情形，返回值类型用关键字void表示，
那么该函数中的return语句如果在末了一行可以省略不写。
函数的运用两个明确：
明确要定义的功能末了的结果是什么？
明确在定义该功能的过程中，是否须要未知内容参与运算
12、重载：
观点：在同一个类中，许可存在一个以上的同名函数，只要它们的参数个数或者参数类型不同即可。
特点：与返回值类型无关，只看参数列表(参数类型以及参数个数)。
好处：方便于阅读，优化了程序设计。
13、数组：
观点：同一种数据类型的凑集。
好处：可以自动给数组中的元素从0开始编号，方便操作这些元素。
14、内存构造：
栈内存：用于存储局部变量，当数据利用完，所占空间会自动开释。
堆内存：数组和工具，通过new建立的实例都存放在堆内存中。
本地方法区：window系统占用
寄存器：小额临时数据
二、面向工具
1、面向工具思想：
(1)概述：面向工具是相对付面向过程而言的，面向过程强调的是功能，面向工具强调的是将功能封装进工具，强调具备功能的工具；
(2)思想特点：
A:是符合人们思考习气的一种思想；
B:将繁芜的事情大略化了；
C:将程序员从实行者变成了指挥者；
比如我要达到某种结果，我就探求能帮我达到该结果的功能的工具，如我要洗衣服我就买洗衣机，
至于怎么洗我不管。
(3)特色：
封装：隐蔽工具的属性和实现细节，仅对外供应公共访问办法
继续: 多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义
这些属性和行为，只要继续那个类即可。
多态: 一个工具在程序不同运行时候代表的多种状态，父类或者接口的引用指向子类工具
2、类和工具：
类：对现实天下中某类事物的描述,是抽象的，观点上的定义。
工具：事物详细存在的个体。
3：成员变量和局部变量的差异(重点)
(1)浸染域
成员变量：针对全体类有效。
局部变量：只在某个范围内有效。(一样平常指的便是方法,语句体内)
(2)存储位置
成员变量：随着工具的创建而存在，随着工具的消逝而消逝，存储在堆内存中。
局部变量：在方法被调用，或者语句被实行的时候存在，存储在栈内存中。
当方法调用完，或者语句结束后，就自动开释。
(3)初始值
成员变量：有默认初始值。
局部变量：没有默认初始值，利用前必须赋值。
4、匿名工具
(1)匿名工具便是没有名字的工具。是工具的一种简写形式。
(2)运用处景
A:只调用一次类中的方法。
B:可以作为实际参数在方法通报中利用
5、封装：
指隐蔽工具的属性和实现细节，仅对外供应公共访问办法；比如电脑机箱、条记本等
好处：
将变革隔离；
方便利用；
提高复用性；
提高安全性
6、关键字private：封装在代码中的表示
(1)私有的意思，权限润色符
(2)用来润色成员变量和成员函数
(3)用private润色的成员只在本类中有效
(4)私有是封装的一种表示
7、布局方法：
(1)特点：
方法名与类名相同
没有返回类型
没有返回值
(2)浸染：布局函数是用于创建工具，并对其进行初始化赋值，工具一建立就自动调用相对应的布局函数，
(3)布局方法的把稳事变:
A:如果一个自定义类没有布局方法，系统会默认给出一个无参布局方法。
B:如果一个自定义类供应告终构方法，那么，系统将不再给出无参布局方法。
这个时候，你可以不该用无参布局方法。
如果你想利用，那么，就必须手动给出无参布局方法。
建议：一样平常情形下，我们的自定义类都要手动给出无参布局方法。
(4)布局方法和成员方法的差异
A:格式差异
布局方法和类名相同，并且没有返回类型，也没有返回值。
普通成员方法可以任意起名，必须有返回类型，可以没有返回值。
B:浸染差异
布局方法用于创建工具，并进行初始化值。
普通成员方法是用于完成特定功能的。
C:调用差异
布局方法是在创建工具时被调用的，一个工具建立，只调用一次相应布局函数
普通成员方法是由创建好的工具调用，可以调用多次
8、布局代码块：
(1)浸染：给工具进行初始化，工具一建立就实行，而且优先于布局函数实行
(2)布局代码块和布局函数的差异：
布局代码块是给所有不同工具的共性进行统一初始化
布局函数是给对应的工具进行初始化
9、this关键字
(1)this关键字代表本类工具的一个引用，谁调用this所在的方法，this就代表谁
(2)this的利用场景
A:用于区分同名成员变量和局部变量；
B:在定义函数时，该函数内部要用到调用该函数的工具时，由于此时工具还没建立，故this代表此工具
B:布局函数间调用
这个时候，this(参数)必须作为第一条语句存在。
10、Person p = new Person();在内存中做了哪些事情。
(1)将Person.class文件加载进内存中。
(2)如果p定义在主理法中，那么，就会在栈空间开辟一个变量空间p。
(3)在堆内存给工具分配空间。
(4)对工具中的成员进行默认初始化。
(5)对工具中的成员进行显示初始化。
(6)调用布局代码块对工具进行初始化。(如果没有就不实行)
(7)调用布局方法对工具进行初始化。工具初始化完毕。
(8)将工具的内存地址赋值给p变量，让p变量指向该工具。
11、static关键字：
(1)静态的意思，用来润色成员变量和成员函数
(2)静态的特点:
随着类的加载而加载
优先于工具存在
对所有工具共享
可以被类名直接调用
(3)静态的把稳事变
A:静态方法只能访问静态成员
为什么：由于静态的内容是随着类的加载而加载，它是前辈内存的。
B:静态方法中不能利用this,super关键字
C:主理法是静态的
public static void main(String[] args)
public:公共的意思，是最大权限润色符。
static:由于jvm调用main方法的时候，没有创建工具。
只能通过类名调用。以是，main必须用static润色。
void:由于main方法是被jvm调用，不须要返回值。用void润色。
main:main是紧张的意思，以是jvm采取了这个名字。是程序的入口。
String[]:字符串数组
args:数组名
在运行的时候，通过java命令给args数组赋值。
格式：java MainTest hello world itcast
(4)静态变量和成员变量的差异
A：调用办法
静态变量也称为类变量，可以直接通过类名调用。也可以通过工具名调用。
这个变量属于类。
成员变量也称为实例变量，只能通过工具名调用。这个变量属于工具。
B：存储位置
静态变量存储在方法区长中的静态区。
成员变量存储在堆内存。
C：生命周期
静态变量随着类的加载而存在，随着类的消逝而消逝。生命周期长。
成员变量随着工具的创建而存在，随着工具的消逝而消逝。
D：与工具的干系性
静态变量是所有工具共享的数据。
成员变量是每个工具所特有的数据。
(5)静态的优点和弊端
优点：
对工具的共享数据进行单独空间的存储，节省内存，没有必要每个工具都存储一份
可直接被类名调用
弊端：
生命周期过长，随着类的消逝而消逝
访问涌现权限，即静态虽好但只能访问静态
(6)什么利用利用静态呢？
A:当所有工具共享某个数据的时候，就把这个成员变量定义为静态润色的。
B:当某个方法没有访问该类中的非静态成员，就可以把这个方法定义为静态润色。
静态的生命周期比较长，以是一样平常不推举利用。
(7)静态代码块
A:它只实行一次，它比main还先实行。
B:实行顺序
静态代码块–布局代码块–布局方法
12、制作API(次重点)
API(全拼):Application Program Interface 运用程序编程接口。
(1)类中的内容须要用文档注释。
(2)利用JDK\bin目录下的javadoc工具。
格式:javadoc -d 目录 -author -version ArrayTool.java
13、单例设计模式：
(1)设计模式：
办理某类问题行之有效的方法，是一种思想，是规律的总结
(2)用来担保某个类在内存中只有一个工具
(3)担保唯一性的思想及步骤
为了避免其他程序建立该类工具，先禁止其他程序建立该类工具，即将布局函数私有化
为了其他程序访问到该类工具，须在本类中创建一个该类私有工具
为了方便其他程序访问到该类工具，可对外供应一个公共访问办法
比如API中的Runtime类便是单例设计模式。
(4)单例设计模式的两种办法
A:饿汉式 当类加载的时候，就创建工具。
复制代码
class Student
{
private Student(){}
private static final Student s = new Student();
public static Student getInstance()
{
return s;
}
}
复制代码
B:
复制代码
class Student
{
private Student(){}
private static final Student s = null;
public static Student getInstance()
{
if(s==null)
{
复制代码
//线程1就进来了，线程2就进来了。
s = new Student();
}
return s;
}
}
饿汉式和
饿汉式是类一加载进内存就创建好了工具；
工具才开始创建。
可以加同步来办理。但是加了同步之后，每一次都要比较锁，效率就变慢了，
以是可以加双重判断来提高程序效率。
注：开拓常用饿汉式，由于饿汉式大略安全。
14、Math类的利用(重点)
(1)数学操作类:该类没有布局函数，方法均为静态的
(2)节制内容
A:成员变量
E：比任何其他值都更靠近e（即自然对数的底数）的double值。
PI：比任何其他值都更靠近pi（即圆的周长与直径之比）的double值。
B:成员方法
static double abs(double a)
返回 double 值的绝对值。返回绝对值
static double ceil(double a)
返回最小的（最靠近负无穷大）double 值，该值大于即是参数，并即是某个整数。
static double floor(double a)
返回最大的（最靠近正无穷大）double 值，该值小于即是参数，并即是某个整数。
max：返回两个值中较大的那个
min：返回两个值中较小的那个
static long round(double a) 返回最靠近参数的 long。
static int round(float a) 返回最靠近参数的 int。
static double random()
返回带正号的 double 值，该值大于即是 0.0 且小于 1.0。
static double pow(double a, double b)
返回第一个参数的第二个参数次幂的值。
static double sqrt(double a)
返回精确舍入的 double 值的正平方根。
15、Random类的利用(重点)
(1)产生随机数的类
(2)节制内容
A:布局方法
Random() 创建一个新的随机数天生器。
Random(long seed) 利用单个 long 种子创建一个新的随机数天生器。
B:成员方法
int nextInt() 返回下一个伪随机数，它是此随机数天生器的序列中均匀分布的 int 值。
int nextInt(int n) 返回一个伪随机数，它是取自此随机数天生器序列的、
在 0（包括）和指定值（不包括）之间均匀分布的 int 值。
16、Scanner类的利用
(1)可以获取从键盘的输入数据
(2)节制内容
布局方法：
Scanner(InputStream source) 布局一个新的 Scanner，它天生的值是从指定的输入流扫描的。
如：Scanner sc = new Scanner(System.in);
方法择要
sc.nextInt();获取整型数据
sc.nextLine();获取字符串数据
17、继续(重点)
(1)把很多类的相同特色和行为进行抽取，用一个类来描述。让多个类和这个类产生一个关系。
这样的话，多个类就可以省略很多代码。这个关系便是继续。java中用extends关键字表示。
(2)继续的体系构造
A:多个详细的工具，不断的向上抽取共享的内容，终极形成了一个体系。这个体系叫做继续体系。
B:继续体系的学习和利用原则
学习顶层的内容。由于他是全体体系的共性内容。
创建子类利用。也便是利用底层的详细工具。
(3)继续的特点:
A:java中只能单继续，没有多继续。
B:java可以有多重(层)继续。
(4)继续的好处：
继续的涌现提高了代码的复用性。
继续的涌现让类与类之间产生了关系，供应了多态的条件。
(5)子父类中的成员关系
A:成员变量
在子类方法中利用一个变量时：
首先，在方法的局部变量中找这个变量，有则利用。
否则，在本类中找成员变量，有则利用。
否则，在父类中找成员变量，有则利用。
否则，报错。
B:成员方法
用子类工具利用一个方法时。
首先，在子类中找这个方法，有则利用。
否则，在父类中找这个方法，有则利用。
否则，报错。
重写和重载的差异？
重载：在同一类中。方法名相同，参数列表不同。重载可以改变返回类型。
重写：在不同类中(子父类中)。
方法声明相同(返回类型，方法名，参数列表均相同)。
重写须要把稳：
子类方法的访问权限要大于即是父类方法的访问权限。
静态只能重写静态。但是这种情形一样平常不会涌现。
布局方法
子类的实例化过程
子类创建工具时，会先去创建父类的工具。
默认是去调用父类的无参布局方法。
子类布局方法中，第一行默认是super()
为什么子类中第一行会默认有super()
由于他继续父类的成员利用，利用前这些成员必须初始化，
而他们是父类的成员，以是，必须通过父类进行初始化。
以是，会先创建一个父类的工具。
当父类没有无参布局方法时
必须利用this或者super调用其他的布局方法。
(6)this和super的差异
this:代表本类工具的引用。
super:代表父类的存储空间。
18、final关键字(重点)
(1)终极的意思，可以用于润色类，方法，变量。
(2)final润色的类不能被继续。
final润色的方法不能被重写。
final润色的变量是一个常量。只能被赋值一次。
内部类只能访问被final润色的局部变量。
19、抽象类(重点)
(1)多个类有相同的方法声明，但是方法体不一样。这个时候，我们考虑把方法声明进行抽取。
让子类继续后，自己去实现方法体。没有方法体的方法，我们须要用抽象标志下。
抽象的关键字是：abstract。
(2)抽象类：
该方法称为抽象方法，包含抽象方法的类便是抽象类。
(3)抽象类的特点：
A:抽象类和抽象方法都要用abstract进行润色
B:抽象类不能被实例化
C:抽象类中不一定有抽象方法，但是，有抽象方法的类一定是抽象类。
(4)抽象类中数据的特点
A:成员变量
抽象类中可以有变量，也可以有常量。
B:成员方法
抽象类中可以有抽象方法，也可以有非抽象方法。
C:布局方法
抽象类是一个类，以是，它有布局方法。
虽然本身不能实例化。但是可以给子类实例化利用。
(5)抽象类中的问题
A:抽象类中是否有布局方法？能不能被实例化？如果不能，为什么有布局方法？
抽象类有布局方法。
抽象类不能被实例化。
抽象类中的布局方法供子类实例化调用。
B:抽象关键字abstract不可以和哪些关键字共存？
private:
私有内容子类继续不到，以是，不能重写。
但是abstract润色的方法，哀求被重写。两者冲突。
final
final润色的方法不能被重写。
而abstract润色的方法，哀求被重写。两者冲突。
static
如果一个抽象方法能通过static润色，那么这个方法，就可以直接通过类名调用。
而抽象方法是没有方法体的，这样的调用无意义。以是，不能用static润色。
C:抽象类中可不可以没有抽象方法？如果可以，这样的类有什么用吗？
抽象类可以没有抽象方法。
抽象类中没有抽象方法的浸染，只是为了不让别的类建立该抽象类工具。这个在awt中有表示。
20、接口interface
(1)当一个类中的方法都是抽象的时候，java供应了另一种表示办法，叫接口。
用interface关键字表示。类与接口关系用implements表示。
(2)接口的成员特点
A:成员变量
是常量，默认润色 public static final
B:成员方法
都是抽象的，默认润色 public abstract
(3)关系
A:类与类的关系
是继续关系。类与类只能单继续，可以多重继续。
B:类和接口的关系
是实现关系。类可以多实现接口。
类在继续一个类的同时，可以实现多个接口。
C:接口和接口的关系
是继续关系。接口可以多继续接口。
(4)接口的特点
A:是对外暴露的规则
B:是功能的扩展
C:接口的涌现降落耦合性。
耦合(类与类之间的关系)
内聚(类完成功能的能力)
编程规范：低耦合，高内聚。
D:接口可以多实现。如：CPU和主板、条记本的USB插口、插座
(5)接口和抽象类的差异
A：抽象类只能被单继续
接口可以多实现,接口的涌现避免了多继续的局限性。
B：抽象类中的数据特点：
成员变量：可以是变量，也可以是常量
成员方法：可以是抽象方法，也可以是非抽象方法
布局方法：有布局方法
接口中的数据特点：
成员变量：是常量。默认润色 public static final
成员方法：都是抽象方法。都有默认润色 public abstract
布局方法：没有布局方法
C：抽象类中定义的是继续体系中的共性功能。
接口中定义的是继续体系中的扩展功能。
D：抽象类被继续是\公众is a\"大众关系:xx是yy的一种
接口被实现是\"大众like a\"大众关系:xx像yy的一种
21、多态：
(1)同一个工具，在程序不同时候的多种运行状态。举例：动物，狗是狗，狗是动物。水(气态，液态，固态)
(2)多态条件
A:存在着继续或者实现关系
B:有方法的重写
C:父类(接口)引用指向子类(实现)工具
(3)多态的好处和弊端：
好处：多态的存在提高了程序的扩展性和后期可掩护性
弊端：虽然可以预先利用，但是只能访问父类中已有的功能，运行的是后期子类的功能内容。
不能预先利用子类中定义的特有功能。
(4)多态中工具调用成员的特点
Fu f = new Zi();
A:成员变量
编译看左边，运行看左边
B:成员方法
编译看左边，运行看右边
C:静态方法
编译看左边，运行看左边
(5)多态的思想
指挥同一批工具干工作。举例：带兵打仗，下课等。
22、instanceof关键字
A:用于判断某个工具是否是某种类型。
B:格式
工具名 instanceof 子类(实现)名
23、Object类：
(1)是所有类的根类，超类。
java中供应的类以及我们自定义的类都直接或者间接的继续自Object类。
(2)Object类中的方法
A:void finalize()
当垃圾回收器确定不存在对该工具的更多引用时，由工具的垃圾回收器调用此方法。
B:Class getClass()
获取工具的字节码文件的描述类，后面再讲反射的时候还会在说这个类。
String name = s.getClass().getName();
C:int hashCode()
获取工具的哈希值。实在便是工具的内存地址值十进制表示
D:String toString()
返回工具的字符串表示。
表示格式：
getClass().getName()+\"大众@\"大众+Integer.toHexString(hashCode());
一样平常我们输出工具名的时候，实在底层调用的便是该工具的toString()方法。
这种返回没故意义，以是，我们会重写这个方法，显示类的成员变量信息。
E:boolean equals(Object obj)
用于比较两个工具的地址值是否相同。
我们获取工具后，比较它的地址值意义不大。以是也会对这个方法进行重写。
重写要完成什么功能，是根据需求定的。
(3)==和equals的用法：
A:==怎么用？
可以用于比较基本数据类型，比较的便是基本数据类型的值是否相等。
可以用于比较引用数据类型，比较的是工具的地址值是否相等。
B:equals怎么用？
equals只能用于比较引用数据类型的。
Object供应的equals是用于比较工具地址值是否相同。
自定义类中，如果重写了equals方法，那么便是按照你自己的需求来比较的。
24、package关键字
(1)包：实在便是文件夹。用于区分不同包下相同的类名。
(2)好处：
A：对类文件进行分类管理。
B：给类供应了多层命名空间
aaa.Demo
bbb.Demo
C：写在程序文件的第一行。
D：包也是一种封装形式。
25、import关键字
(1)导入包的关键字
(2)格式：
import 包名;
(3)把稳：
A:一个程序文件中只有一个package，可以有多个import。
B:用来导包中的类，不导入包中的包。
C:常日写import mypack.Demo，明确自己利用的类。
(4)关键字的顺序
类，包，导包这些关键的顺序。
包 – > 到包 – > 类
26、不同润色符可以润色哪些内容
本类中同一个包中 不同包中的子类中 不同包中
privateOK
默认OKOk
protectedOKOkOK
publicOKOkOKOk
类布局方法成员变量成员方法
privateOKOKOK
默认OkOkOkOK
protectedOKOKOk
public OkOkOKOK
staticOKOk
finalOkOKOK
abstractOkOK
一样平常格式：
成员变量：
权限润色符+static/final+数据类型+成员变量名
public static final int NUM = 10;
成员方法：
权限润色符+static/final/abstract+返回类型+方法名
27、内部类(次重点)
(1)把一个类定义在某个类中的，这个类就被称为内部类，内置类，嵌套类。
(2)访问特点：
A:内部类可以直接访问外部类中的成员，由于内部类持有外部类的引用，
格式为：外部类名.this
B:外部类要想访问内部类的成员，必须创建工具访问。
(3)内部类的访问格式：
A:当内部类定义在外部类的成员位置，而且非私有，则可以在其他外部类中直接建立内部类工具
格式：外部类名.内部类名 变量名 = new 外部类工具.内部类工具
如：Outer.Inner in = new Outer().new Inner()
B:当内部类在外部类成员位置，且被static润色时
外部其他类可直接访问静态内部类的非静态成员
格式：new 外部类名.内部类名().内部类成员
如：new Outer.Inner().function();
外部其他类可直接访问静态内部类的静态成员
格式：new 外部类名.内部类名.内部类成员
如：new Outer.Inner.function();
(4)什么利用时候内部类呢？
假如有A类和B类，A类想直接访问B类的成员，B类访问A类成员的时候，
须要创建A类工具进行访问，这个时候，就可以把A类定义为B类的内部类。
(5)内部类的位置
A:成员位置
可以被private润色(Body，Heart)
可以被static润色。(它访问的外部类的成员必须是静态的)
B:局部位置
可以直接访问外部类中的成员，由于还持有外部类的持用
也可以直接访问局部成员，但是局部成员要用final润色。
把稳：局部内部类不能用private和static润色
(6)通过class文件我们就可以区分是否带有内部类，以及内部类的位置
Outer$Inner:成员内部类
Outer$1Inner:局部内部类
28、匿名内部类(局部内部类的简写) (重点)
(1)条件：继续一个类或者实现一个接口
(把稳不要弄混匿名内部类的条件和多态的条件)
(2)格式：
new 父类名或者接口名()
{
重写父类方法或者实现接口中的方法。
也可以自定义其他方法。
};
(3)什么时候定义匿名内部类？
匿名内部类只是为了简化书写，匿名内部类有局限，常日定义匿名内部类时，该类方法不超过3个
(4)匿名内部类的好处和弊端：
好处：简化代码书写
弊端：
不能直接调用自己的特有方法
不能实行强转换动作
如果该类里面方法较多，不许可利用匿名内部类
29、模板设计模式：
在定义功能时，功能的一部分是确定的，有一部分是不愿定的，而且确定的部分在利用不愿定的部分，
可将不愿定的部分暴露出去，由该类的子类去完成。
如：求一段程序的运行韶光例子。
30、非常
(1)程序运行过程中的不正常征象就叫非常。
(2)导致程序运行不正常的征象有很多，以是，就有很多的非常工具。
而这些非常工具存在着共性的内容，以是，可以不断的进行抽取。终极形成了非常的体系构造。
非常体系的根类是:Throwable
Throwable：
|–Error:重大的问题，我们处理不了。也不须要编写代码处理。比如说内存溢出。
|–Exception:一样平常性的缺点，是须要我们编写代码进行处理的。
|–RuntimeException:运行时非常，这个我们也不须要处理。
实在便是为了让他在运行时出问题，然后我们回来修正代码。
(3)非常的分类
非常有两种：
编译时被检测非常：
该非常在编译时，如果没有处理(没有抛也没有try)，编译失落败。
该非常被标识，代表这可以被处理。
运行时非常(编译时不检测)
在编译时，不须要处理，编译器不检讨。
该非常的发生，建议不处理，让程序停滞。须要对代码进行改动。
(4)非常体系的特点：
非常体系中的所有类及其子类工具都具备可抛性。也便是说可以被throw和throws关键字所操作。
(5)main方法是如何处理非常的。
A:在main里面编写代码进行处理
B:交给jvm自己进行处理。采取的是jvm的默认处理办法。
实在便是相称于调用了非常工具的printStackTrace()方法。
(6)Throwable类的学习
getMessage():获取非常信息，返回字符串。
toString():获取非常类名和非常信息，返回字符串。
printStackTrace():获取非常类名和非常信息，以及非常涌如今程序中的位置。返回值void。
(7)非常的处理·
A:try…catch…finally
基本格式：
复制代码
try
{
可能涌现非常的代码
}
catch(非常工具)
{
非常处理代码
}
finally
{
开释资源
}
复制代码
变形格式：
try…catch
try…catch…catch…
try…catch…catch…finally
多个非常同时被捕获的时候，记住一个原则：
先逮小的，再逮大的。
finally:永久被实行，除非退出jvm。System.exit(0);
口试题2个。
：final,finally,finalize差异。
final是终极的意思。它可以用于润色类，成员变量，成员方法。
它润色的类不能被继续，它润色的变量时常量，它润色的方法不能被重写。
finally:是非常处理里面的关键字。
它个中的代码永久被实行。分外情形：在实行它之前jvm退出。System.exit(0);
finalize:是Object类中的一个方法。
它是于垃圾回收器调用的办法。
：如果catch中有return语句， finally里中的代码会实行吗？
是在return前，还是在return后呢？
会，在return前实行finally里面的代码。
(8)Exception和RuntimeException的差异
A:Exception:一样平常性的缺点，是须要我们编写代码进行处理的。
B:RuntimeException:运行时非常，这个我们也不须要处理。
实在便是为了让他在运行时出问题，然后我们回来修正代码。
在用throws抛出一个的时候，如果这个非常是属于RuntimeException的体系的时候，
我们在调用的地方可以不用处理。(RuntimeException和RuntimeException的子类)
在用throws抛出一个的时候，如果这个非常是属于Exception的体系的时候，
我们在调用的地方必须进行处理或者连续抛出。
(9)自定义非常
定义类继续Exception或者RuntimeException
1,为了让该自定义类具备可抛性。
2，让该类具备操作非常的共性方法。
复制代码
class MyExcepiton extends Exception
{
MyExcepiton(){}
MyExcepiton(String message)
{
super(message);
}
}
class MyException extends RuntimeException
{
MyExcepiton(){}
MyExcepiton(String message)
{
super(message);
}
}
复制代码
(10)throws和throw的差异
A：有throws的时候可以没有throw。
有throw的时候，如果throw抛的非常是Exception体系，那么必须有throws在方法上声明。
B：throws用于方法的声明上，其后跟的是非常类名，后面可以跟多个非常类，之间用逗号隔开
throw用于方法体中，其后跟的是一个非常工具名
三、多线程：
1、进程和线程：
进程：正在进行的程序。每一个进程实行都有一个实行顺序，该顺序是一个实行路径，或者叫一个掌握单元。
线程：进程内部的一条实行路径或者一个掌握单元。
两者的差异：
一个进程至少有一个线程
进程在实行过程中拥有独立的内存单元，而多个线程共享内存；
2、jvm多线程的启动是多线程吗？
java的虚拟机jvm启动的是单线程，就有发生内存透露的可能，而我们利用java程序没涌现这样的问题，
也便是jvm启动至少有两个线程，一个实行java程序，一个实行垃圾回收。所以是多线程。
3、多线程的上风：
办理了多部分同时运行的问题，提高效率
4、线程的弊端：
线程太多会导致效率的降落，由于线程的实行依赖的是CPU的来回切换。
5、什么叫多线程：
一个进程中有多个线程，称为多线程。
6、实现多线程的方法：
实现多线程可以通过继续Thread类和实现Runnable接口。
(1)继续Thread
定义一个类继续Thread类
复写Thread类中的public void run()方法，将线程的任务代码封装到run方法中
直接创建Thread的子类工具，创建线程
调用start()方法，开启线程(调用线程的任务run方法)
//其余可以通过Thread的getName()获取线程的名称。
(2)实现Runnable接口；
定义一个类，实现Runnable接口；
覆盖接口的public void run()的方法，将线程的任务代码封装到run方法中；
创建Runnable接口的子类工具
将Runnabl接口的子类工具作为参数通报给Thread类的布局函数，创建Thread类工具
（缘故原由：线程的任务都封装在Runnable接口子类工具的run方法中。
以是要在线程工具创建时就必须明确要运行的任务）。
调用start()方法，启动线程。
两种方法差异：
(1)实现Runnable接口避免了单继续的局限性
(2)继续Thread类线程代码存放在Thread子类的run方法中
实现Runnable接口线程代码存放在接口的子类的run方法中；
在定义线程时，建议利用实现Runnable接口，由于险些所有多线程都可以利用这种办法实现
7、创建线程是为什么要复写run方法？
Thread类用于描述线程。Thread类定义了一个功能，用于存储线程要运行的代码，该存储功能便是run方法。
7、start()和run方法有什么差异？
调用start方法方可启动线程，而run方法只是thread的一个普通方法，调用run方法不能实现多线程；
Start()方法:
start方法用来启动线程,实现了多线程运行,这时无需等待run方法体代码实行完毕而直接连续实行下面的代码。通过调用Thread类的start()方法来启动一个线程,这时此线程处于就绪(可运行)状态，并没有运行，
一旦得到cpu韶光片(实行权),就开始实行run()方法,这里方法run()称为线程体，它包含了要实行的这个线程的内容，Run方法运行结束,此线程随即终止。
Run()方法:
run()方法只是Thread类的一个普通方法,如果直接调用Run方法,程序中依然只有主线程这一个线程,其程序实行路径还是只有一条，还是要等待run方法体实行完毕后才可连续实行下面的代码，
这样就没有达到多线程的目的。
8、线程的几种状态：
新建：new一个Thread工具或者其子类工具便是创建一个线程，当一个线程工具被创建，但是没有开启，这个时候，
只是工具线程工具开辟了内存空间和初始化数据。
就绪：新建的工具调用start方法，就开启了线程，线程就到了就绪状态。
在这个状态的线程工具，具有实行资格，没有实行权。
运行：当线程工具获取到了CPU的资源。
在这个状态的线程工具，既有实行资格，也有实行权。
冻结：运行过程中的线程由于某些缘故原由(比如wait,sleep)，开释了实行资格和实行权。
当然，他们可以回到运行状态。只不过，不是直接回到。
而是先回到就绪状态。
去世亡：当线程工具调用的run方法结束，或者直接调用stop方法，就让线程工具去世亡，在内存中变成了垃圾。
9、sleep()和wait()的差异：
(1)这两个方法来自不同的类，sleep()来自Thread类，和wait()来自Object类。
(2)sleep是Thread的静态类方法，谁调用的谁去睡觉，纵然在a线程里调用了b的sleep方法，实际上还是a去睡觉，要让b线程睡觉要在b的代码中调用sleep。而wait()是Object类的非静态方法
(3)sleep()开释资源不开释锁，而wait()开释资源开释锁；
(4)利用范围：wait,notify和notifyAll只能在同步掌握方法或者同步掌握块里面利用,而sleep可以在任何地方利用
10、多线程安全问题：
(1)缘故原由:当程序的多条语句在操作线程共享数据时(如买票例子中的票便是共享资源)，由于线程的随机性导致一个线程对多条语句，实行了一部分还没实行完，另一个线程打劫到cpu实行权参与进来实行，此时就导致共享数据发生缺点。比如买票例子中打印重票和错票的情形。
(2)办理方法:对多条操作共享数据的语句进行同步，一个线程在实行过程中其他线程不可以参与进来
11、Java中多线程同步是什么？
同步是用来办理多线程的安全问题的，在多线程中，同步能掌握对共享数据的访问。如果没有同步，当一个线程在修正一个共享数据时，而其余一个线程正在利用或者更新同一个共享数据，这样随意马虎导致程序涌现缺点的结果。
12、什么是锁?锁的浸染是什么?
锁便是工具
锁的浸染是担保线程同步，办理线程安全问题。
持有锁的线程可以在同步中实行，没有锁的线程纵然得到cpu实行权，也进不去。
13、同步的条件:
(1)必须担保有两个以上线程
(2)必须是多个线程利用同一个锁，即多条语句在操作线程共享数据
(3)必须担保同步中只有一个线程在运行
14、同步的好处和弊端
好处：同步办理了多线程的安全问题
弊端：多线程都须要判断锁，比较花费资源
15、同步的两种表现形式：
(1)同步代码块:
可以指定须要获取哪个工具的同步锁,利用synchronized的代码块同样须要锁,但他的锁可以是任意工具
考虑到安全问题，一样平常还是利用同一个工具，相对来说效率较高。
把稳：
虽然同步代码快的锁可以使任何工具，但是在进行多线程通信利用同步代码快时，
必须担保同步代码快的锁的工具和，否则会报错。
同步函数的锁是this，也要担保同步函数的锁的工具和调用wait、notify和notifyAll的工具是
同一个工具，也便是都是this锁代表的工具。
格式：
synchronized(工具)
{
需同步的代码;
}
(2)同步函数
同步方法是指进入该方法时须要获取this工具的同步锁，在方法上利用synchronized关键字，
利用this工具作为锁，也便是利用了当前工具，由于锁住了方法，以是相对付代码块来说效率相对较低。
注:静态同步函数的锁是该方法所在的类的字节码文件工具，即类名.class文件
格式：
润色词 synchronized 返回值类型 函数名(参数列表)
{
需同步的代码;
}
在jdk1.5后，用lock锁取代了synchronized，个人理解也便是对同步代码块做了修正，
并没有供应对同步方法的修正，紧张还是效率问题吧。
16、多线程的单例设计模式：担保某个类中内存中只有一个工具
(1)饿汉式:
1 class Single
2 {
3 private Single(){}//将布局函数私有化，不让别的类建立该类工具
4 private static final Single s=new Single();//自己建立一个工具
5 public static Single getInstance()//供应一个公共访问办法
6 {
7 return s;
8 }
9 }
10 (2)
11 class Single
12 {
13 private Single(){}
14 private static Single s;
15 public static Single getInstance()
16 {
17 if(s==null)
18 s=new Single();
19 return s;
20 }
21 }
饿汉式和
饿汉式是类一加载进内存就创建好了工具；
可以加同步来办理。但是加了同步之后，每一次都要比较锁，效率就变慢了，
以是可以加双重判断来提高程序效率。
如将上述
public static Single getInstance()
{
if(snull)
{
synchronized(Single.class)
{
if(snull)
s=new Single();
}
}
return s;
}
17、去世锁
两个线程对两个同步工具具有循环依赖时，就会发生去世锁。即同步嵌套同步，而锁却不同。
18、wait()、sleep()、notify()、notifyAll()
wait():使一个线程处于等待状态，并且开释所持有的工具的lock。
sleep():使一个正在运行的线程处于就寝状态，是一个静态方法，调用此方法要捕捉InterruptedException非常。
notify():唤醒一个处于等待状态的线程，把稳的是在调用此方法的时候，并不能确切的唤醒某一个等待状态的线程，
而是由JVM确定唤醒哪个线程(一样平常是最先开始等待的线程)，而且不是按优先级。
Allnotity():唤醒所有处入等待状态的线程，把稳并不是给所有唤醒线程一个工具的锁，而是让它们竞争。
18、为什么wait()、notify()、notifyAll()这些用来操作线程的方法定义在Object类中？
(1)这些方法只存在于同步中；
(2)利用这些方法时必须要指定所属的锁，即被哪个锁调用这些方法；
(3)而锁可以是任意工具，以是任意工具调用的方法就定义在Object中。
19、多线程间通讯：
多线程间通讯便是多个线程在操作同一资源,但是操作的动作不同.
(1)为什么要通信
多线程并发实行的时候, 如果须要指定线程等待或者唤醒指定线程, 那么就须要通信.比如生产者消费者的问题，生产一个消费一个,生产的时候须要卖力消费的进程等待,生产一个后完成后须要唤醒卖力消费的线程,同时让自己处于等待，消费的时候卖力消费的线程被唤醒，消费完生产的产品后又将等待的生产线程唤醒，然后使自己线程处于等待。这样来回通信，以达到生产一个消费一个的目的。
(2)怎么通信
在同步代码块中, 利用锁工具的wait()方法可以让当前哨程等待, 直到有其他线程唤醒为止.
利用锁工具的notify()方法可以唤醒一个等待的线程，或者notifyAll唤醒所有等待的线程.
多线程间通信用sleep很难实现，就寝韶光很难把握。
20、Lock和Condition
实现供应比synchronized方法和语句可得到的更广泛的锁的操作，可支持多个干系的Condition工具
Lock是个接口
锁是掌握多个线程对共享数据进行访问的工具。
JDK1.5中供应了多线程升级的办理方案：
将同步synchonized更换成了显示的Lock操作，将Object中的wait、notify、notifyAll更换成了Condition工具。
该工具可以Lock锁进行获取
Lock的方法择要：
void lock() 获取锁。
Condition newCondition() 返回绑定到此 Lock 实例的新 Condition 实例。
void unlock() 开释锁。
Condition方法择要：
void await() 造成当前哨程在接到旗子暗记或被中断之前一贯处于等待状态。
void signal() 唤醒一个等待线程。
void signalAll() 唤醒所有等待线程。
21、停滞线程：
stop方法已经由时，如何停滞线程？
停滞线程的方法只有一种，便是run方法结束。如何让run方法结束呢？
开启多线程运行，运行代码常日是循环体，只要掌握住循环，就可以让run方法结束，也便是结束线程。
分外情形：当线程属于冻结状态，就不会读取循环掌握标记，则线程就不会结束。
为办理该分外情形，可引入Thread类中的Interrupt方法结束线程的冻结状态；
当没有指定的办法让冻结线程规复到运行状态时，须要对冻结进行打消，逼迫让线程规复到运行状态
22、interrupt:
void interrupt() 中断线程:
中断状态将被打消，它还将收到一个 InterruptedException
22、守护线程(后台线程)
setDaemon(boolean on):将该线程标记为守护线程或者用户线程。
当主线程结束，守护线程自动结束，比如圣斗士星矢里面的守护雅典娜，
在多线程里面主线程便是雅典娜，守护线程便是圣斗士，主线程结束了，
守护线程则自动结束。
当正在运行的线程都是守护线程时，java虚拟机jvm退出；以是该方法必须在启动线程前调用；
守护线程的特点：
守护线程开启后和前台线程共同打劫cpu的实行权，开启、运行两者都没差异，
但结束时有差异，当所有前台线程都结束后，守护线程会自动结束。
23、多线程join方法：
void join() 等待该线程终止。
void join(long millis) 等待该线程终止的韶光最长为 millis 毫秒。
throws InterruptedException
特点：当A线程实行到B线程的join方法时，A就会等待B线程都实行完，A才会实行
浸染: join可以用来临时加入线程实行；
24、多线程优先级：yield()方法
yield():暂停当前正在实行的线程工具，并实行其他线程
setPriority(int newPriority):变动线程优先级
int getPriority() 返回线程的优先级。
String toString() 返回该线程的字符串表示形式，包括线程名称、优先级和线程组
(1)MAX_PRIORITY:最高优先级(10级)
(1)Min_PRIORITY:最低优先级(1级)
(1)Morm_PRIORITY:默认优先级(5级)
25、什么是ThreadLocal类,怎么利用它？
ThreadLocal类供应了线程局部 (thread-local) 变量。是一个线程级别的局部变量，并非“本地线程”。
ThreadLocal 为每个利用该变量的线程,供应了一个独立的变量副本，每个线程修正副本时不影响其它线程工具的副本
下面是线程局部变量(ThreadLocal variables)的关键点：
一个线程局部变量(ThreadLocal variables)为每个线程方便地供应了一个单独的变量。
ThreadLocal 实例常日作为静态的私有的(private static)字段涌如今一个类中，这个类用来关联一个线程。
当多个线程访问 ThreadLocal 实例时，每个线程掩护 ThreadLocal 供应的独立的变量副本。
常用的利用可在 DAO 模式中见到，当 DAO 类作为一个单例类时，
数据库链接(connection)被每一个线程独立的掩护，互不影响。(基于线程的单例)
26、什么时候抛出InvalidMonitorStateException非常?为什么？
调用 wait ()/notify ()/notifyAll ()中的任何一个方法时，如果当前哨程没有得到该工具的锁，
那么就会抛出 IllegalMonitorStateException 的非常
也便是说程序在没有实行工具的任何同步块或者同步方法时，
仍旧考试测验调用 wait ()/notify ()/notifyAll ()时。由于该非常是 RuntimeExcpetion 的子类，
以是该非常不一定要捕获(只管你可以捕获只要你乐意
作为 RuntimeException，此类非常不会在 wait (),notify (),notifyAll ()的方法署名提及。
27、在静态方法上利用同步时会发生什么事？
同步静态方法时会获取该类的“Class”工具，以是当一个线程进入同步的静态方法中时，
线程监视器获取类本身的工具锁，其它线程不能进入这个类的任何静态同步方法。
它不像实例方法，由于多个线程可以同时访问不同实例同步实例方法。
28、当一个同步方法已经实行，线程能够调用工具上的非同步实例方法吗？
可以，一个非同步方法总是可以被调用而不会有任何问题。
实际上，Java 没有为非同步方法做任何检讨，锁工具仅仅在同步方法或者同步代码块中检讨。
如果一个方法没有声明为同步，纵然你在利用共享数据Java还是会调用，而不会做检讨是否安全，
以是在这种情形下要特殊小心。一个方法是否声明为同步取决于临界区访问(critial section access)，
如果方法不访问临界区(共享资源或者数据构造)就没必要声明为同步的。
29、在一个工具上两个线程可以调用两个不同的同步实例方法吗？
不能，由于一个工具已经同步了实例方法，线程获取了工具的工具锁。
以是只有实行完该方法开释工具锁后才能实行其它同步方法。
30、什么是线程饿去世，什么是活锁？
线程饿去世和活锁虽然不像去世锁一样是常见的问题，但是对付并发编程的设计者来说就像一次重逢一样。
当所有线程壅塞，或者由于须要的资源无效而不能处理，不存在非壅塞线程使资源可用。
JavaAPI 中线程活锁可能发生在以下环境：
当所有线程在程序中实行 Object.wait (0)，参数为 0 的 wait 方法。
程序将发生活锁直到在相应的工具上有线程调用 Object.notify ()或者 Object.notifyAll ()。
当所有线程卡在无限循环中。
