【Java】继承与多态

最新推荐文章于 2022-05-09 14:57:00 发布
最新推荐文章于 2022-05-09 14:57:00 发布
阅读量201 收藏 2
点赞数
分类专栏： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qzw752890913/article/details/109544424
版权

文章目录

继承
  • Object
    Java中，Object类是所有类的父类。
    因此，所有类都继承了Object类的方法，如getClass()、hashCode()、toString()、equals()。
public class Animal {
    private String picture;
    public void roam(){
        System.out.println("Animal: roaming");
    }
}

public class Dog extends Animal {
    public void roam(){
        System.out.println("Dog: roaming");
    }
}

public class Hippo extends Animal {
    public void roam(){
        System.out.println("Hippo: roaming");
    }
}

public class Test {
    public static void main(String[] args){
        Dog d = new Dog();
        System.out.println("d.getClass(): " + d.getClass());
        System.out.println("d.hashCode(): " + d.hashCode());
        System.out.println("d.toString(): " + d.toString());
        System.out.println("");

        Hippo h = new Hippo();
        System.out.println("h.getClass(): " + h.getClass());
        System.out.println("h.hashCode(): " + h.hashCode());
        System.out.println("h.toString(): " + h.toString());
        System.out.println("");

        if(d.equals(h)){
            System.out.println("true");
        }else{
            System.out.println("false");
        }
    }
}

在这里插入图片描述

  • Java不允许多重继承
    子类只能继承一个父类，不能继承多个父类
  • 使用 super获取父类
    super.roam()
public class Animal {
    private String picture;

    public void roam(){
        System.out.println("Animal: roaming");
    }
}

public class Hippo extends Animal {
    public void roam(){
        super.roam();
        System.out.println("Hippo: roaming");
    }
}

public class Test {
    public static void main(String[] args){
        Hippo h = new Hippo();
        h.roam();
    }
}
  • 通过super()调用父类的构造函数
    父类的构造函数必须在子类的构造函数之前调用。
public class Animal {
    public Animal(){
        System.out.println("making an animal");
    }
}

public class Hippo extends Animal {
    public Hippo(){
        super();
        System.out.println("Step 2: making a hippo");
    }
}

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

在这里插入图片描述

public class Animal {
    private String name;
    public Animal(String theName){
        name = theName;
    }
    public String getName(){
        return name;
    }
}

public class Hippo extends Animal {
    public Hippo(String name){
        super(name);
    }
}

public class Test {
    public static void main(String[] args){
        Hippo hippo = new Hippo("Jeff");
        System.out.println(hippo.getName());
    }
}

在这里插入图片描述

  • 通过this()在构造函数中调用同类的另一个构造函数
    this()只能在构造函数中使用，且必须放在第一行；
    this()和super()不能同时使用。
public class Animal {
    private String name;
    public Animal(){
        this("Tom");
    }
    public Animal(String theName){
        name = theName;
    }
    public String getName(){
        return name;
    }
}

public class Hippo extends Animal {
    public Hippo(String name){
        super(name);
    }
}

public class Dog extends Animal {

}

public class Test {
    public static void main(String[] args){
        Hippo hippo = new Hippo("Jeff");
        System.out.println("hippo'name is "+hippo.getName());

        Dog dog = new Dog();
        System.out.println("dog's name is "+ dog.getName());
    }
}

在这里插入图片描述

  • 访问权限
    • public
    • protected
    • private
  • 如何让类不可被继承
    • 使用final修饰类
      比如，public final class Animal{}。
      另外，final也可以用来修饰类的方法，从而防止方法被覆盖。
    • 将类的构造函数标记为private
      比如，private Animal(){}
  • 方法覆盖
    • 参数类型必须相同，返回值类型必须兼容
    • 不能降低访问权限
多态
public class Animal {
    private String picture;

    public void roam(){
        System.out.println("Animal: roaming");
    }
}

