JAVA学习笔记Ⅲ——面向对象三特性之继承

最新推荐文章于 2023-02-26 16:22:21 发布
最新推荐文章于 2023-02-26 16:22:21 发布
阅读量285 收藏 1
点赞数
分类专栏： JAVA学习笔记 文章标签： java 继承 类
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39567427/article/details/107318856
版权

文章目录

面向对象三大特性：封装、继承、多态

继承

继承，字面意思就是继续、承接。在人类生活中，后代可以继承父代或者祖先留下来的遗产等，皇权的继承等。因此继承可以在一定程度上让我们一开始就拥有一些东西，同时呢，一个人也只有一个生父。因此在JAVA中，继承的关系也是如此。

继承的概念继承的好处结构
继承是类与类的一种关系，是一种包含关系或者说是一种“is a”的关系。
在继承中被继承的类称为父类或者基类，继承而来的类称为子类。
在JAVA中存在一个Object类，这是所有类的父类。
JAVA中的继承属于单继承，只能继承一个父类		1.子类可以拥有父类所有的属性和方法（private修饰属性除外）
2.可以实现代码复用		class 子类 extends 父类
class A extends B{
…}
“属于”关系 与 “单继承”
           
“富二代”，“官二代代码复用
    
       

注：JAVA中的继承是单继承

子类拥有父类的所有属性和方法（非private）实现代码复用

父类Animal.java

package com.template11;

public class Animal {
    public int age;
    public String name;
    public void eat(){
        System.out.println("动物具有吃东西的能力");

    }
}

子类Dog.java

package com.template11;

public class Animal {
    public int age;
    public String name;
    public void eat(){
        System.out.println("动物具有吃东西的能力");

    }
}

初始化Initial.java

package com.template11;

public class Initial {
    public static void main(String[] args){
        //创建dog对象并调用dog属性
        //dog所有属性和方法都是从父类Animal继承而来
        Dog dog = new Dog();
        dog.age = 10;
        dog.name = "Quanhao Guo";

        //调用dog方法
        dog.eat();

        System.out.println(dog.age);
        System.out.println(dog.name);
    }
}

动物具有吃东西的能力
10
Quanhao Guo

方法的重写

方法的重写继承的初始化顺序
1.如果子类对继承父类的方法不满意，可以重写父类继承的方法，当调用方法时会优先调用子类的方法。
2.定义的方法中在返回值类型、方法名、参数类型及个数都要与父类继承的方法相同，才叫方法的重写。
3.调用方法时会优先调用子类的方法		初始化父类→初始化子类
执行初始化对象中属性→执行构造方法中的初始化
先执行父类构造方法再执行子类构造方法。先执行属性初始化，再执行构造方法初始化
        

重写调用示例

Animal.java

package com.template11;

public class Animal {
    public int age = 10;
    public String name;
    public void eat() {
        System.out.println("动物具有吃东西的能力");
    }
    public Animal(){
        age = 100;
        System.out.println("Animal类执行了");
    }
}

Dog.java

package com.template11;

public class Dog extends Animal {
    //重写eat()方法
    public void eat(){
        System.out.println("狗具有吃东西的能力");
    }

}

狗具有吃东西的能力
10
Quanhao Guo

初始化顺序示例

Animal.java

package com.template11;

public class Animal {
    public int age = 10;
    public String name;
    public void eat() {
        System.out.println("动物具有吃东西的能力");
    }
    public Animal(){
        age = 100;
        System.out.println("Animal类执行了");
    }
}

Dog.java

package com.template11;

public class Dog extends Animal {
    //重写eat()方法
    public void eat(){
        System.out.println("狗具有吃东西的能力");
    }

    //重写无参构造方法
    public Dog(){
        System.out.println("Dog类执行了");
    }
}

Initial.java

package com.template11;

public class Initial {
    public static void main(String[] args){
        Animal animal = new Animal();
        System.out.println("animal age:" + animal.age);
        //创建dog对象并调用dog属性
        //dog所有属性和方法都是从父类Animal继承而来
        Dog dog = new Dog();
        dog.age = 10;
        dog.name = "Quanhao Guo";

        //调用dog方法
        dog.eat();

        System.out.println(dog.age);
        System.out.println(dog.name);
    }
}


Animal类执行了
animal age:100
Animal类执行了
Dog类执行了
狗具有吃东西的能力
10
Quanhao Guo

JAVA中 final 关键字

final 关键字
使用final关键字做标识符有”最终的“含义
final 可以修饰类、方法、属性和变量
final 修饰类，则该类不允许被继承
final 修饰方法，则该方法不允许被覆盖（重写）
final 修饰属性，则该类的属性不会进行隐式的初始化（类的初始化属性必须有值）或在构造方法中赋值（但只能选其一，因为不能多次赋值）
final 修饰变量，则该变量的值只能赋一次值，即变为常量

