Java继承和多态

最新推荐文章于 2024-07-22 14:15:06 发布

Tragfarmer

最新推荐文章于 2024-07-22 14:15:06 发布

阅读量285

点赞数 1

分类专栏： java基础文章标签： java

java基础专栏收录该内容

33 篇文章 0 订阅

订阅专栏

这是Java中的一个非常重要的概念。如果你想学习Java，必须更好地理解它。

1- 介绍

2- 类，构造函数和实例
 3- Java继承
4- Java多态

1- 介绍

继承和多态 - 这是Java中的一个非常重要的概念。如果你想学习Java，必须更好地理解它。

2- 类，构造函数和实例

需要在开始学习Java之前明确有关类，继承，构造函数和实例理解。我们考虑一下 Person类，描述了全名，出生年份，生日，逝世日期等信息。

Person.java

package com.yiibai.tutorial.inheritance.basic;

public class Person {

    // Field name - name of person
    private String name;

    // Field bornYear
    private Integer bornYear;

    // Field diedYear.
    private Integer diedYear;

    // Constructor with 3 parameters. The aim is to assign value for the field of Person.
    // Specify the name, year of birth, died year.
    public Person(String name, Integer bornYear, Integer diedYear) {
        this.name = name;
        this.bornYear = bornYear;
        this.diedYear = diedYear;
    }

    // Constructor with 2 parameters.
    // The aim is to assign value for the field of Person.
    // Not assign for diedYear
    public Person(String name, Integer bornYear) {
        this.name = name;
        this.bornYear = bornYear;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getBornYear() {
        return bornYear;
    }

    public void setBornYear(Integer bornYear) {
        this.bornYear = bornYear;
    }

    public Integer getDiedYear() {
        return diedYear;
    }

    public void setDiedYear(Integer diedYear) {
        this.diedYear = diedYear;
    }
}

PersonDemo.java

package com.yiibai.tutorial.inheritance.basic;
 
public class PersonDemo {
 
    public static void main(String[] args) {
 
        // Instance: Thomas Edison.
        Person edison = new Person("Thomas Edison", 1847, 1931);
 
        System.out.println("Info:");
        System.out.println("Name: " + edison.getName());
        System.out.println("Born Year: " + edison.getBornYear());
        System.out.println("Died Year: " + edison.getDiedYear());
 
        // Instance: Bill Gates
        Person billGates = new Person("Bill Gate", 1955);
 
        System.out.println("Info:");
        System.out.println("Name: " + billGates.getName());
        System.out.println("Born Year: " + billGates.getBornYear());
        System.out.println("Died Year: " + billGates.getDiedYear());
 
    }
 
}

区分类，构造函数和实例

Person模拟某一种人的类，这是抽象的东西，但它的信息，在上面的例子中，信息是姓名，出生年份，死亡年份。

构造函数

构造函数总是与类的名称相同
一个类拥有一个或多个构造函数。
构造函数可带或不带参数，没有参数构造函数是默认调用构造函数。
构造函数是用来创建类的实例。

看下面的例子，创建一个构造函数对象(实例)

3- Java继承

我们需要几个类的作为练习例子。

Animal: 模拟动物类
Duck: 动物(Animal)的子类
Cat: 动物(Animal)的子类
Mouse: 动物(Animal)的子类

在这里，我们有 Animal 类，它没有方法体。

public abstract String getAnimalName();

这种方法是一个抽象方法，在子类中，你需要声明和实现这个方法。

Animal 类如果有一个以上抽象方法，它必须声明为抽象的类。抽象类有构造函数，但不能用它创建的实例。

在本质上意味着如果要创建动物的一个对象，需要从一个特定的动物物种创建，在我们的这个实例中，就必须从猫(Cat)，鼠标(Mouse)或鸭(Duck)的构造函数来创建。

Animal.java

package com.yiibai.tutorial.inheritance.animal;
 
// Class with at least one abstract method must be declared as abstract.
public abstract class Animal {
 
