[java基础]一篇带你玩转多态

大家好，大一菜鸟正在自学java中，文章如果有错误的欢迎各位大佬交流指正探讨，一起共同进步

一.多态的基本概述

1. 多态:事物的多种形态，同一对象，在不同时刻下表现出来的不同形态
2. 例子：狗 dog = new dog; 动物 Animal = new dog();狗在这不同时刻下表现出来的不同形态
3. 多态的前提和体现：

• 有继承/实现关系
• .有方法重写
• 有父类引用指向子类对象

4. 我们看一下代码例子：

//动物类
public class Animal {
        public void eat(){
            System.out.println("动物类吃方法");
        }
}
//猫类
public class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("猫类重写了动物类的吃方法");
    }
}
/*
多态的前提和体现：
1.有继承/实现关系
2.有方法重写
3.有父类引用指向子类对象
*/
public class AnimalDemo {
    public static void main(String[] args) {
        //本身的类型引用new，本身的对象
        Cat c = new Cat();
        //有父类引用指向子类对象
        Animal a = new Cat();//多态形式
        a.eat();
    }
}

5. 多态的访问特点:
   

• 成员变量:编译看左边，执行看左边
• 成员方法;编译看左边，执行看右边

因为成员方法有重写，而成员变量没有,所以导致两者访问特点不一样

6. 多态访问静态静态方法的特点:

   编译时看左,运行时看左

7.代码案例:

public class Animal {
    public int age = 15;
   
   public void eat(){
       System.out.println("动物类吃方法");
   }
}
//继承父类
public class Cat extends Animal{
    public int age = 20;
    public int weight = 30;
//重写吃方法
    @Override
    public void eat(){
        System.out.println("猫类吃方法");
    }
    public void playGame(){
        System.out.println("玩捉迷藏");
    }
}
public class AnimalDemo {
    public static void main(String[] args) {
        //有父类引用指向子类对象
        Animal a = new Cat();

        System.out.println(a.age);
    //    System.out.println(a.weight);报错
        a.eat();
     //   a.palyGame();报错
        //成员变量编译看左边，执行看右边
        //成员方法编译看左边，执行看右边 
    }
}

8. 多态机制的优缺点：
   

• 可以提高代码的扩展性
• 但不能使用子类的特有功能

9. 让我们在看代码例子:

//动物类 父类
public class Animal {
    public void eat(){
        System.out.println("动物吃方法");
    }
}
猫类 子类
public class Cat  extends Animal{
    @Override
    public void eat(){
        System.out.println("猫类吃方法");
    }
}
//狗类 子类
public class Dog extends Animal {
    @Override
    public void eat(){
        System.out.println("狗类吃方法");
    }
}
public class AnimalOpeator {
    /*public void userAnimal(Cat cat){
      cat.eat();
    }

    public void userAnimal(Dog dog){
      dog.eat();
    }*/
    public void userAnimal(Animal a){//new Cat();new Dog();
        /*Cat c = new Cat();
        c.eat();
        Dog d = new Dog();
        d.eat();*/
        a.eat();
    }
public class AnimalDemo {
    public static void main(String[] args) {
        //1.new 动物操作类
        AnimalOpeator animalopeater = new AnimalOpeator();
       /* 2.调用猫类中的eat方法
        animalopeater.userAnimal(new Cat());
        //3.调用狗类中的eat方法
        animalopeater.userAnimal(new Dog());*/
        animalopeater.userAnimal(new Cat());
        animalopeater.userAnimal(new Dog());
    }
}

//动物类 父类
public class Animal {
    public void eat(){
        System.out.println("动物类中吃方法");
    }
}
//猫类 子类
public class Cat extends Animal{
    @Override
    public void eat() {
        System.out.println("猫类吃方法");
    }
}
//狗类 子类
public class Dog extends Animal{
    @Override
    public void eat() {
        System.out.println("狗类吃方法");
    }
}
//人类
public class Person extends Animal {
    @Override
    public void eat() {
        System.out.println("人类吃方法");
    }
}
public class AnimalOpeator {
    public void userCat(Cat cat){
        cat.eat();
    }
    public void userDog(Dog dog){
        dog.eat();
    }
    /*public void userAnimal(){
        Animal an = new Cat();
        an.eat();
        Animal an2 = new Dog();
        an2.eat();
    }*/
    public void userAnimal(Animal animal){
        animal.eat();
    }
}
public class AnimalDemo {
    public static void main(String[] args) {
        AnimalOpeator a = new AnimalOpeator();
        a.userCat(new Cat());
        a.userDog(new Dog());
        System.out.println("-----------");
        a.userAnimal(new Cat());
        a.userAnimal(new Dog());
        a.userAnimal(new Person());
        //多态机制的利：提高了程序的扩展性
        //多态机制的弊：不能使用子类的特有功能
    }
}

我是分割线

二.抽象类

1. 一个没有方法体的方法为抽象方法，而类中如果有抽象方法，则为抽象类
2. 抽象方法和抽象类用abstract关键字来修饰
3. 格式:抽象类：abstract class 类名{}
4. 抽象方法: public abstract void 方法名();
5. 让我们看代码例子:

//抽象类
public abstract class Animal {
    /*public void eat(){
        System.out.println("动物吃方法");
    }*/
    //抽象类方法
    public abstract void eat();
    //非抽象方法
    public void show(){
        System.out.println("动物类中的show方法");
    }
}
public class Cat extends Animal{
    //继承抽象类
    //要么继承抽象类要么重写父类所有的抽象方法
    //重写了父类中的eat方法
    @Override
    public void eat(){
        System.out.println("猫类吃方法");
    }
}
public class AnimalDemo {
    public static void main(String[] args) {
     //   Animal a = new Animal();
        //抽象类能通过多态实例化
        Animal a = new Cat();
        a.eat();
        a.show();
    }
}

6.抽象类特点:

• 抽象类中不一定有抽象方法，但是有抽象方法的类必须为抽象类
• 抽象类不能实例化
• 成员变量可以是变量和常量
• 抽象类由具体的子类实例化
• 子类必须对父类(抽象类)中的所有抽象方法进行重写
• 在抽象类中可以定义非抽象方法
• 如果子类不重写抽象类中的抽象方法，则该类还是为抽象类
• 抽象类中可以有构造方法，用于子类访问父类时的数据初始化

7.看代码案例:

public abstract class Animal {
    private int age;
    private final int code = 300;

