Java OOP面试题

jdk8新特性？

lambda表达式 Stream流遍历 hashset hashmap 1.8

线程内存屏障 CAS

1、什么是B/S架构？什么是C/S架构？

1.B/S(Browser/Server)，浏览器/服务器程序，Web应用

2.C/S(Client/Server)，客户端/服务端，桌面应用程序

2、Java都有那些开发平台？

1.JAVASE：主要用在客户端开发

2.JAVAEE：主要用在web应用程序开发

3.JAVAME：主要用在嵌入式应用程序开发

3、什么是JDK？什么是JRE?

1.JDK：java development kit：java开发工具包，是开发人员所需要安装的环境

2.JRE：java runtime environment：java运行环境，java程序运行所需要安装的环境

3.JVM:Java 虚拟机

JDK包含JRE包含JVM

4、Java语言有哪些特点

1.简单易学、有丰富的类库

2.面向对象（Java最重要的特性，让程序耦合度更低，内聚性更高）

3.与平台无关性（JVM是Java跨平台使用的根本）

4.可靠安全

5.支持多线程

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

1.面向过程：

强调功能实现过程，通过函数调用来实现，C语言。

2.面向对象：

一个事物的许多特征的抽象概念就是类，对象是类的具体存在。

我们需要一个笔记本电脑，屏幕键盘作为它的属性，上网作为它的方法。这样我们就在java中就定义了一个笔记本的概念，定义了一个笔记本类，是抽象的。

而我们想要用电脑上网就需要new创建一个笔记本电脑，这是一个类的具体存在，可以称作是一个对象。

6、什么是数据结构？

计算机保存，组织数据的方式

7、Java的数据结构有那些？

数据结构里面的你应该改都知道。

9、类与对象的关系?

类是对象的抽象，对象是类的具体，类是对象的模板，对象是类的实例

10、Java中有几种数据类型

数据类型：基本数据类型。

               引用数据类型。

11、标识符的命名规则

1.标识符的含义：

    是指在程序中，我们自己定义的内容，譬如，类的名字，方法名称以及变量名称等等，都是标识符。

2.命名规则：（硬性要求）

    标识符可以包含英文字母，0-9的数字，$以及_ ,标识符不能以数字开头
    标识符不是关键字

3.命名规范：（非硬性要求）

    类名规范：首字符大写，后面每个单词首字母大写（大驼峰式）。
    变量名规范：首字母小写，后面每个单词首字母大写（小驼峰式）。
    方法名规范：同变量名。

12、instanceof 关键字的作用

instanceof 严格来说是Java中的一个双目运算符，用来测试一个对象是否为一个类的实例。

用法为：

 boolean result = obj instanceof Class;

13、什么是隐式转换，什么是显式转换

14、char类型能不能转成int类型？能不能转化成String类型，能不能转成double类型？

char在java中也是比较特殊的类型，它的int值从1开始，一共有2的16次方个数据；

char<int<long<ﬂoat<double；char类型可以隐式转成int,double类型，但是不能隐式转换成String；

如果char类型转成byte，short类型的时候，需要强转。

15、什么是拆装箱？

1.装箱就是自动将基本数据类型转换为包装器类型（int—>Integer）；调用方法Integer的valueOf(int)方法

2.拆箱就是自动将包装器类型转换为基本数据类型（Integer—>int）。调用方法Integer的intValue()方法

在JDK5之前，如果要生成一个数值为10的Integer对象，必须这样进行：

 Integer i = new Integer(10)

而在从JDK5开始就提供了自动装箱的特性，如果要生成一个数值为10的Integer对象，只需要这样就可以了：

Integer i = 10;

面试题：以下代码会输出什么？

public class Main {
    public static void main(String[] args) {
        Integer i1 = 100;
        Integer i2 = 100;
        Integer i3 = 200;
        Integer i4 = 200;
        System.out.println(i1==i2);
        System.out.println(i3==i4);//超过范围 -128~127 还是取决于参数配置。
    }
}
//结果  true   false

16、Java中的包装类都是那些？

byte：Byte，short：Short，int：Integer，long：Long，

ﬂoat：Float，double：Double，char： Character，boolean：Boolean

17、一个java类中包含哪些内容？

属性、方法、内部类、构造方法、代码块。

18、那针对浮点型数据运算出现的误差的问题，你怎么解决？

使用BigDecimal类进行浮点型数据的运算

19、面向对象的特征有哪些方面?

抽象:

抽象是将一类对象的共同特征总结出来构造类的过程, 包括数据抽象和行为抽象两方面。抽象只关注对象有哪些属性和行为,并不关注这些行为的细节是什么。

继承:

继承是从已有类得到继承信息创建新类的过程.提供继承信息的类被称为父类(超类、基类) ;得到继承信息的类被称为子类(派生类)。继承让变化中的软件系统有了一定的延续性  ,同时继承也是封装程序中可变因素的重要手段。

封装：

通常认为封装是把数据和操作数据的方法绑定起来，对数据的访问只能通过已定义的接口。面向对象的本质就是将现实世界描绘成一系列完全自治、封闭的对象。我们在类中编写的方法就是对实现细节的一种封装；我们编写一个类就是对数据和数据操作的封装。可以说，封装就是隐藏一切可隐藏的东西， 只向外界提供最简单的编程接口（可以想想普通洗衣机和全自动洗衣机的差别，明显全自动洗衣机封装更好因此操作起来更简单；我们现在使用的智能手机也是封装得足够好的，因为几个按键就搞定了所有的事情）。

