面向对象（接口多态）

最新推荐文章于 2023-09-03 11:10:39 发布

冯宝宝^

最新推荐文章于 2023-09-03 11:10:39 发布

阅读量241

点赞数 1

分类专栏： javaSE基础文章标签： java 开发语言后端

本文链接：https://blog.csdn.net/qq_45511798/article/details/122484483

版权

javaSE基础专栏收录该内容

12 篇文章 7 订阅

订阅专栏

1.接口

1.1接口的概述（理解）

接口就是一种公共的规范标准，只要符合规范标准，大家都可以通用。
Java中接口存在的两个意义
1. 用来定义规范
2. 用来做功能的拓展

1.2接口与类相似点：

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

1.3接口与类的区别：

接口不能用于实例化对象。
接口没有构造方法。
接口中所有的方法必须是抽象方法，Java 8 之后接口中可以使用 default 关键字修饰的非抽象方法。
接口不能包含成员变量，除了 static 和 final 变量。
接口不是被类继承了，而是要被类实现。
接口支持多继承。

1.4接口特性

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

1.5抽象类和接口的区别

1. 抽象类中的方法可以有方法体，就是能实现方法的具体功能，但是接口中的方法不行。
1. 抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是 public static final 类型的。
1. 接口中不能含有静态代码块以及静态方法(用 static 修饰的方法)，而抽象类是可以有静态代码块和静态方法。
1. 一个类只能继承一个抽象类，而一个类却可以实现多个接口。

1.6接口的特点（记忆）

接口用关键字interface修饰
```
public interface 接口名 {} 
```

类实现接口用implements表示

public class 类名 implements 接口名 {}

接口不能实例化

我们可以创建接口的实现类对象使用
接口的子类

要么重写接口中的所有抽象方法

要么子类也是抽象类

1.7接口的成员特点（记忆）

成员特点
- 成员变量
  
  只能是常量默认修饰符：public static final
- 构造方法
  
  没有，因为接口主要是扩展功能的，而没有具体存在
- 成员方法
  
  只能是抽象方法
  
  默认修饰符：public abstract
  
  关于接口中的方法，JDK8和JDK9中有一些新特性，后面再讲解

代码演示

接口

public interface Inter {
    public static final int NUM = 10;

    public abstract void show();
}

实现类

class InterImpl implements Inter{

    public void method(){
        // NUM = 20;
        System.out.println(NUM);
    }

    public void show(){

    }
}

测试类

public class TestInterface {
    /*
        成员变量: 只能是常量 系统会默认加入三个关键字
                    public static final
        构造方法: 没有
        成员方法: 只能是抽象方法, 系统会默认加入两个关键字
                    public abstract
     */
    public static void main(String[] args) {
        System.out.println(Inter.NUM);
    }
  
}

列2：

public interface AA {
    public void test();
}

public interface USB {
    public void show();
}

public interface Animal extends USB,AA{
    public void eat();
    public void travel();
}

public class MammalInt implements Animal{
    @Override
    public void eat() {
        System.out.println("Mammal eats");
    }

    @Override
    public void travel() {
        System.out.println("Mammal travels");
    }

    @Override
    public void show() {
        System.out.println("继承了");
    }

    @Override
    public void test() {
        System.out.println("可以多继承");
    }
}

public class Demo {
    public static void main(String[] args) {
            MammalInt m = new MammalInt();
            m.eat();
            m.travel();
            m.show();
            m.test();
    }
}

在实现接口的时候，也要注意一些规则：

一个类可以同时实现多个接口。
一个类只能继承一个类，但是能实现多个接口。
一个接口能继承另一个接口，这和类之间的继承比较相似。

1.8类和接口的关系（记忆）

类与类的关系

继承关系，只能单继承，但是可以多层继承
类与接口的关系

实现关系，可以单实现，也可以多实现，还可以在继承一个类的同时实现多个接口
接口与接口的关系

继承关系，可以单继承，也可以多继承

1.9接口组成【理解】

常量

public static final
抽象方法

public abstract

1.10接口中默认方法【应用】

格式

public default 返回值类型方法名(参数列表) { }
作用