使用final关键字修饰后的父类Animal不能被继承示例

Animal.java

package com.template12;

final public class Animal {
    public int age = 10;
    public String name;
    public void eat() {
        System.out.println("动物具有吃东西的能力");
    }
    public Animal(){
        age = 100;
        System.out.println("Animal类执行了");
    }
}

被final修饰的的方法不能被重写示例

Animal.java

package com.template12;

public class Animal {
    public int age = 10;
    public String name;
    final public void eat() {
        System.out.println("动物具有吃东西的能力");
    }
    public Animal(){
        age = 100;
        System.out.println("Animal类执行了");
    }
}

Animal.java

package com.template12;

public class Animal {
    final public int age = 10;
    public String name;
    public void eat() {
        System.out.println("动物具有吃东西的能力");
    }
    public Animal(){
        age = 100;
        System.out.println("Animal类执行了");
    }
}

final修饰的属性如果未被初始化（包括构造函数内也未初始化）系统不会自动帮我们初始化（即不会默认初始化为0）

Animal.java

package com.template12;

public class Animal {
    final public int age;
    public String name;
    public void eat() {
        System.out.println("动物具有吃东西的能力");
    }
    public Animal(){
        System.out.println("Animal类执行了");
    }
}

因此使用final修饰的属性必须初始化，要么在属性初始化，要么在构造函数进行初始化

对于final修饰局部变量（例如在方法中定义），那么局部变量成为一个常量，不允许被修改。

Animal.java

package com.template12;

public class Animal {
    final public int age = 10;
    public String name;
    public void eat() {
        final int constant = 10;//不允许被再次修改
        constant = 100;
        System.out.println("动物具有吃东西的能力");
    }
    public Animal(){
        System.out.println("Animal类执行了");
    }
}

JAVA中 super 关键字

super 关键字
在对象的内部使用，可以代表父类对象
1.访问父类对象的属性 super.age
2.访问父类的方法 super.eat()
子类的构造过程当中必须调用其父类的构造方法
如果子类的构造方法中没有显示调用父类的构造方法，则系统默认调用父类的无参构造方法
如果子类构造方法中既没有显示调用父类的构造方法，而父类又没有无参构造方法，则编译出错
如果子类显示的调用构造方法，必须在子类的构造方法的第一行

Animal.java

package com.template12;

public class Animal {
    public int age = 10;
    public String name;
    public void eat() {
        System.out.println("动物具有吃东西的能力");
    }
    public Animal(){
        System.out.println("Animal类执行了");
    }
}

Dog.java

package com.template12;

public class Dog extends Animal {
    public int age = 20;

    //重写eat()方法
    public void eat(){
        System.out.println("狗具有吃骨头的能力");
    }

    //重写无参构造方法
    public Dog(){
        //这里隐式的调用了父类的构造方法，类似于增加了一行super()，如下
        //super();如果写了这一行那么这一行必须位于首行
        System.out.println("Dog类执行了");
    }
    
    //定义method方法
    public void method(){
        System.out.println("调用父类的eat()方法");
        super.eat();
        System.out.println("调用子类的eat()方法");
        eat();
        System.out.println("调用父类属性age：" + super.age);
        System.out.println("调用子类(本身)属性age：" + age);
    }
}

Initial.java

package com.template12;

public class Initial {
    public static void main(String[] args){
        Animal animal = new Animal();
        System.out.println("animal age:" + animal.age);
        //创建dog对象并调用dog属性
        //dog所有属性和方法都是从父类Animal继承而来
        Dog dog = new Dog();
        dog.name = "Quanhao Guo";
        dog.method();
    }
}

Animal类执行了
animal age:10
Animal类执行了
Dog类执行了
调用父类的eat()方法
动物具有吃东西的能力
调用子类的eat()方法
狗具有吃骨头的能力
调用父类属性age：10
调用子类(本身)属性age：20

JAVA中 object 类

object 类 与 toString()方法

object 类是所有类的父类，如果一个类没有使用extends关键字明确标识继承另外一个类，那么这个类默认继承 Object 类，Object 类中的方法，适合所有子类。在 Object 类里面定义 toString() 方法的时候返回的对象哈希code（对象地址字符串），可以通过重写 toString() 方法表示出对象的属性。

关系示例toString() 示例
<

Animal.java

package com.template13;

public class Animal extends Object{
    public int age = 10;
    public String name;
    public void eat() {
        System.out.println("动物具有吃东西的能力");
    }
    public Animal(){
        System.out.println("Animal类执行了");
    }
}

Dog.java

package com.template13;

public class Animal extends Object{
    public int age = 10;
    public String name;
    public void eat() {
        System.out.println("动物具有吃东西的能力");
    }
    public Animal(){
        System.out.println("Animal类执行了");
    }
}