多态性：

多态性是指允许不同子类型的对象对同一消息作出不同的响应。
简单的说就是用同样的对象引用调用同样的方法但是做了不同的事情。多态性分为编译时的多态性和运行时的多态性。如果将对象的方法视为对象向外界提供的 服务，那么运行时的多态性可以解释为：当 A 系统访问 B 系统提供的服务时，B 系统有多种提供服务的方式，但一切对  A  系统来说都是透明的（就像电动剃须刀是 A 系统，它的供电系统是 B 系统，B 系统可以使用电池供电或者用交流电， 甚至还有可能是太阳能，A 系统只会通过 B 类对象调用供电的方法，但并不知道供电系统的底层实现是什么，究竟通过何种方式获得了动力）。

方法重载（overload）实现的是编译时的多态性（也称为前绑定），

方法重写（override）实现的是运行时的多态性（也称为后绑定）。

运行时的多态是面向对象最精髓的东西，要实现多态需要做两件事：1). 方法重写（子类继承父类并重写父类中已有的或抽象的方法）；2). 对象造型（用父类型引用引用子类型对象，这样同样的引用调用同样的方法就会根据子类对象的不同而表现出不同的行为）。

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

修饰符	当前类	同包	子类	其他包
public	能	能	能	能
protected	能	能	能	不能
default	能	能	不能	不能
private	能	不能	不能	不能

    类的成员不写访问修饰时默认为 default。默认对于同一个包中的其他类相当于公 开（public），对于不是同一个包中的其他类相当于私有（private）。受保护（protected）对子类相当于公开，对不是同一包中的没有父子关系的类相当于私 有。Java 中，外部类的修饰符只能是 public 或默认，类的成员（包括内部类）的  修饰符可以是以上四种。

21、String是基本数据类型吗？

不是。Java  中的基本数据类型只有  8  个：byte、short、int、long、ﬂoat、double、  char、boolean；除了基本类型（primitive type），剩下的都是引用类型（reference type），Java 5  以后引入的枚举类型也算是一种比较特殊的引用类型。

22、ﬂoat f=3.4;是否正确？

答:不正确。3.4 是双精度数，将双精度型（double）赋值给浮点型（ﬂoat）属于 下转型（down- casting，也称为窄化）会造成精度损失，因此需要强制类型转换 ﬂoat f =(ﬂoat)3.4; 或者写成 ﬂoat f =3.4F;。

23、short s1 = 1; s1 = s1 + 1;有错吗?short s1 = 1; s1 += 1;有错吗？

对于 short s1 = 1; s1 = s1 + 1;由于1是int类型，因此 s1+1 运算结果也是 int 型，需要强制转换类型才能赋值给short 型。而 short s1 = 1; s1 += 1;可以正确编译，因为 s1+= 1;相当于 s1 = (short)(s1 +1);其中有隐含的强制类型转换。

24、重载和重写的区别

重写(Override)

从字面上看，重写就是  重新写一遍的意思。其实就是在子类中把父类本身有的方法重新写一遍。子类继承了父类原有的方法，但有时子类并不想原封不动的继承父类中的某个方法，所以在方法名，参数列表，返回类 型(除过子类中方法的返回值是父类中方法返回值的子类时)都相同的情况下， 对方法体进行修改或重写，这就是重写。但要注意子类函数的访问修饰权限不能少于父类的。

public class Father {
    public static void main(String[] args) {
        Son s = new Son();
        s.sayHello();
    }
    public void sayHello() {
        System.out.println("Hello");
    }
}
class Son extends Father{
    @Override
    public void sayHello() {
        System.out.println("hello by ");
    }
}

原因：在某个范围内的整型数值的个数是有限的，而浮点数却不是。

重写总结：

1.发生在父类与子类之间

2.方法名，参数列表，返回类型（除过子类中方法的返回类型是父类中返回类型的子类）必须相同

3.访问修饰符的限制一定要大于被重写方法的访问修饰符（public>protected>default>private)

4.重写方法一定不能抛出新的检查异常或者比被重写方法申明更加宽泛的检查型异常

重载（Overload）

在一个类中，同名的方法如果有不同的参数列表（**参数类型不同、参数个数不同甚至是参数顺序不同**） 则视为重载。同时，重载对返回类型没有要求，可以相同也可以不同，但**不能通过返回类型是否相同来 判断重载**。

public class Father {
        public static void main(String[] args) {
            Father s = new Father();
            s.sayHello();
            s.sayHello("wintershii");
        }
        public void sayHello() {    
            System.out.println("Hello");
        }
        public void sayHello(String name) {
            System.out.println("Hello" + " " + name);
        }
}

重载总结：

1.重载Overload是一个类中多态性的一种表现

2.重载要求同名方法的参数列表不同(参数类型，参数个数甚至是参数顺序)

3.重载的时候，返回值类型可以相同也可以不相同。无法以返回型别作为重载函数的区分标准

25、equals与==的区别

==：

    == 比较的是变量(栈)内存中存放的对象的(堆)内存地址，用来判断两个对象的地址是否相同，即是否是指相同一个对象。比较的是真正意义上的指针操作。

1、比较的是操作符两端的操作数是否是同一个对象。

2、两边的操作数必须是同一类型的（可以是父子类之间）才能编译通过。