解决接口升级的问题
范例
```
public default void show3() { 
}
```
注意事项
- 默认方法不是抽象方法，所以不强制被重写。但是可以被重写，重写的时候去掉default关键字
- public可以省略，default不能省略
- 如果实现了多个接口，多个接口中存在相同的方法声明，子类就必须对该方法进行重写

1.11接口中静态方法【应用】

格式

public static 返回值类型方法名(参数列表) { }
范例
```
public static void show() {
}
```
注意事项
- 静态方法只能通过接口名调用，不能通过实现类名或者对象名调用
- public可以省略，static不能省略

1.12接口中私有方法【应用】

私有方法产生原因

Java 9中新增了带方法体的私有方法，这其实在Java 8中就埋下了伏笔：Java 8允许在接口中定义带方法体的默认方法和静态方法。这样可能就会引发一个问题：当两个默认方法或者静态方法中包含一段相同的代码实现时，程序必然考虑将这段实现代码抽取成一个共性方法，而这个共性方法是不需要让别人使用的，因此用私有给隐藏起来，这就是Java 9增加私有方法的必然性

定义格式

格式1

private 返回值类型 方法名(参数列表) { }

范例1
```
private void show() {  
}
```

格式2

private static 返回值类型 方法名(参数列表) { }

范例2
```
private static void method() {  
}
```

注意事项
- 默认方法可以调用私有的静态方法和非静态方法
- 静态方法只能调用私有的静态方法

2.多态

2.1多态的概述（记忆）

什么是多态

同一个对象，在不同时刻表现出来的不同形态
多态的前提
- 要有继承或实现关系
- 要有方法的重写
- 要有父类引用指向子类对象

代码演示

class Animal {
    public void eat(){
        System.out.println("动物吃饭");
    }
}

class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

public class Test1Polymorphic {
    /*
        多态的前提:

            1. 要有(继承 \ 实现)关系
            2. 要有方法重写
            3. 要有父类引用, 指向子类对象
     */
    public static void main(String[] args) {
        // 当前事物, 是一只猫
        Cat c = new Cat();
        // 当前事物, 是一只动物
        Animal a = new Cat();
        a.eat();

    }
}

2.2多态中的成员访问特点（记忆）

成员访问特点
- 成员变量
  
  编译看父类，运行看父类
- 成员方法
  
  编译看父类，运行看子类

代码演示

class Fu {
    int num = 10;

    public void method(){
        System.out.println("Fu.. method");
    }
}

class Zi extends Fu {
    int num = 20;

    public void method(){
        System.out.println("Zi.. method");
    }
}


public class Test2Polymorpic {
    /*
         多态的成员访问特点:

                成员变量: 编译看左边 (父类), 运行看左边 (父类)

                成员方法: 编译看左边 (父类), 运行看右边 (子类)
     */
    public static void main(String[] args) {
        Fu f = new Zi();
        System.out.println(f.num);
        f.method();
    }
}

2.3多态的好处和弊端（记忆）

好处

提高程序的扩展性。定义方法时候，使用父类型作为参数，在使用的时候，使用具体的子类型参与操作
弊端

不能使用子类的特有成员

2.4多态中的转型（应用）

向上转型

父类引用指向子类对象就是向上转型
向下转型

格式：子类型对象名 = (子类型)父类引用;

代码演示

class Fu {
    public void show(){
        System.out.println("Fu..show...");
    }
}


class Zi extends Fu {
    @Override
    public void show() {
        System.out.println("Zi..show...");
    }

    public void method(){
        System.out.println("我是子类特有的方法, method");
    }
}

public class Test3Polymorpic {
    public static void main(String[] args) {
        // 1. 向上转型 : 父类引用指向子类对象
        Fu f = new Zi();
        f.show();
        // 多态的弊端: 不能调用子类特有的成员
        // f.method();

        // A: 直接创建子类对象
        // B: 向下转型

        // 2. 向下转型 : 从父类类型, 转换回子类类型
        Zi z = (Zi) f;
        z.method();
    }
}

3.5多态中转型存在的风险和解决方案 (应用)

