Java文字面试测试题

基本数据类型

byte，short，long，int，float，double，char，boolean

基本类型传参和引用类型传参的区别

基本类型传参只传递数组，引用类型传递的是内存地址

Static的含义

静态变量：static关键字用来声明独立于对象的静态变量，无论一个类实例化多少对象，它的静态变量也只有一份拷贝。

’静态变量也被称为类变量，局部变量不能声明为static变量

静态方法：static关键字用来声明独立于对象的静态方法，静态方法不能使用类的非静态变量，静

态方法从参数列表得到数据，然后计算这些数据

final的含义

final表示“最后的，最终的”含义，变量一旦被赋值后，不能被重新赋值。

被final修饰的实例变量必须显式指定初始值。final修饰符通常和static修饰符一起使用来创建类常量

final修饰方法，父类中的final方法可以被子类继承，但不能被子类重写。声明final方法的主要目的

是防止该方法的内容被修改

final类不能被继承，没有类能够继承final类的任何特性

解释封装

在面向对象程式设计方法中，封装是指一种将抽象性函式接口的实现细节部分包装、隐藏起来的方法。

封装可以被认为是一个保护屏障，防止该类的代码和数据被外部类定义的代码随机访问。

要访问该类的代码和数据，必须通过严格的接口控制。

封装最主要的功能在于我们能修改自己的实现代码，而不用修改那些调用我们代码的程序片段。

适当的封装可以让程式码更容易理解与维护，也加强了程式码的安全性。

封装的优点

1. 良好的封装能够减少耦合。

2. 类内部的结构可以自由修改。

3. 可以对成员变量进行更精确的控制。

4. 隐藏信息，实现细节。

实现Java封装的步骤

1. 修改属性的可见性来限制对属性的访问（一般限制为private）

2. 对每个值属性提供对外的公共方法访问，也就是创建一对赋取值方法，用于对私有属性的访问

解释多态

多态是同一个行为具有多个不同表现形式或形态的能力

多态就是同一个接口，使用不同的实例而执行不同操作

多态的实现方式

方式一：重写

方式二：接口

方式三：抽象类和抽象方法

解释继承

子类拥有父类非 private 的属性、方法。

子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。

子类可以用自己的方式实现父类的方法。

Java 的继承是单继承，但是可以多重继承，单继承就是一个子类只能继承一个父类，多重继承

例如B类继承A类，C类继承B类，所以按照关系就是B类是C类的父类，A类是B类的父类

什么是抽象类

抽象类不能被实例化(初学者很容易犯的错)，如果被实例化，就会报错，编译无法通过。只有抽象

类的非抽象子类可以创建对象。

抽象类中不一定包含抽象方法，但是有抽象方法的类必定是抽象类。

抽象类中的抽象方法只是声明，不包含方法体，就是不给出方法的具体实现也就是方法的具体功能。

构造方法，类方法（用 static 修饰的方法）不能声明为抽象方法。

抽象类的子类必须给出抽象类中的抽象方法的具体实现，除非该子类也是抽象类。

什么是抽象方法

抽象方法没有定义，方法名后面直接跟一个分号，而不是花括号。

如果一个类包含抽象方法，那么该类必须是抽象类。

任何子类必须重写父类的抽象方法，或者声明自身为抽象类。

抽象类和普通类的区别

普通类可以去实例化调用；

抽象类不能被实例化，因为它是存在于一种概念而不非具体。

普通类和抽象类都可以被继承，但是抽象类被继承后子类必须重写继承的方法，除非自类也是抽象类。

普通类中不能有抽象方法，抽象类中可以有抽象方法也可以有非抽象方法。

接口和抽象类的区别

接口里面只能有抽象方法，抽象类中可以有抽象方法也可以有非抽象方法。

普通类一次只能继承一个抽象类，普通类一次可以实现多个接口。

抽象类和接口都是用来抽象具体对象的，但是接口的抽象级别最高

抽象类可以有具体的方法和属性,  接口只能有抽象方法和不可变常量

抽象类主要用来抽象类别，接口主要用来抽象功能.

写出四个访问修饰符

java中，可以使用访问控制符来保护对类、变量、方法和构造的访问。支持四种不同的访问权限

default（缺省的）：（即默认，什么也不写）在同一包内可见，不使用任何修饰符。使用范围:类、接口、变量、方法

private：在同一类可见。使用范围：变量、方法，注意不能修饰类（外部类）

public：所有类可见。使用范围：类、接口、变量、方法

protected（受保护的）：同一包内的类和所有子类可见，使用范围：变量、方法，注意不能修饰类（外部类）

ArrayList和LinkedList的区别

二者实现结构不同arraylist是基于数组，linkedlist是基于链表，他们的特性也是由其数据结构决定的