3、比较的是地址，如果是具体的阿拉伯数字的比较，值相等则为true，如：

int a=10 与 long b=10L 与 double c=10.0都是相同的（为true），因为他们都指向地址为10的堆。

equals：

    equals用来比较的是两个对象的内容是否相等，由于所有的类都是继承自java.lang.Object类的，所以  适用于所有对象，如果没有对该方法进行覆盖的话，调用的仍然是Object类中的方法，而Object中的equals方法返回的却是==的判断。

总结：

    所有比较是否相等时，都是用equals      并且在对常量相比较时，把常量写在前面，因为使用object的equals  object可能为null  则空指针在阿里的代码规范中只使用equals  ，阿里插件默认会识别，并可以快速修改，推荐安装阿里插件来排查老代码使用“==”，替换成equals

26、i与i的区别

i++：先赋值，后计算

++i：先计算，后赋值

27、程序的结构有那些？

顺序结构

选择结构

循环结构

28、数组实例化有几种方式？

静态实例化：创建数组的时候已经指定数组中的元素,

int [] a= new int[]{ 1 , 3 , 3};

动态实例化：实例化数组的时候，只指定了数组长度，数组中所有元素都是数组类型的默认值

29、Java中各种数据默认值

byte,short,int,long默认是都是0 char类型的默认值是 \u0000 输出为空一个空格。

boolean默认值是false float与double类型的默认是0.0 对象类型的默认值是null

引用数据类型默认值都为null。

1、NULL：代表声明了一个空对象，不是一个字符串，可以赋给任何对象。

空字符：代表声明了一个对象实例，这个对象实例的值是一个长度为0的空字符串。

2、String s=null; 只是定义了一个句柄，即你有了个引用，但是这个引用未指向任何内存空间。

String s=” “; 这个引用已经指向了一块是空字符串的内存空间，是一个实际的东东了，所以可以对它操作。

String s=”a”和String s=new String(“a”);是有本质上的区别的：

(1) 前者是在字符串池里写入一个字符’a’,然后用s指向它；后者是在堆上创建一个内容为”a”的字符串对象。

30、Java常用包有那些？

Java.lang Java.io Java.sql Java.util

31、Object类常用方法有那些？

equals hashCode toString

wait notify clone

32、java中有没有指针？

有指针，但是隐藏了，开发人员无法直接操作指针，由jvm来操作指针

33、java中是值传递还是引用传递？

理论上说，java都是引用传递，对于基本数据类型，传递是值的副本，而不是值本身。对于对象类型，传递是对象的引用，当在一个方法操作参数的时候，其实操作的是引用所指向的对象。

34、实例化数组后，能不能改变数组长度呢？

不能，数组一旦实例化，它的长度就是固定的。底层是用final修饰的一维数组。

4.函数调用中发生的数据传送是单向的。即只能把实参的值传送给形参，而不能把形参的值反向地传送给实参。因此在函数调用过程中，形参的值发生改变，而实参中的值不会变化。

5.当形参和实参不是指针类型时，在该函数运行时，形参和实参是不同的变量，他们在内存中位于不同的位置，形参将实参的内容复制一份，在该函数运行结束的时候形参被释放，而实参内容不会改变。

而如果函数的参数是指针类型变量,在调用该函数的过程中，传给函数的是实参的地址，在函数体内部使用的也是实参的地址，即使用的就是实参本身。所以在函数体内部可以改变实参的值。

37、构造方法能不能显式调用？

不能，构造方法当成普通方法调用，只有在创建对象的时候它才会被系统调用。

构造方法是创建对象并为对象初始化的。

38、什么是方法重载？

方法的重载就是在同一个类中允许同时存在一个以上的同名方法，只要它们的参数个数或者类型不同即可。在这种情况下，该方法就叫被重载了，这个过程称为方法的重载（override）

方法名相同参数列表不同。

39、构造方法能不能重写？能不能重载？

可以重载。构造器不能被继承，因此不能被重写。

40、内部类与静态内部类的区别？

静态内部类相对与外部类是独立存在的，在静态内部类中无法直接访问外部类中变量、方法。如果要访问的话，必须要new一个外部类的对象，使用new出来的对象来访问。但是可以直接访问静态的变量、调用静态的方法；

普通内部类作为外部类一个成员而存在，在普通内部类中可以直接访问外部类属性，调用外部类的方法。

如果外部类要访问内部类的属性或者调用内部类的方法，必须要创建一个内部类的对象，使用该对象访问属性或者调用方法。

如果其他的类要访问普通内部类的属性或者调用普通内部类的方法，必须要在外部类中创建一个普通内部类的对象作为一个属性，外同类可以通过该属性调用普通内部类的方法或者访问普通内部类的属性

如果其他的类要访问静态内部类的属性或者调用静态内部类的方法，直接创建一个静态内部类对象即可。

public class OuterClass{
      static class InnerClass1{}
      class InnerClass2{}
}
InnerClass1 inner1 = new InnerClass1();
OuterClass outer =new OuterClass();
InnerClass2 inner2 =outer.new InnerClass2();

41、static关键字有什么作用？

static可以修饰内部类、方法、变量、代码块。

static修饰的类是静态内部类，static修饰的方法是静态方法，表示该方法属于当前类的，而不属于某个对象的，静态方法也不能被重写，可以直接使用类名来调用。在static方法中不能使用this或者super关键字。

