Java基础知识

1.JDK,JRE和JDK的区别

JVM: java的虚拟机，java程序运行的平台，不同的平台有自己的虚拟机，因此java语言是跨平台编译语言。

JRE: 包括java的虚拟机和java程序运行所需的核心类库。主要是java.lang包

JDK: 提供给开发人员使用的，其中包括java的开发工具和JRE。其中编译工具为javac.exe  打包工具为jar.exe

2.采用字节码的最大好处

java语言经过虚拟机编译器编译后产生的文件，他不面向特定的处理器，只面向虚拟机。

好处：解决了传统语言执行效率低的问题，同时还保留了解释型语言可移植的特点。

3.Java和C++的区别

1》都是面向对象语言，都支持继承，封装，多态
2》Java不提供指针来直接访问内存，程序更加安全。
3》java支持单继承（接口除外），c++支持多继承
4》java自动内存管理机制，不需要程序员手动释放内存。

4，基础语法

4.1数据类型

基础数据类型：

引用数据类型：
类，接口，数组

4.2 Switch作用在啥数据上

java5之前:  byte, char, int, char

java5之后：引入枚取类型

java7 :引入String

目前所有版本都不支持long型。

4.3float f = 3.4是否正确

不正确，3.4是双精度数，付给float需要转型。

4.4 short s1 = 1;s1=s1+1有错吗？，short s1 = 1;s1+=1有错吗

对于：short s1 = 1;s1=s1+1，由于1为int型，所以s1+1也为int型，所以需要强制转换才能赋给short

然而对于第二个默认是强制类型转换。

4.5 java的修饰符

private： 在同一类可见。使用对象：变量，方法。他不能修饰类（外部类）

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

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

default: 缺省，在同一包内可见 使用对象：类，接口，变量，方法。

4.6 final，finally，finalize区别

final: 修饰：类，方法，变量
修饰类表示这是一个超类，不能被继承，不能被重写。
修饰变量：常量，不能被重新赋值。

finally：一搬用于try_catch代码块中，被Fianlly修饰的代码块不管出现异常与否，都会被执行

finalize: 是一个方法，属于Object类的一个方法，改方法一般有垃圾回收器来调用。

4.7this,super的用法

this用法： 普通直接引用，相当于指向当前类本身。
			形参与实参重名，用this来区分
			用来引用本类的构造函数。
super用法：普通直接引用，相当于指向当前对象父类的引用。
		   子类和父类方法重名时用super来区分。
		   引用父类的构造函数，放在第一句。
尽管可以用this一个构造器，但却不可以调用两个：
	调用this构造器必然会调用其他的构造函数，其他的构造函数也存在super语句，这样调用就失去的意义。
从本质上讲：this是指向对象的指针，二super只是一个关键字。

4.8 static

主要意义：在于用来创建独立于具体对象域变量或者方法，以至于没有创建对象也可以调用属性和方法。
          用来形成静态代码块以优化程序性能（只加载一次）

被static加载的对象不属于任何一个实例对象，而是被类的实例对象所共享,他优先于对象的存在。

5 面向对象

5.1 面向对象和面向过程的区别

面向对象：面向对象是模型化的，只需要抽象出一个类。
优点：容易维护，复用，拓展。由于面向对象具有继承，封装，多态可以设计低偶和的系统。
缺点：性能低一点
面向过程： 面向过程是具体化流程化的，解决问题需要一步一步来。

5.2 面向对象的三大特性

封装：把一个对象私有化，同时还提供一些可以被外界访问的属性方法。

继承：把已经存在得类作为基础，建立新的类，也可以用父类的功能。
	  子类拥有父类除private的属性和方法
	  
多态：顾名思义就是拥有“多种形态”的含义，是指属性或方法在子类中表现为多种形态。
多态的实现方法：封装，继承，向上转型（三个必要条件）。
      实现多态有两种方法：继承和接口
      方法重载：实现的是编译时多态（前绑定）
      方法重写：实现的是运行时多态性（后绑定）

5.3 重写和重载的区别

重载：发生在本类，参数列表不同，与返回值无关，之和方法名，参数列表，参数类型有关。
	  简单而言：重载就是对于不同的情况写不同的方法。
主要特征：
1> :方法名必须相同
2> :方法的参数列表一定不一样
3> :访问修饰符和返回值类型可以相同也可以不同。

重写：发生在子类和父类之间，简单而言就是具体的实现类对父类的实现方法不满意，需要自己写一个满足于自己需求的方法。
主要特征：
1> :方法名必须相同，返回值类型必须相同。
2> :参数列表必须相同。
3> :访问权限不能比父类中被重写的方法更低。
4> :子类和父类在同一包中，可以重写除了private和final之外的所有方法
5> :构造方法不能重写

