20200710 by 1z
- 请你说说Static Nested Class 和 Inner Class的不同
内部类 按可以分为两大种
1. 静态内部类（Static Nested Class）
2. 非静态内部类
普通内部类（方法之外）
局部内部类（方法中）
匿名内部类（接口的实现类）
3. 几种内部类的区别
见37题题解
普通内部类
1. 在一个类里面作为类的一个字段直接定义即可
2. 此时普通的内部类对象是依赖于外部类对象而存在
3. ！内部类对象可以访问外部类中所有访问权限的字段，外部类可以通过内部类的对象引用从而访问内部类中定义的所有访问权限的字段
4. 普通内部类中不能定义静态量
-----------------------------------------
局部内部类
1. 其声明在一个方法体 / 一段代码块的内部，而且不在定义类的定义域之内便无法使用，
2. 其提供的功能使用匿名内部类都可以实现，而本身匿名内部类可以写得比它更简洁，因此局部内部类用的比较少
3. ！在局部内部类里面可以访问外部类对象的所有访问权限的字段
4. 而外部类却不能访问局部内部类中定义的字段，因为局部内部类的定义只在其特定的方法体 / 代码块中有效，一旦出了这个定义域，那么其定义就失效了，
-----------------------------------------
匿名内部类
1. 常见写法 : 在方法参数中新建接口对象 or 类对象 并且实现
2. ！匿名内部类中可以使用外部类的所有属性,但是外部类不能使用匿名内部类中定义的属性
3. 在匿名内部类中,外部类无法获取这个类的类名，无法获取它的属性信息
--------------------------------------------
静态内部类
1. 静态内部类作为一个外部类的静态成员而存在，创建类的静态变量时不需要依赖外部对象
2. 访问一个类的静态变量也无需依赖这个类的对象,因为它独立于所有类的对象
3. ！静态内部类中无法访问外部类的非静态成员（外部类的非静态成员属于每一个外部类对象，而静态内部类就是独立于外部类对象而存在的）
4. 外部类可以访问静态内部类对象的所有权限成员
- 请你讲讲 abstract class(抽象类) 和 interface（接口）有什么区别？
抽象类 和 接口的相同点？
* 均都不可以实例化。
* 接口的实现类 或者 抽象类的子类，只有实现了接口 或 抽象类的方法后才能实例化。
* 在java1.8之后 接口和抽象类均可以实现static方法
抽象类 和 接口的不同点？
* 接口只有定义，不能有方法的实现（在java 1.8中可以定义default方法体）;
抽象类中可以有非抽象方法的定义和实现
* 一个类只能继承自一个抽象类，但是一个类可以实现多个接口(使用接口可以实现多重继承)
* 抽象类中可以定义构造方法，接口中不能
* 抽象类的成员可以是public protected default private 接口中只能为 public (static final xx)
* 抽象类中可以包含非抽象的普通方法，接口中的所有方法必须都是抽象的，不能有非抽象的普通方法。（java1.8之后存在default方法）
- 请说明Override（重写）和 Overload（重载）的区别，Overload的方法是否可以改变返回值的类型
见35问
方法的重写
* 方法的重写是针对于父子关系而言的，表示的是子对象去重写（覆盖）父对象的方法，重写的规律如下
（两同两小一大原则）
· * 1. 保证方法的参数表列一致，方法名一致
* 2. 保证子类的返回类型 <= 父类方法的返回类型
* 3. 保证子类的抛出异常类型 <= 父类方法的抛出异常类型
* 4. 保证子类方法的权限修饰符 >= 父类方法的权限修饰符
方法的重载
* 方法重载就是在一个类种定义多个同名的方法，要求每个方法具有不同的参数类型或者参数个数不同（只限制参数表列不同），保证方法名相同即可。（方法的返回参数，修饰符，可以不同，也可以相同）
* main方法可以被重载
在重载的时候，只需要保证每个方法有不同的参数表列（参数类型 or 参数的数量）即可，因此可以改变返回值的类型（但是不能通过返回值的类型 判断是重载）
- 请说明final,finally,finallize的区别？··
final可以修饰类，方法，变量，final修饰类的时候，表示该类不能被扩展（不能被继承）
finally是java的保证重点代码一定会执行的一种机制（类似文件流的关闭等必须执行的代码）,通过try-finally，try-catch-finally 保证了代码的一定执行
finalize是基础类 java.lang.Object的方法，保证了对象在被垃圾收集之前完成了特定资源的回收。（finalize 在 目前不推荐使用 java9中已经废弃）
- 请说明面向对象的特征有哪些方面？
1.封装
将对象的属性和行为进行包装，只能通过通过对象暴露出的接口进行数据的访问
2.继承
提倡出一种‘父子’关系，允许和鼓励类的复用。一个新的类（派生类）可以从已经存在的类（基类）中进行派生。派生类可以从基类中继承方法 和 实例变量，并且可以根据需求进行增减方法。
3，多态
允许不用类的对象对同一消息做出响应。发出一个命令，有不同的响应结果【设计模式中就是多态的完美体现！】
4.抽象
抽象就是忽略一个主题中与当前目标无关的那些方面，以便更充分地注意与当前目标有关的方面。抽象并不打算了解全部问题，而只是选择其中的一部分，暂时不用部分细节。
参考链接 : https://blog.csdn.net/qq_38900441/article/details/80751686
- 请说明Comparable 和 Comparator接口的作用以及他们的区别
1.Comparable
* 被称为外部比较器
* Comparable位于java.lang包下
* 如果哪个类中实现了该接口，说明这个类可以作为一个待比较的类，通过某种规则进行比较
public class Person implements Comparable<Person>{
String name;
Integer age;
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
public Person() {
super();
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
//排序的规则【多个person 按照age排序】
public int compareTo(Person o) {
return this.age.compareTo(o.age);
}
---------------------------------------------------
2.Comparator
* 被称为内部比较器
* Comparator接口位于java.util包下
* 多用于指定一些集合内部的排序规则(升序 or 降序)
整一个简单的堆排序,
public class SimpleHeapSortByPrior {
public static void main(String[] args) {
//默认是小顶堆
//PriorityQueue queue = new PriorityQueue();
// PriorityQueue queue = new PriorityQueue<Integer>((o1,o2)->{return (int)o1 - (int)o2;});
PriorityQueue queue = new PriorityQueue<Integer>(new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return o1 - o2;
}
});
int[] arr = new int[]{10,8,11,5,16};
for(int i = 0;i < arr.length;i++){
queue.add(arr[i]);
}
for(int i = 0;i < arr.length;i++){
System.out.print(queue.peek()+" ");
queue.poll();
}
}
}
- 接口和抽象类的区别是什么?
见42题
抽象类 和 接口的相同点？
* 均都不可以实例化。
* 接口的实现类 或者 抽象类的子类，只有实现了接口 或 抽象类的方法后才能实例化。
* 在java1.8之后 接口和抽象类均可以实现static方法
抽象类 和 接口的不同点？
* 接口只有定义，不能有方法的实现（在java 1.8中可以定义default方法体）;
抽象类中可以有非抽象方法的定义和实现
* 一个类只能继承自一个抽象类，但是一个类可以实现多个接口(使用接口可以实现多重继承)
* 抽象类中可以定义构造方法，接口中不能
* 抽象类的成员可以是public protected default private 接口中只能为 public (static final xx)
* 抽象类中可以包含非抽象的普通方法，接口中的所有方法必须都是抽象的，不能有非抽象的普通方法。（java1.8之后存在default方法）
- 请说明java中是否支持多继承？
java中不支持多继承，但是可以达到多继承的效果（通过接口多实现 以及 内部类的效果）
1. 接口多实现
* 一个类可以实现多个接口
* 一个接口 可以继承多个接口
interface A
interface B
interface C
A extends B,c(√)
2. 内部类实现多继承
public class MoreExtendDemo extends A {
class InnerClassB extends B {
}
class InnerClassC extends C {
}
public B makeB(){
return new InnerClassB();
}
public C makeC(){
return new InnerClassC();
}
public static void testA(A a) {
// ...
}
public static void testB(B b) {
// ...
}
public static void testC(C c) {
// ...
}
public static void main(String[] args) {
MoreExtendDemo demo = new MoreExtendDemo();
testA(demo);
testB(demo.makeB());
testC(demo.makeC());
}
}
class A{}
class B{}
class C{}
- 请你谈谈如何通过反射创建对象？
1. 获取类的对象，然后调用getInstance方法
2. 通过类对象的getConstructor()或getDeclaredConstructor()方法获得构造器（Constructor）对象并调用其newInstance()方法创建对象
demo
class User{
private String name;
private String age;
public User(){}
public User(String name,String age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "User [name=" + name + ", age=" + age + "]";
}
public void sayHello(String name) {
System.out.println("Hello "+name);
}
}
public class demo1 {
public static void main(String[] args) {
try {
//获取类实例 然后newInstance()
User user = (User) Class.forName("reflect.User").newInstance();
//获取构造器实例 然后newInstance()
User user1=(User) Class.forName("reflect.User").getConstructor(String.class,String.class).newInstance("张三","20");
System.out.println(user);
System.out.println(user1);
}
- 请你说明能否在static环境下访问非static变量？
从类的加载机制而言，在类加载的时候，static已经被加载，此时非static变量没有被记载。因此在static环境下不能访问非static变量
* static变量在类加载的时候已经确定了
* 非static变量要在new实例之后，值才会存在
9万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
