继承，接口，多态与异常

最新推荐文章于 2024-10-09 11:13:12 发布
最新推荐文章于 2024-10-09 11:13:12 发布
阅读量83 收藏
点赞数 1
文章标签： java jvm servlet
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/guichen0203/article/details/129892528
版权

继承

​ 继承是Java的第二大特性，是从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能扩展新的能力。使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。

​ 在实际应用中，继承为程序开发节省了大量的重复性工作，提高开发效率。例如你想创建一个新的类，这个类中的所有成员变量和成员方法在一个已经存在的类中都有，这时这个新的类可以直接继承自父类，然后再添加子类中特有的变量和方法。值得注意的是，一个子类只能继承自一个父类，毕竟一个儿子不能有多个爹。下面就用一个实列来了解继承。

package demo.package1;

/*
创建一个父类Animal
 */
public class Animal {
    /*
    对变量进行私有化封装
     */
    private String name;
    private int age;
    /*
    提供set、get方法
    */
    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
    /*
    创建三个方法
     */
    public void run(){
        System.out.println(name + "is running");
    }

    public void eat(){
        System.out.println(name + "is eating");
    }

    public void query(){
        System.out.println(name + "'s age is" + age);
    }
}


package demo.package1;
/*
创建一个Dog类继承自Animakl
 */
public class Dog extends Animal{

}


package demo;

import demo.package1.Dog;
/*
创建一个测试类
 */
public class Test {
    public static void main(String[] args) {
        /*
        创建一个狗对象，并初始化
         */
        Dog d = new Dog();
        d.setName("Jack");
        d.setAge(3);
        /*
        直接调用父类的方法
         */
        d.eat();
        d.run();
        d.query();
    }
}

​ 可见即便在子类中没有定义变量和方法，子类对象仍可以调用父类的变量和方法。当然有时候父类的方法不适合子类直接使用，这时就可以对方法进行重写。

package demo.package1;
/*
创建一个Dog类继承自Animakl
 */
public class Dog extends Animal{
    /*
    重写run()方法
     */
    @Override
    public void run() {
        System.out.println("狗跑的很快");
    }
}

这时再次运行，对run（）方法的调用就会调用子类中重写的方法

接口

​ 抽象类是从多个类中抽象出来的模板，如果将这种抽象进行的更彻底，则可以提炼出一种更加特殊的“抽象类”——接口（Interface）。接口是Java中最重要的概念之一，它可以被理解为一种特殊的类，不同的是接口的成员没有执行体，是由全局常量和公共的抽象方法所组成。

​ interface与class类似。主要用来定义类中所需包含的函数，接口也可以继承其他接口，一个类可以实现多个接口。使用接口可以规范不同类实现相同的行为。

package demo.package1;

/*
创建一个接口Animal
 */
public interface Animal {
    public void run();
    public void eat();
    public void query();
}

使用接口实现Dog类

package demo.package1;
/*
创建一个Dog类接自Animal
 */
public class Dog implements Animal{
    private String name;
    private int age;

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public void run() {
        System.out.println(name + " is running");
    }

    @Override
    public void eat() {
        System.out.println(name + " is eating");
    }

    @Override
    public void query() {
        System.out.println(name + "'age is " + age);
    }
}

再次运行测试类

​ 接口是支持多继承的，也就是说一个接口可以继承自多个接口。同时每个类也可以实现多个接口。

下面用代码分别演示这两种情况。

多继承

package demo.package1;

public interface SmallAnimal {
    public void small(); 
}


package demo.package1;

/*
创建一个接口Animal
 */
public interface Animal extends Life,SmallAnimal {
    public void run();
    public void eat();
    public void query();
}


package demo.package1;
/*
创建一个Dog类接自Animal
 */
public class Dog implements Animal,Life{
    private String name;
    private int age;

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public void run() {
        System.out.println(name + " is running");
    }

    @Override
    public void eat() {
        System.out.println(name + " is eating");
    }

    @Override
    public void query() {
        System.out.println(name + "'age is " + age);
    }

    @Override
    public void live() {
        System.out.println(name + "居住在这里");
    }

    @Override
    public void small() {
        System.out.println(name + "很小");
    }
}

实现多个接口

package demo.package1;

public interface Life {
    public void live();
}

package demo.package1;
/*
创建一个Dog类接自Animal
 */
public class Dog implements Animal,Life{
    private String name;
    private int age;

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public void run() {
        System.out.println(name + " is running");
    }

    @Override
    public void eat() {
        System.out.println(name + " is eating");
    }

    @Override
    public void query() {
        System.out.println(name + "'age is " + age);
    }

    @Override
    public void live() {
        System.out.println(name + "居住在这里");
    }
}

