摘要：Java知识点精选之类、接口、枚举30问，算是比较基础的，希望大家一起学习进步。

整理了一些JAVA语言的在类、接口、枚举等方面的知识点以及大家常遇到的问题。希望能帮助到大家。

Q：各修饰符所代表的可见性？
public: 可被所有使用
protect：只能被自己和子类使用，或者同一个包路径
private：只能自己使用，儿子都不行
不加修饰符即default权限：包访问权限，和他在同一包内的类都可以访问他，包外的则都不能访问

Q：外部类可以用private或者protect修饰吗？
A：不能，只能用public或者包访问权限。内部类可以。

解释以下final的作用
Q： final 成员？
A：如果是基本类型，则指值不能被改变。如果是对象，指对象的引用不可改变，但是引用处的内容可改变。

Q： final 参数？
A：参数不可变，只能读不能修改，同上

Q： final方法
A：方法不能被子类重写。

Q： final类
A：该类不能被继承。

Q:final局部变量可以作为非final的参数传入吗？会编译报错吗？

public static void main(String[] args){
	final A a = new A();
	changeA(a);
}
public void changeA(A a) {
	// change A...
}

A:可以作为非final的参数传入，不会编译报错。

Q：重载和重写的区别？
A：重载是方法名相同，参数不同。重写是方法参数等都一致的情况下重写父类的方法。

Q: 如果子类重载了父类中的方法，那么子类中还能调用父类中的同名方法吗？
A: 可以（C++中不可以调用父类中的同名重载方法)。

Q: 怎样能避免子类在重写父类的方法，不小心弄成了重载？
（即你想重写父类的f(int), 却不小心写成了f(int，int)，导致调用f(int)时还是调用了父类的f ，怎么能避免这种失误？）
A: 加个@Override关键字即可，原文解释：

Q：父类的成员变量能被重写/覆盖嘛？

class A{
	public String name = "A";
}
class B extends A{
	public String name = "B";
}
public static void main{
	A a = new B();
   System.out.println(a.name);
}

A:
输出A。
注意成员变量不具有多态性，因此你定义的是A，赋值的是B，那么输出的依旧是A里的成员。
如果是被重写的方法的话，那会用B里的方法。

Q：内部类是啥，内部类能访问外部类的成员吗？
A：
内部类概念：

class A {
	class B{
   		...
   }
}

B就是A的内部类,B能访问A的所有成员

Q： A中有1个内部类C， A的子类B中也有1个内部类C， B中的C会覆盖A中的C吗？
A：不会，因为使用时是通过B.C或者A.C去调用的，存在命名空间的关系。

Q：可以在内部类中定义静态成员吗？

class A {
	class B{
    	static int b;
   		...
   }
}

A:
不可以。除非在class B前面加static变为静态类

Q：匿名类是啥，匿名类能访问外面的变量或者对象吗？
A：匿名类概念：

return new A(构造参数){
   {构造器内容}
   类定义 
}

匿名类如果要用外面的对象，外面的对象必须要定义为final。

Q: 嵌套类是啥，能访问外部类的成员吗？
A：

class A {
   static int sa;
   int a;
	static class B{}
}

B只能访问A中的静态成员sa, 而不能访问a。

§ 接口

类是单继承，接口可以多继承

Q：接口中如果要定义成员变量，那成员的默认修饰符是什么？
A： public static final

Q：接口中各方法的默认修饰符是什么？
A： public abstract

Q：接口中可以定义实现具体方法嘛？
A：
java8以上版本可以。
引入了default关键字，在接口中用default关键字修饰接口，就可以在接口中去实现这个接口了。

§ 枚举

Q： enum可以被继承吗？
像下面这样：

enum A extend B{
...
}

A：不可以。enum标识符本身被编译器处理过，自身就继承自Enum类，而java不支持多重继承。但支持实现接口

Q： switch(enum)时需要加default吗？
A：可以不需要。

Q： Enum基类里实现了values()方法吗？
A：没有实现， values方法是编译器加的。因此从List<Enum>里取出的对象，是不能调用values（）的。

Q：enum里的枚举的默认修饰符默认是？
A：static final

§ 静态分派和动态分派

