Java面向对象基础(多态)

‍博客主页:i新木优子
Java基础系列教程:传送门
‍♂️寄语:不经历风雨,长不成大树,不受百炼,难以成钢
欢迎关注点赞收藏⭐留言
作者水平有限,发现错误欢迎留言轰炸

文章目录

  • 一、多态
    • 1.1多态概述
    • 1.2多态中成员的访问特点
    • 1.3多态的好处和弊端
    • 1.4多态中的转型
    • 1.5案例
  • 二、抽象类
    • 2.1抽象类概述
    • 2.2抽象类的特点
    • 2.3抽象类的成员特点
  • 三、接口
    • 3.1接口概述
    • 3.2接口的特点
    • 3.3接口的成员特点
    • 3.4类和接口的关系
    • 3.5抽象类和接口的区别
    • 3.6案例


一、多态

1.1多态概述

继承是面向对象三大特征之一,同一个对象,在不同的时刻表现出来的不同形态就是多态

多态的前提和体现:

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

1.2多态中成员的访问特点

  1. 成员变量:编译看左边,执行看左边
  2. 成员变量:编译看左边,执行看右边

为什么成员变量和成员方法中的访问不一样呢?

  • 因为成员方法有重写,而成员变量没有
public class Animal {

    public int age = 10;

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

    public int age = 7;
    public int weight = 15;

    @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.playGame();

    }
}

1.3多态的好处和弊端

  • 多态的好处:提高了程序的扩展性
    • 具体体现:定义方法的时候,使用父类型作为参数,将来在使用的时候,使用具体的子类型参与操作
  • 多态的弊端:不能使用子类特有的功能

1.4多态中的转型

多态不能使用子类的特有功能,使用向下转型就可一个解决这个问题

  1. 向上转型
    • 从子到父
    • 父类引用指向子类对象
  2. 向下转型
    • 从父到子
    • 父类引用转为子类对象
public class AnimalDemo {
    public static void main(String[] args) {
        //多态
        Animal a = new Cat();
        a.eat();

        /*
        //创建Cat类的对象
        Cat c = new Cat();
        c.eat();
        c.playGame();
         */

        //向下转型
        Cat c = (Cat) a;
        c.eat();
        c.playGame();

    }
}

1.5案例

猫和狗:

需求:采用多态的思想实现猫和狗的案例,并在测试类中进行测试

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

    public Animal() {
    }

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

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

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

    public Cat(String name, int age) {
        super(name, age);
    }

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

    public Dog(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }
}
public class AnimalDemo {
    public static void main(String[] args) {
        Animal a = new Cat();
        a.setName("加菲猫");
        a.setAge(5);
        System.out.println(a.getName() + "," + a.getAge());
        a.eat();

        a = new Cat("加菲猫", 5);
        System.out.println(a.getName() + "," + a.getAge());
        a.eat();

        Animal a1 = new Dog();
        a1.setName("哈士奇");
        a1.setAge(6);
        System.out.println(a1.getName() + "," + a1.getAge());
        a1.eat();

        a1 = new Dog("哈士奇", 6);
        System.out.println(a1.getName() + "," + a1.getAge());
        a1.eat();
    }
}

二、抽象类

2.1抽象类概述

在Java中,一个没有方法体的方法应该定义为抽象方法,而类中如果有抽象方法,该类必须定义为抽象类

public abstract class Animal {

    public abstract void eat();
}

2.2抽象类的特点

  1. 抽象类和抽象方法必须使用abstract关键字修饰

    public abstract class 类名 {}
    
    public abstract void eat()
    
  2. 抽象类中不一定有抽象方法,有抽象方法的类一定是抽象类

  3. 抽象类不能实例化

    抽象类如何实例化?参照多态的方式,通过子类对象实例化,这叫抽象类多态

  4. 抽象类的子类

    要么重写抽象类中的所有抽象方法

    要么是抽象类

2.3抽象类的成员特点

  1. 成员变量

    可以是变量

    也可以是常量

  2. 构造方法

    有构造方法,但是不能实例化

    构造方法的作用是用于子类访问父类数据的初始化

  3. 成员方法

    可以有抽象方法:限定子类必须完成某些动作

    也可以有非抽象方法:提高代码复用性

三、接口

3.1接口概述

接口就是一种公共的规范标准,只要符合规范标准,就都可以通用

就像家里的插座,电脑上的USB口,这些都是接口

Java中的接口更多的体现在对行为的抽象

3.2接口的特点

  1. 接口用关键字interface

    public interface 接口名 {}
    
  2. 类实现接口用implements

    public class 类名 implements 接口名 {}
    
  3. 接口不能实例化

    接口如何实例化呢?参照多态的方式,通过实现类对象实例化,这叫接口多态

    多态的形式:具体类多态,抽象类多态,接口多态

    多态的前提:有继承或实现关系;有方法重写;有父(类/接口)引用指向(子/实现)类对象

  4. 接口的实现类

    要么重写接口中的所有抽象方法

    要么是抽象类

3.3接口的成员特点

  1. 成员变量

    只能是常量

    默认修饰符:public static final

  2. 构造方法

    接口没有构造方法,因为接口主要是对行为进行抽象的,是没有具体存在

    一个类如果没有父类,默认继承自Object类

  3. 成员方法

    只能是抽象方法

    默认修饰符:public abstract