static修饰变量是静态变量或者叫类变量，静态变量被所有实例所共享，不会依赖于对象。静态变量在内存中只有一份拷贝，在JVM加载类的时候，只为静态分配一次内存。

static修饰的代码块叫静态代码块，通常用来做程序优化的。静态代码块中的代码在整个类加载的时候只会执行一次。静态代码块可以有多个，如果有多个，按照先后顺序依次执行。

42、ﬁnal在java中的作用，有哪些用法?

被ﬁnal修饰的类不可以被继承
被ﬁnal修饰的方法不可以被重写
被ﬁnal修饰的变量不可以被改变.如果修饰引用,那么表示引用不可变,引用指向的内容可变.
被ﬁnal修饰的方法,JVM会尝试将其内联,以提高运行效率
被ﬁnal修饰的常量,在编译阶段会存入常量池中.

除此之外,编译器对ﬁnal域要遵守的两个重排序规则：（重排：编译器的特点）

1.在构造函数内对一个final域的写入,与随后把这个被构造对象的引用赋值给一个引用变量,这两个操作之间不能重排序.

（创建final修饰的引用时，一定是先在堆内存中创建对象，后再将引用指向，确保这个引用一定有值。）

2.初次读一个包含final域的对象的引用,与随后初次读这个final域,这两个操作之间不能重排序.

42 static final abstract 之间辨析

abstract只能修饰抽象的东西，即未被实现的东西，而属性一般不用继承，不用被实现，所以不能修饰属性。

普通类是不允许声明为静态的，只有内部类才可以。（静态类是没有实际意义的，而且运行初始化还要占用大量内存，而且假如有静态类，不能被重写，不能被创建，没啥实际意义。）

43、String、StringBuﬀer 和 StringBuilder 的区别是什么？

    String是只读字符串，它并不是基本数据类型，而是一个对象。从底层源码来看是一个ﬁnal类型的字符数组，所引用的字符串不能被改变，一经定义，无法再增删改。每次对String的操作都会生成新的String对象。

 private final char value[];

    每次+操作 ： 隐式在堆上new了一个跟原字符串相同的StringBuilder对象，再调用append方法拼接+后面的字符。
    StringBuﬀer与StringBuilder都继承了AbstractStringBuilder类，而AbtractStringBuilder又实现了CharSequence接口，两个类都是用来进行字符串操作的。在做字符串拼接修改删除替换时，效率比String更高。
    StringBuﬀer是线程安全的，StringBuilder是非线程安全的。所以StringBuilder比StringBuﬀer效率更高，StringBuﬀer的方法大多都加了synchronized关键字。

44、String str=”aaa”与String str=new String(“aaa”)一样吗？

不一样，前者会在字符串常量池中创建对象；后者会在堆内存中创建对象。

45、讲下java中的Math类有那些常用方法？

pow()：幂运算 sqrt()：平方根 round()：四舍五入 abs()：求绝对值

random()：生成一个0-1的随机数，包括0不包括1

46、String类的常用方法有那些？

charAt()：返回指定索引处的字符 indexOf()：返回指定字符的索引 replace()：字符串替换

trim()：去除字符串两端空白 split()：分割字符串，返回一个分割后的字符串数组

getBytes()：返回字符串的byte类型数组 (在网络编程中用到)

length()：返回字符串长度 toLowerCase()：将字符串转成小写字母 toUpperCase()：将字符串转成大写字符

substring()：截取字符串截取图片的名称重新拼接成新的名称。

format()：格式化字符串

equals()：字符串比较

47、Java中的继承是单继承还是多继承

Java中既有单继承：对于java类来说只能有一个父类。

又有多继承：对于接口来说可以同时继承多个接口。

48、super与this表示什么？

super表示当前类的父类引用可以不写总是出现在构造方法的第一位。

this表示当前类的对象

49、普通类与抽象类有什么区别？实例化

普通类不能包含抽象方法，抽象类可以包含抽象方法抽象类不能直接实例化，普通类可以直接实例化

50、什么是接口？为什么需要接口？

接口就是某个事物对外提供的一些功能的声明，是一种特殊的java类，接口弥补了java单继承的缺点

51、接口有什么特点？

接口中声明全是public static ﬁnal修饰的常量接口中所有方法都是抽象方法接口是没有构造方法的接口也不能直接实例化接口可以多继承

52、抽象类和接口的区别?

抽象类：not all

1.抽象方法，只有行为的概念，没有具体的行为实现。使用abstract关键字修饰，没有方法体。子类必须重写这些抽象方法。

2.包含抽象方法的类，一定是抽象类。

3.抽象类只能被继承，一个类只能继承一个抽象类。

接口： all

1.全部的方法都是抽象方法，属性都是常量

2.不能实例化，可以定义变量。

3.接口变量可以引用具体实现类的实例

4.接口只能被实现，一个具体类实现接口，必须实现全部的抽象方法

5.接口之间可以多实现

6.一个具体类可以实现多个接口，实现多继承现象

7.JDK1.8 后，可以有默认方法和默认方法

