Java基础问题整理（一）_java 基础问题

• 优点：
  1、简洁。
  2、非常容易并行计算。
  3、可能代表未来编程趋势。
• 缺点：
  1、若不用并行计算，很多时候计算速度没有比传统的for循环快（并行计算有时需要预热才能显示出效率优势。
  2、不容易调试。
  3、若其他程序员没有学过lambda表达式，代码有安全性。
• Lamda语法有三种形式：
  (参数) ->单行语句；
  (参数) ->{多行语句}；
  (参数) ->表达式；
    括号（）可以大致理解为就是方法，里面是参数变量，->后面是一个单行语句；如果->后面是多行语句，需要用{ }装起来，每条语句后需要有分号;
  ->后面也可以是一个表达式，如：a+b等。
    Lamda表达式是为了避免匿名内部类定义过多无用的操作，

Java语言有哪些特点

java之父詹姆斯·高斯林

• 简单易学（Java语言的语法与C语言和C++语言很接近）
• 面向对象（封装，继承，多态）
• 平台无关性（Java虚拟机实现平台无关性）
• 支持网络编程并且很方便（Java语言诞生本身就是为简化网络编程设计的）
• 支持多线程（多线程机制使应用程序在同一时间并行执行多项任）
• 健壮性（Java语言的强类型机制、异常处理、垃圾的自动收集等）
• 安全性

访问修饰符 public,private,protected,以及不写（默认）时的区别

定义：Java中，可以使用访问修饰符来保护对类、变量、方法和构造方法的访问。Java 支持 4 种不同的访问权限。

分类

