目录
电影里，王多余继承了亿万财产
现实中你继承了蚂蚁花呗
那么在Java中，什么是继承呢？
别急，我将依依道来
前言
Hi~ 你好!
欢迎点击我的博客 : )
这是我的学习总结,希望也能帮助到你
我的博客地址:hi~,我在这里~,欢迎关注哦,
三连不迷路,优质内容持续更新!
一. 继承
1. 继承概念
继承 (inheritance) 机制 ：是面向对象程序设计使代码可以复用的最重要的手段，它允许程序在保持原有类特性的基础上进行扩展，增加新功能 ，这样产生新的类，称 派生类 。继承呈现了面向对象程序设计的层次结构， 体现了由简单到复杂的认知过程继承主要解决的问题是： 共性的抽取，实现代码复用 。
2. 继承的语法
借助
extends
关键字
修饰符 class 子类 extends 父类 {
// ...
}//Animal.java
public class Animal { //父类
public String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public void eat(){
System.out.println(name + "吃饭");
}
public void sleep(){
System.out.println(name + "睡觉");
}
}
//Cat.java
public class Cat extends Animal { //子类继承父类
void call(){
System.out.println("喵喵喵");
}
}
//Dog.java
public class Dog extends Animal{
void call(){
System.out.println("汪汪汪");
}
}
//TestExtend.java
public class TestExtend {
public static void main(String[] args) {
Cat cat1 = new Cat();
cat1.name = "Tom";
System.out.println(cat1.name);
cat1.eat();
cat1.call();
cat1.sleep();
System.out.println("=============");
Dog dog1 = new Dog();
dog1.setName("大黄");
System.out.println(dog1.name);
dog1.setAge(18);
dog1.call();
dog1.eat();
dog1.sleep();
System.out.println(dog1.getAge());
}
}1.子类会将父类中的成员变量或者成员方法继承到子类中2.子类继承父类后，必须要新添加自己特有的成员或方法要与父类，否则就没有必要继承
3. 父类成员访问
1. 子类中访问父类的成员变量
(1)不存在同名成员变量
public class Base {
int a;
int b;
}
public class Derived extends Base {
int c;
public void method(){
a = 10; // 访问从父类中继承下来的a
b = 20; // 访问从父类中继承下来的b
c = 30; // 访问子类自己的c
}
}
(2)子类和父类成员变量同名
public class Derived extends Base { int a; // 与父类中成员a同名，且类型相同 char b; // 与父类中成员b同名，但类型不同 public void method(){ a = 10; // 访问从父类中继承下来的a b = 97; // 访问从父类中继承下来的b c = 30; // 访问子类自己的c System.out.println(a); System.out.println(b); System.out.println(c); } public static void main(String[] args) { Derived d1 =new Derived(); d1.method(); } }
2.在子类方法中/通过子类对象访问成员时：
1.如果访问的成员变量子类中有，优先访问自己的成员变量。(就近原则)2.如果访问的成员变量与父类中成员变量同名，则优先访问自己的3.如果访问的成员变量子类中没有，则访问父类继承下来的，如果父类也没有，则编译报错
3.子类中访问父类的成员方法
1. 成员方法名字不同
成员方法没有同名时，在子类方法中或者通过子类对象访问方法时，则优先访问自己的，自己没有时, 再到父类中找，如果父类中也没有则报错。
2. 成员方法名字相同
通过子类对象访问父类与子类同名方法时，如果父类和子类同名方法的参数列表不同 ( 重载 ) ，根据调用不同的参数选择合适的方法访问，如果没有则报错；
4. super关键字
//父类
public class Base {
int a;
int b;
public void methodA(){
System.out.println("Base中的methodA()");
}
public void methodB(){
System.out.println("Base中的methodB()");
}
}
public class Derived extends Base{
int a; // 与父类中成员变量同名且类型相同
char b; // 与父类中成员变量同名但类型不同
// 与父类中methodA()构成重载
public void methodA(int a) {
System.out.println("Derived中的method()方法");
}
// 与基类中methodB()构成重写(即原型一致，重写后序详细介绍)
public void methodB(){
System.out.println("Derived中的methodB()方法");
}
public void methodC(){
// 对于同名的成员变量，直接访问时，访问的都是子类的
a = 100; // 等价于： this.a = 100;
b = 101; // 等价于： this.b = 101;
// 注意：this是当前对象的引用
访问父类的成员变量时，需要借助super关键字
super是获取到子类对象中从父类继承下来的部分
super.a = 200;
super.b = 201;
// 父类和子类中构成重载的方法，直接可以通过参数列表区分清访问父类还是子类方法
methodA(); // 没有传参，访问父类中的methodA()
methodA(20); // 传递int参数，访问子类中的methodA(int)
// 如果在子类中要访问重写的父类方法，则需要借助super关键字
methodB(); // 直接访问，则永远访问到的都是子类中的methodB()，父类的无法访问到
super.methodB(); // 访问父类的methodB()
}
}主要作用：在子类方法中访问父 类的成员1. 只能在非静态方法中使用(因为静态方法并没有调用对象)2. 在子类方法中，访问父类的成员变量和方法 。
5. 子类构造方法
子类对象构造时，需要先调用基类构造方法，然后执行子类的构造方法
public class Derived extends Base{
public Derived(){
// super(); // 注意子类构造方法中默认会调用父类的无参构造方法：super(),
// 用户没有写时,编译器会自动添加，而且super()必须是子类构造方法中第一条语句，
// 并且只能出现一次
System.out.println("Derived()");
}
}在子类构造方法中，并没有写父类构造的代码，但是在构造子类对象时，先执行父类的构造方法，然后执行子类的构造方法，因为：子类对象中成员是有两部分组成的，父类继承下来的以及子类新增加的部分 。 所以在构造子类对象时候 ，先要调用父类的构造方法，将从父类继承下来的成员构造完整 ，然后再调用子类自己的构造方法，将子类自己新增加的成员初始化完整 。
1. 若父类显式定义无参或者默认的构造方法，在子类构造方法第一行默认有隐含的 super() 调用，2. 如果父类构造方法是带有参数的，此时需要用户为子类显式定义构造方法，并在子类构造方法中选择合适的父类构造方法调用，否则编译失败。3. 在子类构造方法中， super(...) 调用父类构造时，必须是子类构造函数中第一条语句。4. super(...) 只能在子类构造方法中出现一次，并且不能和 this 同时出现
6. super和this
同:1. 都是 Java 中的关键字2. 只能在类的非静态方法中使用，用来访问非静态成员方法和字段3. 在构造方法中调用时，必须是构造方法中的第一条语句，并且不能同时存在
异:1. this 是当前对象的引用，当前对象即调用实例方法的对象， super 相当于是子类对象中从父类继承下来部分成 员的引用2. 在非静态成员方法中， this 用来访问本类的方法和属性， super 用来访问父类继承下来的方法和属性3. 在构造方法中： this(...) 用于调用本类构造方法， super(...) 用于调用父类构造方法，两种调用不能同时在构造 方法中出现4. 构造方法中一定会存在 super(...) 的调用，用户没有写编译器也会增加，但是 this(...) 用户不写则没有
7. 初始化
class Person {
public String name;
public int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
System.out.println("构造方法执行");
}
{
System.out.println("实例代码块执行");
}
static {
System.out.println("静态代码块执行");
}
}
public class TestDemo {
public static void main(String[] args) {
Person person1 = new Person("小王",19);
System.out.println("============================");
Person person2 = new Person("小红",20);
}
}
静态代码块执行
实例代码块执行
构造方法执行
============================
实例代码块执行
构造方法执行1. 静态代码块先执行，并且只执行一次，在类加载阶段执行
2. 当有对象创建时，才会执行实例代码块，实例代码块执行完成后，最后构造方法执行
有继承关系时:
class Student extends Person{
public Student(String name,int age) {
super(name,age);
System.out.println("Student：构造方法执行");
}
{
System.out.println("Student：实例代码块执行");
}
static {
System.out.println("Student：静态代码块执行");
}
}
public class TestDemo {
public static void main(String[] args) {
Student student1 = new Student("天天",19);
System.out.println("===========================");
Student student2 = new Student("开心",20);
}
}
Person: 静态代码块执行
Student：静态代码块执行
Person: 实例代码块执行
Person: 构造方法执行
Student：实例代码块执行
Student：构造方法执行
===========================
Person: 实例代码块执行
Person: 构造方法执行
Student：实例代码块执行
Student：构造方法执行
Process finished with exit code 0
1、父类静态代码块优先于子类静态代码块执行，且是最早执行2、父类实例代码块和父类构造方法紧接着执行3、子类的实例代码块和子类构造方法紧接着再执行4、第二次实例化子类对象时，父类和子类的静态代码块都将不会再执行
8. protected 关键字 和 final 关键字
protected
protected范围:访问不同包中的子类
父类中 private 成员变量虽然在子类中不能直接访问，但是也继承到子类中了
final
关键可以用来修饰变量、成员方法以及类。
1. 修饰变量或字段，表示常量 ( 即不能修改 )2. 修饰类：表示此类不能被继承3. 修饰方法：表示该方法不能被重写
PS:季节性过敏，太难了。身心疲惫，质量难免起伏，我会后续改进！
后记
看到这里,希望能帮到你~
您的点赞 ,收藏 ,关注 是我创作的最大动力!
同时也欢迎在评论区进行交流,共同进步~
322
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
