// Java Program to demonstrate use of Method Overloading
import java.io.*;
class GFG {
    static int multiply(int a, int b) { return a * b; }
    static int multiply(int a, int b, int c)
    {
        return a * b * c;
    }
    static int multiply(int a, int b, int c, int d)
    {
        return a * b * c * d;
    }
    public static void main(String[] args)
    {
        System.out.println("multiply() with 2 parameters");
        System.out.println(multiply(4, 5));
        System.out.println("multiply() with 3 parameters");
        System.out.println(multiply(2, 3, 4));
        System.out.println("multiply() with 4 parameters");
        System.out.println(multiply(2, 3, 4, 1));
    }
}

输出

multiply() with 2 parameters
20
multiply() with 3 parameters
24
multiply() with 4 parameters
24

方法重写：当子类可以提供父类或超类中已定义的方法的实现时，就会发生方法重写。返回类型、名称和参数必须与超类中的方法相似。

例子：

// Java Program to demonstrate use of Method Overriding
import java.io.*;
class Vehicle {
    void drive()
    {
        System.out.println("drive() method of base class");
        System.out.println("driving the Car.");
    }
}
class Car extends Vehicle {
    void drive()
    {
        System.out.println(
            "drive() method of derived class");
        System.out.println("Car is driving.");
    }
}
class GFG {
    public static void main(String[] args)
    {
        Car c1 = new Car();
        Vehicle v1 = new Vehicle();
        c1.drive();
        v1.drive();
        Vehicle vehicle = new Car();
        // drive() method of Vehicle class is overridden by
        // Car class drive()
        vehicle.drive();
    }
}

输出

drive() method of derived class
Car is driving.
drive() method of base class
driving the Car.
drive() method of derived class
Car is driving.

109. 我们可以覆盖私有方法吗？

Java 中无法覆盖私有方法。方法覆盖是指实现子类中的方法而不是父类中的方法。私有方法只能在声明它的类中访问。由于此方法对其他类不可见且无法访问，因此无法覆盖。 

110. 我们可以在子类中改变重写方法的作用域吗？

在 Java 中，无法修改重写方法的范围。子类方法的范围必须等于或大于超类方法的重写方法的范围。例如，如果超类中的重写方法具有公共范围，则子类中的重写方法可以具有公共范围或更易于访问的范围（如 protected 或 default）。但是，它不能具有更排他性的范围（如 private）。

111. 在子类中重写超类方法时，可以修改其 throws 子句吗？

我们可以修改超类方法的 throws 子句，但有一些限制，我们可以在子类中重写超类方法时更改其 throws 子句。如果超类方法未声明任何异常，则子类重写方法只能指定未检查异常。如果超类方法声明了异常，则子类方法可以声明相同的异常、子类异常或根本不声明异常。但是，子类方法不能声明比超类方法中声明的父类异常更广泛的父类异常。

112. Java 中可以使用虚函数吗？

是的，Java 支持虚拟函数。函数默认是虚拟的，可以使用 final 关键字将其变为非虚拟的。

113. 什么是抽象？

抽象是指表示基本特征而不包括背景细节的行为。详细信息或实现被隐藏。最常见的抽象示例是汽车，我们知道如何启动引擎、加速和行驶，但是，引擎的工作方式及其内部组件是隐藏在一般用户之外的复杂逻辑。通常这样做是为了处理复杂性。

114.什么是抽象类？

声明为抽象的类无法实例化，即无法创建对象。它可能包含或不包含抽象方法，但如果类至少有一个抽象方法，则必须将其声明为抽象。

具有抽象方法的抽象类的示例：

// Java Program to implement
// abstract method
import java.io.*;
// Abstract class
abstract class Fruits {
    abstract void run();
}
// Driver Class
class Apple extends Fruits {
    void run()
    {
        System.out.println("Abstract class example");
    }
    // main method
    public static void main(String args[])
    {
        Fruits obj = new Apple();
        obj.run();
    }
}

输出

Abstract class example

115. 何时使用抽象方法？

当我们想要使用一种方法但希望子类来决定实现时，就会使用抽象方法，在这种情况下，我们对父类使用抽象方法。

116. 如果基类实现了 Serializable 接口，如何避免在子类中序列化？

如果基类实现了 Serializable 接口，那么我们可以通过定义 writeObject() 方法并抛出 NotSerializableException() 来避免子类中的序列化。

117. Java 中的集合框架是什么？