• private : 在同一类内可见。使用对象：变量、方法。 注意：不能修饰类（外部类）
• default (即缺省，什么也不写，不使用任何关键字）: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。
• protected : 对同一包内的类和所有子类可见。使用对象：变量、方法。 注意：不能修饰类（外部类）。
• public : 对所有类可见。使用对象：类、接口、变量、方法

java内部类

内部类： 所谓内部类就是在一个类内部进行其他类结构的嵌套操作。

内部类与外部类的关系

• 对于非静态的内部类，内部类的创建依赖外部类的实例对象，在没有外部类实例之前是无法创建内部类的。
• 内部类可以直接访问外部类的元素（包括私有域），外部类在内部类之前创建，创建内部类时会将外部类的对象传入
• 外部类可以通过内部类的引用间接访问内部类元素，要想访问内部类属性，必须先创建内部类对象
• 内部类是一个相对独立的个体，与外部类没有关系。
• 内部类可以访问外部类所有的方法和属性，如果内部类和外部类有相同的成员方法和成员属性，内部类的成员方法调用要优先于外部类即内部类的优先级比较高（只限于类内部，在主方法内，内部类对象不能访问外部类的成员方法和成员属性），外部类只能访问内部类的静态常量或者通过创建内部类来访问内部类的成员属性和方法。

内部类的优点:

• 内部类与外部类可以方便的访问彼此的私有域（包括私有方法、私有属性）。
• 内部类是另外一种封装，对外部的其他类隐藏。
• 内部类可以实现java的单继承局限。

内部类的缺点:

• 结构复杂。

在Java中内部类主要分为成员内部类、静态内部类、方法内部类、匿名内部类
  1、成员内部类
  类比成员方法，成员内部类内部不允许存在任何static变量或方法 正如成员方法中不能有任何静态属性 （成员方法与对象相关、静态属性与类有关），成员内部类是依附外部类的，只有创建了外部类才能创建内部类。

2、静态内部类
  关键字static可以修饰成员变量、方法、代码块、其实还可以修饰内部类，使用static修饰的内部类我们称之为静态内部类，静态内部类和非静态内部类之间存在一个最大的区别，非静态内部类在编译完成之后会隐含的保存着一个引用，该引用是指向创建它的外围类，但是静态类没有。没有这个引用就意味着：静态内部类的创建不需要依赖外部类可以直接创建，静态内部类不可以使用任何外部类的非static类（包括属性和方法），但可以存在自己的成员变量。

3、方法内部类
  方法内部类顾名思义就是定义在方法里的类，方法内部类不允许使用访问权限修饰符（public、private、protected）均不允许。方法内部类对外部完全隐藏，除了创建这个类的方法可以访问它以外，其他地方均不能访问 (换句话说其他方法或者类都不知道有这个类的存在)方法内部类对外部完全隐藏，出了创建这个类的方法可以访问它，其他地方均不能访问。方法内部类如果想要使用方法形参，该形参必须使用final声明（JDK8形参变为隐式final声明）。

4、匿名内部类
  匿名内部类就是一个没有名字的方法内部类，因此特点和方法与方法内部类完全一致，除此之外，还有自己的特点：匿名内部类必须继承一个抽象类或者实现一个接口；匿名内部类没有类名，因此没有构造方法。

抽象类和接口的区别

下面比较一下两者的语法区别：

1、抽象类可以有构造方法，接口中不能有构造方法。
2、抽象类中可以有普通成员变量，接口中没有普通成员变量
3、抽象类中可以包含非抽象的普通方法，接口中的所有方法必须都是抽象的，不能有非抽象的普通方法。
4、抽象类中的抽象方法的访问类型可以是public，protected和（默认类型,虽然
eclipse下不报错，但应该也不行），但接口中的抽象方法只能是public类型的，并且默认即为public abstract类型。
5、抽象类中可以包含静态方法，接口中不能包含静态方法
6、抽象类和接口中都可以包含静态成员变量，抽象类中的静态成员变量的访问类型可以任意，但接口中定义的变量只能是public static final类型，并且默认即为public static final类型。
7、 一个类可以实现多个接口，但只能继承一个抽象类。

下面接着再说说两者在应用上的区别：

接口更多的是在系统架构设计方法发挥作用，主要用于定义模块之间的通信契约。而抽象类在代码实现方面发挥作用，可以实现代码的重构。

创建对象的过程

以此为例：Student s = new Student();
步骤:
(1):加载Student.class文件进内存
(2):在栈内存为s开辟空间
(3):在堆内存为学生对象开辟空间
(4):对学生对象的成员变量进行默认初始化
(5):对学生对象的成员变量进行显示初始化
(6):通过构造方法对学生对象的成员变量赋值
(7):学生对象初始化完毕，把对象地址赋值给s变量

方法重写和方法重载的区别

方法的重载和重写都是实现多态的方式，区别在于前者实现的是编译时的多态性，而后者实现的是运行时的多态性。

• 重载：发生在同一个类中，方法名相同参数列表不同（参数类型不同、个数不同、顺序不同），与方法返回值和访问修饰符无关，即重载的方法不能根据返回类型进行区分
• 重写：发生在父子类中，方法名、参数列表必须相同，返回值小于等于父类，抛出的异常小于等于父类，访问修饰符大于等于父类（里氏代换原则）；如果父类方法访问修饰符为private则子类中就不是重写。

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

• 面向过程：
  优点：性能比面向对象高，因为类调用时需要实例化，开销比较大，比较消耗资源;比如单片机、嵌入式开发、Linux/Unix等一般采用面向过程开发，性能是最重要的因素。
  缺点：没有面向对象易维护、易复用、易扩展
• 面向对象：
  优点：易维护、易复用、易扩展，由于面向对象有封装、继承、多态性的特性，可以设计出低耦合的系统，使系统更加灵活、更加易于维护
  缺点：性能比面向过程低

面向过程是具体化的，流程化的，解决一个问题，你需要一步一步的分析，一步一步的实现。
  面向对象是模型化的，你只需抽象出一个类，这是一个封闭的盒子，在这里你拥有数据也拥有解决问题的方法。需要什么功能直接使用就可以了，不必去一步一步的实现，至于这个功能是如何实现的，管我们什么事？我们会用就可以了。
  面向对象的底层其实还是面向过程，把面向过程抽象成类，然后封装，方便我们使用的就是面向对象了。

面向对象的特征

1、抽象：
  抽象就是忽略一个主题中与当前目标无关的那些方面，以便更充分的注意与当前目标有关的方面。抽象并不打算了解全部问题，而是选择其中一部分，暂时不用部分细节，抽象包括两个方面：一是过程抽象，二是数据抽象

2、封装
  Java中的封装是指一个类把自己内部的实现细节进行隐藏，只暴露对外的接口。封装又分为属性的封装和方法的封装，把属性定义为私有的，他们通过setter和getter方法对属性的值进行设定和获取。
封装目的：增强安全性和简化编程，使用者不必在意具体实现细节，通过外部接口就可以访问类的成员。

3、继承
  继承是指将多个相同的属性和方法提取出来，新建一个父类。Java中一个类只能继承一个父类，且只能继承访问权限非private的属性和方法。
  继承目的：实现代码复用

4、多态
  它是指在父类中定义的属性和方法被子类继承之后，可以具有不同的数据类型或表现出不同的行为，这使得同一个属性或方法在父类及其各个子类中具有不同的含义。

对面向对象来说，多态分为编译时多态和运行时多态。

• 编译时多态：是指Java允许方法名相同而参数不同。
• 运行时多态： 是指Java运行根据调用该方法的类型决定调用哪个方法。

sleep和wait的区别？

1、来自不同的类
  wait()来自于Object类。sleep()来自于Thread类。

2、锁的释放
  wait()会释放锁，sleep()不会释放锁

3、使用范围
  wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用，而sleep可以在任何地方使用。

4、作用
  sleep()的作用是让线程休眠指定的时间，在时间到达时恢复线程执行。wait()是Object的方法，可以说对任意一个对象调用wait()方法，wait()方法会将调用者的线程挂起，知道其他线程调用同一个对象的notify()方法才会重新激活调用者。

反射

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

• 静态编译：在编译时确定类型，绑定对象
• 动态编译：运行时确定类型，绑定对象

反射机制优缺点

• 优点： 运行期类型的判断，动态加载类，提高代码灵活度。
• 缺点： 性能瓶颈,反射相当于一系列解释操作，通知 JVM 要做的事情，性能比直接的java代码要慢很多。

反射机制的应用场景有哪些？
  反射是框架设计的灵魂。
  在我们平时的项目开发过程中，基本上很少会直接使用到反射机制，但这不能说明反射机制没有用，实际上有很多设计、开发都与反射机制有关，例如模块化的开发，通过反射去调用对应的字节码；动态代理设计模式也采用了反射机制，还有我们日常使用的 Spring／Hibernate 等框架也大量使用到了反射机制。
  举例：①我们在使用JDBC连接数据库时使用Class.forName()通过反射加载数据库的驱动程序；②Spring框架也用到很多反射机制，最经典的就是xml的配置模式。Spring 通过 XML 配置模式装载Bean 的过程：1) 将程序内所有 XML 或 Properties 配置文件加载入内存中; 2)Java类里面解析xml或properties里面的内容，得到对应实体类的字节码字符串以及相关的属性信息; 3)使用反射机制，根据这个字符串获得某个类的Class实例; 4)动态配置实例的属性