多态

​ 多态就是事物的多种形态，一个对象在不同条件下所表现的不同形式。

​ 多态存在的三个必要条件

  1. 继承或实现：在多态中必须存在有继承或实现关系的子类和父类

  2. 方法的重写：子类对父类中的某些方法进行重新定义（重写，使用@Override注解进行重写）

  3. 基类引用指向派生类对象，即父类引用指向子类对象，父类类型：指子类对象继承的父类类型，或、实现的父接口类型

    ​ 多态在形式上表现为使用父类的类名创建一个子类对象。由于多态是指成员方法的多态，所以使用多态时成员变量的编译和运行都是看以左边类型，而对成员方法的编译时，则是编译看左边，运行看右边。

    ​ 现在继续使用父类Animal和子类Dog演示多态的具体操作。

    package demo.package1;
/*
创建一个Dog类接自Animal
 */
public class Dog extends Animal{
   public int age = 25;
    @Override
    public int getAge() {
        return age;
    }

    @Override
    public void setAge(int age) {
        this.age = age;
    }

}


    package demo.package1;

/*
创建一个接口Animal
 */
public class Animal {
    public int age = 50;


    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

}


    package demo;

import demo.package1.Animal;
import demo.package1.Dog;
/*
创建一个测试类
 */
public class Test {
    public static void main(String[] args) {
        /*
        创建一个狗对象，并初始化
         */
        Animal a = new Dog();
        System.out.println(a.getAge());
        System.out.println(a.age);
    }
}

    ​ 可见在分别使用成员变量输出对象的age和使用成员方法输出对象的age时，成员方法使用子类方法，成员变量使用父类变量。即符合多态时成员变量的编译和运行都是看以左边类型，而对成员方法的编译时，则是编译看左边，运行看右边的原则。

    ​ 当然，多态也存在他的弊端。由于其特殊的编译运行规则，使用多态时无法使用子类的特有成员方法。例如我在狗类在添加一个query方法，在调用该方法时会爆红。

    package demo.package1;
/*
创建一个Dog类接自Animal
 */
public class Dog extends Animal{
   public int age = 25;
    @Override
    public int getAge() {
        return age;
    }

    @Override
    public void setAge(int age) {
        this.age = age;
    }
    public void query(){
        System.out.println("狗的年龄是" + age);
    }

}


    package demo;

import demo.package1.Animal;
import demo.package1.Dog;
/*
创建一个测试类
 */
public class Test {
    public static void main(String[] args) {
        /*
        创建一个狗对象，并初始化
         */
        Animal a = new Dog();
        a.query();
    }
}

    image-20230401085610913

异常

​ 异常处理可以允许我们在程序运行时进行诊断和补救。异常（Exception）不等于错误（Error）

​ Error是程序无法处理的错误，比如OutOfMemoryError、ThreadDeath等。这些异常发生时，Java虚拟机(JVM)一般会选择线程终止。此类异常是程序的致命异常，是无法捕获处理的。

​ Exception是程序本身可以处理的异常，这种异常分两大类运行时异常和非运行时异常。 程序中应当尽可能去处理这些异常。

​ 下图是Error类和Exception类的继承关系。

​ 其中异常分为两个子类：运行时异常（RuntimeException）和非运行时异常（除RuntimeException外的所有异常，如IOException、SQLException等以及用户自定义的Exception异常）

​ RuntimeException都是非检查型异常，程序中可以选择捕获处理，也可以不处理。这些异常一般是由程序逻辑错误引起的，例如数组越界、算数异常等，程序应该从逻辑角度尽可能避免这类异常的发生。下表是RuntimeException及其描述。

​ 非运行时异常类型上都属于Exception类及其子类。从程序语法角度讲是必须进行处理的异常，如果不处理，程序就不能编译通过。下表是 非运行时异常及其描述。

​ 当然，在了解了异常之后，我们要捕获异常并进行一定的处理。

​ 捕获异常常用的方法是try-catch语句。try后是需要检查的语句，catch后是对异常的处理，一般还会在最后加上finally语句，表示最终的处理，无论如何finally语句一定会被执行。

​ 举个例子，现在有一个数组array = {0，1，2，3，4}，输入两个数字k和x，将下标为k的数字除以x，最后输出新的数组，代码如下：

package demo;

import java.util.Scanner;

public class Test {

    public static void main(String[] args) {
        int[] array = new int[5];
        for (int i = 0; i < 5; i ++ ) {
            array[i] = i;
        }

        Scanner sc = new Scanner(System.in);
        int k = sc.nextInt();
        int x = sc.nextInt();

        try {
            array[k] /= x;
        } catch (ArithmeticException e) {
            System.out.println("除零错误！");
            e.printStackTrace();
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("数组越界！");
            e.printStackTrace();
        } finally {
            for (int i = 0; i < 5; i ++ ) {
                System.out.print(array[i] + " ");
            }
        }
    }
}