集合是 Java 中的对象单位。集合框架是 Java 中的一组接口和类，用于以各种方式表示和操作对象集合。集合框架包含类（ArrayList、Vector、LinkedList、PriorityQueue、TreeSet）和多个接口（Set、List、Queue、Deque），其中每个接口用于存储特定类型的数据。

118. 解释 Collection 框架中使用的各种接口。

集合框架实现

1. Collection 接口
2. List 接口
3. Set 接口
4. Queue 接口
5. Deque 接口
6. Map 接口

Collection 接口： Collection 是可用的主要接口，可以使用 java.util.Collection 导入。

句法：

public interface Collection<E> extends iterable

119. 如何在 Java 中同步 ArrayList？

ArrayList 可以使用下面提到的两种方法进行同步：

1. 使用 Collections.synchronizedList()
2. 使用 CopyOnWriteArrayList

使用 Collections.synchronizedList()：

public static List<T> synchronizedList(List<T> list)

使用 CopyOnWriteArrayList：

1. 创建一个空列表。
2. 它实现了 List 接口
3. 它是 ArrayList 的线程安全变体
4. T 代表通用

120. 当我们在 Java 中拥有 Vectors （它们是同步的）时，为什么我们需要一个同步的 ArrayList？

由于某些原因，即使我们有 Vector，也需要 ArrayList：

1. ArrayList 比 Vectors 更快。
2. ArrayList 支持多线程，而 Vectors 仅支持单线程使用。
3. ArrayList 使用起来更安全，因为 Vectors 支持单线程，而单个操作的安全性较低且同步时间较长。
4. 由于向量的同步特性，它在 Java 中被认为已经过时了。

121.为什么我们不能创建一个通用数组？

无法创建泛型数组，因为数组在运行时会携带其元素的类型信息，因此如果元素的类型不相似，则会在运行时抛出“ArrayStoreException”。由于泛型类型信息在编译时被类型擦除所擦除，因此数组存储检查会通过，而它本应失败。

122. 你能解释一下 Java 中常规数组和 ArrayList 的元素在内存中是如何存储的吗？请解释一下。

Java 中常规数组的元素存储在连续的内存位置中，这意味着每个元素都存储在连续的内存块中。这样就可以通过索引轻松访问任何元素，因为可以使用数组的基地址和每个元素的大小来计算地址

相比之下，ArrayList 类实现了动态数组，这意味着其大小可以随着元素的添加或删除而改变。ArrayList 元素也存储在连续的内存位置，类似于数组。但是，当 ArrayList 达到其容量并需要添加更多元素时，将创建一个新的、更大的底层数组。然后将旧数组中的元素复制到新数组中。此过程确保 ArrayList 可以动态增长，同时将元素保持在连续的内存位置中。

123.解释将ArrayList转换为Array以及将Array转换为ArrayList的方法。

将 List 转换为 ArrayList

有多种方法可以将 List 转换为 ArrayList

程序员可以使用 Arrays 类的 asList() 方法将 Array 转换为 ArrayList。它是 Arrays 类的一个静态方法，接受 List 对象。

句法：

Arrays.asList(item)

// Java program to demonstrate conversion of
// Array to ArrayList of fixed-size.
import java.util.*;
// Driver Class
class GFG {
    // Main Function
    public static void main(String[] args)
    {
        String[] temp = { "Abc", "Def", "Ghi", "Jkl" };
        // Conversion of array to ArrayList
        // using Arrays.asList
        List conv = Arrays.asList(temp);
        System.out.println(conv);
    }
}

[Abc, Def, Ghi, Jkl]

ArrayList 到 Array 的转换

Java 程序员可以将 ArrayList 转换为

句法：

List_object.toArray(new String[List_object.size()])

import java.util.List;
import java.util.ArrayList;

// Driver Class
class GFG {
    // Main Function
    public static void main(String[] args) {
        // List declared
        List<Integer> arr = new ArrayList<>();
        arr.add(1);
        arr.add(2);
        arr.add(3);
        arr.add(2);
        arr.add(1);
        
        // Conversion
        Object[] objects = arr.toArray();
        
        // Printing array of objects
        for (Object obj : objects)
            System.out.print(obj + " ");
    }
}

1 2 3 2 1

124.ArrayList的大小如何动态增长？并说明其内部是如何实现的。

由于 ArrayLists 基于数组的特性，它的大小会动态增长，以确保始终有足够的空间容纳元素。首次创建 ArrayList 元素时，默认容量约为 10-16 个元素，这主要取决于 Java 版本。当原始数组的容量已满时，ArrayList 元素会从原始数组复制到新数组。随着 ArrayList 大小的动态增加，该类会创建一个更大大小的新数组，并将所有元素从旧数组复制到新数组。现在，新数组的引用在内部使用。动态增加数组的过程称为调整大小。 

