JAVA继承、接口、多态

最新推荐文章于 2024-08-05 15:15:41 发布

洺润

最新推荐文章于 2024-08-05 15:15:41 发布

阅读量2.2k

点赞数 6

分类专栏： JAVA

本文链接：https://blog.csdn.net/s_zero/article/details/88975717

版权

JAVA 专栏收录该内容

36 篇文章 2 订阅

订阅专栏

先来张图方便理解：
在这里插入图片描述

1. 继承

1.1 概念

继承就是子类继承父类的特征和行为，使得子类对象或者说实例具有父类的实例
域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。

1.2简单举例

动物包括哺乳动物，哺乳动物又包括猫和狗，所以猫和狗是有一些相同的特性的

//代码格式
class 父类 {
}
 
class 子类 extends 父类 {
}

1.3 继承的作用

编程时经常会有大量重复的代码，导致臃肿，降低开发效率，所以Java继承的作用就体现出来了：定义一个类做为父类，将一些共有的属性和方法定义在这个类中，当某一个类需要使用到这些方法和属性的时候，就可以直接通过extends关键字就可以直接调用父类中的成员变量和方法，更为方便快捷。

1.4 继承类型

JAVA不支持多继承，只支持单继承和多重继承，也就是说子类和父类只能一对一，继承关键字extends只能承载一个类，具体形式如下：
在这里插入图片描述

1.5 继承特性与相关使用规则

子类拥有父类非 private 的属性、方法。
父类方法使用final修饰代表此方法不会被子类所重写。
子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。子类也可以用自己的方式实现父类的方法。
提高了类之间的耦合性（继承的缺点，耦合度高就会造成代码之间的联系越紧密，代码独立性越差）。
子类的所有的构造函数，默认都会访问父类中空参数的构造函数，因为子类每一个构造函数内的第一行都有一句隐式super（），当父类中没有空参数的构造函数时，子类必须手动通过super语句形式来指定要访问父类中的构造函数。
当子类出现和父类一模一样的函数时；子类对象调用该函数，会运行子类函数的内容；如同父类的函数被覆盖一样，这种情况是函数的其中一个特性：覆盖（重写）
当子类继承父类，沿袭了父类的功能到子类中，但是子类虽具备该功能，但是功能的内容却和父类不一致时；没有必要定义新功能，而是使用覆盖特性，保留父类的功能定义，并重写功能内容。
千万不要为了获取其他类的功能，简化代码而继承；必须是类与类之间有所属关系才可以继承

1.6 Java 重写(Override)与重载(Overload)

重写

定义：子类对父类的允许访问的方法的实现过程进行重新编写,不能改变返回值和形参。即外壳不变，核心重写

代码实例：

class Animal{
   public void eat(){
      System.out.println("动物需要吃东西");
   }
}
 
class Dog extends Animal{
   public void eat(){
   //再次用使用super关键字：super.move();
   //super关键字可调用父类的方法来重写
      System.out.println("狗改不了吃屎");
   }
}
 
public class TestDog{
   public static void main(String args[]){
      Animal a = new Animal(); // Animal 对象
      Animal b = new Dog(); // Dog 对象
 
      a.move();// 执行 Animal 类的方法
 
      b.move();//执行 Dog 类的方法
   }
}
/*输出结果
动物需要吃东西
狗改不了吃屎
使用super关键字后，b.move将能生成上两行结果
*/

. 重写规则：

参数列表必须完全与被重写方法的相同；
返回类型必须完全与被重写方法的返回类型相同；
访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类的一个方法被声明为public，那么在子类中重写该方法就不能声明为protected。
父类的成员方法只能被它的子类重写。
声明为final的方法不能被重写。
声明为static的方法不能被重写，但是能够被再次声明。
子类和父类在同一个包中，那么子类可以重写父类所有方法，除了声明为private和final的方法。
子类和父类不在同一个包中，那么子类只能够重写父类的声明为public和protected的非final方法。
重写的方法能够抛出任何非强制异常，无论被重写的方法是否抛出异常。但是，重写的方法不能抛出新的强制性异常，或者比被重写方法声明的更广泛的强制性异常，反之则可以。
构造方法不能被重写。
如果不能继承一个方法，则不能重写这个方法。

重载

定义：重载(overloading) 是在一个类里面，方法名字相同，而参数不同。返回类型可以相同也可以不同，重载方法时必须每个方法的参数列表都不一样

重载规则:

被重载的方法必须改变参数列表(参数个数或类型不一样)；
被重载的方法可以改变返回类型；
被重载的方法可以改变访问修饰符；
被重载的方法可以声明新的或更广的检查异常；
方法能够在同一个类中或者在一个子类中被重载。
无法以返回值类型作为重载函数的区分标准。

重写与重载的区别
在这里插入图片描述

2. 接口

2.1 定义：

接口在JAVA编程语言中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法。

接口并不是类，编写接口的方式和类很相似，但是它们属于不同的概念。类描述对象的属性和方法。接口则包含类要实现的方法。

除非实现接口的类是抽象类，否则该类要定义接口中的所有方法。