53、hashCode的作用

    java的集合有两类，一类是List，还有一类是Set。前者有序可重复，后者无序不重复。当我们在set中插入的时候怎么判断是否已经存在该元素呢，可以通过equals方法。但是如果元素太多，用这样的方法就会比较麻烦。
    于是有人发明了哈希算法来提高集合中查找元素的效率。  这种方式将集合分成若干个存储区域，每个对象可以计算出一个哈希码，可以将哈希码分组，每组分别对应某个存储区域，根据一个对象的哈希码就可以确定该对象应该存储的那个区域。
    hashCode方法可以这样理解：它返回的就是根据对象的内存地址换算出的一个值。这样一来，当集合要添加新的元素时，先调用这个元素的hashCode方法，就一下子能定位到它应该放置的物理位置上。   如果这个位置上没有元素，它就可以直接存储在这个位置上，不用再进行任何比较了；如果这个位置上已经有元素了，就调用它的equals方法与新元素进行比较，相同的话就不存了，不相同就散列其它的地址。这样一来实际调用equals方法的次数就大大降低了，几乎只需要一两次。

54、Java的四种引用，强弱软虚（了解）

强软弱虚

55、Java创建对象有几种方式？

java中提供了以下四种创建对象的方式:

1.new创建新对象 new 类名();

2.通过反射机制 c.newInstance();

类名.class Class.foName(全类名) 对象名.getClass();

3.通过ObjectInputStream反序列化机制，把一个对象以二进制的形式读出。

4.采用clone机制

第五种方式他妈的又让他装B了

//创建一个User类,用get/set来写name和age，写一个构造函数，写一个返回值，继承Cloneable接口，实现其方法。
public class User implements Cloneable {
    public User() {
        System.out.println("构造函数");
    }
    private String name;
    private int age;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    @Override
    public String toString() {
        return "User [name=" + name + ", age=" + age + "]";
    }
      @Override
    protected User clone() throws CloneNotSupportedException {
        // TODO Auto-generated method stub
        User u1 =(User) super.clone();
        return u1;
    }
}
//写一个Test类来克隆对象
public class Test2 {
    public static void main(String[] args) {
        User a1 = new User();
        a1.setName("张三");
        a1.setAge(20);
        try {
            User a2 = a1.clone();  //克隆是不会执行构造函数的，只能看到一条"构造函数"输出
            System.out.println(a2==a1);  //false 内存地址不一样
            System.out.println(a1); //a1与a2内存地址不一样，但是属性相同
            System.out.println(a2);
            System.out.println("-----------------------");
              //浅度克隆
            a1.setName("李四");
            a1.setAge(21);
            System.out.println(a1);   //a1发生改变
            System.out.println(a2);   //a2未发生变化
        } catch (CloneNotSupportedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }    
    }
}

56、有没有可能两个不相等的对象有相同的hashcode

有可能.在产生hash冲突时,两个不相等的对象就会有相同的 hashcode 值.

57、深拷贝和浅拷贝的区别是什么?

浅拷贝:

    被复制对象的所有变量都含有与原来的对象相同的值,而所有的对其他对象的引用仍然指向原来的对象。 换言之,浅拷贝仅仅复制所拷贝的对象,而不复制它所引用的对象.

public class ShallowCopy {
    public static void main(String[] args) throws CloneNotSupportedException {
        Teacher teacher = new Teacher();
        teacher.setName("riemann");
        teacher.setAge(27);
        Student2 student1 = new Student2();
        student1.setName("edgar");
        student1.setAge(18);
        student1.setTeacher(teacher);
        Student2 student2 = (Student2) student1.clone();
        System.out.println("浅拷贝后");
        System.out.println(student2.getName());
        System.out.println(student2.getAge());
        System.out.println(student2.getTeacher().getName());
        System.out.println(student2.getTeacher().getAge());
        System.out.println("修改老师的信息后-------------");
        // 修改老师的信息
        teacher.setName("Games");
        System.out.println(student1.getTeacher().getName());
        System.out.println(student2.getTeacher().getName());
    }
}
class Teacher implements Cloneable {
    private String name;
    private int age;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}
class Student2 implements Cloneable {
    private String name;
    private int age;
    private Teacher teacher;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public Teacher getTeacher() {
        return teacher;
    }
    public void setTeacher(Teacher teacher) {
        this.teacher = teacher;
    }
    public Object clone() throws CloneNotSupportedException {
        Object object = super.clone();
        return object;
    }
}
//输出结果
浅拷贝后
edgar
18
riemann
27
修改老师的信息后-------------
Games
Games
结果分析： 
      两个引用student1和student2指向不同的两个对象，但是两个引用student1和student2中的两个teacher引用指向的是同一个对象，所以说明是浅拷贝。

1.JavaOOP面试题 - 图1

深拷贝:

    被复制对象的所有变量都含有与原来的对象相同的值。而那些引用其他对象的变量将指向被复制过的新对象，而不再是原有的那些被引用的对象。换言之，深拷贝把要复制的对象所引用的对象都复制了一遍。

public class DeepCopy {
    public static void main(String[] args) throws CloneNotSupportedException {
        Teacher2 teacher = new Teacher2();
        teacher.setName("riemann");
        teacher.setAge(27);
        Student3 student1 = new Student3();
        student1.setName("edgar");
        student1.setAge(18);
        student1.setTeacher(teacher);
        Student3 student2 = (Student3) student1.clone();
        System.out.println("深拷贝后");
        System.out.println(student2.getName());
        System.out.println(student2.getAge());
        System.out.println(student2.getTeacher().getName());
        System.out.println(student2.getTeacher().getAge());
        System.out.println("修改老师的信息后-------------");
        // 修改老师的信息
        teacher.setName("Games");
        System.out.println(student1.getTeacher().getName());
        System.out.println(student2.getTeacher().getName());
    }
}
class Teacher2 implements Cloneable {
    private String name;
    private int age;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}