风险

如果被转的引用类型变量,对应的实际类型和目标类型不是同一种类型,那么在转换的时候就会出现ClassCastException
解决方案
- 关键字
  
  instanceof
- 使用格式
  
  变量名 instanceof 类型
  
  instanceof 是 Java 的一个二元操作符，类似于 ==，>，< 等操作符。
  
  instanceof 是 Java 的保留关键字。它的作用是测试它左边的对象是否是它右边的类的实例，返回 boolean 的数据类型。
  
  通俗的理解：判断关键字左边的变量，是否是右边的类型，返回boolean类型结果

代码演示

abstract class Animal {
    public abstract void eat();
}

class Dog extends Animal {
    public void eat() {
        System.out.println("狗吃肉");
    }

    public void watchHome(){
        System.out.println("看家");
    }
}

class Cat extends Animal {
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

public class Test4Polymorpic {
    public static void main(String[] args) {
        useAnimal(new Dog());
        useAnimal(new Cat());
    }

    public static void useAnimal(Animal a){  // Animal a = new Dog();
                                             // Animal a = new Cat();
        a.eat();
        //a.watchHome();

//        Dog dog = (Dog) a;
//        dog.watchHome();  // ClassCastException  类型转换异常
      
        // 判断a变量记录的类型, 是否是Dog
        if(a instanceof Dog){
            Dog dog = (Dog) a;
            dog.watchHome();
        }
    }

}

总结：

1:多态是什么，前提是什么?
    1，要有继承或实现关系
    2，要有方法的重写
    3，要有父类引用指向子类对象

2:多态中成员访问的特点?
    成员变量
        编译看左边，运行看左边
    成员方法
        编译看左边，运行看右边
    静态方法
        编译看左边，运行看左边
        所以前面静态方法不能算方法的重写

3:多态的好处及弊端？
	多态的好处：提高了程序的扩张性
	具体体现：定义方法的时候，使用父类型作为参数，将来在使用的时候，使用具体的子类型参与操作
	多态的弊端：不能使用子类的特有功能

4:什么是向上转型？
   答：父类引用指向子类对象
   Person p = new Student(); 这就是向上转型

  什么是向下转型？
   向下转型就是类型强制转换
   Student s = (Student)p; 这就是向下转型

5:多态练习(上课敲的代码)
    5.1：榨汁机练习
    5.2：定义动物类Animal,定义猫类，狗类，猪类，兔子类，并重写eat方法，根据每个动物的特点，实现具体想吃的食物
         在main方法中定义方法，接收动物类对象，打印动物吃的食物
    
6:抽象类概述及其特点?
    对于能够准确描述的行为，我们写方法体，但是对于我们无法清晰描述的具体行为的方法，我们可以不写方法体
    对于无法具体描述的行为，我们称为抽象行为，也叫抽象方法，必须使用abstract关键字来修饰
    如果一个类中有抽象方法，那么该类必须是抽象类，所以我们需要使用abstract来修饰
    如果后期有具体子类来进行继承，那么子类必须重写父类中的所有抽象方法，才能使用！
    
    抽象类特点
        抽象类和抽象方法必须用abstract关键字修饰
        抽象类不一低昂有抽象方法，有抽象方法的类不一定是抽象类
        
        抽象类不能实例化
            那么，抽象类如何实例化呢？
            按照多态的方式，由具体的子类实例化，其实这也是多态的一种，抽象类多态
            
        抽象类子类
            要么是抽象类
            要么是具体类，必须重写抽象类中的所有抽象方法

冯宝宝^

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
面向对象（接口多态）

1.接口1.1接口的概述（理解）接口就是一种公共的规范标准，只要符合规范标准，大家都可以通用。 Java中接口存在的两个意义用来定义规范用来做功能的拓展 1.2接口与类相似点：一个接口可以有多个方法。接口文件保存在 .java 结尾的文件中，文件名使用接口名。接口的字节码文件保存在 .class 结尾的文件中。接口相应的字节码文件必须在与包名称相匹配的目录结构中。 1.3接口与类的区别：接口
复制链接

扫一扫