    // Name, for example, Tom Cat, Jerry Mouse.
    private String name;
 
    // Default constructor
    public Animal() {
        // Assign the default
        this.name = this.getAnimalName();
    }
 
    public Animal(String name) {
        this.name = name;
    }
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    // Returns the name of this animal.
    // An abstract method.
    // The specific contents of this method will be written in the subclass.
    public abstract String getAnimalName();
 
}

接下来看看从Animal继承的Cat类

Cat还具有构造函数，也有自己的字段。在构造函数中的第一行必须调用super(..)，这意味着调用父类的构造函数，给父类的字段赋值。

如果你不调用super() ，JAVA在编译时构造函数的第一行会自动插入super() 。

Cat.java

package com.yiibai.tutorial.inheritance.animal;
 
public class Cat extends Animal {
 
    private int age;
    private int height;
 
    public Cat(int age, int height) {
        // Call the default Constructor of the parent class (Animal)
        // Aims initialize the fields in the parent class.
        super();
 
        // Next, Assign value to its fields
        this.age = age;
        this.height = height;
    }
 
    public Cat(String name, int age, int height) {
     
        // Call the default Constructor of the parent class (Animal)
        // Aims initialize the fields in the parent class.        
        super(name);
 
        // Next, Assign value to its fields
        this.age = age;
        this.height = height;
    }
 
    public int getAge() {
        return age;
    }
 
    public void setAge(int age) {
        this.age = age;
    }
 
    public int getHeight() {
        return height;
    }
 
    public void setHeight(int height) {
        this.height = height;
    }
 
 
    // Implement content for abstract methods declared in the parent class.
    @Override
    public String getAnimalName() {
        return "Cat";
    }
 
}

当创建一个Cat对象，会发生什么？

来看看动物的子类Mouse类

Mouse.java

package com.yiibai.tutorial.inheritance.animal;
 
public class Mouse extends Animal {
 
    private int weight;
 
    // Default constructor
    public Mouse() {
        // Call to constructor Mouse(int)
        this(100);
    }
 
 
    // Constructor with one parameter.
    public Mouse(int weight) {
         
        // If you does not call super(..)
        // then java will call to default Constructor of the parent class.
        // super()
         
        this.weight = weight;
    }
 
 
    // Constructor with 2 parameters.
    public Mouse(String name, int weight) {
        super(name);
        this.weight = weight;
    }
 
    public int getWeight() {
        return weight;
    }
 
    public void setWeight(int weight) {
        this.weight = weight;
    }
 
    @Override
    public String getAnimalName() {
        return "Mouse";
    }
}

InstanceofDemo.java

package com.yiibai.tutorial.inheritance.demo;
 
import com.yiibai.tutorial.inheritance.animal.Animal;
import com.yiibai.tutorial.inheritance.animal.Cat;
import com.yiibai.tutorial.inheritance.animal.Mouse;
 
public class InstanceofDemo {
 
    public static void main(String[] args) {
 
         
        // Create an Animal object.
        // Animal is abstract class
        // It can not create the object from its constructors.
        Animal tom = new Cat("Tom", 3, 20);
 
        System.out.println("name: " + tom.getName());
        System.out.println("animalName: " + tom.getAnimalName());
 
 
        // Using instanceof operator to
        // check if an object is an instance of a specific class.
        boolean isMouse = tom instanceof Mouse;
        System.out.println("Tom is mouse? " + isMouse);
 
        boolean isCat = tom instanceof Cat;
        System.out.println("Tom is cat? " + isCat);
 
        boolean isAnimal = tom instanceof Animal;
        System.out.println("Tom is animal? " + isAnimal);
 
    }
 
}

运行示例的结果：

name: Tom
animalName: Cat
Tom is mouse? false
Tom is cat? true
Tom is animal? true

InheritMethodDemo.java

package com.yiibai.tutorial.inheritance.demo;
 
import com.yiibai.tutorial.inheritance.animal.Cat;
 
public class InheritMethodDemo {
 