Java获取反射的三种方法
1、通过new对象实现反射机制
2、通过路径实现反射机制
3、通过类名实现反射机制

泛型

泛型指的就是广泛通用的类型，就是为了参数化类型，或者说可以将类型当做参数传递给一个类或者方法。

泛型好处

泛型的主要目的是实现java的类型安全，泛型可以使编译器知道一个对象的限定类型是什么，消除了强制类型转换，使得代码可读性好，减少了很多出错的机会。

泛型的实现原理

泛型的实现时靠类型擦除技术，类型擦除是在编译期完成的，也就是在编译期编译器会将泛型的类型参数都擦除成它的限定类型，如果没有则擦除为object类型之后在获取的时候再强制类型转换为对应的类型。在运行期间并没有泛型的任何信息，因此也没有优化。

&和&&的区别

&运算符有两种用法：(1)按位与；(2)逻辑与。
  &&运算符是短路与运算。逻辑与跟短路与的差别是非常巨大的，虽然二者都要求运算符左右两端的布尔值都是true 整个表达式的值才是 true。&&之所以称为短路运算，是因为如果&&左边的表达式的值是 false，右边的表达式会被直接短路掉，不会进行运算。
  注意：逻辑或运算符（|）和短路或运算符（||）的差别也是如此。

== 和 equals 的区别是什么

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

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

• 情况1：类没有覆盖 equals() 方法。则通过 equals() 比较该类的两个对象时，等价于通过“==”比较这两个对象。
• 情况2：类覆盖了 equals() 方法。一般，我们都覆盖 equals() 方法来两个对象的内容相等；若它们的内容相等，则返回 true (即，认为这两个对象相等)。

final 有什么用？

用于修饰类、属性和方法；
被final修饰的类不可以被继承
被final修饰的方法不可以被重写
被final修饰的变量不可以被改变，被final修饰不可变的是变量的引用，而不是引用指向的内容，引用指向的内容是可以改变的

final finally finalize区别

final可以修饰类、变量、方法，修饰类表示该类不能被继承、修饰方法表示该方法不能被重写、修饰变量表示该变量是一个常量不能被重新赋值。
  finally一般作用在try-catch代码块中，在处理异常的时候，通常我们将一定要执行的代码方法finally代码块中，表示不管是否出现异常，该代码块都会执行，一般用来存放一些关闭资源的代码。
  finalize是一个方法，属于Object类的一个方法，而Object类是所有类的父类，该方法一般由垃圾回收器来调用，当我们调用System.gc() 方法的时候，由垃圾回收器调finalize()，回收垃圾，一个对象是否可回收的最后判断

this关键字的用法

this是自身的一个对象，代表对象本身，可以理解为：指向对象本身的一个指针。
  this的用法在java中大体可以分为3种：
  1、普通的直接引用，this相当于是指向当前对象本身。
  2、形参与成员名字重名，用this来区分：
  3、引用本类的构造函数

super关键字的用法

super可以理解为是指向自己超（父）类对象的一个指针，而这个超类指的是离自己最近的一个父类。
super也有三种用法：
1、普通的直接引用
  与this类似，super相当于是指向当前对象的父类的引用，这样就可以用super.xxx来引用父类的成员。
