一、八大基本数据类型

类型  大小  封装类

byte  1字节 Byte

boolean 1字节 Boolean

char    2字节  Character

short  2字节 Short

int      4字节  Integer

float  4字节  Float

long  8字节  Long

double 8字节 Double

转换关系

基本类型转换为字符串有三种方法：

1.使用包装类的toString()方法

2.使用String类的valueOf()方法

3.用一个空字符串加上基本类型，得到的就是基本类型数据对应的字符串

字符串转换成基本类型有两种方法：

1.调用包装类的paraseXxx静态方法

int d=Integer.praseInt(str);

2.调用包装类的valueOf()方法转换成基本类型的包装类，就会自动拆箱

int e=Integer.valueOf(str); 

二、三大特性

继承：子类获得父类方法和属性的行为，可以根据自身需求扩展出新的属性和行为，提高了代码的复用性。

ps.当子父类中出现相同方法时，会先运行子类中的方法。

重写的特点：方法名一样，访问修饰符权限不小于父类（jdk1.8开始默认default），返回类型一致，参数列表一致。

封装：将客观事物包装成类，隐藏内部实现，对外界提供操作接口，Java中一般用private修饰，提供set和get方法。

多态：同一操作对不同对象产生不同的结果，简单来说就是用父类的引用指向子类的对象

ps.重载：编译时多态

    重写：运行时多态

三、面向过程和面向对象

面向过程

优点：性能比面向对象高，因为类调用时需要实例化，开销比较大，比较消耗资源；如单片机、嵌入式开发、Linux/Unix等一般采用面向过程开发，性能是最重要的因素。

缺点：没有面向对象易维护、易复用、易扩展

面向对象

优点：易维护、易复用、易扩展，由于面向对象有封装、继承、多态的特性，可以设计出低耦合的系统，使系统更加灵活、更加易于维护

缺点：性能比面向过程低

四、Java反射机制

      在运行状态中，对于任意一个类，都能够知道其所有属性和方法；对于任意一个对象，都能够调用其任意方法和属性。这种动态获取信息及动态调用对象方法的功能称为Java语言的反射机制。

获取Class对象的三种方式

1. 调用某个对象的getClass()方法

Class clazz = person.getClass();

2. 调用某个类的class属性

Class clazz = Person.class;

3. 使用Class类的forName()静态方法

Class clazz = Class.forName("Person");

通过反射创建对象

方法1：通过类对象调用newInstance()方法，例如：String.class.newInstance()

方法2：通过类对象的getConstructor()或getDeclaredConstructor()方法获得构造器（Constructor）对象并调用其newInstance()方法创建对象，例如：String.class.getConstructor(String.class).newInstance("Hello");

反射机制主要提供了以下功能：

1.在运行时判断任意一个对象所属的类。

2.在运行时构造任意一个类的对象。

3.在运行时判断任意一个类所具有的成员变量和方法。

4.在运行时调用任意一个对象的方法。

5.生成动态代理。

五、Java异常机制

错误异常类分为Error和Exception，都继承自父类Throwable

error

      表示程序在运行过程中出现的严重错误，是jvm层次出现的错误，大多是逻辑错误，属于编译器不会捕捉的异常，异常发生时jvm会选择终止程序。

exception

      表示可恢复异常，是编译器可以捕获到的异常，分为检查时异常（checked exception）和运行时异常（runtime exception）

检查时异常：sql  IO等，必须被 try{}catch语句块所捕获,或者在方法签名里通过throws子句声明。

运行时异常：NullPointer classcast  ArrayIndexOutOfBounds  被0除 等，需要程序员自己分析代码决定是否捕获和处理。

其他

1.finally中的return会覆盖try catch中的return

2.try或catch中的return值存在局部变量表中，当执行完finally后返回局部变量表中的值

3.finally不运行的情况：

（1）在进入try之前就出现异常

（2）在try中强制退出,如 System.exit(0);

（3）关闭CPU

六、object类的方法

1、Object()默认构造方法。

2、clone() 创建并返回此对象的一个副本。

3、equals(Object obj) 指示某个其他对象是否与此对象“相等”。

4、finalize()当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。

5、getClass()返回一个对象的运行时类。

6、hashCode()返回该对象的哈希码值。

7、notify()唤醒在此对象监视器上等待的单个线程。

8、notifyAll()唤醒在此对象监视器上等待的所有线程。

9、toString()返回该对象的字符串表示。

10、wait()导致当前的线程等待，直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法。

wait(long timeout)导致当前的线程等待，直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法，或者超过指定的时间量。

wait(long timeout, int nanos) 导致当前的线程等待，直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法，或者其他某个线程中断当前线程，或者已超过某个实际时间量。

