多态

多态是面向对象编程中最后一个（封装、继承、多态）也是最重要的特征。

程序设计当中，多态意味着，允许不同类的对象对同一消息做出不同的响应。

多态分为：

1. 编译时多态 （设计时多态方法重载）

2. 运行中多态 （程序运行时动态决定调用哪个方法）

   
   
   image.png

一般所说的java中的多态大多是运行时多态。

必要条件

• 满足继承关系
• 父类引用指向子类对象

示例

image.png

新建一个Animal类，作为动物基类，有两个属性，name、month，和一个eat方法。
Animal的子类中有自己特有的子类属性和方法，
Cat中有weight、run()，
Dog中有sex、sleep()。
且都重写了父类Animal中的eat()方法。

新建Animal.java：

public class Animal {
    private String name;
    private int month;

    public Animal(){

    }

    public Animal(String name, int month){
        this.name = name;
        this.month = month;
    }

    public String getName() {
        return name;
    }

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

    public int getMonth() {
        return month;
    }

    public void setMonth(int month) {
        this.month = month;
    }

    public void eat(){
        System.out.println("动物都有吃东西的能力");
    }
}

新建Cat.java:

public class Cat extends Animal{
    private double weight;

    public Cat(){

    }

    public Cat(String name, int monnth, double weight){
        super(name, monnth);
        this.weight = weight;
    }

    public double getWeight() {
        return weight;
    }

    public void setWeight(double weight) {
        this.weight = weight;
    }

    public void run(){
        System.out.println("小猫快乐地奔跑");
    }

    @Override
    public void eat() {
        super.eat();
        System.out.println("猫吃鱼");
    }
}

新建Dog.java:

public class Dog extends Animal {
    private String sex;

    public Dog(){

    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public Dog(String name, int month, String sex){
        this.setMonth(month);
        this.setName(name);
        this.setSex(sex);
    }

    public void sleep(){
        System.out.println("小狗午睡");
    }

    @Override
    public void eat() {
        System.out.println("狗吃肉");
    }
}

然后在定义一个测试文件Test.java:

public class Test {
    public static void main(String[] args){
        Animal one = new Animal();
        Animal two = new Cat();
        Animal three = new Dog();
        one.eat();
        two.eat();
        three.eat();

    }
}

运行Test.java

image.png

虽然都是吃这种行为，也同样都是Animal类型的引用，但是随着它具体在程序运行时实例化的对象类型不同，那么它的执行的具体行为能力是不一样的，这就是在java中多态的表现。

向上转型

父类引用指向子类实例：Animal one = new Animal();
把一个子类对象转型为父类对象，向上转型(隐式转型、自动转型)，代码中是父类引用指向子类实例，
父类引用指向子类实例，可以调用子类重写父类的方法以及父类派生的方法，无法调用子类独有的方法。

注意：

父类中的静态方法无法被子类重写，所以向上转型之后，只能调用父类原有的静态方法

向下转型(强制类型转换)

子类引用指向父类实例，必须进行强制类型转换，可以调用子类特有的方法。
必须满足转型条件才能强转。

instanceof运算符可以进行判断，左边对象是否是他右边对象的实例，换句话说就是左侧对象是否满足右侧对象类型的特征如果是，返回true。

if (obj instanceof Cat)

父类中的静态方法(含有static修饰的方法)，只能被子类继承使用，无法被子类重写。

public static void say(){

}

抽象类

Java中使用抽象类，限制实例化

public abstract class A{

}

通过abstract 修饰的类叫做抽象类。

当一个类为抽象类时，就不允许实例化了，可以通过向上转型指向子类。

抽象类应用场景：

某个父类只是知道其子类应该包含怎样的方法，但无法准确知道这些子类如何实现这些方法。
当我们将父类设置为抽象类时，既可以借由父类和子类的继承关系限制子类随意性，同时也在一定程度上避免了无意义的实例化。

抽象方法

abstract 修饰的方法为抽象方法。
抽象方法要求：

1. 不允许包含方法体
2. 子类中必须重写父类中的抽象方法
3. 如果不重写，子类自己必须被定义为抽象类
4. 包含抽象方法的类必须是抽象类

总结：

1. 抽象类不能直接实例化
2. 子类如果没有重写父类所有的抽象方法，则也要定义为抽象类
3. 抽象方法所在的类一定是抽象类
4. 抽象类中可以没有抽象方法
5. static、final、private关键字不能与abstract 并存。

接口

当多个类型之间具有相同的行为能力的时候，java中可以借由接口来进行类型之间的联系。

通过接口可以解决java当中单继承所带来的一些类型无法共享的问题。

• 接口定义了某一批类所需要的遵守的规范
• 接口不关心这些类的内部数据，也不关心这些类里方法的实现细节，它只规定这些类里必须提供某些方法。

语法：

[修饰符] interface 接口名 [extends 父接口1，父接口2...]
{
  零个到多个常量定义...
  零个到多个抽象方法定义...
  零个到多个默认方法定义...（jdk1.8新增）
  零个到多个静态方法方法的定义...（jdk1.8新增）
}

• 接口可以实现多继承，即一个子接口可以同时继承多个父接口
• 实现接口的类如果不能实现所有接口中待重写的方法，则必须设置为抽象类。
• 一个类可以继承自一个父类，同时实现多个接口

内部类

在Java中，可以将一个类定义在另一个类里面或者一个方法里面，这样的类称为内部类。与之对应，包含内部类的类称为外部类。

内部类分为四种：

• 成员内部类
• 静态内部类
• 方法内部类
• 匿名内部类

优势：内部类提供了更好的封装，可以把内部类隐藏在外部类之内，不允许同一个包的其他类访问该类，更好的实现了信息隐藏。

1.成员内部类

内部类中最常见的就是成员内部类，也称为普通内部类。
如下：

package com.imooc.people;

//外部类
public class Demo {
    int name;