class Student3 implements Cloneable {
    private String name;
    private int age;
    private Teacher2 teacher;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public Teacher2 getTeacher() {
        return teacher;
    }
    public void setTeacher(Teacher2 teacher) {
        this.teacher = teacher;
    }
    public Object clone() throws CloneNotSupportedException {
        // 浅复制时：
        // Object object = super.clone();
        // return object;
        // 改为深复制：
        Student3 student = (Student3) super.clone();
        // 本来是浅复制，现在将Teacher对象复制一份并重新set进来
        student.setTeacher((Teacher2) student.getTeacher().clone());
        return student;
    }
}
//输出结果：
深拷贝后
edgar
18
riemann
27
修改老师的信息后-------------
Games
riemann
结果分析：
    两个引用student1和student2指向不同的两个对象，两个引用student1和student2中的两个teacher引用指向的是两个对象，但对teacher对象的修改只能影响student1对象,所以说是深拷贝。

1.JavaOOP面试题 - 图2

总结：B复制了A，当修改A时，看B是否会发生变化，如果B也跟着变了，说明这是浅拷贝，拿人手短，如果B没变，那就是深拷贝，自食其力。深拷贝相比于浅拷贝速度较慢并且花销较大。

58、static都有哪些用法?

1.静态变量和静态方法，也就是被static所修饰的变量/方法都属于类的静态资源,类实例所共享.

2.除了静态变量和静态方法之外,static也用于静态块,多用于初始化操作：

public calss PreCache{
        static{
            //执行相关操作
        }
}

3.此外static也多用于修饰内部类,此时称之为静态内部类.

4.最后一种用法就是静态导包,即 import static .import static是在JDK 1.5之后引入的新特性,可以用来指定导入某个类中的静态资源,并且不需要使用类名,可以直接使用资源名,比如:

import static java.lang.Math.*;
public class Test{
    public static void main(String[] args){
        System.out.println(Math.sin(20));
        //传统做法
        System.out.println(sin(20));
    }
}

59、a=a+b与a+=b有什么区别吗?存在自动转换。

    += 操作符会进行隐式自动类型转换,此处a+=b隐式的将加操作的结果类型强制转换为持有结果的类型, 而a=a+b则不会自动进行类型转换.

例1：

byte a = 127;
byte b = 127;
b = a + b; // 报编译错误:cannot convert from int to byte 
b += a;

例2：以下代码是否有错,有的话怎么改？

short s1= 1;
s1 = s1 + 1;

    有错误.short类型在进行运算时会自动提升为int类型,也就是说 s1+1 的运算结果是int类型,而s1是short 类型,此时编译器会报错.

正确写法：+=操作符会对右边的表达式结果强转匹配左边的数据类型,所以没错.

short s1= 1;
s1 += 1;

60、ﬁnal、ﬁnalize()、ﬁnally

性质不同:

1.ﬁnal为关键字；

2.ﬁnalize()为方法；

3.ﬁnally为区块标志，用于try语句中；

作用:

1.ﬁnal为用于标识常量的关键字，ﬁnal标识的关键字存储在常量池中（在这里ﬁnal常量的具体用法将在下面进行介绍）；

2.ﬁnalize()方法在Object中进行了定义，用于在对象“消失”时，由JVM进行调用用于对对象进行垃圾回收，类似于C++中的析构函数；用户自定义时，用于释放对象占用的资源（比如进行I/0操作）；

3.ﬁnally{}用于标识代码块，与try{}进行配合，不论try中的代码执行完或没有执行完（这里指有异常），该代码块之中的程序必定会进行；

61、&和&&的区别

&是位运算符。&&是布尔逻辑运算符，在进行逻辑判断时用&处理的前面为false后面的内容仍需处理，用&&处理的前面为false不再处理后面的内容。

62、静态内部类如何定义

定义在类内部的静态类，就是静态内部类。

1.静态内部类可以访问外部类所有的静态变量和方法，即使是 private 的也一样。

2.静态内部类和一般类一致，可以定义静态变量、方法，构造方法等。

3.其它类使用静态内部类需要使用“外部类.静态内部类”方式。？？？

4.Java集合类HashMap内部就有一个静态内部类Entry。Entry是HashMap存放元素的抽象，HashMap 内部维护 Entry 数组用了存放元素，但是 Entry 对使用者是透明的。像这种和外部类关系密切的，且不依赖外部类实例的，都可以使用静态内部类。

63、什么是成员内部类

定义在类内部的非静态类，就是成员内部类。

64、Static Nested Class和Inner Class的不同

    Nested Class （一般是C的说法），Inner Class (一般是JAVA的说法)。Java内部类与C嵌套类最大的不同就在于是否有指向外部的引用上。

注：静态内部类（Inner Class）意味着：

1.创建一个static内部类的对象，不需要一个外部类对象。

2.不能从一个static内部类的对象访问一个外部类对象。

65、什么时候用assert

assertion(断言)在软件开发中是一种常用的调试方式，很多开发语言中都支持这种机制。在实现中，assertion就是在程序中的一条语句，它对一个boolean表达式进行检查，一个正确程序必须保证这个boolean表达式的值为true；如果该值为false，说明程序已经处于不正确的状态下，系统将给出警告或退出。一般来说，assertion用于保证程序最基本、关键的正确性。assertion检查通常在开发和测试时开启。为了提高性能，在软件发布后，assertion检查通常是关闭的。

