Java基础一

1、 什么是面向对象？谈谈你对面向对象的理解

面向对象与面向过程的区别：

• 面向过程：注重事情的每一个步骤及顺序，比较高效
• 面向对象：注重事情有哪些参与者（对象），及各自需要做什么，更易于复用、拓展和维护

封装：内部细节对外部调用透明，外部调用无需修改或者关心内部实现，例如：

• javabean的属性私有，提供getset对外访问，因为属性的赋值或者获取逻辑只能由javabean本身决定，不能由外部胡乱修改
• orm框架 操作数据库，我们不需要关心链接是如何建立的、sql是如何执行的，只需要引入mybatis，调用方法即可

继承：子类共性的方法或者属性直接使用父类的，而不需要自己再定义，只需扩展自己个性化的

多态：基于对象所属类不同，外部对同一个方法的调用，实际执行的逻辑不同。主要是为了扩展程序的功能
三个条件（继承，方法重写，父类引用指向子类对象）

父类类型 变量名 = new 子类对象
变量名.方法名();
//弊端：无法调用子类特有的功能

2、JDK JRE JVM的区别与联系

JDK：Java Development Kit java开发工具
JRE：Java Runtime Environment java运行时环境
JVM：Java Virtual Machine java虚拟机

3、==和qeuals

== ：对于基本类型和引用类型 == 的作用效果是不同的

• 基本类型：比较的是值是否相同；
• 引用类型：比较的是引用是否相同；
  ==对比的是栈中的值，基本数据类型是变量型，引用类型是堆中内存对象的地址

equals：equals 本质上就是 ==，只不过 String 和 Integer 等重写了 equals 方法，把它变成了值比较。

== 对于基本类型来说是值比较，对于引用类型来说是比较的是引用；而 equals 默认情况下是引用比较，只是很多类重新了 equals 方法，比如 String、Integer 等把它变成了值比较，所以一般情况下 equals 比较的是值是否相等。

4、final

1. 简述final作用
2. 为什么局部内部类和匿名内部类只能访问局部final变量？

final

• final 修饰的类叫最终类，该类不能被继承。
• final 修饰的方法不能被重写，但是可以重载。
• final 修饰的变量叫常量，常量必须初始化，初始化之后值就不能被修改。

1. 修饰成员变量
   如果final修饰的是类变量，只能在静态初始化块中指定初始值或者声明该类变量时指定初始值
   如果final修饰的是成员变量，可以在非静态初始化块、声明该变量或者构造器中执行初始值
2. 修饰局部变量
   系统不会为局部变量进行初始化，局部变量必须由程序员显示初始化。因此使用final修饰局部变量时：
   既可以在定义时指定默认值（不可再次赋值），也可以不指定默认值，但后面只能赋值一次
3. 修饰基本类型数据和引用类型数据
   如果是基本类型的变量，则其数值一旦在初始化之后便不能更改；
   如果是引用类型的变量，则在对其初始化之后便不能再让其指向另一个对象，但引用的值是可变的。

为什么局部内部类和匿名内部类只能访问局部final变量？
局部内部类和匿名内部类在编译之后会生成两个class文件，Test.class Test1.class

public class Test{
	public static void main(String[] args) {
	}
	//局部final变量a,b
	public void test(final int b) {
		final int a = 10;
		//匿名内部类
		new Thread(){
			public void run() {
				System.out.println(a);
				System.out.println(b);
			}
		}.start();
	}
}

class OutClass {
	private int age = 12;

	public void outPrint(final int x){
		class InClass {
			public void InPrint(){
				System.out.println(x);
				System.out.println(age);
			}
		}
		new InClass().InPrint();
	}
}

首先需要知道的一点是：内部类和外部类是处于同一个级别的，内部类不会因为定义在方法中就会随着方法的执行完毕就被销毁。

这里就会产生问题：当外部类的方法结束时，局部变量就会被销毁了，但是内部类对象可能还存在（当没有被引用时才会死亡）。这里就会出现矛盾：内部类对象访问了一个不存在的变量。为了解决这个问题，就将局部变量复制了一份作为内部类的成员变量，这样当局部变量死亡后，内部类仍可以访问它，实际访问的是局部变量的“copy”。这样就好像延长了局部变量的生命周期。

将局部变量复制为内部类的成员变量时，必须保证这两个变量是一样的，也就是如果我们在内部类中修改了成员变量，方法中的局部变量也得跟着改变，怎么解决？
将局部变量设置为final，对它初始化后，就保证了内部类的成员变量和方法的局部变量保持一致。这实际上也是一种妥协，使得局部变量与内部类内建立的拷贝保持一致。

5、String StringBuffer StringBuilder区别及使用场景

String是final修饰的，不可变，每次操作都会产生新的String对象
StringBuffer和StringBuilder都是在原对象上操作
StringBuffer是线程安全的，StringBuilder是线程不安全的
StringBuffer方法都是synchronized修饰的 多线程 共享变量 结果正确
性能：StringBuilder>StringBuffer>String

场景：经常需要改变字符串内容时使用后面两个
优先使用StringBuilder，多线程使用共享变量时使用StringBuffer

6、重载和重写的区别

重载：发生在同一个类中，方法名必须相同，参数类型不同、个数不同、顺序不同，方法返回值和访问修饰符可以不同，发生在编译时。
重写：发生在父子类中，方法名、参数列表必须相同，返回值范围小于等于父类，抛出的异常范围小于等于父类，访问修饰符范围大于等于父类；如果父类方法访问修饰符为private，则子类就不能重写该方法。

public int add(int a,String b)
public String add(int a,String b)
//编译报错

7、接口和抽象类的区别

• 抽象类可以存在普通成员函数，而接口中只能存在public abstract方法
• 抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是public static final类型的
• 抽象类只能继承一个，借口可以实现多个

接口的设计目的：是对类的行为进行约束（更准确的是有一种“有”约束，因为接口不能规定类不可以有什么行为），也就是提供一种机制，可以强制要求不同的类具有相同的行为。它只约束了行为的有无，但不对如何实现行为进行限制。

抽象类的设计目的：是代码复用。当不同的类具有某些相同的行为（记为行为集合A），且其中一部分行为的实现方式一致时（A的非真子集，记为B），可以让这些类都派生于一个抽象类。在这个抽象类中实现了B，避免让所有的子类来实现B，这就达到了代码复用的目的。而A减B的部分，留给各个子类自己实现。正是因为A-B在这里没有实现，所以抽象类不允许实例化出来（否则当调用A-B时，无法执行）。

抽象类是对类本质的抽象，表达的是is a 的关系，比如：BWM is a car。抽象类包含并实现子类的通用特性，将子类存在差异化的特性进行抽象，交由子类去实现。

而接口是对行为的抽象，表达的是like a 的关系。比如：Bird like a Aircraft（像飞行棋一样可以飞），但其本质上is a bird。接口的核心是定义行为，即实现类可以做什么，至于实现类主体是谁，如何实现，接口并不关心。

使用场景：当你关注一个事物的本质时，用抽象类；当你关注一个操作的时候，用接口。

抽象类的功能要远超过接口，但是定义抽象类的代价高。因为从高级语言来说（从实际设计上来说也是）每个类只能继承一个类。在这个类中，你必须继承或编写出其所有子类的所有共性。虽然接口在功能上会弱化许多，但是它只是针对一个动作的描述。而且你可以在一个类中同时实现多个接口。在设计阶段会降低难度。