Initial.java

package com.template13;

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

Animal类执行了
Dog类执行了
Dog{age=20}

JAVA中 equals()方法

equals()方法

比较的是对象的引用是否指向同一块内存地址

  

Transport.java

package com.template15;

public class Transport {

    public int seats;
    public int speed;
    public float price;

    public void setSpeed(int speed) {
        this.speed = speed;
    }

    public void setPrice(float price) {
        this.price = price;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Transport transport = (Transport) o;
        return seats == transport.seats &&
                speed == transport.speed &&
                Float.compare(transport.price, price) == 0;
    }


    public Transport(int seats, int speed, float price){
        this.seats = seats;
        setSpeed(speed);
        setPrice(price);


    }
}

Initial.java

package com.template15;

public class Initial {
    public static void main(String[] args){
        Bus bus_1 = new Bus(100, 200, 300);
        Bus bus_2 = new Bus(100, 200, 300);

        System.out.println("bus_1 parameters：");
        System.out.println(bus_1.seats +" " + bus_1.speed + " " + bus_1.price);
        System.out.println("bus_2 parameters：");
        System.out.println(bus_2.seats +" " + bus_2.speed + " " + bus_2.price);
        
        if(bus_1.equals(bus_2)){
            System.out.println("两者相等");
        }
        else{
            System.out.println("两者不等");
        }
    }
}

Bus.java

package com.template15;

public class Bus extends Transport {

    public Bus(int seats, int speed, float price) {
        super(seats, speed, price);
    }
}


