java继承与多态学习笔记

多态

向上转型

• 实际上就是创建一个子类对象将其当作父类对象来使用

class Animal1{
    public String name;
    public int age;

    public Animal1(String name, int age) {
        this.name = name;
        this.age = age;//快捷键Alt+Insert
    }

    public void eat() {
        System.out.println(this.name +"正在吃");
    }
}
class Dog extends Animal1{
    public Dog(String name, int age) {
        super(name, age);//快捷键Alt+Enter
    }

    public void bark(){
        System.out.println(this.name+"汪汪叫");
    }
}
class Bird extends Animal1{
    public Bird(String name, int age) {
        super(name, age);
    }

    public void qiqi(){
        System.out.println(this.name+"吱吱叫");
    }
        }
public class Animal {
    public static void main(String[] args) {
        //Dog dog = new Dog();
        Animal1 animal1 = new Dog("小白",3);
        animal1.eat();
        //
    }
}

• 通过父类应用访问的时候，只能访问父类自己特有的，不能访问自己的。如不能访问animal1.bark().

class Animal1{
    public String name;
    public int age;

    public Animal1(String name, int age) {
        this.name = name;
        this.age = age;//Alt+Insert
    }

    public void eat() {
        System.out.println(this.name +"正在吃");
    }
}
class Dog extends Animal1{
    public Dog(String name, int age) {
        super(name, age);//Alt+Enter
    }

    @Override//方法重写的注解
    public void eat() {
        System.out.println(this.name+"正在吃狗粮");
    }

    public void bark(){

        System.out.println(this.name+"汪汪叫");
    }
}

class Bird extends Animal1{
    public Bird(String name, int age) {
        super(name, age);
    }

    public void qiqi(){
        System.out.println(this.name+"吱吱叫");
    }
        }
public class Animal {
    public static void main(String[] args) {
//        Dog dog = new Dog();
        Animal1 animal1 = new Dog("小白",3);
        animal1.eat();
        //animal1.bark();不能访问
    }
}

方法的重写(覆盖/覆写)

• 方法名相同
• 方法的参数列表相同(个数、顺序、类型)
• 方法的返回值相同

动态绑定

• 父类引用 引用子类对象【向上转型】
• 通过父类引用 调用 重写的方法
  

静态绑定

• 在编译的时候就确定调用什么方法

public  void func(){
    }
public void func(int a){
    }

总结

• 静态的方法不能重写

• 被private修饰的方法不能重写

• 被final修饰的方法不能重写【密封方法】

• 如果方法被重写子类的访问权限要>=父类 ，

  private < 包访问权限 < protected < public

发生向上转型的时机

    public void func(Animal1 animal1){
    }//方法传参

public static void main(String[] args) {
        Animal1 animal1 = new Dog("小白",3);//直接赋值

    public static Animal1 func2(){
        return new Dog("小黄",3);
    }//返回值

多态

• 引用的对象不一样，调用同一种方法表现的行为不一样

class Shape {
    public void draw() {
        System.out.println("画一个图案");
    }
}
    class Cycle extends Shape{
        @Override
        public void draw() {
            System.out.println("画一个圆圈");
            }
    }
    class Rect extends Shape{
        @Override
        public void draw() {
            System.out.println("画一个矩形");
        }
    }
    class Triangle extends Shape{
        @Override
        public void draw() {
            System.out.println("画一个三角形");
        }
    }
public class demo0328 {
    public static void drawMap(Shape shape){
        shape.draw();
    }
    public static void main(String[] args) {
        drawMap(new Cycle());
        drawMap(new Rect());
        drawMap(new Triangle());
    }
}

    public static void drawMaps() {
        Rect rect = new Rect();
        Shape shapeCycle = new Cycle();
        Triangle triangle = new Triangle();

        Shape[] shapes = {shapeCycle, rect, rect, shapeCycle, triangle};
        for (Shape shape : shapes) {
            shape.draw();
        }
    }

    public static void main(String[] args) {
        drawMaps();
    }
}

向下转型

public static void main(String[] args) {
        Animal1 animal1 = new Dog("小白",3);
        Dog dog = (Dog)animal1;//小范围给大范围会报错，得强转
        dog.bark();

• 非常不安全
• 强转类型错误在编译阶段不会报错，在运行阶段报错