七、获取用键盘输入常用的的两种方法

方法1：通过 Scanner

Scanner input=new Scanner(System.in);

String s=input.nextLine();

input.close();

方法2：通过 BufferedReader

BufferedReader input=new BufferedReader(new InputStreamReader(System.in));

String s=input.readLine();

九、final关键字

主要用在三个地方：变量、方法、类。

1、对于一个final变量，如果是基本数据类型的变量，则其数值一旦在初始化之后便不能更改；如果是引用类型的变量，则在对其初始化之后便不能再让其指向另一个对象。

2、当用final修饰一个类时，表明这个类不能被继承。final类中的所有成员方法都会被隐式地指定为final方法。

3、使用final方法的原因有两个。第一个原因是把方法锁定，以防任何继承类修改它的含义；第二个原因是效率。在早期的Java实现版本中，会将final方法转为内嵌调用。但是如果方法过于庞大，可能看不到内嵌调用带来的任何性能提升（现在的Java版本已经不需要使用final方法进行这些优化了）。类中所有的private方法都隐式地指定为final。

对比

一、重写和重载

重载：

1、让类以统一的方式处理不同数据类型的一种手段

2、Java的重载就是在类中创建多个同名方法，具有不同的参数，根据传入参数选择调用哪一个方法，这就是多态性

3、重载的时候，参数名或类型不同，返回类型可同可不同

重写：

1、如果子类的方法与父类有相同的名字和参数，我们就称该方法被重写

2、子类方法会覆盖父类的方法，可以用super调用父类方法

3、子类重写方法的修饰权限不能小于父类

二、抽象类和接口

三、线程,程序,进程

        线程与进程相似，但线程是一个比进程更小的执行单位。一个进程在其执行的过程中可以产生多个线程。与进程不同的是同类的多个线程共享同一块内存空间和一组系统资源，所以系统在产生一个线程，或是在各个线程之间作切换工作时，负担要比进程小得多，也正因为如此，线程也被称为轻量级进程。

      程序是含有指令和数据的文件，被存储在磁盘或其他的数据存储设备中，也就是说程序是静态的代码。

        进程是程序的一次执行过程，是系统运行程序的基本单位，因此进程是动态的。系统运行一个程序即是一个进程从创建，运行到消亡的过程。简单来说，一个进程就是一个执行中的程序，它在计算机中一个指令接着一个指令地执行着，同时，每个进程还占有某些系统资源如CPU时间，内存空间，文件，文件，输入输出设备的使用权等等。换句话说，当程序在执行时，将会被操作系统载入内存中。 线程是进程划分成的更小的运行单位。线程和进程最大的不同在于基本上各进程是独立的，而各线程则不一定，因为同一进程中的线程极有可能会相互影响。从另一角度来说，进程属于操作系统的范畴，主要是同一段时间内，可以同时执行一个以上的程序，而线程则是在同一程序内几乎同时执行一个以上的程序段。

四、equals()与==的区别

== : 判断两个对象的地址是不是相等。即判断两个对象是不是同一个对象。(基本数据类型==比较的是值，引用数据类型==比较的是内存地址)

equals() : 判断两个对象是否相等。但它一般有两种使用情况：

情况1：类没有重写 equals() 方法。则通过 equals() 比较该类的两个对象时，等价于通过“==”比较这两个对象。

情况2：String类重写了equals()方法，它首先判断的是两个对象的引用是否指向同一内存地址，是的话就返回true ,否则继续往下走，比较字符串的内容，相等的时候就返回true ,否则返回false。

五、String、StringBuffer、StringBuilder

六、成员变量与局部变量

从语法形式上：成员变量是属于类或实例对象的，而局部变量是在方法中定义的变量或是方法的参数；成员变量可以被 public,private,static 等修饰符所修饰，而局部变量不能被访问控制修饰符及 static 所修饰；但是，成员变量和局部变量都能被 final 所修饰；

从变量在内存中的存储方式来看:如果成员变量是使用static修饰的，那么这个成员变量是属于类的，如果没有使用使用static修饰，这个成员变量是属于实例的。而对象存在于堆内存，局部变量存在于栈内存

从变量在内存中的生存时间上看:非静态的成员变量是对象的一部分，它随着对象的创建而存在，而局部变量随着方法的调用而自动消失。

成员变量如果没有被赋初值:则会自动以类型的默认值而赋值（一种情况例外被 final 修饰的成员变量也必须显示地赋值）；而局部变量则不会自动赋值。

七、hashCode 与 equals

hashCode（）介绍

