JavaSE-No.7.2——Java的继承(与组合)

JavaSE传送门

JavaSE_Start

JavaSE-No.6.3——代码块与内部类

JavaSE-No.7.1——Java的继承(super关键字)

---

注： 关于继承分为两篇文章讲解，配合??No.7.1食用更佳，那我们就继续吧~

目录

• 1. 父类子类代码块的执行顺序
• 2. protected关键字
• 3. 继承方式
• 4. final关键字
• 5. 继承与组合

---

1. 父类子类代码块的执行顺序

接着上一篇文章，我们增加静态代码块和实例代码块

class Animal {
    public String name;
    public int age;
    public String color;

    public Animal() {
        System.out.println("父类的构造方法(Animal)");
    }

    static {
        System.out.println("父类的静态代码块(Animal)");
    }

    {
        System.out.println("父类的实例代码块(Animal)");
    }
    
    public void eat() {
        System.out.println(name+"正在吃饭！");
    }
}
class Dog extends Animal{

    public Dog() {
        super();
        System.out.println("子类的构造方法(Dog)");
    }
    static {
        System.out.println("子类的静态代码块(Dog)");
    }

    {
        System.out.println("子类的实例代码块(Dog)");
    }

    public void walk() {
        System.out.println(name+"正在和主人散步。");
    }
}

当我们在main中实例化一个Dog，代码块的执行顺序是怎样的呢？

public class Test {
    public static void main(String[] args) {
        Dog dog = new Dog();
    }
}

运行结果展示：

总结：

1、父类静态代码块优先于子类静态代码块执行，且是最早执行

2、父类实例代码块和父类构造方法紧接着执行

3、子类的实例代码块和子类构造方法紧接着再执行

那如果我们再new一次呢？

public class Test {
    public static void main(String[] args) {
        Dog dog = new Dog();
        System.out.println("================");
        Dog dog2 = new Dog();
    }
}

运行结果展示：

我们可以看到静态代码块只执行了一次。

总结： 第二次实例化子类对象时，父类和子类的静态代码块都将不会再执行。

---

2. protected关键字

在类和对象章节中，为了实现封装特性，Java中引入了访问限定符，我们这次来讲一下protected关键字。

我们新建一个包TestDemo，写入一个类Test

#同一个包中的同一类

public class Test {
    protected int n;

    public void func() {
        System.out.println(n);//可以访问protected修饰的n
    }
}

#同一个包中的不同类

在同一个包下新建一个java文件Test2

public class Test2 {
    public static void main(String[] args) {
        Test test = new Test();
        System.out.println(test.n);//可以访问protected修饰的n
    }
}

#不同包中的子类

我们现在Test类是在TestDemo这个包下的Test.java文件下的，现在我们新建一个包TestDemo2，新建一个java文件。

在新建的TestDemo.java中写一个Test的子类

import TestDemo.Test;//导入包

public class TestDemo extends Test {
    public static void main(String[] args) {
        
    }
}

# 注意 # 我们直接在main方法中写入，我们可以看到报错，我们这里并不能访问被protected修饰的n。

Test test = new Test();
System.out.println(test.n);//报错，无法访问

那我们要如何访问呢？

我们应该通过super访问父类中被protected修饰的n。

public class TestDemo extends Test {
    public void test() {
        System.out.println(super.n);//通过super访问
    }
    
    public static void main(String[] args) {
 
    }
}

那如果我们想在main方法中访问，应该怎么做呢？

public class TestDemo extends Test {
    public void test() {
        System.out.println(super.n);
    }

    public static void main(String[] args) {
        TestDemo testDemo = new TestDemo();
        testDemo.test();
    }
}

#不同包中的非子类不能访问

# 注意事项 #

1. 我们希望类要尽量做到 "封装", 即隐藏内部实现细节, 只暴露出 必要 的信息给类的调用者.
2. 因此我们在使用的时候应该尽可能的使用 比较严格 的访问权限. 例如如果一个方法能用 private, 就尽量不要用 public.

---

3. 继承方式

java中支持以下几种继承方式：

# 注意事项 #

1. java中不支持多继承。
2. 一般我们不希望出现超过三层的继承关系，（即：B继承A，C继承B，D继承C，E继承D……），如果我们想要从语法上进行限制继承, 就可以使用 final 关键字。

---

4. final关键字

final关键可以用来修饰变量、成员方法以及类。

修饰变量或字段，表示常量(不能修改)

final int A = 10; //final修饰的变量最好要大写
A = 20; // 编译出错

修饰类：表示此类不能被继承

例如： B（密封类）无法被继承。

修饰方法：表示该方法不能被重写(后序介绍)

---

5. 继承与组合

和继承类似, 组合也是一种表达类之间关系的方式, 也是能够达到代码重用的效果。组合并没有涉及到特殊的语法, 仅仅是将一个类的实例作为另外一个类的字段。

继承我们可以理解为is关系， 比如：狗是动物；猫是动物……

而组合我们可以理解为has关系， 比如：学校有老师，有学生；卧室里有床，有地板……

例如： 学校有很多老师，有很多学生

class Teacher {
	//····
}
class Student {
	//····
}
class School {
    private Student[] students;
    private Teacher[] teachers;
    //····
}

# 注意 # 在继承和组合同样可行的情况下，优先使用组合而不是继承。（因为：组合更安全，更简单，更灵活，更高效。）

---

??(( д)(д ))??

以上就是今天要讲的内容了，希望对大家有所帮助，如果有问题欢迎评论指出，会积极改正！！下一篇文章会讲述Java的多态的相关知识，期待大家支持，谢谢~