接口无法被实例化，但是可以被实现。一个实现接口的类，必须实现接口内所描述的所有方法，否则就必须声明为抽象类。另外，在 Java 中，接口类型可用来声明一个变量，他们可以成为一个空指针，或是被绑定在一个以此接口实现的对象
定义接口的语法格式

[可见度] interface 接口名称 [extends 其他的接口名名] {
        // 声明变量
        // 抽象方法

实现接口的语法格式

...implements 接口名称[, 其他接口名称, 其他接口名称..., ...] ...

示例如下：

//定义接口
public interface Animal{
	public void behavior();
}
//实现接口
public class Dog implement Animal{
	public void behavior(){
		System.out.println("Dogs bark!");
	}
}

public class Cat implement Animal{
	public void behavior(){
		System.out.println("Mew!");
	}
}

2.2 接口特性

接口中每一个方法也是隐式抽象的,接口中的方法会被隐式的指定为 public abstract（只能是 public abstract，其他修饰符都会报错）。
接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量（并且只能是 public，用 private 修饰会报编译错误）。
接口中的方法是不能在接口中实现的，只能由实现接口的类来实现接口中的方法。(jdk1.8 及之后版本方法可以有默认实现)
接口可以继承接口

2.3接口与其它的比较

2.3.1 接口与类的比较

相似点：

一个接口可以有多个方法。
接口文件保存在 .java 结尾的文件中，文件名使用接口名。
接口的字节码文件保存在 .class 结尾的文件中。
接口相应的字节码文件必须在与包名称相匹配的目录结构中。

区别：

接口不能用于实例化对象。
接口没有构造方法。
接口中所有的方法必须是抽象方法。
接口不能包含成员变量，除了 static 和 final 变量。
接口不是被类继承了，而是要被类实现。
接口支持多继承。

2.3.2 接口与抽象类的比较

区别1：抽象类描述事物的本质，接口描述事物的功能，如水杯，保温杯，保温： class 保温杯 extends 水杯 ;class 保温杯
implements 保温
区别2：抽象类中可以实现方法，接口不能
区别3: 接口中的成员变量只能是 public static final 类型的,抽象类没有限制
区别4：接口中不能含有静态代码块以及静态方法(用 static 修饰的方法)，而抽象类是可以有静态代码块和静态方法。
区别5：一个类只能继承一个抽象类，而一个类却可以实现多个接口。

2.3.3 实现接口与继承的比较

区别1:不同的修饰符修饰(interface),(extends)
区别2:JAVA不支持子类和父类之间的多继承，只支持单继承，但是可以支持接口的多继承
区别3:在接口中只能定义全局常量,和抽象方法,而在继承中可以定义属性方法,变量,常量等…
区别4:某个接口被类实现时,在类中一定要实现接口中的抽象方法,而继承可以任意调用
总结：
接口是：对功能的描述继承是：什么是一种什么
例如：你可以有多个干爹（接口），但只能有一个亲爹（继承）

2.4 接口的继承

和类的单继承类似，接口也能继承接口，而且还可以多继承，既一个接口可以继承多个接口，实例如下：

public interface Animal{
	public void behavior();
}

public interface Dog extends Animal{
	public void  run();
	public void getName(String name);
}

public interface Hashiqi extends Dog{
	public void  breakHome();
	public void Stupid(String behavior);
}

}

多继承：

public interface Bomei extends Animal,Dog

此时接口Bomei的实现类应该继承的两个接口中的共3个方法

3. 多态

在这里插入图片描述

3.1 定义

多态是同一个行为具有多个不同表现形式或形态的能力。
多态性是对象多种表现形式的体现。

3.2 多态的优点

消除类型之间的耦合关系
可替换性
可扩充性
接口性
灵活性
简化性

3.3 多态存在的条件

继承
重写
父类引用指向子类对象

比如：

//父类引用指向子类对象
Parent p = new Child();

当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，再去调用子类的同名方法。

多态的好处：可以使程序有良好的扩展，并可以对所有类的对象进行通用处理。

以下是一个多态实例的演示，详细说明请看注释：

package com.zt;

public class Test {
    public static void main(String[] args) {
        show(new Cat());  // 以 Cat 对象调用 show 方法
        show(new Dog());  // 以 Dog 对象调用 show 方法

        Animal a = new Cat();  // 向上转型，父类引用指向子类对象
        a.eat();               // 调用的是 Cat 的 eat
        Cat c = (Cat)a;        // 向下转型
        c.work();        // 调用的是 Cat 的 work
    }

    public static void show(Animal a)  {
        a.eat();
        // 用instanceof做类型判断
        if (a instanceof Cat)  {  // 猫做的事情
            Cat c = (Cat)a;//类型转换
            c.work();
        } else if (a instanceof Dog) { // 狗做的事情
            Dog c = (Dog)a;
            c.work();
        }
    }
}

abstract class Animal {
    abstract void eat();
}

class Cat extends Animal {
    public void eat() {
        System.out.println("吃鱼");
    }
    public void work() {
        System.out.println("抓老鼠");
    }
}

class Dog extends Animal {
    public void eat() {
        System.out.println("啃骨头");
    }
    public void work() {
        System.out.println("拆家");
    }
}
/*输出结果：
吃鱼
抓老鼠
啃骨头
拆家
吃鱼
抓老鼠
*/