面向对象(接口多态)

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
    评论

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值