5.4 面向对象的五大特征（了解）

1> 单一职责原则：类的功能单一，不能保罗万新。
2> 开放封闭原则：一个模块对于扩展是开放的，对于修改是封闭的
3> 里氏替换原则：子类能替换父类出现在父类能够出现的任何地方
4> 依赖倒置原则：高层次模块不依赖于低层次的模块，他们都应该依赖于抽象，抽象不应该依赖于具体实现，具体实现应该依赖与抽象
5>接口分离原则：

6 类和接口

6.1 接口和抽象类区别

抽象类：用来捕捉子类的通用特性，**是对于类的抽象，是一种模板设计。**
        可以有构造器，访问修饰符任意,声明字段任意。

接口：抽象方法的集合，**是行为的抽象，是一种行为规范。**   
      不能有构造器，访问修饰符默认为public，不能为private和protected，声明字段默认为final和static
      
相同点：
1> 接口和抽象类都不能被实例化
2> 都位于继承的顶端，用于被其他实现和继承
3> 都包含抽象方法，子类都必须覆写这些方法

注意：java8之后引入了默认构造方法和静态方法，现在，接口提供默认的实现方法，不强制子类实现它。

6.2 抽象类能用final修饰吗？

不能，定义抽象类的目的是让其他类去继承的。

6.3 创建一个对象用什么关键字？对象实例和对象引用有和不同？

关键字 new，new创建一个对象实例（对象实例会存在于堆内存中）
对象引用指向对象实例（对象引用存在于栈内存中）
一个对象引用可以指向一个或0个对象，一个对象可以有n个引用指向它

7 变量和方法

7.1 成员变量和局部变量的区别

变量：在程序执行中，在某个范围内其值可以发生改变的量，从本质上来讲，变量其实是内存中的一小块区域。
成员变量：方法外部，类内部定义的变量
局部变量：类的方法中的变量。

区别：
作用域： 成员变量：整个类有效；局部变量：只在某个范围内有效

存储位置：成员变量：与对象同生工死，在堆内存中。  局部变量：方法调用时而存在，存储在栈 内存中，方法调用完后，自动释放。

初始值：成员变量：有默认的初始值， 局部变量：没有默认的初始值，使用前必须赋值

7.2 在java中定义一个不做事且没有参数的构造方法的作用

Java程序在执行子类的构造方法之前，如果没有用super来调用特定的构造函数，则会调用父类中“没有参数的构造方法”，所以当我们没有用super时，若父类没有默认无参构造方法，则会编译失败。

7.3 在调用子类构造方法之前会调用父类没有参数的构造方法，其目的是？

帮助子类初始化

7.4 构造方法有哪些特性

名字与类名相同

没有返回值，但是不能void申明构造函数

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

7.5 静态变量和实例变量的区别

静态变量：不属于任何实例的对象，属于类的，在内存中只有一份，类加载的过程中,JVM只为静态变量分配一次内存。

实例变量：类每次加载都会创建一份。

7.6 静态变量和普通变量的区别

静态变量：被所有对象所共享，内存中只存在一个副本，他当且仅当在类的初次加载时会被初始化。

普通变量：在创建对象时被初始化，存在多个副本，互不影响。

静态变量的初始化顺序按照定义的顺序进行初始化。

7.7 静态方法和实例方法的不同？

1》在外部调用静态方法时，可以使用“类名.方法名”，也可以使用“对象名.方法名”，而实例方法只能用“对象名.方法名”。
也就是说，调用静态方法时无需创建对象。
2》静态方法在访问本类的成员时，只能访问静态的，不允许访问实例成员变量和方法。

8 内部类

8.1 定义

在Java中可以吧一个类的定义放在另外一个类的定义内部。内部类的本身就是类的一个属性，与其他属性定义方法一致。

8.2 内部类的分类

内部类可分为四种：成员内部类，局部内部类，匿名内部类和静态内部类。

8.3 静态内部类

定义在类内部的静态类。
静态内部类可以访问外部类中所用的静态变量，而不可以访问外部类的非静态变量
定义方式： new 外部类.静态内部类（）

8.4 成员内部类

定义在类内部，成员位置上的非静态类就称为成员内部类。
创建方式：外部类实例.new 内部类（）

8.5 局部内部类

定义在方法中的内部类。定义在实例方法中的局部类可以访问外部类的所有成员变量和方法。
局部内部类的创建方法：在对应的方法内，new 内部类（）

8.6 匿名内部类

就是没有名字的内部类，日常开发中使用较多。

