Java预备知识
1.面向对象和面向过程的区别
面向过程：面向过程性能比面向对象高。因为类调用时需要实例化，开销比较大，比较消耗资源，所以当性能是最重要的考量因素的时候，比如单片机、嵌入式开发、Linux/Unix等一般采用面向过程开发。但是，面向过程没有面向对象易维护、易复用、易扩展。
面向对象：面向对象易维护、易复用、易扩展。因为面向对象有封装、继承、多态性的特性，所以可以设计出低耦合的系统，使系统更加灵活、更加易于维护。但是，面向对象性能比面向过程低。
2.Java语言有哪些特点?
面向对象(封装，继承，多态)；平台无关性(Java虚拟机实现平台无关性)；可靠性；安全性；支持多线程(C++语言没有内置的多线程机制，因此必须调用操作系统的多线程功能来进行多线程程序设计，而Java语言却提供了多线程支持)；编译与解释并存；
3.关于JVM JDK和JRE
Java虚拟机(JVM)是运行Java字节码的虚拟机。JVM有针对不同系统的特定实现(Windows，Linux，macOS)，目的是使用相同的字节码，它们都会给出相同的结果。字节码和不同系统的JVM实现是Java语言“一次编译，随处可以运行”的关键所在。
在Java中，JVM可以理解的代码就叫做字节码(即扩展名为.class的文件)，它不面向任何特定的处理器，只面向虚拟机。Java语言通过字节码的方式，在一定程度上解决了传统解释型语言执行效率低的问题，同时又保留了解释型语言可移植的特点。所以Java程序运行时比较高效，而且，由于字节码并不针对一种特定的机器，因此，Java程序无须重新编译便可在多种不同操作系统的计算机上运行。
JDK和JRE
JDK是Java Development Kit，它是功能齐全的JavaSDK。它拥有JRE所拥有的一切，还有编译器(javac)和工具(如javadoc和jdb)。它能够创建和编译程序。
JRE是Java运行时环境。它是运行已编译Java程序所需的所有内容的集合，包括Java虚拟机(JVM)，Java类库，java命令和其他的一些基础构件。但是，它不能用于创建新程序。
如果你只是为了运行一下Java程序的话，那么你只需要安装JRE就可以了。如果你需要进行一些Java编程方面的工作，那么你就需要安装JDK了。但是，这不是绝对的，有时，即使您不打算在计算机上进行任何Java开发，仍然需要安装JDK。例如，如果要使用JSP部署Web应用程序，那么从技术上讲，您只是在应用程序服务器中运行Java程序。那你为什么需要JDK呢？因为应用程序服务器会将JSP转换为Java servlet，并且需要使用JDK来编译servlet。
4.字符型常量和字符串常量的区别?
形式上:字符常量是单引号引起的一个字符;字符串常量是双引号引起的若干个字符
含义上:字符常量相当于一个整型值(ASCII值),可以参加表达式运算;字符串常量代表一个地址值(该字符串在内存中存放位置)
占内存大小:字符常量只占2个字节;字符串常量占若干个字节(注意：char在Java中占两个字节)
字节：char2；byte1；short2；int4；long8；float4；double8
5.面向对象编程三大特性:封装继承多态
封装：封装把一个对象的属性私有化，同时提供一些可以被外界访问的属性的方法，如果属性不想被外界访问，我们大可不必提供方法给外界访问。但是如果一个类没有提供给外界访问的方法，那么这个类也没有什么意义了。
继承：继承是使用已存在的类的定义作为基础建立新类的技术，新类的定义可以增加新的数据或新的功能，也可以用父类的功能，但不能选择性地继承父类。通过使用继承我们能够非常方便地复用以前的代码。
关于继承如下3点请记住：
(1)子类拥有父类对象所有的属性和方法(包括私有属性和私有方法)，但是父类中的私有属性和方法子类是无法访问，只是拥有。
(2)子类可以拥有自己属性和方法，即子类可以对父类进行扩展。
(3)子类可以用自己的方式实现父类的方法。
多态：所谓多态就是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定，而是在程序运行期间才确定，即一个引用变量到底会指向哪个类的实例对象，该引用变量发出的方法调用到底是哪个类中实现的方法，必须在由程序运行期间才能决定。
在Java中有两种形式可以实现多态：继承(多个子类对同一方法的重写)和接口(实现接口并覆盖接口中同一方法)。
6.简述线程、程序、进程的基本概念。以及他们之间关系是什么?
线程与进程相似，但线程是一个比进程更小的执行单位。一个进程在其执行的过程中可以产生多个线程。与进程不同的是同类的多个线程共享同一块内存空间和一组系统资源，所以系统在产生一个线程，或是在各个线程之间作切换工作时，负担要比进程小得多，也正因为如此，线程也被称为轻量级进程。
程序是含有指令和数据的文件，被存储在磁盘或其他的数据存储设备中，也就是说程序是静态的代码。
进程是程序的一次执行过程，是系统运行程序的基本单位，因此进程是动态的。系统运行一个程序即是一个进程从创建，运行到消亡的过程。简单来说，一个进程就是一个执行中的程序，它在计算机中一个指令接着一个指令地执行着，同时，每个进程还占有某些系统资源如 CPU 时间，内存空间，文件，输入输出设备的使用权等等。换句话说，当程序在执行时，将会被操作系统载入内存中。 线程是进程划分成的更小的运行单位。线程和进程最大的不同在于基本上各进程是独立的，而各线程则不一定，因为同一进程中的线程极有可能会相互影响。从另一角度来说，进程属于操作系统的范畴，主要是同一段时间内，可以同时执行一个以上的程序，而线程则是在同一程序内几乎同时执行一个以上的程序段。
Java基础
1.Comparable和Comparator的区别
https://www.cnblogs.com/szlbm/p/5504634.html
两种比较器Comparable和Comparator，后者相比前者有如下优点：
1、如果实现类没有实现Comparable接口，又想对两个类进行比较（或者实现类实现了Comparable接口，但是对compareTo方法内的比较算法不满意），那么可以实现Comparator接口，自定义一个比较器，写比较算法
2、实现Comparable接口的方式比实现Comparator接口的耦合性要强一些，如果要修改比较算法，要修改Comparable接口的实现类，而实现Comparator的类是在外部进行比较的，不需要对实现类有任何修改。从这个角度说，其实有些不太好，尤其在我们将实现类的.class文件打成一个.jar文件提供给开发者使用的时候。实际上实现Comparator接口的方式后面会写到就是一种典型的策略模式。
2.Java中方法的参数传递机制*
值传递和引用传递的区别并不是传递的内容。而是实参到底有没有被复制一份给形参。并不是传递了地址就是引用传递，是否是引用传递是看是否有复制一份值，然后把复制的传个形参。
Java程序设计语言总是采用按值调用。也就是说，方法得到的是所有参数值的一个拷贝，也就是说，方法不能修改传递给它的任何参数变量的内容。
Java 编程语言只有值传递参数。当一个对象实例作为一个参数被传递到方法中时，参数的值就是该对象的引用一个副本。指向同一个对象,对象的内容可以在被调用的方法中改变，但对象的引用(不是引用的副本)是永远不会改变的。
https://www.nowcoder.com/questionTerminal/b296e9e1c40542ec8677c1e452b6b576
3.Java深拷贝与浅拷贝的区别
浅拷贝：对基本数据类型进行值传递，对引用数据类型进行引用传递般的拷贝，此为浅拷贝。
深拷贝：对基本数据类型进行值传递，对引用数据类型，创建一个新的对象，并复制其内容，此为深拷贝。
4.Java中方法重载与重写的区别(多态体现)*
重载：发生在同一个类中，方法名必须相同，参数类型不同、个数不同、顺序不同，方法返回值和访问修饰符可以不同。
重写：重写是子类对父类的允许访问的方法的实现过程进行重新编写,发生在子类中，方法名、参数列表必须相同，返回值范围小于等于父类，抛出的异常范围小于等于父类，访问修饰符范围大于等于父类。另外，如果父类方法访问修饰符为 private 则子类就不能重写该方法。也就是说方法提供的行为改变，而方法的外貌并没有改变。
5.Java中“==”与equal的区别*
== : 它的作用是判断两个对象的地址是不是相等。即，判断两个对象是不是同一个对象(基本数据类型==比较的是值，引用数据类型==比较的是内存地址)。
equals() : 它的作用也是判断两个对象是否相等。但它一般有两种使用情况：
情况 1：类没有覆盖 equals() 方法。则通过 equals() 比较该类的两个对象时，等价于通过“==”比较这两个对象。
情况 2：类覆盖了 equals() 方法。一般，我们都覆盖 equals() 方法来比较两个对象的内容是否相等；若它们的内容相等，则返回 true (即，认为这两个对象相等)。
值得注意的是，当创建 String 类型的对象时，虚拟机会在常量池中查找有没有已经存在的值和要创建的值相同的对象，如果有就把它直接赋给当前引用。如果没有就在常量池中重新创建一个 String 对象。
6.hashCdoe与equal **
hash函数是根据key计算出应该存储地址的位置，而哈希表是基于哈希函数建立的一种查找表。Java对象的eqauls方法和hashCode方法是这样规定的：
1、相等(相同)的对象必须具有相等的哈希码(或者散列码)。
2、如果两个对象的hashCode相同，它们并不一定相同。
关于第一点，相等(相同)的对象必须具有相等的哈希码(或者散列码)，为什么？
想象一下，假如两个Java对象A和B，A和B相等(eqauls结果为true)，但A和B的哈希码不同，则A和B存入HashMap时的哈希码计算得到的HashMap内部数组位置索引可能不同，那么A和B很有可能允许同时存入HashMap，显然相等/相同的元素是不允许同时存入HashMap，HashMap不允许存放重复元素。
关于第二点，两个对象的hashCode相同，它们并不一定相同
也就是说，不同对象的hashCode可能相同；假如两个Java对象A和B，A和B不相等(eqauls结果为false)，但A和B的哈希码相等，将A和B都存入HashMap时会发生哈希冲突，也就是A和B存放在HashMap内部数组的位置索引相同这时HashMap会在该位置建立一个链接表，将A和B串起来放在该位置，显然，该情况不违反HashMap的使用原则，是允许的。当然，哈希冲突越少越好，尽量采用好的哈希算法以避免哈希冲突。
结论：
1.equal()相等的两个对象他们的hashCode()肯定相等，也就是用equal()对比是绝对可靠的。
2.hashCode()相等的两个对象他们的equal()不一定相等，也就是hashCode()不是绝对可靠的。
所以解决方式是，每当需要对比的时候，首先用hashCode()去对比，如果hashCode()不一样，则表示这两个对象肯定不相等(也就是不必再用equal()去再对比了),如果hashCode()相同，此时再对比他们的equal()，如果equal()也相同，则表示这两个对象是真的相同了，这样既能大大提高了效率也保证了对比的绝对正确性！
哈希码产生的依据：哈希码并不是完全唯一的，它是一种算法，让同一个类的对象按照自己不同的特征尽量的有不同的哈希码，但不表示不同的对象哈希码完全不同。也有相同的情况，看程序员如何写哈希码的算法。
7.Object类有哪些方法？
9个：
1、toString方法-----public String toString()
返回该对象的字符串表示。
2、getClass方法----public final native Class<?> getClass()
获得运行时类型。
3、equals方法----public boolean equals(Object obj)
一般 "equals" 和 "==" 是不一样的，但是在Object中两者是一样的。子类一般都要重写这个方法，用于确认两个对象是否相同。
4、hashCode方法----public native int hashCode();
返回该对象的哈希码值，该方法用于哈希查找，重写了equals方法一般都要重写hashCode方法。
①两个obj，如果equals()相等，hashCode()一定相等
②两个obj，如果hashCode()相等，equals()不一定相等
为了比较两个对象时更高效，可以考虑在Java集合中，判断两个对象是否相等的规则是：第一步，如果hashCode()相等，则查看第二步，否则不相等;
第二步，查看equals()是否相等，如果相等，则两obj相等，否则还是不相等。
为什么这样做？个人的理解是让适当的函数完成适当的功能，毕竟hashCode()比equals()在某种程度上来得快。
5、clone方法----protected native Object clone() throws CloneNotSupportedException;
创建并返回此对象的一个副本，实现对象的浅复制，只有实现了Cloneable接口才可以调用该方法，否则抛出CloneNotSupportedException异常。
6、wait方法
① public final native void wait(long timeout) throws InterruptedException
② public final void wait(long timeout, int nanos) throws InterruptedException
③ public final void wait() throws InterruptedException
在使用的时候要求在synchronize语句中使用，wait方法用于让当前线程失去操作权限，当前线程进入等待序列
wait方法就是使当前线程等待该对象的锁，当前线程必须是该对象的拥有者，也就是具有该对象的锁。wait()方法一直等待，直到获得锁或者被中断；wait(long timeout)设定一个超时间隔，如果在规定时间内没有获得锁就返回；wait(long timeout,nanos)与wait(long timeout)类似，用毫微秒度量的实际时间量可以通过以下公式计算：1000000*timeout+nanos。
调用该方法后当前线程进入睡眠状态，直到以下事件发生。
（1）其他线程调用了该对象的notify方法。
（2）其他线程调用了该对象的notifyAll方法。
（3）其他线程调用了interrupt中断该线程。
（4）时间间隔到了。
此时该线程就可以被调度了，如果是被中断的话就抛出一个InterruptedException异常。
7、notify方法----public final native void notify()
该方法唤醒在该对象上等待的某个线程
8、notifyAll方法----public final native void notifyAll()
该方法唤醒在该对象上等待的所有线程。
9、finalize方法----protected void finalize() throws Throwable
这个函数在进行垃圾回收的时候会用到。
8.static关键字的作用是什么*
9.抽象类和接口的区别*
接口的方法默认是public，所有方法在接口中不能有实现(Java8开始接口方法可以有默认实现)，而抽象类可以有非抽象的方法。
接口中除了static、final变量，不能有其他变量，而抽象类中则不一定。
一个类可以实现多个接口，但只能实现一个抽象类。接口自己本身可以通过extends关键字扩展多个接口。
接口方法默认修饰符是public，抽象方法可以有public、protected和default这些修饰符(抽象方法就是为了被重写所以不能使用private关键字修饰！)。
从设计层面来说，抽象是对类的抽象，是一种模板设计，而接口是对行为的抽象，是一种行为的规范。
备注：在JDK8中，接口也可以定义静态方法，可以直接用接口名调用。实现类和实现是不可以调用的。如果同时实现两个接口，接口中定义了一样的默认方法，则必须重写，不然会报错。
jdk9的接口被允许定义私有方法。
总结一下jdk7~jdk9Java中接口概念的变化(相关阅读)：
在jdk7或更早版本中，接口里面只能有常量变量和抽象方法。这些接口方法必须由选择实现接口的类实现。
jdk8的时候接口可以有默认方法和静态方法功能。
10.HashMap底层实现(推荐看JDK集合源码)**
https://blog.csdn.net/suifeng629/article/details/82179996
11.Java的IO和NIO(结合IO管理)*
按照流的流向分，可以分为输入流和输出流；
按照操作单元划分，可以划分为字节流和字符流；
按照流的角色划分为节点流和处理流。
Javaio流共涉及40多个类，这些类看上去很杂乱，但实际上很有规则，而且彼此之间存在非常紧密的联系，Javaio流的40多个类都是从如下4个抽象类基类中派生出来的：
InputStream/Reader:所有的输入流的基类，前者是字节输入流，后者是字符输入流。
OutputStream/Writer:所有输出流的基类，前者是字节输出流，后者是字符输出流。
BIO,NIO,AIO 有什么区别?
BIO(BlockingI/O):同步阻塞I/O模式，数据的读取写入必须阻塞在一个线程内等待其完成。在活动连接数不是特别高（小于单机1000）的情况下，这种模型是比较不错的，可以让每一个连接专注于自己的I/O并且编程模型简单，也不用过多考虑系统的过载、限流等问题。线程池本身就是一个天然的漏斗，可以缓冲一些系统处理不了的连接或请求。但是，当面对十万甚至百万级连接的时候，传统的BIO模型是无能为力的。因此，我们需要一种更高效的I/O处理模型来应对更高的并发量。
NIO(NewI/O):NIO是一种同步非阻塞的I/O模型，在Java1.4中引入了NIO框架，对应java.nio包，提供了Channel,Selector，Buffer等抽象。NIO中的N可以理解为Non-blocking，不单纯是New。它支持面向缓冲的，基于通道的I/O操作方法。NIO提供了与传统BIO模型中的Socket和ServerSocket相对应的SocketChannel和ServerSocketChannel两种不同的套接字通道实现,两种通道都支持阻塞和非阻塞两种模式。阻塞模式使用就像传统中的支持一样，比较简单，但是性能和可靠性都不好；非阻塞模式正好与之相反。对于低负载、低并发的应用程序，可以使用同步阻塞I/O来提升开发速率和更好的维护性；对于高负载、高并发的（网络）应用，应使用NIO的非阻塞模式来开发
12.String和StingBuilder、StringBuffer的区别 String 为什么是不可变的? **
可变性：简单的来说：String类中使用final关键字修饰字符数组来保存字符串， private final char value[ ]，所以String对象是不可变的。在Java9之后，String类的实现改用byte数组存储字符串private final byte[ ] value;
而StringBuilder与StringBuffer都继承自AbstractStringBuilder类，在AbstractString Builder中也是使用字符数组保存字符串char[ ] value但是没有用final关键字修饰，所以这两种对象都是可变的。
StringBuilder与StringBuffer的构造方法都是调用父类构造方法也就是AbstractStringBuilder实现的，大家可以自行查阅源码。
线程安全性：String中的对象是不可变的，也就可以理解为常量，线程安全。AbstractStringBuilder是StringBuilder与StringBuffer的公共父类，定义了一些字符串的基本操作，如expandCapacity、append、insert、indexOf等公共方法。StringBuffer对方法加了同步锁或者对调用的方法加了同步锁，所以是线程安全的。StringBuilder并没有对方法进行加同步锁，所以是非线程安全的。
性能：每次对String类型进行改变的时候，都会生成一个新的String对象，然后将指针指向新的String对象。StringBuffer每次都会对StringBuffer对象本身进行操作，而不是生成新的对象并改变对象引用。相同情况下使用StringBuilder相比使用StringBuffer仅能获得10%~15%左右的性能提升，但却要冒多线程不安全的风险。
对于三者使用的总结：
操作少量的数据：适用String
单线程操作字符串缓冲区下操作大量数据：适用StringBuilder
多线程操作字符串缓冲区下操作大量数据：适用StringBuffer
13.生产者和消费者模式(与并发编程一起学习)
14.Java反射
JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性；这种动态获取信息以及动态调用对象方法的功能称为java语言的反射机制。
15.final,static,this,super 关键字总结*
https://snailclimb.gitee.io/javaguide/#/docs/java/basic/final,static,this,super
final关键字主要用在三个地方：变量、方法、类。
对于一个final变量，如果是基本数据类型的变量，则其数值一旦在初始化之后便不能更改；如果是引用类型的变量，则在对其初始化之后便不能再让其指向另一个对象。
当用final修饰一个类时，表明这个类不能被继承。final类中的所有成员方法都会被隐式地指定为final方法。
使用final方法的原因有两个。第一个原因是把方法锁定，以防任何继承类修改它的含义；第二个原因是效率。在早期的Java实现版本中，会将final方法转为内嵌调用。但是如果方法过于庞大，可能看不到内嵌调用带来的任何性能提升(现在的Java版本已经不需要使用final方法进行这些优化了)。类中所有的private方法都隐式地指定为final。
static关键字主要有以下四种使用场景：
修饰成员变量和成员方法:被static修饰的成员属于类，不属于单个这个类的某个对象，被类中所有对象共享，可以并且建议通过类名调用。被static声明的成员变量属于静态成员变量，静态变量存放在Java内存区域的方法区。调用格式：类名.静态变量名类名.静态方法名()。
静态代码块:静态代码块定义在类中方法外,静态代码块在非静态代码块之前执行(静态代码块—>非静态代码块—>构造方法)。该类不管创建多少对象，静态代码块只执行一次.
静态内部类(static修饰类的话只能修饰内部类)：静态内部类与非静态内部类之间存在一个最大的区别:非静态内部类在编译完成之后会隐含地保存着一个引用，该引用是指向创建它的外围类，但是静态内部类却没有。没有这个引用就意味着：1.它的创建是不需要依赖外围类的创建。2.它不能使用任何外围类的非static成员变量和方法。
静态导包(用来导入类中的静态资源，1.5之后的新特性):格式为：import static这两个关键字连用可以指定导入某个类中的指定静态资源，并且不需要使用类名调用类中静态成员，可以直接使用类中静态成员变量和成员方法。
this关键字用于引用类的当前实例。 例如：
class Manager {
Employees[] employees;
void manageEmployees() {
int totalEmp = this.employees.length;
System.out.println("Total employees: " + totalEmp);
this.report();
}
void report() { }
}
在上面的示例中，this关键字用于两个地方：
this.employees.length：访问类Manager的当前实例的变量。
this.report()：调用类Manager的当前实例的方法。
此关键字是可选的，这意味着如果上面的示例在不使用此关键字的情况下表现相同。但是，使用此关键字可能会使代码更易读或易懂。
super关键字用于从子类访问父类的变量和方法。例如：
public class Super {
protected int number;
protected showNumber() {
System.out.println("number = " + number);
}
}
public class Sub extends Super {
void bar() {
super.number = 10;
super.showNumber();
}
}
在上面的例子中，Sub类访问父类成员变量number并调用其其父类Super的showNumber()方法。
使用this和super要注意的问题：
在构造器中使用super()调用父类中的其他构造方法时，该语句必须处于构造器的首行，否则编译器会报错。另外，this调用本类中的其他构造方法时，也要放在首行。
this、super不能用在static方法中。
简单解释一下：
被static修饰的成员属于类，不属于单个这个类的某个对象，被类中所有对象共享。而this代表对本类对象的引用，指向本类对象；而super代表对父类对象的引用，指向父类对象；所以，this和super是属于对象范畴的东西，而静态方法是属于类范畴的东西。
16.ArrayList和LinkedList区别
ArrayList是实现了基于动态数组的数据结构，LinkedList是基于链表结构。
随机访问的get和set方法，ArrayList要优于LinkedList，因为LinkedList要移动指针。
新增和删除操作add和remove，LinkedList比较占优势，因为ArrayList要移动数据。
ArrayList：
因为数组在存储数据时是按顺序存储的，存储数据的内存也是连续的，所以他的特点就是寻址读取数据比较容易，插入和删除比较困难。简单解释一下为什么，在读取数据时，只需要告诉数组要从哪个位置（索引）取数据就可以了，数组会直接把你想要的位置的数据取出来给你。插入和删除比较困难是因为这些存储数据的内存是连续的，要插入和删除就需要变更整个数组中的数据的位置。举个例子：一个数组中编号0->1->2->3->4这五个内存地址中都存了数组的数据，但现在你需要往4中插入一个数据，那就代表着从4开始，后面的所有内存中的数据都要往后移一个位置，这可是很耗时的。
所以，对于ArrayList，它在集合的末尾删除或添加元素所用的时间是一致的，但是在列表中间的部分添加或删除时所用时间就会大大增加。但是它在根据索引查找元素的时候速度很快。
LinkedList：LinkedList底层是双向列表。当需要在首位置插入元素时，first 引用指向需要插入到链表中的节点对象，新的节点对象的next引用指向原先的首节点对象；所以，对于LinkedList，它在插入、删除集合中任何位置的元素所花费的时间都是一样的，但是它根据索引查询一个元素的时候却比较慢。
ArrayList和LinkedList的缺点如下:
(1)对ArrayList和LinkedList而言，在列表末尾增加一个元素所花的开销都是固定的。对ArrayList而言，主要是在内部数组中增加一项，指向所添加的元素，偶尔可能会导致对数组重新进行分配；而对LinkedList而言，这个开销是 统一的，分配一个内部Entry对象。
(2)在ArrayList集合中添加或者删除一个元素时，当前的列表移动元素后面所有的元素都会被移动。而LinkedList集合中添加或者删除一个元素的开销是固定的。
(3)LinkedList集合不支持 高效的随机随机访问（RandomAccess），因为可能产生二次项的行为。
(4)ArrayList的空间浪费主要体现在在list列表的结尾预留一定的容量空间，而LinkedList的空间花费则体现在它的每一个元素都需要消耗相当的空间
ArrayList和LinkedList的应用场景如下:
ArrayList使用在查询比较多，但是插入和删除比较少的情况，而LinkedList用在查询比较少而插入删除比较多的情况。
17.自动装箱与拆箱
装箱：将基本类型用它们对应的引用类型包装起来
拆箱：将包装类型转换为基本数据类型
18.在一个静态方法内调用一个非静态成员为什么是非法的?
由于静态方法可以不通过对象进行调用，因此在静态方法里，不能调用其他非静态变量，也不可以访问非静态变量成员。
19. 成员变量与局部变量的区别有哪些？
从语法形式上看:成员变量是属于类的，而局部变量是在方法中定义的变量或是方法的参数；成员变量可以被public,private,static等修饰符所修饰，而局部变量不能被访问控制修饰符及static所修饰；但是，成员变量和局部变量都能被final所修饰。
从变量在内存中的存储方式来看:如果成员变量是使用static修饰的，那么这个成员变量是属于类的，如果没有使用static修饰，这个成员变量是属于实例的。而对象存在于堆内存，局部变量则存在于栈内存。
从变量在内存中的生存时间上看:成员变量是对象的一部分，它随着对象的创建而存在，而局部变量随着方法的调用而自动消失。
成员变量如果没有被赋初值:则会自动以类型的默认值而赋值(一种情况例外:被final修饰的成员变量也必须显式地赋值)，而局部变量则不会自动赋值。
20. 对象实体与对象引用有何不同?
Demo demo=new Demo();
这一条语句，其实包括了四个动作：
(1)右边的“newDemo”，是以Demo类为模板，在堆空间里创建一个Demo对象。
(2)末尾的()意味着，在对象创建后，立即调用Demo类的构造函数，对刚生成的对象进行初始化。
(3)左边的“Demodemo”创建了一个Demo类引用变量，它存放在栈空间中。也就是用来指向Demo对象的对象引用。这里如果后续不接new，那么就没有指向。
(4)“=”操作符使对象引用指向刚创建的那个Demo对象。
总之，new创建对象实例在堆内存中，对象引用存放在栈内存中，最终对象引用指向对象。一个对象引用可以指向0个或1个对象(一根绳子可以不系气球，也可以系一个气球);一个对象可以有n个引用指向它(可以用n条绳子系住一个气球)。
如果联系上JVM，那么前面还有：Java程序执行时，第一步系统创建虚拟机进程，然后虚拟器用类加载器ClassLoader加载java程序类文件到方法区。
这里首先在方法区找是否完成对类信息的加载，如果是的话直接用，否的话先由类加载器加载类信息。
类加载完成后，主线程运行staticmain()时在虚拟机栈中建栈帧，压栈。执行到newObject()时，在堆heap里创建对象。
21.一个类的构造方法的作用是什么?若一个类没有声明构造方法，该程序能正确执行吗?
主要作用是完成对类对象的初始化工作。可以执行，因为一个类即使没有声明构造方法也会有默认的不带参数的构造方法。
22.构造方法有哪些特性？
名字与类名相同。没有返回值，但不能用void声明构造函数。生成类的对象时自动执行，无需调用。
23.静态方法和实例方法有何不同
在外部调用静态方法时，可以使用"类名.方法名"的方式，也可以使用"对象名.方法名"的方式。而实例方法只有后面这种方式。也就是说，调用静态方法可以无需创建对象。
静态方法在访问本类的成员时，只允许访问静态成员(即静态成员变量和静态方法)，而不允许访问实例成员变量和实例方法；实例方法则无此限制。
24.自动装箱与拆箱
装箱：将基本类型用它们对应的引用类型包装起来
拆箱：将包装类型转换为基本数据类型
25.在一个静态方法内调用一个非静态成员为什么是非法的?
由于静态方法可以不通过对象进行调用，因此在静态方法里，不能调用其他非静态变量，也不可以访问非静态变量成员。
26. 获取用键盘输入常用的两种方法
方法 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();
548
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
