思考题回答

idea快捷键

Ctrl + Shift + N：打开文件
 Ctrl + E：最近打开的文件
 Ctrl + F：查找
 Ctrl + R：替换
 Ctrl + Z：撤销
 Ctrl + Y：恢复
 Ctrl + X：剪切
 Ctrl + C：复制
 Ctrl + V：粘贴
 Ctrl + A：全选
 Ctrl + F12：打开控制台
 Alt + F7：查找用法
 Ctrl + Alt + L：格式化代码
 Ctrl + Alt + O：优化导入
 Ctrl + Shift + F：全局查找
 Ctrl + Shift + R：全局替换
 Ctrl + F11：切换全屏模式
 Ctrl + Tab：切换标签页
 Ctrl + Shift + Tab：反向切换标签页
 Alt + Up/Down Arrow：在方法之间导航
 Ctrl + Up/Down Arrow：在代码行之间导航
 Ctrl + Shift + U：大小写转换

重写的规则；重载的规则

一...重写的规则：

1.父类的成员方法只能被它的子类重写。
2.声明为 static 的方法不能被重写，但是能够再次声明。
且重写有严格的格式要求：子类的方法名字和父类必须一致，参数列表（个数，类型，顺序）也要和父类一致。

二...重载的规则：

 
1.方法名必须相同。
2. 参数列表必须不同（参数类型、个数、顺序）。
3.不能通过访问权限、返回类型、抛出的异常进行重载。
4. 方法的异常类型和数目不会对重载造成影响。

区分重载和重写：

重载和重写都是实现多态的方式，但是方法的重载实现的是编译时的多态性，而方法的重写实现的是运行时的多态性。
 
重载：是在一个类中定义相同的方法名，参数不同。具体表现为参数个数、参数类型、参数顺序不同。
重写：是子类重写父类的方法。子类和父类有相同的方法名、相同的参数类型和参数个数，但是方法体有所不同。
 
下面以 Java 代码为例进行详细解释：
 

 
class Father {
    public void print(String str) {
        System.out.println("父类方法执行了");
    }
}

class Son extends Father {
    @Override
    public void print(String str) {
        System.out.println("子类方法执行了");
    }
}

public class Main {
    public static void main(String[] args) {
        // 创建子类对象
        Son son = new Son();
        // 调用重写后的方法
        son.print("重写");
        // 调用父类方法
        son.print(123);
    }
}
 
 

上述代码中， print() 方法在父类和子类中都有定义，但是在子类中方法被 @Override 注解所修饰，这表明该方法是一个重写方法。而在父类中， print() 方法没有被任何注解修饰，这说明它是一个重载方法。在 Java 中，如果要重写一个方法，需要在子类中使用 @Override 注解来修饰该方法，否则 Java 将会认为这个方法是一个重载方法而不是重写方法。

抽象类的特点有：

1. 抽象类不能被实例化，即不能创建抽象类的对象。
2. 抽象类可以包含抽象方法，抽象方法没有方法体，只包含方法的签名，用于强制子类实现该方法。
3. 抽象类的子类必须实现抽象类中的所有抽象方法，否则该子类也必须被声明为抽象类。
4. 抽象类可以包含普通方法，这些方法可以有方法体，并且可以被其子类继承和使用。
5. 抽象类可以通过继承关系实现多态性，即不同的子类可以根据自己的实现来重写抽象类中的方法。
 

接口和类的区别：

在 Java 中，类和接口是两种不同的抽象概念，它们之间有以下区别：
 
1. 类可以包含抽象方法和非抽象方法，而接口中只能包含抽象方法。
2. 类中的抽象方法可以有方法体，而接口中的抽象方法必须没有方法体。
3. 类可以实现接口，但接口不能继承类。
4. 一个类可以同时继承一个类和实现多个接口，但一个类只能继承一个父类。
5. 类中的成员变量可以是各种类型，而接口中的成员变量只能是基本数据类型或 final 类型。
6. 类可以使用 this 关键字来访问自身的成员变量和方法，而接口只能使用 public 关键字来访问自身的成员变量和方法。
7. 类可以被 instanceof 操作符所识别，但接口不能被 instanceof 操作符所识别。
 
总的来说，类更适合于描述一个具体的抽象概念，而接口更适合于描述一组抽象概念。

抽象类和接口的的区别：

抽象类和接口是 Java 中的两种不同的抽象概念，它们之间有以下区别：
 
1. 抽象类可以包含抽象方法和非抽象方法，而接口中只能包含抽象方法。
2. 抽象类中的抽象方法可以有方法体，而接口中的抽象方法必须没有方法体。
3. 抽象类可以实现接口，但接口不能继承抽象类。
4. 一个类可以同时继承一个抽象类和实现多个接口，但一个类只能继承一个父类。
5. 抽象类中的成员变量可以是各种类型，而接口中的成员变量只能是基本数据类型或 final 类型。
6. 抽象类可以使用 this 关键字来访问自身的成员变量和方法，而接口只能使用 public 关键字来访问自身的成员变量和方法。
7. 抽象类可以被 instanceof 操作符所识别，但接口不能被 instanceof 操作符所识别。
 
总的来说，抽象类更适合于描述一个具体的抽象概念，而接口更适合于描述一组抽象概念。

上转型和下转型：

1. 上转型（Upcasting）：是将子类对象转换为父类对象的过程。这个过程是安全的，因为父类可以接收来自子类的任何对象。例如：
 
 

Dog dog = (Dog) animal;

在这个例子中， Dog 类是 Animal 类的子类，通过上转型，将 Dog 类型的对象赋值给 Animal 类型的变量 dog 。
 
2. 下转型（Downcasting）：是将父类对象转换为子类对象的过程。这个过程是不安全的，如果父类对象不是子类对象的实例，将会抛出 ClassCastException 异常。例如：
 
 

Animal dog = new Dog();

在这个例子中， animal 变量是 Animal 类型的对象，通过下转型，将 Animal 类型的对象转换为 Dog 类型的对象。
 
上转型和下转型在继承关系中提供了灵活性，但需要注意类型转换的安全性。在进行下转型时，建议使用 instanceof 关键字进行类型检查，以确保转换是安全的。

在Java中自定义一个异常类：
 

在 Java 中可以通过继承 Throwable 类或者 Exception 类来自定义一个异常类，也可以通过继承 RuntimeException 类来自定义运行时异常，但不要继承 Error 类。下面提供一个自定义异常类的示例：
 
 

public class CustomException extends Exception {
    // 无参构造方法
    public CustomException() {
    }

    // 带一个字符串参数的构造方法
    public CustomException(String message) {
        super(message);
    }
}
 

 
上述代码中，自定义了一个名为 CustomException 的异常类，并且继承了 Exception 类，在自定义异常类中定义了两个构造方法，分别是无参构造方法和带一个字符串参数的构造方法，这个字符串将作为描述该异常对象的异常信息。
 
请注意，在定义自定义异常类时，类名通常以 Exception 结尾。如果继承 Exception 类产生的编译期异常，在代码中必须使用 throw 或者 try-catch 关键字来处理这个异常，而继承 RuntimeException 类产生的运行期异常可以不用处理。