public class Quter {
    private void test(final int i){
        new Service(){

            public void method() {
                for(int j = 0;j<i;j++){
                    System.out.println("匿名内部类");
                }
            }
        }.method();
    }
    interface  Service{
        void method();
    }
    
}

创建方法：
new Service(){

            public void method() {
                for(int j = 0;j<i;j++){
                    System.out.println("匿名内部类");
                }
            }
        }.method();

匿名内部类除了没有名字，还应有如下特点：
1》必须继承一个抽象类或实现一个接口。

2》匿名内部类不能定义静态变量和方法。

3》当所有的方法的形参需要被匿名内部类使用时，必须申明为final

4》匿名内部类不能是抽象的，它必须实现继承的类或者实现接口中的所有方法。

8.7 内部类的优点

1》一个内部类对象可以访问创建它的外部类所有数据，包括私有数据

2》内部类部位同一包的其他类可见，具有很好的封装性。

3》内部类有效的实现了“多重继承”，优化了java单继承的缺陷。

4》匿名内部类可以很方便的定义回调。

8.8 内部类的应用场景

1》 一些算法场合

2》解决一些非面向对象的语句块

3》适当使用内部类，是的代码具有很好的灵活性和可扩展性。

4》当某个类除了他的外部类，本能被其他类使用时。

8.9 局部内部类和匿名内部类，为什么变量必须加上final？

因为生命周期的关系，局部变量存在于栈中，方法中执行结束后，非final的局部变量就被销毁，而局部内部类对于局部变量的引用还在。此时如果局部内部类调用局部变量就会出错，因此加上了final。

9 对象相等判断

9.1 == 和equals的区别是啥

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

equals: 判断两个对象是否相等;
1》类中没有覆盖equals时，通过equals比较两个对象，相当于==，比较两个对象。
2》类中覆盖了equals方法。一般我们覆盖equals方法比较两个对象内容相等。

String 方法的equals是被重写过的，Object的equals方法比较对对象的地址，而String的equals比较的是两个对象的值。
当创建String类型的对象是，虚拟机会在常量池中查找有没有已经存在的值和要创建的值相同的对象，如果有，就把他赋给当前引用，如果没有就在常量池中创建一个。

9.2 hashCode()介绍

hashCode()的作用是获取哈希码，也称散列码，实际上返回一个int整数。哈希码的作用：确定哈希表中的索引位置，存在于Object中

9.3 为啥要有hashCode()

我们以HashSet如何检查重复为例来说明为啥需要HashCode()：

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

9.4 equals 方法被覆盖过，则hshCode方法则必须覆盖。

hashCode的默认行为是对堆上的对象产生特殊值。如果没有重写hashCode（），则改Class的两个对象无论如何都不会相等（即使两个对象指向相同的数据）

9.5 对象相等和指向他们的引用相等，两者有啥不同？

对象相等：比的是内存是存放的内容是否相等。

引用相等： 比较的是他们指向的内存地址是否相等。

10 值传递

java中方法参数的使用情况：
1》一个方法不能修改一个基本数据类型的参数
2》一个方法可以改变一个对象参数的状态
3》一个方法不能让一个对象参数引用一个新的对象

10.1 值传递和引用传递的区别

值传递：指的是方法调用时，传递的参数是按值得拷贝传递，传递的值是指的拷贝，也就是说传递后就互不相关了

引用传递：方法调用时传递的是按引用进行传递，其实传递的是引用的地址，也就是变量所对应的内存空间的地址。传递的是指的引用，也就是说传递后与传递前的指向同一内存空间。

11 JDK常用的包有哪些

java.lang :系统的基础类
java.io: 与输入输出有关的类，比如文件操作
java.nio: 提高io包中性能而写的一个新的包。
java.net:与网络有关的类
java.util：系统辅助类，特别是集合类
java.sql: 数据库操作的类

12 BIO,NIO，AIO的区别

BIO:同步阻塞I/O模式，数据的读取必须在一个线程内等待完成。在活动链接小于1000的情况下，比较适合
不用考虑过载，和限流等问题，线程池本身就是一个天然的漏斗，可以缓冲一些系统处理不了的连接和请求。

NIO:同步非阻塞的I/O模型，提供了Selector,Channel,Buffer等抽象。NIO的N,不是单纯的New,可以支持面向缓冲，基于通道的I/O操作方法。对于高负载和高并发的（网路）应用，应用NIO来开发。

AIO: 异步非阻塞，异步IO是基于事件和回调机制实现的，也就是操作之后会直接返回不会阻塞在那里，当后台处理完成后，操作系统会通知相应的线程进行后续处理。

13 反射

13.1 反射的机制

反射机制是在运行状态，对于任意一个类，都能够知道这个的类所有属性和方法。

反射学习