随机遍历访问时linkedlist的性能要低于arraylist

arraylist的初始化时默认10容量，而linkedlist默认初始化为空

linkedlist的增删要优于arraylist
 

List和Set区别

List，Set都是继承自Collection接口

List特点：元素有放入顺序，元素可重复 ，Set特点：元素无放入顺序，元素不可重复，重复元素会覆盖掉，（元素虽然无放入顺序，但是元素在set中的位置是有该元素的HashCode决定的，其位置其实是固定的，加入Set 的Object必须定义equals()方法 ，另外list支持for循环，也就是通过下标来遍历，也可以用迭代器，但是set只能用迭代，因为他无序，无法用下标来取得想要的值。） 

Set和List对比： 

Set：检索元素效率低下，删除和插入效率高，插入和删除不会引起元素位置改变。

List：和数组类似，List可以动态增长，查找元素效率高，插入删除元素效率低，因为会引起其他元素位置的改变

ArrayList常用方法

add(E e) 在集合末尾新增一个元素

add(int index, E element) 在指定位置添加元素

get(int index）获取指定位置的元素

remove(int index) 删除指定位置的元素

remove(Object o) 删除指定元素

indexOf(Object o) 查询指定元素的位置 lastIndexOf也一样，只是从尾部开始遍历

set(int index, E element) 设置指定位置的元素值

retainAll(Collection<?> c) 求两个集合的交集

clear() 循环将元素值=null

contains(Object o) 是否包含某元素

HashSet常用方法

add(Object obj) 向Set集合中添加元素，添加成功返回true，否则返回false。

size() 返回Set集合中的元素个数。

remove(Object obj) 删除Set集合中的元素，删除成功返回true，否则返回false。

isEmpty() 如果Set不包含元素，则返回 true ，否则返回false。

clear() 移除此Set中的所有元素。

iterator() 返回在此Set中的元素上进行迭代的迭代器。

contains(Object o) 如果Set包含指定的元素，则返回 true，否则返回false。

 

如何给List<Person>中的数据按照年龄进行升序排序？

public class Test_01 implements Comparable<Test_01>{
    private int age;

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Test_01() {
    }

    public Test_01(int age) {
        this.age = age;
    }

    @Override
    public int compareTo(Test_01 o) {
        return this.age-o.age;
    }

HashMap的底层数据结构是什么

数组，链表，红黑树

Jdk1.7之前，HashMap是由数据+链表组成；1.8之后，HashMap是由数组+链表+红黑树组成

链表长度大于8之后，这个链表会自动变成红黑树，这样做的目的是提高查询效率

红黑树可以根据左旋，右旋，减少两侧的深度差。

如果不人为干涉，二叉树可能变为链表结构

就可以通过左旋，右旋，让这个特殊的二叉树变为一个平衡二叉树

       红黑树就是自平衡二叉树（自动进行左旋，或者右旋），减少两侧的深度差，保持平衡

HashMap为什么有数组和链表，而不是单纯的数组呢？

       为了解决哈希（hash）冲撞问题，我们要明白一个问题，向HashMap放值的逻辑是什么？

       根据key，计算hash值，再根据hash值除以数组的长度，取余数。余数就是要存放的下标。

例：map.put(“孙悟空”);

根据 孙悟空 字符串算出hash值，再除以16取余数，余数一定是0~15；假设余数是10，那么就放在下标是10的位置

为什么要扩容两倍？原因如下

如果元素数量达到数组的75%，会自动扩容（假设原来是16，现在是32），然后所有的元素都要rehash（重新计算hash值）。

hash值要除以新的容量（32）取余数。要保证新的下标和旧的下标保持一致

       例：map.put(“孙悟空”);     

       得到一个hash值，hash值除以16取余数，假设余数是10.过一会扩容了，容量变成32，再计算hash值除以32取余数，还要保证这个数的余数刚好是10

Hash冲撞

      map.put(“大师兄”,”孙悟空”);          | 可能=10（下标）

map.put(“二师兄”,”猪八戒”);          | 可能=10
 

如果不做处理，那么这两个元素可能在同一位置，后面的元素就必定覆盖到前面的元素。为了解决这个问题，就引入了链表，然后大师兄可以放在这个链表的第一个节点，二师弟可以放在链表的第二个节点

怎么从List中移除下标是2的元素

List.remove(2)

List.remove(list.get(2))

定义一个方法，判断集合List<Person>中是否存在name是“张三”的人，如果存在返回下标，如果不存在返回-1

Public int isExist(List<Person> persons, String name){

for(int i=0;i<persons.size();i++){

If(persons.get(i).getName().equals(name)){

Return i;

}

}

Return -1;

}