初始java( 4 )7000字详解

简介: 初始java( 4 )7000字详解

一:继承

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 继承的语法

在Java中如果要表示类之间的继承关系,需要借助extends关键字,具体如下:

修饰符 class 子类 extends 父类 {
  //代码
 }

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

// 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();
 }
}

注意:在java中只支持单继承,并不支持多继承

下面是我对继承的理解:

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

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

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

成员变量访问遵循就近原则,自己有优先用自己的,如果没有则向父类中找。

下面是个简单的代码示例:

class Parent {
    int num = 10;
}
class Child extends Parent {
    int num = 20;
    void display() {
        System.out.println( num); // 访问自己的成员变量
    }
}
public class Main {
    public static void main(String[] args) {
        Child child = new Child();
        child.display();
    }
}

输出结果是: 20

```java
class Parent {
    int num = 10;
}
class Child extends Parent {
    void display() {
        System.out.println( num); // 访问自己的成员变量
    }
}
public class Main {
    public static void main(String[] args) {
        Child child = new Child();
        child.display();
    }
}

输出结果是: 10

class Parent {
}
class Child extends Parent {
    int num = 20;
    void display() {
        System.out.println( num); // 访问自己的成员变量
    }
}
public class Main {
    public static void main(String[] args) {
        Child child = new Child();
        child.display();
    }
}

输出结果是: 20

同理,子类中如果存在和父类同名的方法,那么也是遵循这个原则,子类有就访问自己的,没有再去父类中找

1.5 super关键字

但是当子类和父类的变量或者方法重名了,我们又确实想访问父类的变量或者方法,那么该怎么办呢?

我们直接访问是无法做到的,但是java为我们提供了super关键字,该关键字主要作用:在子类方法中访问父类的成员。和this类似,super也有三种作用:

  • super.成员变量
  • super.方法名()
  • super()

下面通过一个简单的代码例子来说明super的作用:

当在子类中使用super关键字时,有三种常见的用法:

  1. super.成员变量:用于访问父类中的成员变量。
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. super.方法名():用于在子类中调用父类中的方法。
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关键字即可。

注意事项:

  • super和this都只能在非静态方法中使用

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

父子父子,有父才有子

java规定,在子类的构造方法中,要通过super()调用父类的构造方法,先帮从父类继承过来的变量进行构造,再构造自己的变量,通过调用父类构造方法和子类构造方法后,就可以对一个类中的所有的变量进行初始化了

子类对象中成员是有两部分组成的,父类继承下来的以及子类新增加的部分 。父子父子肯定是先有父再有子,所以在构造子类对象时候 ,先要调用基类的构造方法,将从父类继承下来的成员构造完整,然后再调用子类自己的构造方法,将子类自己新增加的成员初始化完整 。

注意:

  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());
    }
}

在上述示例中,父类Parent定义了一个有参构造方法来初始化age属性。子类Child的构造方法使用super(age)显式地调用了父类的构造方法来初始化父类的age属性。通过这种方式,子类可以在构造对象时进行对父类属性的初始化操作。

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);
 }
}

执行结果:

通过分析执行结果,得出以下结论:

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

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

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

4、第二次实例化子类对象时,父类和子类的静态代码块都将不会再执行

1.8继承关系视图

二:final关键字

在Java中,final关键字可以用来修饰变量、方法和类。它的作用如下:

  1. 修饰变量:当final关键字修饰一个变量时,表示该变量的值只能被赋值一次,赋值后不可再改变。一般将final修饰的变量称为常量,通常使用大写字母表示。常量的值在程序运行期间保持不变。

示例代码:

final int age = 18;
// age = 20;  // 编译错误,不能再次赋值给常量age
System.out.println(age);  // 输出结果:18
  1. 修饰方法:当final关键字修饰一个方法时,表示该方法不能被子类重写。这样可以确保方法的实现不会被修改,保持方法的稳定性。(这里了解即可,后面会讲什么是重写)

示例代码:

public class SuperClass {
    public final void printMessage() {
        System.out.println("This is a final method.");
    }
}
public class SubClass extends SuperClass {
    // 尝试重写final方法,编译错误
    // public void printMessage() { }
    public static void main(String[] args) {
        SubClass sub = new SubClass();
        sub.printMessage();
    }
}
  1. 修饰类:当final关键字修饰一个类时,表示该类不能被继承,即不能有子类。这样可以保护类的实现不被修改或继承。

示例代码:

public final class FinalClass {
    // 类的实现
}
// 试图继承final类,编译错误
// public class SubClass extends FinalClass { }

总结:

  • final修饰变量表示常量,其值不可改变;
  • final修饰方法表示该方法不可被重写;
  • final修饰类表示该类不可被继承。
目录
相关文章
|
4天前
|
弹性计算 关系型数据库 微服务
基于 Docker 与 Kubernetes(K3s)的微服务:阿里云生产环境扩容实践
在微服务架构中,如何实现“稳定扩容”与“成本可控”是企业面临的核心挑战。本文结合 Python FastAPI 微服务实战,详解如何基于阿里云基础设施,利用 Docker 封装服务、K3s 实现容器编排,构建生产级微服务架构。内容涵盖容器构建、集群部署、自动扩缩容、可观测性等关键环节,适配阿里云资源特性与服务生态,助力企业打造低成本、高可靠、易扩展的微服务解决方案。
1106 0
|
3天前
|
机器学习/深度学习 人工智能 前端开发
通义DeepResearch全面开源!同步分享可落地的高阶Agent构建方法论
通义研究团队开源发布通义 DeepResearch —— 首个在性能上可与 OpenAI DeepResearch 相媲美、并在多项权威基准测试中取得领先表现的全开源 Web Agent。
533 10
|
13天前
|
人工智能 运维 安全
|
12天前
|
人工智能 测试技术 API
智能体(AI Agent)搭建全攻略:从概念到实践的终极指南
在人工智能浪潮中,智能体(AI Agent)正成为变革性技术。它们具备自主决策、环境感知、任务执行等能力,广泛应用于日常任务与商业流程。本文详解智能体概念、架构及七步搭建指南,助你打造专属智能体,迎接智能自动化新时代。
|
4天前
|
弹性计算 Kubernetes jenkins
如何在 ECS/EKS 集群中有效使用 Jenkins
本文探讨了如何将 Jenkins 与 AWS ECS 和 EKS 集群集成,以构建高效、灵活且具备自动扩缩容能力的 CI/CD 流水线,提升软件交付效率并优化资源成本。
303 0
|
11天前
|
人工智能 异构计算
敬请锁定《C位面对面》,洞察通用计算如何在AI时代持续赋能企业创新,助力业务发展!
敬请锁定《C位面对面》,洞察通用计算如何在AI时代持续赋能企业创新,助力业务发展!
|
12天前
|
机器学习/深度学习 人工智能 自然语言处理
B站开源IndexTTS2,用极致表现力颠覆听觉体验
在语音合成技术不断演进的背景下,早期版本的IndexTTS虽然在多场景应用中展现出良好的表现,但在情感表达的细腻度与时长控制的精准性方面仍存在提升空间。为了解决这些问题,并进一步推动零样本语音合成在实际场景中的落地能力,B站语音团队对模型架构与训练策略进行了深度优化,推出了全新一代语音合成模型——IndexTTS2 。
807 23
|
4天前
|
缓存 供应链 监控
VVIC seller_search 排行榜搜索接口深度分析及 Python 实现
VVIC搜款网seller_search接口提供服装批发市场的商品及商家排行榜数据,涵盖热销榜、销量排名、类目趋势等,支持多维度筛选与数据分析,助力选品决策、竞品分析与市场预测,为服装供应链提供有力数据支撑。
|
4天前
|
缓存 监控 API
Amazon item_review 商品评论接口深度分析及 Python 实现
亚马逊商品评论接口(item_review)可获取用户评分、评论内容及时间等数据,支持多维度筛选与分页调用,结合Python实现情感分析、关键词提取与可视化,助力竞品分析、产品优化与市场决策。

热门文章

最新文章