思考题解答

1.IDEA的快捷键

Ctrl+X 删除一行  

Ctrl+D 复制一行  

Ctrl + O/I 重写方法/实现方法  

Ctr + shift + U 大小写转换

fori 生成for循环  

itli 生成List的遍历  

Ctrl + F 在当前文件中查找  

Ctrl + F9 编译项目

Ctrl + Shift + F9 编译当前文件  

Shift + F6 重命名  

Ctrl + Alt + C/F/M/P/V 抽取常量/字段/方法/参数/变量  

Ctrl + Shift + C 复制文件的完整路径

2.重写和重载的规则

重写

访问修饰符的限制一定要不小于被重写方法的访问修饰符

参数列表必须与被重写方法的相同

如果一个方法不能被继承, 则不能重写它

不能重写被标识为final的方法

 静态方法不能被重写

重载

方法名称必须相同

参数列表必须不同(个数不同、或类型不同、参数排列顺序不同等)

方法的返回类型可以相同也可以不相同

仅仅返回类型不同不足以成为方法的重载

3.区分重写和重载

重写的方法名称，参数类别，返回值类型均相同

重载的方法名称相同，参数类型或个数不同

重写中被重写的方法不能拥有更严格的权限

重载中对权限没有要求

重写发生在继承类中

重载发生在一个类中

以下是代码上的区别

关于重写的代码

abstract class Animal {
    String name;

    Animal(String name) {
        this.name = name;
    }

    abstract void sound();
    void eat() {
        System.out.println(name + " is eating.");
    }
}

class Dog extends Animal {
    Dog(String name) {
        super(name);
    }

    @Override
    void sound() {
        System.out.println(name + " is barking.");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog myDog = new Dog("Buddy");
        myDog.sound();
        myDog.eat();
    }
}

运行结果为

Buddy is barking.
Buddy is eating.

关于重载的代码

class Calculator {
    int add(int a, int b) {
        return a + b;
    }

    double add(double a, double b) {
        return a + b;
    }
}

public class Main {
    public static void main(String[] args) {
        Calculator calc = new Calculator();
        int result1 = calc.add(5, 10);
        double result2 = calc.add(2.5, 3.7);

        System.out.println("Integer addition: " + result1);
        System.out.println("Double addition: " + result2);
    }
}

运行结果为

Integer addition: 15
Double addition: 6.2

可以看到，当调用add()方法时，根据传入的参数类型来匹配对应的重载方法。重载允许我们在一个类中定义多个具有相同名字但不同参数的方法，这样可以根据不同类型的参数来执行不同的逻辑

4.抽象类的特点

抽象类不能被实例化。

抽象类不一定需要包含抽象方法，也就是说，Abstract类中不一定需要Abstract方法。而且还可以有实现的方法（普通方法， 如public void eat()).

一旦包含了abstract方法，则该类必须是abstract抽象类

abstract只能修饰类和方法，不能修饰属性和其他的

抽象类可以有任意成员， 抽象类的本质还是类，比如，非抽象方法，构造器， 静态属性等等

总结起来，抽象类是一种不能被实例化的类，它包含了一些抽象方法和属性的定义，要求子类去实现这些抽象方法。通过使用抽象类，我们可以定义一些规范和共享行为，并使类之间的继承关系更加灵活和有序

5.接口和类的区别

类是一个具体的实现，可以包含属性、方法和构造函数等；而接口是一个规范、协议，只定义了一组方法和常量，并不提供实现

类可以直接实例化为对象，而接口不能被实例化。接口只能被实现，并且需要通过实现接口的类来创建对象

一个类可以直接继承自另一个类，形成类之间的继承关系，通过继承可以获得父类的属性和方法，并且可以在子类中进行重写和扩展。而类无法直接继承接口，但可以通过实现接口来获取接口中定义的方法，并对其进行实现

类可以定义构造函数，用于创建对象时进行初始化操作，而接口不能包含构造函数

6.抽象类和接口的区别

接口和抽象类的概念不一样。接口是对动作的抽象，抽象类是对根源的抽象

在高级语言上，一个类只能继承一个类（抽象类）(正如人不可能同时是生物和非生物)，但是可以实现多个接口(吃饭接口、走路接口)

接口是抽象类的变体，接口中所有的方法都是抽象的，而抽象类是声明方法的存在而不去实现它的类。
接口可以多继承，抽象类不行
接口定义方法，不能实现，而抽象类可以实现部分方法
接口中基本数据类型为static 而抽类象不是的

当关注一个事物的本质的时候，用抽象类；当关注一个操作的时候，用接口

7.上转型和下转型

上转型：实际上就是创建一个子类对象，将其当作父类对象来使用

使用格式：父类类型 对象名 = new 子类类型（）

假设有一个vegetable类，vegetable类中有一个show（）方法，代码如下：

class vegetable{
	public void show() {
		System.out.println("this is a vegetable");
	}
}

有一个tomato
类继承自vegetable类，该类有自己的方法test（），并且重写了父类的show（）方法，代码如下：

class tomato extends vegetable{
    @Override
    public void show() {
	System.out.println("this is a tomato");
    }
    public void test() {
	System.out.println("i am a tomato");
    }
}

实例化tomato类，并新建一个vegetable类的引用变量引用该实例，调用实例的show（）方法：

Vegetable vegetable = new tomato();
vegetable.show();

运行结果为

this is a tomato

当运行text（）时，则会报错。

这里用到了向上转型，换言之，就是用父类的引用变量去引用子类的实例，这是允许的。当向上转型之后，父类引用变量可以访问子类中属于父类的属性和方法，但是不能访问子类独有的属性和方法。例子中由于子类重写了父类的show（）方法，所以调用的show（）方法是子类的show（）方法，输出结果为：“this is a apple”,而调用子类的test（）方法则会报错。

下转型：并不是所有的对象都可以向下转型，只有当这个对象原本就是子类对象通过向上转型得到的时候才能够成功转型

实例化Tomato类，并新建一个Vegetable类的引用变量“vegetable”引用该实例，然后新建一个Tomato类的引用变量，引用向下转型的“vegetable”变量，代码如下

Vegetable vegetable = new Vegetable();
Tomato tomato = (Tomato) fruit;

假设有一个potato类继承自Vegetable类，代码如下：

class Potato extends Vegetable{
    @Override
    public void show() {
	System.out.println("this is a Potato");
    }
    public void test() {
	System.out.println("i am a Potato");
    }
}

实例化Tomato类，并新建一个Vegetable类的引用变量“vegetable”引用该实例，然后新建一个Tomato类的引用变量，引用向下转型的“vegetable”变量，代码如下：

Vegetable vegetable = new tomato();
Potato potato = (Potato) vegetable;

上述代码虽然能够编译成功，但是在运行的时候会报错，因为vegetable对象是由Tomato对象向上转型得到的，只能够向下转型成Tomato对象，不能够向下转型成Potato对象

8.如何在Java中自定义一个异常类

创建一个新的类，并继承Exception类或其子类，例如RuntimeException。

public class CustomException extends Exception {
    // 可以添加自定义的构造方法和其他成员变量、方法等
}

在自定义异常类中，可以添加自定义的构造方法和其他成员变量、方法等，以满足特定的需求。

public class CustomException extends Exception {
    private int errorCode;
    
    public CustomException(String message, int errorCode) {
        super(message);
        this.errorCode = errorCode;
    }
    
    public int getErrorCode() {
        return errorCode;
    }
}

在需要抛出异常的地方，使用throw关键字抛出自定义异常对象。

public void someMethod() throws CustomException {
    if (someCondition) {
        throw new CustomException("Custom exception occurred", 500);
    }
}