bus_1 parameters：
100 200 300.0
bus_2 parameters：
100 200 300.0
两者相等
DeepHao
关注
专栏目录
JAVA学习笔记——面向对象编程：继承1
weixin_43410001的博客
04-05 532
目录类、超类和子类超类和子类覆盖方法子类构造器多态方法的调用过程阻止继承：final 类和方法强制类型转换抽象类受保护访问Object 类：所有类的超类equals 方法hashCode 方法toString 方法 类、超类和子类 超类和子类 关键字 extends 表明正在构造的新类派生于一个已存在的类。已存在的类称为超类 (superclass)、基类 (base class) 或父类 (parent class)；新类称为子类 (subclass)、派生类 (derived class) 或孩子类 (
Java学习笔记——面向对象
l903445981的博客
07-20 290
首先介绍了静态方法和非静态方法的调用方式，接着对static关键字进行补充介绍，然后介绍了Java是值引用的，介绍了this，super的概念，继承、多态，抽象方法与接口的定义与实现
Java小白必备之面向对象-继承的定义与使用
Code皮皮虾的博客
08-21 714
文章目录1、继承概述2、继承的使用（代码实例）3、继承类型（代码实例） 1、继承概述 什么是继承？ 继承是java面向对象编程技术的一块基石，因为它允许创建分等级层次的类。 继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。 在现实生活中也是存在继承关系的，例如：父辈的财产由其后代继承。 继承关键字 继承可以使用 extends这个关键字来实现继承，而且所有的类都是继承于 java.lang.Object，当一个类没有继承的
JAVA继承
weixin_66109724的博客
11-06 98
如果父类构造器没有参数，则在子类的构造器中不需要使用 super 关键字调用父类构造器，系统会自动调用父类的无参构造器。
【Java基础】22-12-30 日面向对象相关内容。
qq_46289793的博客
12-30 72
Java基础知识。
继承 关键字extends 实例package com.cjg.test； public class Animal { private String name； private int age；
py编程|爱分享
03-20 2230
package com.cjg.test;//创建个父类Animal 并定义私有属性（因私有属性不能被调用采用set，get方法），方法public class Animal { private String name; private int age; public String getName() { return name; } public void setName(String na......
Java面向对象三大特征——继承
qq_63708623的博客
03-13 3707
类的继承什么是继承呢？如何继承Java继承中要注意的问题：继承中变量访问的特点方法重写super关键字Object类 什么是继承呢？ 我们先来观察一下这俩个类（为了方便演示，先不对类进行封装） Dog类 public class Dog { int age; String name; public void shout() { System.out.println("发出叫声"); } } Cat类 public class Cat { int age; String name; pub
Java基础笔记06——面向对象编程篇
qq_43689353的博客
05-04 908
面向对象编程
Java学习笔记——面向对象之重写（Override）与重载（Overload）
D77的博客
07-12 385
Java 重写(Override)与重载(Overload)
Java学习笔记04——子类与继承
最新发布
qq_45033269的博客
02-26 1347
用abstract关键字修饰的方法称为abstract方法（抽象方法），抽象方法只允许声明，不允许实现（没有方法体）。同时不能使用static或final关键字修饰抽象方法。用abstract关键字修饰的类称为abstract类（抽象类）。. . . }允许抽象类拥有抽象方法（其他类中不能有抽象方法），也允许拥有非抽象方法。不能使用new运算符创建抽象类的对象。如果某个非抽象类是抽象类的子类，则其必须重写父类的抽象方法，给出方法体。
面向对象——继承、多态、抽象类、接口
l1223cf的博客
05-04 706
一、继承 1、继承：类和类之间满足一个类属于（is a）另一个类 例如：dog is an animal 2、继承关键字：extends dog extends animal; 其中，dog称为子类或派生类，animal称为父类或者基类 3、继承规则 （1）使用继承必须满足 is a 关系 （2）一个子类只能使用extends继承一个父类（单继承），继承允许多层继承，但不允许多重继承。 例如：Labrador extends dog; ...
脸打肿都不要忘了呀，Java 重写时应当遵守的 11 条规则！！
沉默王二
03-26 1万+
CSDN 的小伙伴们，大家好，我是沉默王二。 重写（Overriding）算是 Java 中一个非常重要的概念，理解重写到底是什么对每个 Java 程序员来说都至关重要，这篇文章就来给大家说说重写过程中应当遵守的 12 条规则。 01、什么是重写？ 重写带来了一种非常重要的能力，可以让子类重新实现从超类那继承过来的方法。在下面这幅图中，Animal 是父类，Dog 是子类，Dog 重新实现了 move() 方法用来和父类进行区分，毕竟狗狗跑起来还是比较有特色的。 重写的方法和被重写的方法，不仅方法名相同，
Java小程序之 人(person)喂养猫（cat）和狗（dog）统称为动物（Animal),要求：运用抽象类、继承 提示：Animal为抽象类，Cat、Dog为..........
weixin_45144624的博客
07-15 4281
抽象类、继承的练习 请细细品味！点赞，关注！支持一下，给点动力！ 1.定义动物类 属性：年龄，颜色 生成空参有参构造，set和get方法 行为：eat(String something)方法(无具体行为,不同动物吃的方式和东西不一样,something表示吃的东西) 2.定义狗类继承动物类，行为：eat(String something)方法,看家lookHome方法(无参数) 3.定义猫类继承动物类，行为：eat(String something)方法,逮老鼠catchMouse方法(无参数) 4.定义P
多态题目Animal
gfh
01-25 1904
public class Animal { private String name; public Animal(String name) { this.name = name; } public String getName() { return name; } public void setName(String name) { this.name = name;
Java基础 第三章 继承、多态(接口/抽象类)
Water.you的博客
03-15 428
一、继承 1.1 继承概念 继承是java面向对象编程技术的一块基石，因为它允许创建分等级层次的类。 继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为，提升代码的复用，减少冗余； 比如： 猫和老虎属于属于猫科动物，狗和狼属于犬科动物 猫科动物和犬科动物又是属于动物类。 所以继承需要符合的关系是：is-a，父类更通用，子...
java动物继承代码实例,Java 继承
weixin_39628342的博客
03-11 1754
Java 继承一、实验介绍1、继承2、方法重写3、继承的初始化顺序二、实验步骤1 继承的定义继承可以看成是类与类之间的衍生关系。例如：狗类是动物类，牧羊犬类又是狗类。于是我们可以说狗类继承了动物类，而牧羊犬类就继承了狗类。于是狗类就是动物类的子类(或派生类)，动物类就是狗类的父类(或基类)。所以继承需要符合的关系是：is-a，父类更通用，子类更具体。创建一个类需要它来继承某一个类的语法：class...
java自学笔记3：java中的继承
十二指环的博客
11-28 257
一.1.继承的概念： 继承是类与类的一种关系。java中的继承是单继承。2.继承的好处 子类拥有父类的所有属性和方法，private修饰的无效哦 实现代码复用3.语法规则： class子类 extends 父类 例:class Dog extends Animal{ … }4.创建子类时，可以选择要继承的父类 二.Java中的方法重写1.子类可以继承父类的
动物类的继承
AI_QS_CSDN的博客
04-24 1万+
动物类的继承 要求： 1.在一个名为Test.java的文件中定义四个类：动物类Animal，狗类Dog和猫类Cat继承Animal，测试类Test，要求编写代码的同时编写简单注释。 2.动物类Animal要求体现以下内容： （1） 私有成员变量：姓名name，年龄age （2） 构造方法：无参构造、带参构造 （3） 成员方法：s...
java基础—继承题目：编写一个Animal类，具有属性：种类；具有功能：吃、睡。定义其子类Fish...
热门推荐
weixin_30617695的博客
09-22 1万+
编写一个Animal类，具有属性：种类；具有功能：吃、睡。定义其子类Fish package zhongqiuzuoye; public class Animal { //属性 private String type; public String getType() { return type; } ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值