public class Dog extends Animal {
    public void roam(){
        System.out.println("Dog: roaming");
    }
}

public class Test {
    public static void main(String[] args){
        Dog d = new Dog();
        d.roam();

        Animal dog = new Dog();
        dog.roam();
    }
}

在这里插入图片描述

抽象类
public class Animal {
    private String picture;
    public void roam(){
        System.out.println("Animal: roaming");
    }
}

public class Dog extends Animal {
    public void roam(){
        System.out.println("Dog: roaming");
    }
}

public class Hippo extends Animal {
    public void roam(){
        super.roam();
        System.out.println("Hippo: roaming");
    }
}

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

        Hippo hippo = new Hippo();
        hippo.roam();

        Animal animal = new Animal();
        animal.roam();
    }
}

创建出Dog对象、Hippo对象很合理，但Animal对象却有些出人意料，它应该长什么样？几条腿？
也就是说Animal类不应该被初始化。
类 Dog、类Hippo是具体类，可以被初始化为对象；
类Animal，则是抽象类，不应该被初始化的类，用abstract修饰。

public abstract class Animal {
    private String picture;
    public void roam(){
        System.out.println("Animal: roaming");
    }
}

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

在这里插入图片描述

抽象方法
  • 抽象方法没有实体
  • 抽象方法必须在抽象类中声明
  • 继承了抽象类的子类必须实现抽象类中的抽象方法，即抽象方法必须被覆盖
  • 抽象类中既可以有抽象方法，也可以有非抽象方法
public abstract class Animal {
    private String picture;
    public abstract void eat();
    public void roam(){
        System.out.println("Animal: roaming");
    }
}

public class Dog extends Animal {
    public void roam(){
        System.out.println("Dog: roaming");
    }
}

public class Hippo extends Animal {
    public void roam(){
        System.out.println("Hippo: roaming");
    }
}

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

在这里插入图片描述

public abstract class Animal {
    private String picture;
    public abstract void eat();
    public void roam(){
        System.out.println("Animal: roaming");
    }
}

public class Dog extends Animal {
    public void eat(){
        System.out.println("Dog eat bone");
    }
    public void roam(){
        System.out.println("Dog: roaming");
    }
}

public class Hippo extends Animal {
    public void eat(){

    }
    public void roam(){
        System.out.println("Hippo: roaming");
    }
}

public class List {
    private Animal[] list = new Animal[5];
    private int nextIndex = 0;
    public void add(Animal a){
        if(nextIndex < list.length){
            list[nextIndex] = a;
            System.out.println("Add animal at " + nextIndex);
            nextIndex++;
        }
    }
}

public class Test {
    public static void main(String[] args){
        List list = new List();
        Dog d = new Dog();
        list.add(d);
        Hippo h = new Hippo();
        list.add(h);
    }
}

在这里插入图片描述

接口
  • 所有方法都是抽象的
    抽象类既可以有抽象方法，也可以有非抽象方法。
    接口，可以理解成100%的抽象类，即所有的方法都是抽象的。
  • 定义接口
    定义接口用interface
  • 实现接口
    实现接口用implements
public class Animal {
    private String picture;
    public void eat(){
        System.out.println("Animal:eat something");
    }
}

public class Canine extends Animal{
    public void roam(){
        System.out.println("Canine:roam");
    }
}

public interface Pet {
    void play();
    void beFriendly();
}

public class Dog extends Canine implements Pet {
    public void eat(){
        System.out.println("Dog: eat bone");
    }
    public void play(){
        System.out.println("Dog: play");
    }
    public void beFriendly(){
        System.out.println("Dog: be friendly");
    }
}

public class Test {
    public static void main(String[] args){
        Dog dog = new Dog();
        dog.eat();
        dog.roam();
        dog.play();
        dog.beFriendly();
    }
}

在这里插入图片描述
在这里插入图片描述
接口里声明的方法默认是public和abstract，所以上面就省写了，当然也可以像下面这样都写上，

