Java基础第二天--多态、接口

多态

多态的概述

同一个对象，在不同时刻表现出来的不同形态

多态的前提和体现

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

    public class Animal {

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

    public class Cat extends Animal {

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

    public class AnimalDemo {
        public static void main(String[] args) {
            Animal a = new Cat();
        }
    }

多态中成员访问特点

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

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

• 因为成员方法有重写，而成员变量不一样呢？

    public class Animal {

        public int age = 40;
        public void eat() {
            System.out.println("动物吃东西");
        }
    }

    public class Cat extends Animal {

        public int age = 20;
        public int weight = 10;

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

        public void playGame() {
            System.out.println("猫捉老鼠");
        }
    }

    public class Dog extends Animal {

        @override
         public void eat() {
            System.out.println("狗吃骨头");

        public void lookDoor() {
            System.out.println("狗看门");
        }
    }

    public class AnimalOperator {
        public void useAnimal(Animal a){
            //Animal a = new Cat();
            //Animal a = new Dog();
            a.eat();
        }
    }

    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();

            AnimalOperator ao = new AnimalOperator();
            Dog d = new Dog();
            ao.useAnimal(d);
        }
    }

多态的好处和弊端

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

多态中的转型

向上转型:

• 从子到父，父类引用指向子类对象

向下转型:

• 从父到子，父类引用转为子类对象

    public class Animal {

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

    public class Cat extends Animal {

        @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(); //向上转型
            a.eat();

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

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

抽象类

抽象类概述

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

抽象类特点

• 抽象类和抽象类方法必须使用abstract关键字修饰
  
      public abstract class 类名{}
  
      public abstract void eat();
• 抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类
• 抽象类不能实例化
  
      抽象类如何实现实例化呢？参照多态的方式，通过子类对象实例化，这叫抽象类多态
• 抽象类的子类
  
      要么重写抽象类中的所有抽象方法
  
      要么是抽象类

抽象类的成员特点

• 成员变量
  
      可以是变量
  
      也可以是常量
• 构造方法
  
      有构造方法，但是不能实例化
  
      构造方法的作用是用于访问父类数据的初始化
• 成员方法
  
      可以有抽象方法：限定子类必须完成某些动作
  
      也可以有非抽象方法：提高代码复用性

猫和狗抽象类案例

    //创建动物类
    public abstract 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 abstract void eat();
    }

    //创建猫类
    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(3);
		    System.out.println(a.getName()+","+a.getAge());
		    a.eat();
		    System.out.println("========");

		    a = new Cat("布偶",3);
		    System.out.println(a.getName()+","+a.getAge());
		    a.eat();
	    }
    }

接口

接口概述

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

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

接口的特点

• 接口用关键字interface修饰
  
      public interface 接口名 {}
• 类实现接口用implements表示
  
      public class 类名 implements 接口名{}
• 接口不能实例化
  
      接口如何实例化呢？ 参照多态的方式，通过实现类对象实例化，这叫接口多态。
  
      多态的形式：具体类多态，抽象类多态，接口多态
• 接口的实现类
  
      要么重写接口中的所有抽象方法
  
      要么是抽象类

接口的成员特点

• 成员变量
  
      只能是常量
  
      默认修饰符：public static final
• 构造方法
  
      接口没有构造方法，因为接口主要是对行为进行抽象的，是没有具体存在
  
      如果一个类没有显式继承某个父类，则默认继承Object类
• 成员方法
  
      只能是抽象方法
  
      默认修饰符：public abstract

猫和狗接口案例

    //定义接口Jumpping
    public interface Jumpping{
        public abstract void jump();
    }
    //创建动物类
    public abstract 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 abstract void eat();
    }

    //创建猫类
    public class Cat extends Animal implements Jumpping {

	    public Cat() {
	    }

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

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

        @Override
	    public void jump() {
		    System.out.println("猫可以跳高了");
	    }
    }

    public class Dog extends Animal implements Jumpping {

	    public Dog() {
	    }

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

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

        @Override
	    public void jump() {
		    System.out.println("狗可以跳高了");
	    }
    }

    public class AnimalDemo {
	    public static void main(String[] args) {
            //创建对象，调用方法
            Jumpping j = new Cat();
            j.jump();
            System.out.println("========");

		    Animal a = new Cat();
		    a.setName("布偶");
		    a.setAge(3);
		    System.out.println(a.getName()+","+a.getAge());
		    a.eat();

		    a = new Cat("布偶",3);
		    System.out.println(a.getName()+","+a.getAge());
		    a.eat();
            System.out.println("========");

            Cat c = new Cat();
            c.setName("布偶");
            c.setAge(3);
            System.out.println(a.getName()+","+a.getAge());
            c.eat();
            c.jump();
	    }
    }

类和接口的关系

• 类和类的关系
  
      继承关系，只能单继承，但是可以多层继承
• 类和类的接口关系
  
      实现关系，可以单实现，也可以多实现，还可以在继承一个类的同时实现多个接口
• 接口和接口的关系
  
      继承关系，可以单继承，也可以多继承

抽象类和接口的区别

• 成员区别
  
      抽象类：变量，常量；有构造方法；有抽象方法，也有非抽象方法
  
      接口：常量；抽象方法
• 关系区别
  
      类与类：继承，单继承
  
      类与接口：实现，可以单实现，也可以多实现
  
      接口与接口：继承，单继承，多继承
• 设计理念区别
  
      抽象类：对类抽象，包括属性、行为
  
      接口：对行为抽象，主要是行为

    //抽象运动员类
    public abstract class Player extends Person {
        public Player() {
        }

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

        public abstract void study();
    }

    //说英语的接口
    public interface SpeakEnglish {
        public abstract void speak();
    }

     public class TableTennisPlayer extends Player implements SpeakEnglish{
        public TableTennisPlayer() {
        }

        public TableTennisPlayer(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 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 PersonDemo {
        public static void main(String[] args) {
            //创建对象
            TableTennisPlayer ttp = new TableTennisPlayer();
            ttp.setName("小明");
            ttp.setAge(30);
            System.out.println(ttp.getName()+","+ttp.getAge());//小明，30
            ttp.eat();//乒乓球运动员吃大白菜，喝小米粥
            ttp.study();//乒乓球运动员学习如何发球和接球
            ttp.speak();//乒乓球运动员说英语
            System.out.println("========");

            BasketballPlayer bp = new BasketballPlayer();
            bp.setName("小华");
            bp.setAge(28);
            System.out.println(bp.getName()+","+bp.getAge());//小华，28
            bp.eat();//篮球运动员吃牛肉，喝牛奶
            bp.study();//篮球运动员学习如何运球和投篮
        }
    }