Java~面向对象编程多态的理解、抽象类、接口

多态的理解：
在设计一个方法时，通常希望该方法具备一定的通用性。例如要实现一个动物叫的方法，由于每种动物的叫声是不同的，因此可以在方法中接收一个动物类型的参数，当传入猫类对象时就发出猫类的叫声，传入犬类对象时就发出犬类的叫声。在同一个方法中，这种由于参数类型不同而导致执行效果各异的现象就是多态。
简而言之：
在Java中为了实现多态，允许使用一个父类类型的变量来引用一个子类类型的对象，根据被引用子类对象特征的不同，得到不同的运行结果。
在这里插入图片描述
注意：
继承、方法重写、向上转型是多态得以实现的基础。
抽象类：
针对上面wom描述的情况，Java允许在定义方法时不写方法体，不包含方法体的方法为抽象方法，抽象方法必须使用abstract关键字来修饰，具体示例如下：
在这里插入图片描述
当一个类中包含了抽象方法，该类必须使用abstract关键字来修饰，使用abstract关键字修饰的类为抽象类，具体示例如下：

抽象类总结：包含抽象方法的类，我们把它叫做抽象类

1、用关键字abstract进行修饰
2、在抽象类当中可以有普通类的所有属性或者方法
3、和普通的类不一样的地方就是，包含了抽象方法。
4、和普通的类不一样的地方就是他不能够被实例化
```
 Shape shape = new Shape();
```
5、抽象类的主要作用就是用来被继承的
6、抽象类就是用来被继承的所以：不能被final所修饰
```
 final abstract class Shape
```
7、抽象方法也不能是私有的或者是 static的
8、只要有一个类，继承了这个抽象类那么必须要重写抽象类当中的抽象方法。
9、如果这个类，不想重写抽象类里面的抽象方法，

  那么此时这个类也可以设置为抽象类。

接口：
如果一个抽象类中的所有方法都是抽象的，则可以将这个类用另外一种方式来定义，即接口。接口是由常量和抽象方法组成的特殊类，是对抽象类的进一步抽象。
在定义接口时，需要使用interface关键字来声明，其语法格式如下：
在这里插入图片描述
接口注意事项：

1、interface关键字修饰
2、里面的数据成员必须是一个常量.
```
public  static  final  int a = 10;
```
3、里面的成员方法是默认为：public abstract
4、在接口当中不能够定义一个已经实现的方法。
5、JDK1.8新特性：接口当中可以有实现的方法但是这个方法一定是被default修饰的
6、类和接口的关系：实现–》implements 可以实现继承多个接口
7、解决了java当中单继承的问题可以变为多继承
8、实现该接口一定要重写该接口当中的方法
9、接口仍然是不可以被实例化的

扫描二维码关注公众号，回复： 11238416 查看本文章
10、实现该接口的重写方法的时候，一定不能够省略public
接口将功能进行独立
接口是不能被接口实现的
== 接口和接口之前可以通过extends进行联系==
一个接口可以extends多个接口
示例如下：

代码如下：

public abstract class Animal {
    private String name;
    private String color;

    public String getName() {
        return name;
    }

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

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public abstract void eat();

    public abstract void sleep();

    public Animal() {

    }

    public Animal(String name, String color) {
        this.name = name;
        this.color = color;
    }
}
public interface IRunning {
    void run();
}
public interface Iwalking {
    void walk();
}
public interface ISwimming {
    void swim();
}
public interface IFlying {
    void fly();
}
public class fish extends Animal implements ISwimming {
    public void eat() {
        System.out.println("fish eat little fish");
    }

    public void sleep() {
        System.out.println("fish sleep in walter");
    }

    public void swim() {
        System.out.println("fish can swim");
    }

    public fish(String name, String color) {
        super(name, color);
    }
}
public class Forg extends Animal implements Iwalking, IRunning, ISwimming {
    @Override
    public void eat() {
        System.out.println("forg eat small animals");
    }

    @Override
    public void sleep() {
        System.out.println("forg sleep on leaf");
    }

    @Override
    public void run() {
        System.out.println("forg can run");
    }

    @Override
    public void swim() {
        System.out.println("forg can swim");
    }

    @Override
    public void walk() {
        System.out.println("forg can walk");
    }

    public Forg(String name, String color) {
        super(name, color);
    }
}
public class Duck extends Animal implements ISwimming, IRunning, Iwalking, IFlying {
    private String kind;

    public String getKind() {
        return kind;
    }

    public void setKind(String kind) {
        this.kind = kind;
    }

    @Override
    public void eat() {
        System.out.println("duck eat seed");
    }

    @Override
    public void sleep() {
        System.out.println("duck sleep on land");
    }

    @Override
    public void fly() {
        System.out.println("duck can fly");
    }

    @Override
    public void run() {
        System.out.println("duck can run");
    }

    @Override
    public void swim() {
        System.out.println("duck can swim");
    }

    @Override
    public void walk() {
        System.out.println("duck can walk");
    }

    public Duck(String name, String color) {
        super(name, color);
    }
}
import java.time.chrono.IsoChronology;

public class Test {

    public static void swim(ISwimming iSwimming) {
        iSwimming.swim();
    }

    public static void run(IRunning iRunning) {
        iRunning.run();
    }

    public static void fly(IFlying iFlying) {
        iFlying.fly();
    }

    public static void walk(Iwalking iwalking) {
        iwalking.walk();
    }

    public static void main(String[] args) {
        ISwimming forg = new Forg("wawa", "black");
        ISwimming duck = new Duck("dudu", "write");
        forg.swim();
        duck.swim();
        System.out.println("======================");
        Forg forg1 = new Forg("YY", "red");
        fish fish = new fish("XX", "black");
        Duck duck2 = new Duck("LLL", "yellow");
        swim(forg1);
        swim(fish);
        swim(duck2);
        run(duck2);
        walk(forg1);
        fly(duck2);
        System.out.println("==============");
        Animal animal = new fish("anan", "red");
        Animal animal1 = new Duck("aaa", "ccc");
        animal.eat();
        animal1.eat();
        System.out.println(animal.getColor());
        Duck duck1 = new Duck("ccc", " sss");
        duck1.setKind("write sky duck");
        System.out.println(duck1.getKind());
    }
}

运行结果：

forg can swim
duck can swim
======================
forg can swim
fish can swim
duck can swim
duck can run
forg can walk
duck can fly
==============
fish eat little fish
duck eat seed
red
write sky duck

Process finished with exit code 0

Java~面向对象编程多态的理解、抽象类、接口

猜你喜欢