public interface Pet{
    public abstract void play();
    public abstract void beFriendly();
}

在这里插入图片描述

静态方法
  • 静态方法用static标记
  • 静态方法通过类名来调用
    静态变量是通过类名来调用的，而不是通过实例来调用的，静态方法不依赖于实例变量。也正因为此，静态方法中不能调用非静态变量，或者说，静态方法中不能使用实例变量。如果在静态方法中使用实例变量，编译器会因为不知道到底使用哪个实例的变量而报错。
    在这里插入图片描述
    同样，静态方法中不能调用非静态方法，因为非静态方法依赖于实例变量。
    在这里插入图片描述
静态变量

静态变量由所有实例共享。
静态变量通过类名来访问。

public class Player {
    private String name;
    public static int playerCount = 0;
    public Player(String theName){
        name = theName;
        playerCount++;
    }
}

public class Test {
    public static void main(String[] args){
        System.out.println(Player.playerCount);

        Player one = new Player("Tom");
        System.out.println(Player.playerCount);

        Player two = new Player("John");
        System.out.println(Player.playerCount);
    }
}

在这里插入图片描述

final

用final标识的变量，不能被修改；
用final标识的方法，不能被覆盖；
用final标识的构造函数，该构造函数所在类不能被继承，也不能创建该类的实例。

static final变量

用static修饰的final变量是常数。
在这里插入图片描述

static final变量的初始化

static final变量有以下两种初始化方式。

  • 第一种：声明时赋值
public class Test {
    public final static double PI = 3.141592;
}
  • 第二种：在静态初始化程序中赋值
    静态初始化程序在加载类时执行，且在该类的其他所有代码之前执行。
public class Test {
    public static final double PI;
    static {
        PI = 3.141592;
    }
}
方法重载

函数名相同，参数不同。参数个数不同或参数类型不同。

