Java学习笔记（六）-蒲公英云

一：多态

二：抽象类

三：接口

一：多态

1.1 多态的概述

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

举例：猫

我们可以说猫是猫：猫 cat=new 猫（）；

可以说猫是动物：动物 animal=new 猫（）；

这里的猫在不同的时刻表现出来了不同的形态，这就是多态。

多态的前提和体现：

1.有继承/实现关系。

2.有方法重写。

3.有父类引用指向子类对象。

public class Demo {
    public static void main(String[] args) {
animal a=new cat();
a.eat();//猫吃鱼
    }
}
class animal {
public void eat(){
    System.out.println("动物吃东西！");
}
}
class cat extends animal {
@Override
    public void eat(){
    System.out.println("猫吃鱼！");
}
}

1.2 多态中成员访问特点

成员变量：编译看左边，执行看左边

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

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

因为成员方法有重写，而成员变量没有。

1.3 多态的好处和弊端

多态的好处：提高了程序的拓展性。

具体体现：定义方法的时候，使用父类型作为参数，将来在使用的时候，使用具体的子类型参与操作。

多态的弊端：不能使用子类的特有功能。

public class Demo {
    public static void main(String[] args) {
        AniamlOperator ao = new AniamlOperator();
        cat c = new cat();
        // ao.useanimal(c);
        ao.useaniaml(c);
        dog d = new dog();
        // ao.useanimal(d);
        ao.useaniaml(d);
    }
}
class animal {
    public int age = 10;
    public void eat() {
        System.out.println("动物吃东西！");
    }
}
class cat extends animal {
    public int age = 18;
    public int weight = 10;
    @Override
    public void eat() {
        System.out.println("猫吃鱼！");
    }
    public void play() {
        System.out.println("猫捉老鼠！");
    }
}
class dog extends animal {
    public void eat() {
        System.out.println("狗吃骨头！");
    }
}
class AniamlOperator {
    public void useanimal(cat c) {
        c.eat();
    }
    public void useanimal(dog d) {
        d.eat();
    }
    public void useaniaml(animal a) {
        a.eat();
    }
}

1.4 多态的转型

1.向上转型

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

2.向下转型

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

public class Demo {
    public static void main(String[] args) {
        //多态
        animal a = new cat();//向上转型
        a.eat();
        /*cat c = new cat();
        c.eat();
        c.play();*/
        //向下转型
        cat c = (cat) a;
        c.eat();
        c.play();
    }
}
class animal {
    public int age = 10;
    public void eat() {
        System.out.println("动物吃东西！");
    }
}
class cat extends animal {
    public int age = 18;
    public int weight = 10;
    @Override
    public void eat() {
        System.out.println("猫吃鱼！");
    }
    public void play() {
        System.out.println("猫捉老鼠！");
    }
}

二：抽象类

2.1 抽象类的概述：

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

2.2 抽象类的特点：

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

public abstract class 类名{}

public abstract void eat（）；

抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类
抽象类不呢实例化

抽象类如何实例化呢？参照多态的方式，通过子类对象实例化，这叫抽象类多态。

抽象类的子类

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

要么是抽象类

public class Demo {
    public static void main(String[] args) {
       // animal a=new animal(); 这里报错，因为抽象类不能直接实例化
        animal a=new cat();
        a.eat();
        a.sleep();
    }
}
  abstract class animal{//抽象类
    public abstract void eat();//抽象方法（有抽象方法就一定是抽象类）
      public void sleep(){
          System.out.println("睡觉");
      }
  }
  class cat extends animal{
    @Override
    public void eat(){
        System.out.println("猫吃鱼");
    }
  }
  abstract class dog extends animal{
      public abstract void eat();
  }

2.3 抽象类的成员特点

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

三：接口

3.1 接口的概述：

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

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

3.2 接口的特点

接口用关键字interface修饰：public interface 接口名{}
类实现接口用implements表示：public class类名 implements 接口名{}
接口不能实例化

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

多态的形式：具体类多态，抽象类多态，接口多态。

多态的前提：有继承或者实现关系；有方法重写；有父（类/接口）引用指向（子/实现）类对象

接口的实现类

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

要么是抽象类

演示代码：

public class jumpDemo {
    public static void main(String[] args) {
jumpping j=new cat();
j.jump();//猫可以跳高了
    }
}
interface jumpping{//定义一个接口
    public abstract void jump();
}
class cat implements jumpping{
    @Override
    public void jump(){
        System.out.println("猫可以跳高了！");
    };
}
abstract class dog implements jumpping{//抽象类，可以不重写方法
}

3.3 接口的成员特点

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

（案例：猫）
watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBASmlhWGluZ05hc2hpc2h1YQ_size_14_color_FFFFFF_t_70_g_se_x_16

public class jumpDemo {
    public static void main(String[] args) {
        //创建对象，调用方法
        jumpping j = new cat();
        j.jump();//猫跳高了！！！
       // j.eat();//猫吃鱼！！！
        System.out.println("-----------");
        //创建对象，调用方法
        animal a=new cat();
        a.setName("小米");
        a.setAge(5);
        System.out.println(a.getName()+","+a.getAge());
       // a.show();//小米,5
a=new cat();
        //cat c=new cat("小花",12);
    }
}
/*
jumping接口
*/
interface jumpping {
    public void jump();
   // public void eat();
}
/*
动物类
*/
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;
    }
    abstract public void eat();
   /* public void show() {
        System.out.println(name + "," + age);
    }*/
}
/*
猫类
*/
class cat extends animal implements jumpping {
    public cat() {
    }
    public cat(String name, int age) {
        super(name, age);
    }
    @Override
    public void jump() {
        System.out.println("猫跳高了！！！");
    }
    @Override
    public void eat() {
        System.out.println("猫吃鱼！！！");
    }
}

3.4 类和接口的关系

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

public interface inter1 {
}
interface inter2{

}
interface inter3 extends inter1,inter2{
//接口和接口是继承关系，并且是多继承
}
class interimple extends Object implements inter1,inter2,inter3{
//继承了一个Object类和三个接口
}

3.5 抽象类和接口的区别