初识 java - 4 ( 5000字详解 )

已于 2025-05-17 09:50:06 修改
阅读量1.2w 收藏 5
点赞数 6
分类专栏： java 文章标签： java
于 2023-08-06 17:38:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_73232539/article/details/132131575
版权

一：继承

1.1 继承的引入

首先我们来说说为什么要有继承，继承在生活中的体现是什么？

我们知道每个人都会有 DNA，DNA 中有许多基因，我们中有许多基因都是从父亲母亲那继承过来的，当然我们还会继承父母的很多东西，在 java 中同样也存在继承，java 中的继承的目的主要是用于共性提取，代码复用，减少代码的重复性，下面通过一个例子来说明：

// Dog类
public class Dog{
  string name;
  int age;
  float weight;
 
  public void eat(){
    System.out.println(name + "正在吃饭");
 }
 
  public void sleep(){
    System.out.println(name + "正在睡觉");
 }
 
  void Bark(){
   System.out.println(name + "汪汪汪~~~");
 }
}

// Cat类
public class Cat{
  string name;
  int age;
  float weight;
 
  public void eat(){
    System.out.println(name + "正在吃饭");
 }
 
  public void sleep()
 {
    System.out.println(name + "正在睡觉");
 }
 
  void mew(){
    System.out.println(name + "喵喵喵~~~");
 }
}

在这里插入图片描述

通过比较会发现，猫和狗类中存在着大量的重复，为了能够把重复的代码进行复用，java 提出了继承的概念，专门用来进行共性提取，实现代码的复用

1.2 继承的概念

继承：是使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加新功能。

在这里插入图片描述

上述图示中，Dog 和 Cat 都继承了 Animal 类，其中：Animal 类称为 父类 / 基类 或 超类， Dog 和 Cat 可以称为 Animal 的子类 / 派生类，继承之后，子类可以复用父类中成员，子类在实现时只需关心自己新增加的成员即可。

1.3 继承的语法

所以我们对上述代码进行重新设计，通过继承的方式实现共性提取，代码复用

// Animal.java
public class Animal{
  String name;
  int age;
 
  public void eat(){
    System.out.println(name + "正在吃饭");
 }
 
  public void sleep(){
    System.out.println(name + "正在睡觉");
 }
}

// Dog.java
public class Dog extends Animal{  
  void bark(){
    System.out.println(name + "汪汪汪~~~");
 }
}

// Cat.Java
public class Cat extends Animal{ 
  void mew(){
    System.out.println(name + "喵喵喵~~~");
 }
}

// TestExtend.java
public class TestExtend {
  public static void main(String[] args) {
    Dog dog = new Dog();
    // dog类中并没有定义任何成员变量，name 和 age 属性肯定是从父类 Animal 中继承下来的
    System.out.println(dog.name);
    System.out.println(dog.age);
    // dog 访问的 eat() 和 sleep() 方法也是从 Animal 中继承下来的
    dog.eat();
    dog.sleep();
    dog.bark();
 }
}

在这里插入图片描述

注意：并不是所有的父类的代码都会继承，父类的构造方法和静态方法以及被 private 修饰的成员并不会被继承，构造方法的名字必须与类名相同，因此构造方法是无法被继承的，而静态是独属于一个类的，如果被继承了就违背了独属的原则，private 只在自己的类中可见，你继承过去有啥意义吗？所以说 private 修饰的成员也是不会被继承的。

1.4 父类成员和子类成员冲突问题

通过子类对象访问成员时：

  • 如果访问的成员变量子类中有，优先访问自己的成员变量。
  • 如果访问的成员变量子类中无，则访问父类继承下来的，如果父类也没有定义，则编译报错。
  • 如果访问的成员变量与父类中成员变量同名，则优先访问自己的。

成员变量访问遵循就近原则，自己有优先用自己的，如果没有则向父类中找，同理，子类中如果存在和父类同名的方法，那么也是遵循这个原则，子类有就访问自己的，没有再去父类中找

1.5 super 关键字

但是当子类和父类的变量或者方法重名了，我们又确实想访问父类的变量或者方法，那么该怎么办呢？我们直接访问是无法做到的，所以 java 为我们提供了 super 关键字，和 this 类似，super 也有三种作用：

  • super.成员变量
  • super.方法名( )
  • super( )
  1. 访问父类中的成员变量。
class Animal {
    String name = "Animal类的成员变量";
}

class Dog extends Animal {
    String name = "Dog类的成员变量";