richest_qi
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
面向对象编程
Fighting261的博客
05-11 322
继承 代码中创建的类, 主要是为了抽象现实中的一些事物(包含属性和方法). 有的时候客观事物之间就存在一些关联关系, 那么在表示成类和对象的时候也会存在一定的关联. 例如, 设计一个类表示动物 public class Animal { public String name; public Animal(String name) { this.name = name; } public void eat(String food) { System.out.println(this.name
Java继承、接口与多态
Thierryxc的博客
08-08 360
继承要点 子类是extends父类出来的。 子类会继承父类所有public类型的实例变量和方法，但不会继承父类任何的private类型的实例变量和方法。 继承下来的方法可以被覆盖掉，但实例变量不能被覆盖。即是某个方法在子类中被覆盖过，调用时会使用覆盖过的版本。如果覆盖后想调用父类的方法，就要用super.method()。 继承的意义 通过提取出类间共同的抽象性，可以排除重复的程序代码而将这个部
Java中的animal类
qq_62512326的博客
05-09 9424
一.先创建一个Animal类 代码如下： public class Animal { private String name; private int age; public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { ...
Java面向对象——多态
程序员的时光
12-26 394
Java中的多态性表现： 1，方法的重载和重写； 2，可以用父类的引用指向子类的具体实现，而且可以随时更换为其他子类的具体实现； 先建一个父类Animals; package m12d26; public class Animal { public void say(){ System.out.println("我是一个动物"); } } 再建两个子类： pack...
java面向对象之——继承
qq_53999369的博客
05-05 1093
面向对象的特征之一 ——继承 那什么是继承呢？     继承是从已有的类中派生出新的类。 继承怎么用？     在类名后加extends关键字+被继承的类名表示继承关系 继承有什么用吗？     通俗的来说，子类可以吸收父类类的属性和行为， 并能扩展新的能力。 继承的语法有什么基本要求吗？    1.JAVA不支持多继承，单继承使JAVA的继承关系很简单，一个类只能有一个 直接父类。 &n
java继承与多态
06-01
Java继承与多态专题讲解，详细生动，例子丰富，适合初学者
Java 继承与多态的深入理解
08-29
"Java 继承与多态的深入理解" 继承是Java语言中的一种机制，允许一个类继承另一个类的特征和行为，使得子类具有父类的各种属性和方法。继承的特点是：在继承关系中，父类更通用、子类更具体。父类和子类需要满足is-...
java继承与多态PPT教案学习.pptx
09-30
Java继承与多态知识点 Java继承与多态是面向对象编程语言的重要概念，本文将对Java继承与多态进行详细的介绍和解释。 一、继承的含义 继承实际上是存在于面向对象程序中的两个类之间的一种关系。当一个类获取另一...
Java继承与多态 Employee简单员工信息录入程序
12-29
类与类属性：Employee: firstName,lastName,socialSecurityNumber SalaridEmployee: weeklySalary(周薪） HourlyEmployee: wage(每小时的工钱),hours（月工作小时数） CommisionEmployee: grossSales(销售额),...
Java继承与多态实验报告.doc
10-01
Java继承与多态实验报告.doc
Java创建动物类animal，以及其子类
cangming1的博客
06-29 1万+
（1）创建动物类animal 具有属性体重 具有方法移动(move)和睡觉（sleep） 移动时输出“animal moving” 睡觉上输出“animal sleepping” publicclassAnimal { intweight; publicvoidmove(){ System.out.println("animal moving"); } publicvoidsleep(){ System.out.println("animal slepping");...
Java面向对象编程1
forever的博客
06-15 881
面向对象编程1
Java面向对象（下）
m0_52309949的博客
04-25 668
Java之面向对象前言一、多态二、使用步骤1.引入库2.读入数据总结 前言 关于Java面向对象最后的知识点：多态。其中可能会有一些知识点被我不归属多态，我会再写一篇博客关于剩下没有被我归属于三大特性的知识， 一、多态 示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。 二、使用步骤 1.引入库 代码如下（示例）： import numpy as np import pandas as pd import matplotlib.pyplot as plt im..
面向对象第七章课后作业
suixinCaesar的博客
05-07 692
（1）编写能产生ArrayIndexOutOfBoundsException异常的代码，并将其捕获，在控制台上输出异常信息。package com.homework.demo.test7; public class ArraysIndex { public static void main(String[] args) { int arr [] = new int [3]; //长度...
继承 关键字extends 实例package com.cjg.test； public class Animal { private String name； private int age；
py编程|爱分享
03-20 2193
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基础—继承题目：编写一个Animal类，具有属性：种类；具有功能：吃、睡。定义其子类Fish...
weixin_30617695的博客
09-22 1万+
编写一个Animal类，具有属性：种类；具有功能：吃、睡。定义其子类Fish package zhongqiuzuoye; public class Animal { //属性 private String type; public String getType() { return type; } ...
JAVA中的public class与class的区别详解
热门推荐
知行合一
03-28 2万+
1.类的访问权限 1.为了控制某个类的访问权限，修饰词必须出现在关键字class之前。例如：public class Animal {} 2.在编写类的时候可以使用两种方式定义类： （1）public class定义类 public class Animal{ ... } （2）class定义类 class Animal{ } 2.public class定义类 1. 如果一个类声明的时候使...
java编写动物乐园_编写动物乐园java，满意会加分的！！！
weixin_34729012的博客
02-13 884
展开全部publicclassAnimal{publicStringname;publicintlegs;publicStringsound;publicAnimal(Stringname,intlegs,Stringsound){e68a8462616964757a686964616f31333332623262this.name=name;this.legs=...
java动物类_Java创建动物类animal，以及其子类
weixin_39967405的博客
02-15 6039
(1)创建动物类animal具有属性体重具有方法移动(move)和睡觉(sleep)移动时输出“animal moving”睡觉上输出“animal sleepping”publicclassAnimal {intweight;publicvoidmove(){System.out.println("animal moving");}publicvoidsleep(){System....

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值