125. Java 中的 Vector 是什么？

Java 中的向量与之类似，可以在其中存储多个元素。向量遵循以下某些规则：

1. 可以使用 Java.util.Vector 导入 Vector。
2. 向量是使用动态数组实现的，因为向量的大小根据插入到其中的元素而增加或减少。 
3. 使用索引号的向量元素。
4. 向量本质上是同步的，这意味着它们只使用单个线程（在特定时间只执行一个过程）。
5. 向量包含许多不属于集合框架的方法。

句法：

Vector gfg = new Vector(size, increment);

126. 如何使 Java ArrayList 为只读？

仅使用 Collections 提供的 Collections.unmodifiableList() 方法即可准备好 ArrayList。 

句法：

array_readonly = Collections.unmodifiableList(ArrayList);

例子：

import java.util.*;

public class Main {
    public static void main(String[] argv) throws Exception {
        try {
            // creating object of ArrayList
            ArrayList<Character> temp = new ArrayList<>();
            // populate the list
            temp.add('X');
            temp.add('Y');
            temp.add('Z');
            // printing the list
            System.out.println("Initial list: " + temp);
            
            // getting readonly list
            // using unmodifiableList() method
            List<Character> new_array = Collections.unmodifiableList(temp);
            
            // printing the list
            System.out.println("ReadOnly ArrayList: " + new_array);
            
            // Attempting to add element to new Collection
            System.out.println("\nAttempting to add element to the ReadOnly ArrayList");
            new_array.add('A');
        } catch (UnsupportedOperationException e) {
            System.out.println("Exception is thrown : " + e);
        }
    }
}

输出

Initial list: [X, Y, Z]
ReadOnly ArrayList: [X, Y, Z]

Attempting to add element to the ReadOnly ArrayList
Exception is thrown : java.lang.UnsupportedOperationException

127. Java中的优先级队列是什么？

优先级队列是一种类似于常规队列或堆栈数据结构的抽象数据类型。元素中存储的元素取决于从低到高定义的优先级。PriorityQueue 基于优先级堆。

句法：

import java.util.*;

class PriorityQueueDemo {
    // Main Method
    public static void main(String args[]) {
        // Creating empty priority queue
        PriorityQueue<Integer> var1 = new PriorityQueue<Integer>();
        // Adding items to the pQueue using add()
        var1.add(10);
        var1.add(20);
        var1.add(15);
        // Printing the top element of PriorityQueue
        System.out.println(var1.peek());
    }
}

10

128.解释 LinkedList 类。

LinkedList 类是使用双向链表存储元素的 Java 类。它继承了 AbstractList 类并实现了 List 和 Deque 接口。LinkedList 类的属性如下：

1. LinkedList 类是非同步的。
2. 保持插入顺序。
3. 它可以用作列表、堆栈或队列。

句法：

LinkedList<class> list_name=new LinkedList<class>();

129.Java中的Stack类是什么，它提供的各种方法有哪些？

Java 中的 Stack 类是一种 LIFO 数据结构，它实现了后进先出数据结构。它派生自 Vector 类，但具有特定于堆栈的功能。Java 中的 Stack 类提供以下方法：

• peek()：返回堆栈顶部的项目，但不将其移除
• empty()：如果堆栈为空，则返回 true，否则返回 false
• push()：将一个元素推到堆栈顶部
• pop()：移除并返回堆栈顶部的项目
• search()：返回对象从堆栈顶部开始的第 1 个基本位置。如果对象不在堆栈中，则返回 -1

130. Java Collections 框架中的 Set 是什么？列出它的各种实现？

集合是不存储重复元素的集合。它们不保留元素的任何顺序。Java 集合框架提供了 Set 接口的几种实现，包括：

• HashSet： Java 中的 HashSet 将元素存储在哈希表中，从而提供更快的查找和插入速度。HashSet 是无序的。
• LinkedHashSet： LinkedHashSet 是 HashSet 的一种实现，它维护元素的插入顺序。
• TreeSet： TreeSet 按照元素的自然顺序或创建时提供的自定义比较器确定的排序顺序存储元素。

131.Java 中的 HashSet 类是什么，它如何存储元素？

HashSet 类实现 Java 集合框架中的 Set 接口，是 HashSet 类的成员。与重复值不同，它存储不同元素的集合。在此实现中，使用哈希函数将每个元素映射到数组中的索引，并使用该索引快速访问元素。它根据输入元素为数组中的元素生成索引，并根据该索引存储元素。假设哈希函数在存储桶之间适当地分配元素，则 HashSet 类为基本操作（添加、删除、包含和大小）提供恒定时间性能。