    void printName() {
        System.out.println(super.name);  // 访问父类的成员变量
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.printName();  // 输出：Animal类的成员变量
    }
}
  1. 在子类中调用父类中的方法。
class Animal {
    void print() {
        System.out.println("Animal类的方法");
    }
}

class Dog extends Animal {
    void print() {
        super.print();  // 调用父类的方法
        System.out.println("Dog类的方法");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.print();  // 输出：Animal类的方法     Dog类的方法     
    }
}
  1. super()：用于在子类的构造方法中调用父类的构造方法。
class Animal {
    String name;

    Animal(String n) {
        name = n;
    }

    void printName() {
        System.out.println(name);
    }
}

class Dog extends Animal {
    Dog(String n) {
        super(n);  // 调用父类的构造方法
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog("Dog对象");
        dog.printName();  // 输出：Dog对象
    }
}

注意事项：super 和 this 都不能在静态方法中使用，因为静态方法不需要引用。

1.6 子类的构造方法与父类的构造方法

父子父子，有父才有子，子类要先帮从父类继承过来的变量进行构造，所以在构造子类对象时候 ，先要调用父类的构造方法，将从父类继承下来的成员构造完整，然后再调用子类自己的构造方法，将子类自己新增加的成员初始化完整 。

  1. 若父类显式定义无参或者默认的构造方法，在子类构造方法第一行默认有隐含的 super() 调用，即调用父类构造方法
  2. 如果父类构造方法是带有参数的，此时需要用户为子类显式定义构造方法，并在子类构造方法中选择合适的父类构造方法调用，否则编译失败。
  3. 在子类构造方法中，super( ) 调用父类构造时，必须是子类构造函数中第一条语句。
  4. super( ) 不能和 this 同时出现，因为 super和 this 都要放第一行，这矛盾了
class Parent {
    private int age;
    
    public Parent(int age) {
        this.age = age;
    }
    
    public int getAge() {
        return age;
    }
}

class Child extends Parent {
    private String name;
    
    public Child(String name, int age) {
        super(age); // 调用父类的构造方法进行年龄的初始化
        this.name = name;
    }
    
    public String getName() {
        return name;
    }
}

public class Main {
    public static void main(String[] args) {
        Child child = new Child("Alice", 10);
        System.out.println("Name: " + child.getName());
        System.out.println("Age: " + child.getAge());
    }
}

1.7 再谈代码块

1.7.1 无继承关系上的执行顺序：

还记得之前讲过的代码块吗？我们简单回顾一下几个重要的代码块：实例代码块和静态代码块。在没有继承关系时的执行顺序。

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("bit",10);
    System.out.println("                ");
    Person person2 = new Person("gaobo",20);
 }
}

静态代码块执行
实例代码块执行
构造方法执行

实例代码块执行
构造方法执行

1.7.2 继承关系上的执行顺序：

class Person {
  public String name;
  public int age;
  public Person(String name, int age) {
    this.name = name;
    this.age = age;
    System.out.println("Person：构造方法执行");
 }
 {
    System.out.println("Person：实例代码块执行");
 }
  static {
    System.out.println("Person：静态代码块执行");
 }
}
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 TestDemo4 {
  public static void main(String[] args) {
    Student student1 = new Student("张三",19);
    system.out.println("= = = = = = = = = = = = = = = = = = = =");
    Student student2 = new Student("gaobo",20);
    }
  public static void main1(String[] args) {
    Person person1 = new Person("bit",10);
    System.out.println("= = = = = = = = = = = = = = = = = = = =");
    Person person2 = new Person("gaobo",20);
 }
}

Person：静态代码块执行
Student：静态代码块执行
Person：实例代码块执行
Person：构造方法执行
Student：实例代码块执行
Student：构造方法执行
= = = = = = = = = = = = = = = = = = = =
Person：实例代码块执行
Person：构造方法执行
Student：实例代码块执行
Student：构造方法执行

通过分析执行结果，得出以下结论：

  1. 父类静态代码块优先于子类静态代码块执行，且是最早执行
  2. 父类实例代码块和父类构造方法紧接着执行
  3. 子类的实例代码块和子类构造方法紧接着再执行
  4. 第二次实例化子类对象时，父类和子类的静态代码块都将不会再执行

二：final 关键字

在 Java 中，final 的作用如下：

  • final 修饰变量表示常量，其值不可改变；
  • final 修饰方法表示该方法不可被重写；
  • final 修饰类表示该类不可被继承。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

ice___Cpu

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值