JAVA中类的继承笔记

类的继承

继承的格式：extends

public class subclass extends Superclass
{}

java不同于C++中的多继承，只能有一个直接父类

private修饰的方法无法被继承。

父类构造方法无法被继承。（在子类构造函数执行时会先执行父类构造函数，每一个子类构造方法的第一条语句默认都是：super()）

好处：

1. 代码复用性
2. 代码可维护性
3. 多态的前提之一

弊端：

1. 类与类之间的耦合性增强

重写父类的方法

1. 方法的重写需要遵循“两同两小一大”规则：

   方法名相同、形参列表相同；

   子类方法返回值类型应比父类方法返回值类型更小或相等，抛出异常也如上；

   （这里返回值类型比父类返回值类型更小指的是：当父类返回值是一个对象**（引用类型才适用，基本类型必须相同）**时，子类返回值应当是该对象或者该对象的子类。

   个人理解：在内存中如果父类返回值更小，则父类调用子类重写的方法时会导致返回值中的一些变量没有0.0值.0，从而出错，因为父类引用指向子类对象时调用方法返回值的接受类型是默认父类方法声明的类型。）

   子类方法的访问权限应当比父类权限更大或相等；

   （父类向上转型为子类实现多态时要保证能访问子类方法，总而言之父类要比子类更安全更底层）

   private<默认<protected<public

覆盖方法和被覆盖的方法要么都是类方法，要么都是实例方法（static修饰的方法不是不能重写吗？起不到重写的作用）

2. 在子类中调用父类中被覆盖的方法：super关键字

   super.变量名;

   super.方法名();

   当在构造函数中使用super关键字时，只能放在子类构造函数第一行

   super、this关键字都不能出现在static修饰的方法中，因为super、this关键字都是针对对象的

3. 重写注意事项

   • private关键字修饰的方法无法重写，所以当子类写了一个跟父类私有方法一模一样的方法，也是在子类中重新定义的一个方法。（该用private的地方一定要用，因为private可以从一定程度上保证线程安全。）

4. @Override：

   • 是一个注解。
   • 可以帮助我们检查重写方法的方法声明的正确性，最好使用。

继承中成员访问的特点

成员变量

就近原则：谁近用谁。

个人理解：系统创建子类对象时，实际上会给子类对象分配两块内存，一块用于存储子类本身的实例变量，一块用于存储继承父类的实例变量。

所以在没有显示调用者时，查找变量顺序：

1. 查找局部变量
2. 查找当前类中是否包含成员变量
3. 查找当前类的直接父类是否包含该变量，依次上溯所有父类，如果任然没有找到，则编译错误。

显示调用变量方式：当前类：this；父类：super

构造方法

this（参数）构造函数中不能递归调用本构造函数（就是说一定会有一个出口调用super（））。

super（参数）super调用父类构造器，所以super调用必须出现在子类构造器执行体的第一行，this调用和super调用不会同时出现。

this（）和super（）使用注意事项：

1. 不能在其他方法中使用，只能在构造函数中使用
2. 位于构造方法中的第一行有效代码，所以不能同时出现。
3. 每一个构造方法的首行有默认语句super（），所以创建任何Java对象时最先执行的总是java.lang.Object类的构造器。
4. 如果this（参数）语句在首行出现，默认的super语句被覆盖，通过this（参数）语句调用的构造方法中的super（）语句调用父类构造函数。
5. 请记得将空参构造方法写出来，因为默认调用的是空参构造，避免报错。

class baseclass {
    int num = 10;
//    public baseclass()
//    {
//        System.out.println("父类无参构造。");
//    }
    public baseclass(int num)
    {
        System.out.println("父类……有参构造。");
    }
}
class subclass extends baseclass
{
    int num = 30;
    public subclass()//报错,因为此时没有父类无参构造函数
    {
        //super();
        System.out.println("子类无参构造。");
    }
  
}

为什么要先执行父类的构造函数？

因为需要先给父类中的成员变量进行初始化，方便子类使用。

创建实例时顺序：

1. 父类静态代码块和静态变量（按声明顺序执行）
2. 子类静态代码块和静态变量
3. 父类构造代码块和构造方法
4. 子类构造代码块和构造方法

个人理解：在JVM的初始化类的阶段，会去执行类构造器方法(这个方法是JVM自动生成的)其中集合了显示初始化和静态代码块的语句，而静态变量赋值和静态代码块执行是按顺序的，而且JVM会保证父类的方法比子类先执行。，且该方法使用时会同步加锁，只会被加载一次。

成员方法

注意：父类的变量是静态绑定的，和方法里确认变量值的就近原则区分一下：

public class test01{
    int num = 2;
    public void ha()
    {
        System.out.println(num);
    }
    public static void main(String[] args) {
        test01 h = new subClass();
        h.ha();//输出2 因为就近原则实际上变量是在父类的内存块中
    }
}
class subClass extends test01{
    int num = 1;
}

如果子类重写父类方法：就会根据就近原则输出 1。

public class test01{
    int num = 2;
    public void ha()
    {
        System.out.println(this.num);
    }
    public static void main(String[] args) {
        test01 h = new subClass();
        h.ha();//输出1 就近原则
        System.out.println("------------");
        System.out.println(h.num);//输出2 编译看左边
    }
}
class subClass extends test01{
    int num = 1;
    public void ha()
    {
        System.out.println(num);
    }
}

重写时注意事项

子类向上转型为父类：执行子类重写的方法。

static修饰的方法：跟着类走，static修饰的方法无法进行重写。

可以使用@override注解判断子类是否重写父类方法。