132. Java 集合框架中的 LinkedHashSet 是什么？

LinkedHashSet 是 Hashset 的有序版本，由所有元素的双向链接列表维护。当需要迭代顺序时，它非常有用。在 LinkedHashSet 中进行迭代时，元素将按照插入的顺序返回。

句法： 

LinkedHashSet<E> hs = new LinkedHashSet<E>();

例子：

import java.io.*;
import java.util.*;

// Driver Class
class GFG {
    // Main Function
    public static void main(String[] args) {
        // LinkedHashSet declared
        LinkedHashSet<Integer> hs = new LinkedHashSet<Integer>();
        // Add elements in HashSet
        hs.add(1);
        hs.add(2);
        hs.add(5);
        hs.add(3);
        // Print values
        System.out.println("Values:" + hs);
    }
}

Values:[1, 2, 5, 3]

133.Java 中的 Map 接口是什么？

Map 接口存在于 Java 集合中，可与 Java.util 包一起使用。Map 接口用于以键值形式映射值。Map 包含所有唯一键。此外，它还提供与之相关的方法，如 containsKey()、contains value() 等。 

Map集合中有多种类型的Map，如下所述：

1. SortedMap
2. TreeMap
3. HashMap
4. LinkedHashMap

134. 解释 Java 中的树形图

TreeMap 是一种以键值对形式存储数据的映射。它使用红黑树实现。TreeMap 的特点是：

1. 它仅包含唯一元素。
2. 它不能有一个 NULL 键 
3. 它可以有多个 NULL 值。
4. 它是非同步的。
5. 它保持升序。

135.什么是EnumSet？

EnumSet 是 Set 接口的专门实现，用于枚举类型。EnumSet 的一些功能如下：

1. 它是非同步的。
2. 比HashSet更快。
3. EnumSet 中的所有元素必须来自单一枚举类型。
4. 它不允许空对象，并且会抛出NullPointerException异常。
5. 它使用故障安全迭代器。

句法：

public abstract class EnumSet<E extends Enum<E>> 

参数： E指定元素。

136.什么是BlockingQueue？

阻塞队列是支持在检索和移除元素时等待队列变为非空的操作，以及在添加元素时等待队列中的空间可用操作的队列。

句法：

public interface BlockingQueue<E> extends Queue<E>

参数： E 是 Collection 中存储的元素类型

137.Java 中的 ConcurrentHashMap 是什么，你实现了它吗？

ConcurrentHashMap是使用Hashtable实现的。

句法：

public class ConcurrentHashMap<K, ​V> 
extends AbstractMap<K, ​V> 
implements ConcurrentMap<K, ​V>, Serializable

参数：K 是键对象类型，V 是值对象类型

138.可以使用任何类作为 Map 的键吗？

是的，如果它遵循下面提到的某些预定义规则，我们就可以将其用作 Map Key：

1. 重写 equals() 方法的类也必须重写 hashCode() 方法
2. concurrentHashMap 类是线程安全的。
3. ConcurrentHashMap的默认并发级别是16。
4. 无法在 ConcurrentHashMap 中插入空对象作为键或值。

139. 什么是迭代器？

Iterator 接口提供了在 Java 中迭代任何 Collection 的方法。Iterator 是 Java Collections Framework 中 Enumeration 的替代品。它可以使用 _iterator()_ 方法从 Collection 中获取迭代器实例。它还允许调用者在迭代过程中从底层集合中删除元素。

140. 什么是枚举？

枚举是一种用户定义的数据类型。它主要用于为整数常量分配名称，这些名称使程序易于阅读和维护。枚举的主要目的是定义用户定义的数据类型。

例子：

// A simple enum example where enum is declared 
// outside any class (Note enum keyword instead of 
// class keyword) 
enum Color 
{ 
    RED, GREEN, BLUE; 
}

141. Collection 和 Collections 有什么区别？

142. 区分 Java 中的 Array 和 ArrayList。

143.Java中Array和Collection有什么区别？

144.ArrayList和LinkedList的区别。

145.区分Java中的ArrayList和Vector。

146.Iterator和ListIterator有什么区别？

147.区分HashMap和HashTable。

148. 迭代器 (Iterator) 和枚举 (Enumeration) 有什么区别？

149. Comparable 和 Comparator 有什么区别？

150.Set和Map有什么区别？