3.4类和接口的关系

  • 类和类的关系

    继承关系,只能单继承,但是可以多层继承

  • 类和接口的关系

    实现关系,可以单实现,也可以多实现,还可以在继承一个类的同时实现多个接口

    public class 类名 extends 父类 implements 接口1, 接口2, 接口3 {}
    
  • 接口和接口的关系

    继承关系,可以单继承,也可以多继承

    public interface 接口1 extends 接口2, 接口3 {}
    

3.5抽象类和接口的区别

  • 成员区别

    抽象类                            变量;常量;有构造方法;有抽象方法;有非抽象方法          
    接口                              常量;抽象方法            
    
  • 关系区别

    类与类                            继承;单继承
    类与接口                          实现;可以单实现;可以多实现
    接口与接口                         继承,单继承;多继承        
    
  • 设计理念区别

    抽象类                            对类抽象;包括属性、行为
    接口                              对行为抽象;主要是行为
    

抽象类是对事物的抽象,而接口是对行为的抽象

3.6案例

运动员和教练:

需求:现在有乒乓球运动员和篮球运动员,乒乓球教练和篮球教练。为了出国交流,跟乒乓球相关的人员都需要学习英语,请分析,这个案例有哪些具体类、抽象类、接口,并用代码实现。

分析:从具体到抽象

Java面向对象基础(多态)_第1张图片

实现:从抽象到具体

使用:具体类的对象

思路:

  • 定义英语接口
  • 定义抽象人类
  • 定义抽象教练类,继承人类
  • 定义抽象运动员类,继承人类
  • 定义具体篮球教练类,继承教练类
  • 定义具体乒乓球教练类,继承教练类,实现英语接口
  • 定义具体篮球运动员类,继承运动员类
  • 定义具体乒乓球运动员类,继承远动员类,实现英语接口
  • 定义测试类,进行测试
public interface SpeakEnglish {
    void speak();
}
public abstract class Person {
    private String name;
    private int age;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public abstract void eat();
}
public abstract class Coach extends Person {
    public Coach() {
    }

    public Coach(String name, int age) {
        super(name, age);
    }

    public abstract void teach();
}
public abstract class Player extends Person {
    public Player() {
    }

    public Player(String name, int age) {
        super(name, age);
    }

    public abstract void study();
}
public class BasketballCoach extends Coach{
    public BasketballCoach() {
    }

    public BasketballCoach(String name, int age) {
        super(name, age);
    }

    @Override
    public void teach() {
        System.out.println("篮球教练教篮球");
    }

    @Override
    public void eat() {
        System.out.println("篮球教练吃饭");
    }
}
public class PingPangCoach extends Coach implements SpeakEnglish{
    public PingPangCoach() {
    }

    public PingPangCoach(String name, int age) {
        super(name, age);
    }

    @Override
    public void teach() {
        System.out.println("乒乓球教练教乒乓球");
    }

    @Override
    public void eat() {
        System.out.println("乒乓球教练吃饭");
    }

    @Override
    public void speak() {
        System.out.println("乒乓球教练说英语");
    }
}
public class BasketballPlayer extends Player{
    public BasketballPlayer() {
    }

    public BasketballPlayer(String name, int age) {
        super(name, age);
    }

    @Override
    public void study() {
        System.out.println("篮球运动员学习篮球");
    }

    @Override
    public void eat() {
        System.out.println("篮球运动员吃饭");
    }
}
public class PingPangPlayer extends Player implements SpeakEnglish{
    public PingPangPlayer() {
    }

    public PingPangPlayer(String name, int age) {
        super(name, age);
    }

    @Override
    public void study() {
        System.out.println("乒乓球学习乒乓球");
    }

    @Override
    public void eat() {
        System.out.println("乒乓球运动员吃饭");
    }

    @Override
    public void speak() {
        System.out.println("乒乓球运动员说英语");
    }
}
/*
    测试类,带惨构造方法可以自己尝试哦
 */
public class PersonDemo {
    public static void main(String[] args) {
        //创建对象
        PingPangPlayer ppp = new PingPangPlayer();
        ppp.setName("张继科");
        ppp.setAge(20);
        System.out.println(ppp.getName() + "," + ppp.getAge());
        ppp.eat();
        ppp.study();
        ppp.speak();
        System.out.println("---------------");

        BasketballPlayer bp = new BasketballPlayer();
        bp.setName("科比");
        bp.setAge(30);
        System.out.println(bp.getName() + "," + bp.getAge());
        bp.eat();
        bp.study();
        System.out.println("***************");

        PingPangCoach ppc = new PingPangCoach();
        ppc.setName("刘国梁");
        ppc.setAge(35);
        System.out.println(ppc.getName() + "," + ppc.getAge());
        ppc.eat();
        ppc.teach();
        ppc.speak();
        System.out.println("---------------");

        BasketballCoach bc = new BasketballCoach();
        bc.setName("姚明");
        bc.setAge(30);
        System.out.println(bc.getName() + "," + bc.getAge());
        bc.eat();
        bc.teach();


    }
}

你可能感兴趣的:(Java,java,开发语言)