    public He getSex(){
        return new He();
    }
    
    //成员内部类
    class He{
        public String sex(){
            return "男";
        }
    }
}

获取内部类对象实例的三种方式：

public static void main(String[] args){
    Demo a = new Demo();
    a.name = 3;
    //方式一
    Demo.He h = new Demo().new He();
    //方式二
    h = a.new He();
    //方式三
    a.getSex();
}

• 内部类在外部使用时，无法直接实例化，需要借由外部类信息才能完成实例化
• 内部类的访问修饰符，可以任意，但是访问范围会受到影响
• 内部类可以直接访问外部类的成员；如果出现同名属性，优先访问内部类中定义的
• 可以使用外部类.this.成员的方式，访问外部类中同名的信息
• 外部类访问内部类信息，需要通过内部类实例，无法直接访问
• 内部类编译后.class文件命名：外部类$内部类.class

2.静态内部类

• 静态内部类中，只能直接访问外部类的静态成员，如果需要调用非静态成员，可以通过对象实例
• 静态内部类对象实例时，可以不依赖于外部类对象
• 可以通过外部类.内部类.静态成员的方式，访问内部类中的静态成员
• 当内部类属性与外部类属性同名时，默认直接调用内部类中的成员；
• 如果需要访问外部类中的静态属性，则可以通过 外部类.属性 的方式；
• 如果需要访问外部类中的非静态属性，则可以通过 new 外部类().属性的方式；

3.方法内部类

定义在外部类方法中的内部类，也称为局部内部类。

image.png

方法的约束对方法内部类同样有效。

• 定义在方法内部，作用范围也在方法内
• 和方法内部成员使用规则一样，class前面不可以添加public、private、protected、static
• 类中不能包含静态成员
• 类中可以包含final、abstract修饰的成员

4.匿名内部类

匿名内部类

public static void main(String[] args) {
        PersonTest test=new PersonTest();

        test.getRead(new Person(){
            {
                //构造代码块
            }
            @Override
            public void read() {
                System.out.println("男生喜欢看科幻类书籍");
            }
            
        });
        test.getRead(new Person(){
            @Override
            public void read() {
                System.out.println("女生喜欢读言情小说");
            }
            
        });
    }

}

• 匿名内部类没有类型名称、实例对象名称
• 编译后的文件命名：外部类$数字.class
• 无法使用private、public、protected、abstract、static修饰
• 无法编写构造方法，可以添加构造代码块
• 不能出现静态成员
• 匿名内部类可以实现接口也可以实现继承父类，但是不可兼得

如果内容对你有帮助，记得关注作者给个赞哦~，后续会持续更新。