hashCode() 的作用是获取哈希码，也称为散列码；它实际上是返回一个int整数。这个哈希码的作用是确定该对象在哈希表中的索引位置。hashCode() 定义在JDK的Object.java中，这就意味着Java中的任何类都包含有hashCode() 函数。

散列表存储的是键值对(key-value)，它的特点是：能根据“键”快速的检索出对应的“值”。这其中就利用到了散列码！（可以快速找到所需要的对象）

为什么要有 hashCode

我们以“HashSet 如何检查重复”为例子来说明为什么要有 hashCode：

当你把对象加入 HashSet 时，HashSet 会先计算对象的 hashcode 值来判断对象加入的位置，同时也会与其他已经加入的对象的 hashcode 值作比较，如果没有相符的hashcode，HashSet会假设对象没有重复出现。但是如果发现有相同 hashcode 值的对象，这时会调用 equals（）方法来检查 hashcode 相等的对象是否真的相同。如果两者相同，HashSet 就不会让其加入操作成功。如果不同的话，就会重新散列到其他位置。这样我们就大大减少了 equals 的次数，相应就大大提高了执行速度。

hashCode（）与equals（）的相关规定

1.如果两个对象相同，则hashcode一定也是相同的

2.两个对象相同,对两个对象分别调用equals方法都返回true

3.两个对象有相同的hashcode值，它们也不一定是相同的，如

String a=“abc”;

String b =new String("abc");

这里a和b的hashcode是相等的，因为String重写了hashcode()方法，比较的是引用指向的内容

4.因此，equals 方法被覆盖过，则 hashCode 方法也必须被覆盖

5.hashCode() 的默认行为是对堆上的对象产生独特值。如果没有重写 hashCode()，则该 class 的两个对象无论如何都不会相等（即使这两个对象指向相同的数据）

equals()的重写

      String 、Math、还有Integer、Double等封装类重写了Object中的equals()方法，让它不再比较其对象在内存中的地址，而是比较引用指向对象的值，即比较的是内容。由于Object的equals()方法比较的是地址值，所以Object equals相等时，其hashcode必然相等，因为都是对象的地址，所以自己定义的类如果要加入到集合类中一定要记得重写这两个方法。

代码执行顺序

静态成员变量或静态代码块>main方法>非静态成员变量或非静态代码块>构造方法

问题

1.在一个静态方法内调用一个非静态成员为什么是非法的

      静态方法属于类，在类加载的过程中就已经初始化，先于实例创建，而非静态变量是属于实例对象的，自然无法调用。

2.在调用子类构造方法之前会先调用父类没有参数的构造方法,其目的是?

帮助子类做初始化工作

3.构造器 Constructor 是否可被 override

      在讲继承的时候我们就知道父类的私有属性和构造方法并不能被继承，所以 Constructor 也就不能被 override（重写）,但是可以 overload（重载）,所以你可以看到一个类中有多个构造函数的情况。

4、构造方法有哪些特性

名字与类名相同；

没有返回值，但不能用void声明构造函数；

生成类的对象时自动执行，无需调用。

5、在 Java 中定义一个不做事且无参数的构造方法的作用

      Java 程序在执行子类的构造方法之前，如果没有用 super() 来调用父类特定的构造方法，则会调用父类中“没有参数的构造方法”。因此，如果父类中只定义了有参数的构造方法，而在子类的构造方法中又没有用 super() 来调用父类中特定的构造方法，则编译时将发生错误，因为 Java 程序在父类中找不到没有参数的构造方法可供执行。解决办法是在父类里加上一个不做事且没有参数的构造方法。

6、内部类可以引用它的包含类的成员吗

      完全可以。如果不是静态内部类，那没有什么限制！ 一个内部类对象可以访问创建它的外部类对象的成员包括私有成员。

　　如果你把静态嵌套类当作内部类的一种特例，那在这种情况下不可以访问外部类的普通成员变量，而只能访问外部类中的静态成员。

7、接口和抽象类的区别

接口中所有的方法隐含的都是抽象的。而抽象类则可以同时包含抽象和非抽象的方法。

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

类可以不实现抽象类和接口声明的所有方法，当然，在这种情况下，类也必须得声明成是抽象的。

8、wait方法的底层原理

wait方法会将当前线程放入wait set，等待被唤醒，并放弃lock对象上的所有同步声明。

1、将当前线程封装成ObjectWaiter对象node；

2、通过ObjectMonitor::AddWaiter方法将node添加到_WaitSet列表中；

3、通过ObjectMonitor::exit方法释放当前的ObjectMonitor对象，这样其它竞争线程就可以获取该ObjectMonitor对象。

4、最终底层的park方法会挂起线程；

（最后与之对应的notify方法）会随机唤醒_WaitSet中随机一个线程