    //构造方法
    public Animal() {
        System.out.println("父类无参构造方法");
    }
    public Animal(int age){
        this.age = age;
        System.out.println("父类有参构造方法");
    }
    public void show(){
        age=200;
        System.out.println(age);
      //  code =400;常量无法被改变
        System.out.println(code);
    }
    //抽象类
    public abstract void eat();
}
public class Cat extends Animal {
    public Cat(int age){
        super(age);
        System.out.println("猫类有参构造方法");
    }

    @Override
    public void eat() {
        System.out.println("子类吃方法");
    }
}
public class Test01 {
    public static void main(String[] args) {
        Animal animal = new Cat(20);
        animal.show();
    }
}
/*控制台输出:
父类有参构造方法
猫类有参构造方法
200
300 
*/

abstract不能与哪些关键字共存？

• private 与之冲突 abstract的方法必须被子类重写，而private不能被继承
• final 与之冲突 final修饰的方法，变量都不能修改，而abstract修饰的方法必须被重写
• static 不能共存 无意义 static是静态的,abstract方法中无方法体，无法调用

我是分割线

三.接口

1. 接口是一种公共的规范标准，只要符合规范标准，就可以通用
2. java中的接口更多是对行为的抽象
3. 定义接口的格式:用关键字interface修饰 public interface 接口名{}
4. 类实现接口的格式:

​ public class 类 implements 接口{}

5. 接口的特点:

• 接口用关键字interface修饰
• 类实现接口用implements表示
• 接口不能实例化，参照多态的实现方式，通过实现类对象实例化，则接口多态
• 多态形式:具体类多态，抽象类多态，接口多态
• 多态的前提:有继承和实现关系；有方法重写；有父(类/接口)引用指向(子/实现)类对象
• 接口的实现:要么重写接口中的所有抽象方法，要么是抽象类
• 成员变量只能是常量，默认public static final
• 接口没有构造方法
• 一个类如果没有父类，默认继承自object类
• 只能是抽象方法，但 jdk8开始后是可以定义非抽象类方法，需要加default关键字，默认public abstract

5. 让我们看一下代码例子

//接口类
public interface Animal {
    //成员变量
    //默认public final static
    public int code = 20;
    public int code2 = 30;
    public final int code3 = 40;
    public static final int code4 = 50;
    //默认成员方法为抽象方法public abstract 默认
   public abstract void eat();
   //在接口中只能定义抽象方法但 jdk8开始后是可以定义非抽象类方法，需要加default关键字
    public default void show(){//非抽象方法
        System.out.println("定义了一个非抽象类");
    }
}
//狗类实现类
public class DogImpl implements Animal{
    public DogImpl(){
        super();//父类无参构造方法 是object 父类
        //在构造方法中默认的情况下
        //一个类如果没有父类，默认继承自object类
    }
    @Override
    public void eat() {
        System.out.println("狗类eat实现类");
    }
}
public class Demo {
    public static void main(String[] args) {
        Animal dog = new DogImpl();
        System.out.println(dog.code);
        //默认final，常量code =300;
        System.out.println(dog.code2);
        System.out.println(dog.code3);
        System.out.println(dog.code4);
        System.out.println("------------");
        //默认静态static关键字可以通过类名.属性名称 (Animal.属性名称）来访问
        System.out.println(Animal.code);
        System.out.println(Animal.code2);
        System.out.println(Animal.code3);
        System.out.println(Animal.code4);
    }
}

我是分割线

四.类，接口，抽象类的区别和联系

1. 类和类关系:继承关系，只能单继承，但可以多继承
2. 类和接口的关系:实现关系，可以单实现，也可以在继承一个类的同时可实行多个接口
3. 接口和接口的关系:继承关系，可以单继承，也可以多继承
4. 抽象类和接口的区别:

• 成员区别:抽象类有常量，变量，有构造方法，有抽象类和非抽象类方法

  ​ 接口：常量；抽象方法

• 关系区别:类与类:继承；单继承；类与接口:实现，可以单实现，也可以多实现 接口与接口:继承；单继承和多继承

• 设计理念区别:抽象类:对类抽象，包括属性，行为 接口：对行为抽象，主要是行为