66、Java有没有goto

java中的保留字，现在没有在java中使用

67、数组有没有length()这个方法? String有没有length()这个方法

数组没有length()这个方法，有length的属性。String有length()这个方法。

68、用最有效率的方法算出2乘以8等于几？

2 << 3

69、ﬂoat型ﬂoat f=3.4是否正确?

不正确。精度不准确,应该用强制类型转换，如下所示：ﬂoat f = (ﬂoat)3.4;

这种写法为double类型。

70、排序都有哪几种方法？请列举

排序的方法有：插入排序（直接插入排序、希尔排序），交换排序（冒泡排序、快速排序），选择排序（直接选择排序、堆排序），归并排序，分配排序（箱排序、基数排序）快速排序的伪代码。

71、静态变量和实例变量的区别？

静态变量 static int i = 10; 使用时：A.i;

实例变量 int i = 20; 使用时：A a = new A(); a.i;

72、说出一些常用的类，包，接口，请各举5个

常用的类：BuﬀeredReader BuﬀeredWriter FileReader FileWirter String Integer

常用的包：java.lang java.awt java.io java.util java.sql

常用的接口：Collection List Map Set Serializable

73、hashCode() 有什么用？与 a.equals(b) 有什么关系？

    hashCode() 方法是相应对象整型的 hash 值。它常用于基于 hash 的集合类，如 Hashtable、HashMap、LinkedHashMap等等。它与 equals() 方法关系特别紧密。根据 Java 规范，两个使用equals() 方法来判断相等的对象，必须具有相同的 hash code。

74、Java中的编译期常量是什么？使用它又什么风险？

    公共静态不可变（public static ﬁnal ）变量也就是我们所说的编译期常量，这里的 public 可选的。实际上这些变量在编译时会被替换掉，因为编译器知道这些变量的值，并且知道这些变量在运行时不能改变。这种方式存在的一个问题是你使用了一个内部的或第三方库中的公有编译时常量，但是这个值后面被其他人改变了，但是你的客户端仍然在使用老的值，甚至你已经部署了一个新的jar。为了避免这种情况，当你在更新依赖 JAR 文件时，确保重新编译你的程序。

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

    在最外层循环前加一个标记如 A，然后用 break A;可以跳出多重循环。（Java 中支持带标签的 break 和continue 语句，作用有点类似于 C 和 C++中的 goto 语句，但是就像要避免使用 goto 一样，应该避免使用带标签的 break 和 continue，因为它不会让你的程序变得更优雅，很多时候甚至有相反的作用， 所以这种语法其实不知道更好）

76、两个对象值相同(x.equals(y) == true)，但却可有不同的hash code，这句话对不对？

    不对，如果两个对象 x 和 y 满足 x.equals(y) == true，它们的哈希码（hash code）应当相同。

Java 对于 eqauls 方法和 hashCode 方法是这样规定的：

(1)如果两个对象相同（equals 方法返回 true），那么它们的 hashCode 值一定要相同；

(2)如果两个对象的 hashCode 相同，它们并不一定相同。

当然，你未必要按照要求去做，但是如果你违背了上述原则就会发现在使用容器时，相同的对象可以出现在 Set 集合中，同时增加新元素的效率会大大下降（对于使用哈希存储的系统，如果哈希码频繁的冲突将会造成存取性能急剧下降）。

77、是否可以继承String类？

    String 类是 ﬁnal 类，不可以被继承，继承 String 本身就是一个错误的行为，对 String 类型最好的重用方式是关联关系（Has-A）和依赖关系（Use-A）而不是继承关系（Is-A）。

78、当一个对象被当作参数传递到一个方法后，此方法可改变这个对象的属性，并可返回变化后的结果，那么这里到底是值传递还是引用传递？

    是值传递。Java    语言的方法调用只支持参数的值传递。当一个对象实例作为一个参数被传递到方法中时，参数的值就是对该对象的引用。

79、抽象的（abstract）方法是否可同时是静态的（static）,是否可同时是本地方法（native），是否可同时被synchronized修饰？

    都不能。抽象方法需要子类重写，而静态的方法是无法被重写的，因此二者是矛盾的。本地方法是由本地代码（如 C 码）实现的方法，而抽象方法是没有实现的，也是矛盾的。synchronized 和方法的实现细节有关，抽象方法不涉及实现细节，因此也是相互矛盾的。

80、char型变量中能不能存贮一个中文汉字，为什么？

    char 类型可以存储一个中文汉字，因为 Java 中使用的编码是 Unicode（不选择任何特定的编码，直接使用字符在字符集中的编号，这是统一的唯一方法），一个 char 类型占 2 个字节（16 比特），所以放一个中文是没问题的。
    **补充：**使用 Unicode 意味着字符在 JVM 内部和外部有不同的表现形式，在 JVM内部都是 Unicode，当这个字符被从 JVM 内部转移到外部时（例如存入文件系统中），需要进行编码转换。所以 Java 中有字节流和字符流，以及在字符流和字节流之间进行转换的转换流，如 InputStreamReader 和OutputStreamReader，这两个类是字节流和字符流之间的适配器类，承担了编码转换的任务。