    public static void main(String[] args) {
 
        // Create instance of Cat.
        Cat tom = newCat("Tom", 3, 20);
         
         
        // Call the method inherited from the parent class.
        System.out.println("name: "+ tom.getName());
        System.out.println("animalName: "+ tom.getAnimalName());
         
        System.out.println("-----------------");
 
        // Call the method declared in the class Cat.
        System.out.println("Age: "+ tom.getAge());
        System.out.println("Height: "+ tom.getHeight());
    }
 
}

运行示例的结果：

name: Tom
animalName: Cat
-----------------
Age: 3
Height: 20

Java类转换

CastDemo.java

package com.yiibai.tutorial.inheritance.demo;

import java.util.Random;

import com.yiibai.tutorial.inheritance.animal.Animal;
import com.yiibai.tutorial.inheritance.animal.Cat;
import com.yiibai.tutorial.inheritance.animal.Mouse;
 
public class CastDemo {
 
    // Method returns a random animal.
    public static Animal getRandomAnimal() {
        // Returns a random value 0 or 1
        int random = new Random().nextInt(2);
 
        Animal animal = null;
        if (random == 0) {
            animal = new Cat("Tom", 3, 20);
        } else {
            animal = new Mouse("Jerry", 5);
        }
        return animal;
    }
 
    public static void main(String[] args) {
 
        Animal animal = getRandomAnimal();
 
        if (animal instanceof Cat) {
            // Cast to Cat
            Cat cat = (Cat) animal;
 
            // And call method of the Cat class.
            System.out.println("Cat height: " + cat.getHeight());
        } else if (animal instanceof Mouse) {
            // Cast to Mouse
            Mouse mouse = (Mouse) animal;
 
            // And call method of the Mouse class.
            System.out.println("Mouse weight: " + mouse.getWeight());
        }
 
    }
 
}

4- Java多态

假设你有一只猫Asian Cat,，你可以作为一只猫或者作为一种动物调用是多态的体现。

或者另外一个例子：你简历的记录是一个亚洲男子，而你实际上是一个中国人。

下面的例子说明了如何声明和现实行为。

AsianCat 是 Cat 类的子类。

AsianCat.java

package com.yiibai.tutorial.inheritance.animal;
public class AsianCat extends Cat {
    public AsianCat(String name, int age, int height) {
        super(name, age, height);
    }
    // Override methods of the parent class (Cat)
    @Override
    public String getAnimalName() {
        return "Asian Cat";
    }
}

Java的多态性如下图所述：

PolymorphismDemo.java

package com.yiibai.tutorial.polymorphism;

import com.yiibai.tutorial.inheritance.animal.AsianCat;
import com.yiibai.tutorial.inheritance.animal.Cat;
 
public class PolymorphismDemo {
 
   public static void main(String[] args) {
 
       Cat cat1 = new Cat("Tom", 3, 20);
 
       Cat cat2 = new AsianCat("ATom", 2, 19);
 
       System.out.println("Animal Name of cat1: " + cat1.getAnimalName());
 
       System.out.println("Animal Name of cat2: " + cat2.getAnimalName());
 
   }
 
}

运行示例的结果如下：

Animal Name of cat1: Cat
Animal Name of cat2: Asian Cat

Tragfarmer

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Java继承和多态

这是Java中的一个非常重要的概念。如果你想学习Java，必须更好地理解它。1- 介绍2- 类，构造函数和实例3- Java继承4- Java多态1- 介绍继承和多态 - 这是Java中的一个非常重要的概念。如果你想学习Java，必须更好地理解它。2- 类，构造函数和实例需要在开始学习Java之前明确有关类，继承，构造函数和实例理解。我们考虑一下
复制链接

扫一扫