Java面向对象完结

  Java面向对象终于来到了完结篇，最后剩下的内容是面向对象中最难理解的一个特性——多态，虽然在自己写代码时很少用到，但是在企业级开发中是必不可少的部分，还会把剩余的一些内部类的知识给小伙伴们介绍。

多态

package demo01;

public abstract class Animal {
    String name;

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

    public abstract void eat();

    public abstract void speak();
}

package demo01;

public class Cat extends Animal{
    public Cat(String name) {
        super(name);
    }

    @Override
    public void eat() {
        System.out.println("我是" + name + "，我喜欢吃鱼");
    }

    @Override
    public void speak() {
        System.out.println("我是" + name + "，我会喵喵喵");
    }

    public void climb() {
        System.out.println("我是" + name + "，我会爬树");
    }
}

package demo01;

public class Dog extends Animal{
    public Dog(String name) {
        super(name);
    }

    @Override
    public void eat() {
        System.out.println("我是" + name + "，我喜欢吃骨头");
    }

    @Override
    public void speak() {
        System.out.println("我是" + name + "，我会汪汪汪");
    }

    public void watch() {
        System.out.println("我是" + name + "，我会看家");
    }
}

package demo01;

public class Oop5 {
    public static void main(String[] args) {
        //多态的本质：父类或接口引用子类对象，调用时会调用子类的成员方法。
        //编译看左，运行看右。因为编译时看左边，父类对象没有子类的特有方法，因此在animal_cat中无法调用Cat类的climb方法。运行时是按照右边创建的子类进行调用，调用的是子类的方法。
        //向上转型：父类名 对象名 = new 子类名，即创建子类对象，当作父类看待，这是安全的。例如猫是子类，看做一个动物，这是合理的。缺陷是无法调用子类特有的方法，编译不通过。
        //向下转型：子类名 对象名 = (子类名) 父类对象 即将父类对象还原成子类对象，这时不安全的。例如你不能说动物就是猫，还可能是狗，因此必须保证它确实就是一只猫。所以必须保证对象本来创建的时候就是子类A，才能从父类转型为子类A，如果对象创建的时候是子类B，则向下转型为子类A，会在运行时报错。
        Animal animalCat = new Cat("小猫");
        Animal animalDog = new Dog("小狗");
        //在这里animalCat无法调用到子类的climb属性，编译就会报错。
        animalCat.eat();
        animalCat.speak();
        animalDog.eat();
        animalDog.speak();
        //在这里可以将父类对象animalCat转型为Dog，编译不会报错，但是运行时会报错。只能将其向下转型为Cat类对象，因为在创建时animalCat就是Cat类型。
        Cat cat = (Cat) animalCat;
        cat.eat();
        cat.speak();
        cat.climb();
        Dog dog = (Dog) animalDog;
        dog.eat();
        dog.speak();
        dog.watch();
    }
}

Java内部类

package demo01;

//外部类：可以使用public和默认权限修饰符修饰。如果使用默认权限修饰符则包外不可导入该类。
//成员内部类：可以使用四种权限修饰符，和成员变量类似。
//局部内部类：只能在方法内使用，因此不可以写权限修饰符。

public class OuterClass {
    //成员内部类的定义方式，定义在外部类的成员变量中
    public static class InnerClass {
        public void speak() {
            System.out.println("我是InnerClass内部类中的speak方法");
        }
    }

    public void localInnerClass() {
        //局部内部类的定义方式，定义在一个方法的内部
        class LocalInnerClass {
            public void speak() {
                System.out.println("我是OuterClass外部类中localInnerClass方法中的LocalInnerClass局部内部类中的speak方法");
            }
        }
        //使用局部内部类，仅仅在当前所属的方法中才能使用它，超出这个方法外面就不可以使用了
        LocalInnerClass localInnerClass = new LocalInnerClass();
        localInnerClass.speak();
    }

    public void speak() {
        System.out.println("我是OuterClass外部类中的speak方法");
    }
}

package demo01;

public class Oop5 {
    public static void main(String[] args) {
        //使用外部类
        OuterClass outerClass = new OuterClass();
        //使用成员内部类，需要外部类名.内部类名 对象名 = new 外部类名.内部类名()
        OuterClass.InnerClass innerClass = new OuterClass.InnerClass();
        //使用匿名内部类，如果接口的实现类或者父类的子类只使用一次，可以省略该类的定义，直接重写方法即可。
        OuterClass anonymous = new OuterClass() {
          @Override
          public void speak() {
              System.out.println("我是匿名内部类中的speak方法");
          }
        };
        outerClass.speak();
        outerClass.localInnerClass();
        innerClass.speak();
        anonymous.speak();
    }
}

Java小结

  到今天为止，面向对象的所有内容都已经给小伙伴们分享完了，至于其中包含的奇技淫巧，需要小伙伴们慢慢磨砺，多态是设计模式的基础，以后会给小伙伴们详细介绍设计模式，在这里一定要掌握多态的用法。