81、Java中会存在内存泄漏吗，请简单描述。

    理论 上 Java 因为 有垃 圾回 收机 制（ GC）不 会存 在内 存泄 露问 题（ 这也 是 Java 被广泛 使用 于服务器 端编 程的 一个 重要 原因 ）； 然而 在实 际开 发中 ，可 能会 存在 无用但 可达 的对 象，这些 对象 不能 被 GC 回收 ，因此 也会 导致 内存 泄露 的发 生 。

    例如Hibernate 的 Session（ 一级 缓存 ）中的 对象属于持久态，垃圾回收器是不会回收这些对象的，然而这些对象 中可能存在无用的垃圾对象 ，如果不及时关 闭（close）或清 空（ ﬂush）一级缓存就可能导致内存泄露 。下面例子中的代码也会导致内存泄露。

import java.util.Arrays;
import java.util.EmptyStackException; 
public class MyStack<T> {
  private T[] elements; 
  private int size = 0;
    private static final int INIT_CAPACITY = 16; 
  public MyStack() {
        elements = (T[]) new Object[INIT_CAPACITY];
    }
  public void push(T elem) { 
    ensureCapacity(); 
    elements[size++] = elem;
    }
  public T pop() { 
    if(size == 0)
            throw new EmptyStackException(); 
        return elements[--size];
        }    
  private void ensureCapacity() { 
    if(elements.length == size) {
            elements = Arrays.copyOf(elements, 2 * size + 1);
        }
    }
}

    上面的代码实现了一个栈（先进后出（FILO））结构，乍看之下似乎没有什么明显的问题，它甚至可以 通过你编写的各种单元测试。然而其中的 pop 方法却存在内存泄露的问题，当我们用 pop 方法弹出栈中的对象时，该对象不会被当作垃圾回收，即使使用栈的程序不再引用这些对象，因为栈内部维护着对这些对象的过期引用（obsolete    reference）。在支持垃圾回收的语言中，内存泄露是很隐蔽的，这种内存泄露其实就是无意识的对象保持。如果一个对象引用被无意识的保留起来了，那么垃圾回收器不会处理这个对象，也不会处理该对象引用的其他对象，即使这样的对象只有少数几个，也可能会导致很多的对象被排除在垃圾回收之外，从而对性能造成重大影响，极端情况下会引发  Disk  Paging（物理内存与硬盘的虚拟内存交换数据），甚至造成 OutOfMemoryError。

82、是否可以从一个静态（static）方法内部发出对非静态（non- static）方法的调用？

    不可以，静态方法只能访问静态成员，因为非静态方法的调用要先创建对象，在调用静态方法时可能对象并没有被初始化。

83、如何实现对象克隆？

有两种方式：

1). 实现 Cloneable 接口并重写 Object 类中的 clone()方法；

2). 实现 Serializable 接口，通过对象的序列化和反序列化实现克隆，可以实现真正的深度克隆，代码如下。

**注意：**基于 序列 化和 反序 列化 实现 的克 隆不 仅仅 是深 度克 隆， 更重 要的 是通 过泛型限 定， 可以 检查 出要 克隆 的对 象是 否支 持序 列化 ，这 项检 查是 编译 器完 成的 ，不是 在运 行时 抛出 异常，这种是方案明显优于使 用Object 类的 clone 方法 克隆 对象。 让问 题在 编译 的时 候暴 露出 来总是好 过把 问题 留到 运行 时。

84、接口是否可继承（extends）接口？抽象类是否可实现implements接口？抽象类是否可继承具体类（concreteclass）？

接口可以继承接口，而且支持多重继承。抽象类可以实现 (implements)接口，抽象类可继承具体类也可以继承抽象类。

85、一个.java源文件中是否可以包含多个类（不是内部类）？有什么限制？

可以，但一个源文件中最多只能有一个公开类（public class）而且文件名必须和公开类的类名完全保持一致。

86、Anonymous Inner Class(匿名内部类)是否可以继承其它类？是否可以实现接口？

可以继承其他类或实现其他接口，在 Swing 编程和 Android 开发中常用此方式来实现事件监听和回调。

87、内部类可以引用它的外部类的成员吗？有没有什么限制？

一个内部类对象可以访问创建它的外部类对象的成员，包括私有成员。

88、JDBC操作的步骤

加载数据库驱动类

获得数据库连接

执行sql语句

给占位符赋值

处理返回结果

关闭资源

89、在使用jdbc的时候，如何防止出现sql注入的问题。

使用PreparedStatement类（给占位符传值），而不是使用Statement类（值的拼接）。

90、怎么在JDBC内调用一个存储过程？

使用CallableStatement。

91、是否了解连接池，使用连接池有什么好处？

    数据库连接是非常消耗资源的，影响到程序的性能指标。连接池是用来分配、管理、释放数据库连接的，可以使应用程序重复使用同一个数据库连接，而不是每次都创建一个新的数据库连接。通过释放空 闲时间较长的数据库连接避免数据库因为创建太多的连接而造成的连接遗漏问题，提高了程序性能。

92、你所了解的数据源技术有那些？使用数据源有什么好处？

    dbcp,c3p0等，用的最多还是c3p0，因为c3p0比dbcp更加稳定，安全；通过配置文件的形式来维护数据库信息，而不是通过硬编码。当连接的数据库信息发生改变时，不需要再更改程序代码就实现了数据库信息的更新。

1.JavaOOP面试题