2、子类中的成员变量或方法与父类中的成员变量或方法同名时，用super进行区分。
3、引用父类构造函数
  super（参数）：调用父类中的某一个构造函数（应该为构造函数中的第一条语句）。
  this（参数）：调用本类中另一种形式的构造函数（应该为构造函数中的第一条语句）。

this与super的区别

super: 它引用当前对象的直接父类中的成员（用来访问直接父类中被隐藏的父类中成员数据或函数，基类与派生类中有相同成员定义时如：super.变量名 super.成员函数据名（实参）
  this：它代表当前对象名（在程序中易产生二义性之处，应使用this来指明当前对象；如果函数的形参与类中的成员数据同名，这时需用this来指明成员变量名）

super()和this()类似，区别是，super()在子类中调用父类的构造方法，this()在本类内调用本类的其它构造方法。
  super()和this()均需放在构造方法内第一行。尽管可以用this调用一个构造器，但却不能调用两个。
  this和super不能同时出现在一个构造函数里面，因为this必然会调用其它的构造函数，其它的构造函数必然也会有super语句的存在，所以在同一个构造函数里面有相同的语句，就失去了语句的意义，编译器也不会通过。
  this()和super()都指的是对象，所以，均不可以在static环境中使用。包括：static变量,static方法，static语句块。
  从本质上讲，this是一个指向本对象的指针, 然而super是一个Java关键字。

static

static的主要意义是在于创建独立于具体对象的域变量或者方法。以致于即使没有创建对象，也能使用属性和调用方法！
  static关键字还有一个比较关键的作用就是 用来形成静态代码块以优化程序性能。static块可以置于类中的任何地方，类中可以有多个static块。在类初次被加载的时候，会按照static块的顺序来执行每个static块，并且只会执行一次。
  为什么说static块可以用来优化程序性能，是因为它的特性:只会在类加载的时候执行一次。因此，很多时候会将一些只需要进行一次的初始化操作都放在static代码块中进行。

static的独特之处
  1、被static修饰的变量或者方法是独立于该类的任何对象，也就是说，这些变量和方法不属于任何一个实例对象，而是被类的实例对象所共享。
怎么理解 “被类的实例对象所共享” 这句话呢？就是说，一个类的静态成员，它是属于大伙的【大伙指的是这个类的多个对象实例，我们都知道一个类可以创建多个实例！】，所有的类对象共享的，不像成员变量是自个的【自个指的是这个类的单个实例对象】…我觉得我已经讲的很通俗了，你明白了咩？
  2、在该类被第一次加载的时候，就会去加载被static修饰的部分，而且只在类第一次使用时加载并进行初始化，注意这是第一次用就要初始化，后面根据需要是可以再次赋值的。
  3、static变量值在类加载的时候分配空间，以后创建类对象的时候不会重新分配。赋值的话，是可以任意赋值的！
  4、被static修饰的变量或者方法是优先于对象存在的，也就是说当一个类加载完毕之后，即便没有创建对象，也可以去访问。

static应用场景
  因为static是被类的实例对象所共享，因此如果某个成员变量是被所有对象所共享的，那么这个成员变量就应该定义为静态变量。因此比较常见的static应用场景有：
1、修饰成员变量
2、修饰成员方法
3、静态代码块
4、修饰类【只能修饰内部类也就是静态内部类】
5、静态导包

static注意事项
1.静态只能访问静态。
2.非静态既可以访问非静态的，也可以访问静态的。

break ,continue ,return 的区别及作用

• break 跳出总上一层循环，不再执行循环(结束当前的循环体)
• continue 跳出本次循环，继续执行下次循环(结束正在执行的循环 进入下一个循环条件)
• return 程序返回，不再执行下面的代码(结束当前的方法 直接返回)

在 Java 中，如何跳出当前的多重嵌套循环

在Java中，要想跳出多重循环，可以在外面的循环语句前定义一个标号，然后在里层循环体的代码中使用带有标号的break 语句，即可跳出外层循环。例如：
public static void main(String[] args) { ok: for (int i = 0; i < 10; i++) { for (int j = 0; j < 10; j++) { System.out.println(“i=” + i + “,j=” + j); if (j == 5) { break ok; } } } }

值传递和引用传递有什么区别

• 值传递：指的是在方法调用时，传递的参数是按值的拷贝传递，传递的是值的拷贝，也就是说传递后就互不相关了。
• 引用传递：指的是在方法调用时，传递的参数是按引用进行传递，其实传递的引用的地址，也就是变量所对应的内存空间的地址。传递的是值的引用，也就是说传递前和传递后都指向同一个引用（也就是同一个内存空间）。

JDK 中常用的包有哪些

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