JAVA相关

方法重写

发生在类的继承中，这个方法子和父名称一样，子生效

重写（override）规则：

  1. 参数列表必须完全与被重写方法相同
  2. 返回类型必须完全与被重写的返回类型相同
  3. 访问权限不能比父类中被重写的访问权限更低。例如：如果父类的一个方法被声明为public，name子类中重写该方法就不能声明为protected
  4. 父类的成员方法只能被他的子类重写
  5. 声明为static和private的方法不能被重写，但是能够被再次声明
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    public class Demo1{
        public stsic void main(String[] args){
            Student s = new Student();
            s.say();
        }
    }

    class Person{
        public void say(){
            System.out println("锄禾日当午，汗滴禾下土")
            }
    }

    class Student extends Person{
        public void say(){
            System.out.println("床前明月光");
        }
    }

注意：面试题：Java中重写（override）和重载（overland）的区别

  1. 重写是发生在子父类中的操作
  2. 重载是一个类里面参数列表的长度、参数类型和参数类型顺序不同（分为构造方法重载和方法重载）

a. 发生的位置
重载：一个类中
重写：子父类中
b. 参数列表限制
重载：必须不同
重写：必须相同
c. 返回值类型：
重载：与返回值类型无关
重写：返回值类型必须一致
d. 访问权限：
重载：与访问权限无关
重写： 子的方法权限 必须不能小于 父的方法权限
e.异常（bug）处理：
重载：与异常无关
重写：可以减少或删除（异常范围可以更小更精准，但是不能抛出新的异常）


异常处理

情况描述：当程序出现bug时，Java虚拟机发现异常，虚拟机就会new出来一个新的对象，用类似返回的方式返回错误类型和异常原因，同时中断程序。

处理异常

对异常进行处理，捕获异常，避免异常返回使程序中断

1
2
3
4
5
6
7
8
9
10
try{
    //有可能发生异常的代码
}catch(异常类型1 对象名1){
    //异常的操作
}catch(异常类型1 对象名1){
    //异常的操作
}...
finally{
    //异常的统一出口
}

catch语句相当于if语句
如果满足异常类型，则实现代码块里面的操作


易错警告
eg1.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
package com.java.demo1;

public class Demo6 {
    public static void main(String[] args) {

        Person p =haha();
        System.out.println(p.age);
    }

    public static Person haha(){
        Person p = new Person();
       try{
           p.age = 18;
           return p;
       }finally{
           p.age = 28;
       }

    }
    static class Person{
        int age;
    }
}
//始终是一个对象，最后执行finally，p.age年龄被更改

eg2.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
package com.java.demo1;

public class Demo7 {
    public static void main(String[] args) {

        int a =haha();
        System.out.println(a);
    }

    public static int haha(){
        int a = 10;
        try{
            return a;
        }finally{
            a = 20;
        }

    }

}
//return a;中的a是被备份的那个
//实际上又开辟了一块内存空间，这是返回的a和finally中的赋值的a无关

eg3.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
package com.java.demo1;

public class Demo8 {
    public static void main(String[] args) {
        haha();
    }
    public static void haha(){
        try{
            int a = 10;
            int b = 0;
            System.out.println(a/b);
        }
        catch(Exception e){
            //退出JVM
            System.exit(0);
        }finally {
            System.out.println("锄禾日当午，汗滴禾下土");

        }
    }
}

唯一一种在代码中使finally不执行的代码就是上述eg3.
 System.exit(0);
总结：finally问题总绕不开两点：
1.finally必然执行
2.return的时机以及备份的具体内容

final关键字

final用于修饰属性、变量
变量成为了常量，无法对其再次进行赋值
final修饰的局部变量，只能赋值一次（可以先声明后赋值）
final修饰的是成员属性，必须在声明时赋值
全局常量（public static final）


常量的命名规范：
由一个或多个单词组成，单词与单词之间必须使用下划线隔开，单词中所有字母大写
例如：SQL_INSET




final用于修饰类
final修饰的类，不可以被继承
final用于修饰方法
final修饰的方法，不能被子类重写
全局常量（public static final）