Q：下面输出什么，属于什么分派？

 void test() {
        Father father = new Son();          //静态分派
        print(father);
    }
 
    void print(Father father) {
        System.out.println("this is father");
    }
 
    void print(Son son) {
        System.out.println("this is son");
    }

A:输出this is father。属于静态分派。
静态分派概念：编译器就能确定调用哪个方法。
这里2个print属于重载方法，通过输入参数的定义类型即立刻确定调用哪个
静态分派取决于静态类型

静态类型概念：编译期写在java文件里能马上看到的类型
例如 A a = Factory.create(args);
那么左边的A就是静态类型，而右边的类型取决于运行期，是不确定的。

Q：上一题的进阶：

  public class Overload {
    private static void sayHello(char arg){
      System.out.println("hello char");
    }
    private static void sayHello(Object arg){
      System.out.println("hello Object");
    }
    private static void sayHello(int arg){
      System.out.println("hello int");
    }
    private static void sayHello(long arg){
      System.out.println("hello long");
    }
    // 测试代码
    public static void main(String[] args) {
      sayHello('a');
    }
  }

输出什么？
A：输出 hello char
因为‘a’是一个char类型数据（即静态类型是char），所以会选择参数类型为char的重载方法。
若注释掉sayHello(char arg)方法，那么会输出 hello int
因为‘a’除了可代表字符串，还可代表数字97。因此当没有最合适的sayHello(char arg)方式进行重载时，会选择第二合适（第二优先级）的方法重载，即sayHello(int arg)

总结：当没有最合适的方法进行重载时，会选优先级第二高的的方法进行重载，如此类推。
优先级顺序为：char>int>long>float>double>Character>Serializable>Object>…
其中…为变长参数，将其视为一个数组元素。变长参数的重载优先级最低。
因为 char 转型到 byte 或 short 的过程是不安全的，所以不会选择参数类型为byte 或 short的方法进行重载，故优先级列表里也没有。

Q：下面输出什么，属于什么分派：

   void test() {
        Father father = new Son();       
        father.name();    
    }
 
    class Son extends Father {
        void name(){
            System.out.println("son");
        }
    }
 
    class Father {
        void name(){
            System.out.println("father");
        }
    }

A：输出son，属于动态分派。运行的时候根据所指向的具体对象才确定调用哪个方法

Q：

静态分派属于单分派还是多分派？
动态分派属于单分派还是多分派？
A：
静态分派是多分派。
动态分派是单分派。
多分派概念: 分派时即要考虑调用者的类型，也要考虑参数类型。
而单分派只考虑调用者的类型。

动态分派原理：

Q：类方法在class文件中是什么样的? 是符号引用还是直接引用？
A：class文件中，所定义的方法都只是符号引用，即只是个符号，知道方法名字，但是不知道方法的实际指令运行地址
符号引用如下，不过我这展示的时class_info即类的符号引用，实际上还会有method_info即方法的引用：

然后方法在class文件中时这样存放的，先是一个method_count数量，接着再存储方法。

此时是不知道方法的指令地址的。除非从符号引用转为直接引用。

Q：什么时候方法的符号引用会转为实际方法区中的直接引用？
A：
类加载的解析阶段会把满足「编译期可知，运行期不可变」的方法的符号引用替换为指向方法区的直接引用，不会延迟到运行时再去完成。

构造
私有
静态
final修饰
上面这4类方法在类加载时都会被识别出来，并转成指向方法区的直接引用（即能知道了指令地址了，而不是字节码的符号）

Q：动态分派(即多态），虚拟机里是怎么确定调用哪个方法的？
如下，他怎么确定调用的是Son实现的do，还是father实现的do？

int a = 1;
Father f = new Son()
f.do(a);

A：
首先，通过静态分派，他知道一定选用的是f(int a) 这个方法，但是他不知道选用哪个类的do(int a)方法。
而你执行f.do(a)时，操作数栈上会存放一个对象引用

那么执行f方法的虚拟机指令就会通过这个对象引用，找到他的实际类型的class

他会在这个实际类中查找是否有实现这个方法，具体看class文件中有没有这个方法的定义

如果没有找到，他就去父类找，父类的关系class文件中就可以知道

如果父类没有，就接着往上找，直到找到实现了的。

本文分享自华为云社区《Java知识点问题精选之类、接口、枚举》，原文作者：breakDraw 。

点击关注，第一时间了解华为云新鲜技术~