面向对象

tan
95 阅读3分钟

面向对象

多态

多态定义

多态是在继承、实现情况下的一种现象，分为对象多态、行为多态

多态的优点 :更利于拓展和维护

多态的缺点：不能访问子类特有功能

image-20241031233028973.png

instance 关键字

public class Animal {
    public void eat() {
        System.out.println("吃东西...");
    }
}

// 子类
class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("狗吃骨头...");
    }

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

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

    public void catchMouse() {
        System.out.println("猫抓老鼠...");
    }
}

// 子类
class Pig extends Animal {
    @Override
    public void eat() {
        System.out.println("猪拱白菜...");
    }

    public void sleep() {
        System.out.println("🐷特别能睡...");
    }
}


    public static void main(String[] args) {
        useAnimal(new Dog());
        System.out.println("=========================");
        useAnimal(new Cat());
        System.out.println("=========================");
        useAnimal(new Pig());
    }
    public static void useAnimal(Animal a){
        a.eat();
        if(a instanceof Dog){
            ((Dog) a).lookHome();
        }else if(a instanceof Cat){
            ((Cat) a).catchMouse();
        }else{
            ((Pig) a).sleep();
        }
    }
 /*   public static void useAnimal(Dog a){
        a.eat();
        a.lookHome();
    }
    public static void useAnimal(Cat a){
        a.eat();
        a.catchMouse();
    }
    public static void useAnimal(Pig a){
        a.eat();
        a.sleep();
    }*/

final 关键字

  • final修饰类，类不能被继承
  • final修饰方法，方法不能重写
  • final修饰变量，变量只能被赋值一次
  • final修饰基本类型的变量，基本类型的值不能修改
  • final修饰引用类型的变量，应用类型的地址不能改变，但是里面的之可以改变

抽象

  • 被abstract修饰的类是抽象类，被abstract修饰的方法是抽象方法（不允许写方法体）
  • 抽象方法必须放在抽象类中
  • 抽象类不能创建对象,但是可以作为父类让子类继承，而且子类必须重写父类所有的抽象方法

抽象类的注意事项

  • 抽象类不一定有抽象方法，抽象方法一定在抽象类中

  • 类该有的成员（构造器（两个作用 - 创建对象 - 数据吃初始化）、成员变量、方法）抽象类都可以有

模板方法模式

public  abstract class Template {
    public final void write(){
        System.out.println("《我的爸爸》");
        body();
        System.out.println("啊,我亲爱的爸爸");
    }
    public abstract void body();
}


public class LeiJun extends   Template {
    @Override
    public void body(){
        System.out.println("军儿快手收吧，外面都是XXX");
    }

}

image-20241031235636316

image-20241031235636316.png

接口(抽象中的抽象)

  • 接口不能创建对象

  • 类与接口的关系是实现关系 , 用implements连接 , 实现接口的类称为实现类。

  • 弥补了类单继承的不足，一个类同时可以实现多个接
  • 让程序可以面向接口编程，这样程序员就可以灵活方便的切换各种业务实现
抽象注意事项

  • 抽象类和抽象放必须使用abstract修饰

  • 抽象类不能实例化

  • 抽象类中有抽象方法,也有非抽象方法,但是抽象方法必须存在抽象类中

    ​ 抽象方法 : 规范子类必须重写

    ​ 非抽象方法 : 让子类去继承提高代码复用性

  • 抽象的子类,要么重写抽象类中所有的抽象方法,要么子类是一个抽象类

接口其他注意事项 1、一个接口继承多个接口，如果多个接口中存在方法签名冲突，则此时不支持多继承。 2、一个类实现多个接口，如果多个接口中存在方法签名冲突，则此时不支持多实现。 3、一个类继承了父类，又同时实现了接口，父类中和接口中有同名的默认方法，实现类会优先用父类的。 4、一个类实现了多个接口，多个接口中存在同名的默认方法，可以不冲突，这个类重写该方法即可。

public class Test2 {
    interface A{};
    interface B extends A{};
    interface C extends B{}

    class AA{}
    class BB extends AA implements B, C{}

}
avatar
文章
阅读
粉丝