​ 显而易见，当k > 4 时，数组会越界，而当x = 0 时，会出现算数异常，现在运行一些分别模拟上列情况。

​ 在运行中可见对异常捕获的具体方式，同时也印证了无论是否存在异常，finally语句都会执行。

​ 在捕获完异常后，我们会对异常进行处理。对于非检查型异常的处理方式是修改完善代码逻辑，消除异常，而对于检查性异常，我们会选择抛出异常。

​ 抛出异常的方式有两种：第一种是使用try-catch语句配合throw在函数内抛出，第二种是直接在函数名后添加异常签名抛出。在IDEA中，可以使用Alt + Enter快速选择想要使用的抛出异常的方式。

guichen0203
关注
java继承与多态实验小结_java继承和多态、接口小结
weixin_42552124的博客
02-28 1723
详细代码自己找自己敲，以下会不定时更新。一个文件中只能有一个公共类java的继承只能是单继承。一个类之所以能够调用父类成员，是由于java编译器会自动为子类添加一个引用名为super的父类成员对象。创建子类对象的过程就是从底层的基类往上，一层层地来调用构造方法。如果调用父类的有参构造方法，需要用到super关键字。多态：多态具体表现在重写和重载多态就是类的多种表现方式比如同名不同参子类重写父类(父...
java-接口继承和多态
m0_52196529的博客
10-12 1508
java-接口继承
继承，接口，多态
m0_56597578的博客
03-16 411
继承多态接口的用法意思。
Java基础——多态（继承多态、接口多态）
榴莲男孩的博客
07-25 2844
多态 多态的概念 定义 多态 polymorphism ：对象根据所接收的消息而做出动作，同样的消息为不同的对象接收时可导致完全不同的行动，该现象 称为多态性 静态绑定 编译时多态 指在编译程序时就根据调用方法提供的信息，把它所对应的具体方法确定下来。即 在编译时就把调用方法名与具体方法绑定在一起方法重载 动态绑定 运行时多态 指在编译程序时还不能确定方法调用所对应的具体方法，只有在程序运行过程中才能确定具体的方法。 即 在程序运行时才把调用方法名与具体方法绑定在一起继承多态、接口多态 为何需要多态？
java 多态 接口_Java继承、多态和接口
weixin_35171603的博客
02-20 272
继承含义：可以通过扩展一个已有的类，并继承该类的属性和行为，来创建一个新的类优点：1)代码的重用性2)子类扩展父类的属性和方法3)父类的属性和方法可用于子类4)设计应用程序变得更加简单继承的实现：关键字extends：用于继承其他类(extends出现在类声明类名后，extends后接要继承的类名)访问修饰符 class 子类名 extends 父类名(){};1 public clas...
【Java】继承、多态、接口
woodwhale的博客
01-31 4547
Java中的继承和接口 1、用类比引入继承概念 众所周知，Java是一门面向对象的语言。如果我们要设计多种多样的交通工具，比如汽车、火车、飞机，虽然这些工具功能不同、形态不同，但是他们很多的基本功能相同，比如——载人，行驶，是否能飞…，于是我们把class Vehicle（交通工具类）当作设计交通工具的标准，再通过这个标准创建不同的交通工具，包括汽车、火车、飞机等等（class Car，class Train，class Air…），这些工具的共有属性都是继承设计标准(class Vehicle)中的属性。
封装、继承、多态、接口
qq_45895931的博客
07-05 710
封装，就是隐藏对象的属性和实现细节，仅对外公开接口，控制在程序中属性的读和修改的访问级别。 目的:增强安全性和简化编程，使用者可以不用了解具体的实现细节，只需奥通过外部接口，以特定的访问权限来使用类的成员。广义来说：一切公共代码的抽取都可以叫封装。 一般体现在公共方法的封装。工具类 狭义来说：隐藏对象的属性和实现细节作用： 保护属性的有效性。继承是面向对象中的一个概念，可以使子类具有父类的非私有的属性和方法或者可以重新定义、追加属性和方法等。继承就是子类继承父类的特征和行为，使得子类对象实例具有父类的属性和
Java第七章总结：继承、多态类与接口
nmy15570188135的博客
04-04 964
在开始学习使用class关键字定义类时，就应用到了继承原理，因为在Java中所有的类都直接或间接继承了java.lang.Object类是比较特殊的类，它是所有类的父类，是Java类层中的最高层类。getClass()方法是Object类定义的方法，它会返回对象执行时的Class实例，然后使用此实例调用getName()方法可以取得类的名称。定义为final的类不能被继承。将方法定义为final类型，可以防止子类修改父类的定义与现实方式，同时定义为final的方法的执行效果要高于非final方法。
Java学习 day10 （继承与多态）接口、多态
gaosong0623的博客
05-18 622
前言： 之前我们说过，java语言的三大特性，封装、继承和多态，昨天我们学了继承，今天我们来学一学java中我认为最变态的特性之一，多态。 今日重点： 接口 三大特征——多态 引用类型转换 接口 ...
java 继承与多态的区别_浅析java继承与多态，抽象类与接口的区别
weixin_33587731的博客
02-16 426
Java 是个纯粹的面向对象语言，没有过程式的写法，所有操作都是基于对象。面向对象的设计可以更好的解决系统维护、扩展、和代码重用的需求，代码过多后过程式的逻辑组织会变得异常复杂，所以就发展出了面向对象式编程。而面向对象的基本特性就是封装、继承、与多态。一、继承extends 关键字表示继承某个已存在的类，已存在的类称为“超类”、“基类”、或“父类”，而新继承的类称为“子类”、“派生类”。子类可以方...
Java 面向对象（继承、多态、接口、异常）.ppt
08-21
掌握类的继承、方法重写、super关键字的使用、final关键字、抽象类和接口、多态的使用以及异常的处理方式 熟悉面向对象继承和多态的概念
Java面向对象三大特性，即封装、继承、多态
12-23
@Java 面向对象三大特性知识模板 大家好，我是Ziph！ 今天分享下面向对象三大特性的知识内容。 结合思维导图学习效果更佳！...Java面向对象三大特性思维导图 一、封装 封装的必要性：在对象的外部为对象的属性赋值，...
类和对象、对象和封装、继承、多态、异常等教学...
10-15
"第六章 接口.pdf"会介绍接口的定义、实现以及接口与多态的关系。 6. **异常处理**： - **异常**：异常是在程序运行过程中出现的非正常情况，Java提供了一套异常处理机制。"第七章 异常.pdf"将讲述如何使用try-...
C语言 | 第十章 | 函数 作用域
ZJC744575的博客
10-05 1233
为完成某一功能的程序指令(语句)的集合,称为函数。在C语言中,函数分为:自定义函数、系统函数(查看C语言函数手册)函数还有其它叫法，比如方法等，在本视频课程中，我们统一称为 函数。返回类型 函数名（形参列表）{执行语句...;// 函数体return 返回值;// 可选形参列表：表示函数的输入函数中的语句：表示为了实现某一功能代码块函数可以有返回值,也可以没有, 如果没有返回值，返回类型 声明为 void。
C++学习笔记----8、掌握类与对象（四）---- 不同类型的数据成员（1）
weixin_71738303的博客
10-05 936
c++对于数据成员给了你许多选项。除了在类中声明简单的数据成员，可以生成静态数据成员供所有类的对象共享，const成员，引用成员，reference-to-const成员，等等。本节我们解释一下这些不同类型的数据成员的细节。
JDK1.0主要特性
FoolRabbit的专栏
10-06 364
JDK1.0主要特性。
字符函数和字符串函数和内存函数
Java_fenxiang的博客
10-05 706
strtok函数原型与功能概述在 C 语言中，strtok函数的原型为char *strtok(char *str, const char *delim)。它的主要功能是将字符串str按照delim中指定的分隔符进行分割，返回被分割出来的子字符串。工作原理首次调用：当第一次调用strtok时，需要将待分割的字符串str作为...
Java中的break、continue和return语句
weixin_73230994的博客
10-05 379
break语句用于终止某个语句块的执行，一般使用在switch或者循环【for, while ,do-while】（提前退出或结束循环不是终止程序）1.continue语句用于结束本次循环，继续执行下一次循环2.continue语句出现在多层嵌套的循环语句体中时，可以通过标签指明要跳过的是哪一层循环，这个和前面的标签的使用规则一样。
Netty 相比原生IO模型的优势
最新发布
lssffy的博客
10-09 366
Java提供了多种I/O模型，每种模型都有其适用的场景和特点，随着网络应用需求的变化，I/O模型也在不断发展。阻塞I/O（BIO，Blocking I/O）传统的I/O模型，使用简单，但每次I/O操作都会阻塞线程。每个请求需要独立的线程来处理，这在并发请求较少时问题不大，但在高并发情况下，线程资源将成为瓶颈。非阻塞I/O（NIO，Non-Blocking I/O）引入了多路复用技术，一个线程可以处理多个连接，避免了BIO中每个连接占用一个线程的问题。通过Selector。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值