Analisis contoh polimorfik berorientasikan objek Java

Pemahaman polimorfisme

Apakah polimorfisme? ? Difahamkan secara literal, ia bermaksud pelbagai bentuk, iaitu, objek yang diwujudkan oleh kelas yang berbeza memanggil kaedah yang sama Ia juga boleh difahami bahawa objek dari kelas yang berbeza menghasilkan keadaan yang berbeza selepas tingkah laku yang sama.

Untuk memahami polimorfisme, kita mesti memahami dua perkara utama transformasi menaik dan menulis semula, dan kemudian memahami secara mendalam konsep polimorfisme Selepas membaca transformasi ke atas dan menulis semula, kita akan melihat konsep polimorfisme. , anda akan tiba-tiba menjadi tercerahkan dan mendapat banyak kejelasan sekaligus. Kerana syarat untuk polimorfisme ialah transformasi ke atas, penulisan semula dan pewarisan.

Transformasi ke atas

Pertama sekali, premis polimorfisme ialah warisan Memandangkan ia adalah warisan, mesti ada hubungan antara kelas induk dan subkelas.

Mari kita ingat semula cara mencipta objek subkelas dan objek kelas induk.

class Animal{
    public String name;//名字
    public int age;
    public void eat() {
        System.out.println("我要吃饭！！！");
    }
    public void sleep() {
        System.out.println("我要睡觉！！！");
    }
}
class Cat extends Animal{
    public void mew() {
        System.out.println("喵喵喵！！！");
    }
}
public class TestDemo1 {
    public static void main(String[] args) {
         Cat cat =new Cat();//实例化子类对象
         cat.name="mimi";
         Animal animal = new Animal();//实例化父类对象
         animal.eat();
    }
}

Kelas Kucing dicipta di sini dan kemudian mewarisi kelas Haiwan. Kita boleh memanggil kaedah dan sifat dengan membuat seketika objek Kucing dan Haiwan.

Kemudian apakah transformasi ke atas? ? ?

Pada asalnya, rujukan objek subkelas merujuk kepada objek subkelas, dan kini rujukan kelas induk merujuk kepada objek subkelas Ini ialah transformasi ke atas.

Mari kita gunakan kod untuk memahami:

Ini ialah transformasi ke atas, kita juga boleh menggunakan rujukan kelas induk kaedah Panggilan haiwan;

Kemudian kita akan mendapati bahawa menggunakan rujukan ini boleh memanggil kaedah dan sifat kelas induk, tetapi tidak boleh memanggil kaedah dan sifat subkelas, jadi kenapa? ? Sebabnya ialah kelas induk tidak mempunyai kaedah ini dalam subkelas, jadi ia tidak boleh dipanggil. Ringkasan: Semasa transformasi ke atas, rujukan kelas induk merujuk kepada objek subkelas Rujukan kelas induk ini hanya boleh memanggil atribut dan kaedah kelas induk, tetapi bukan subkelas.

Tiga bentuk transformasi menaik

Yang pertama: tugasan langsung

Iaitu, cara kami menulisnya di atas:

  Animal animal1 = new Cat();//父类对象的引用 引用子类对象--->向上转型
  Animal animal2 = new Dog();

Jenis kedua : sebagai parameter kaedah:

Jenis ketiga adalah sebagai nilai pulangan:

Mari kita kembali ke hasil cetakan tadi What is;

Tetapi bagaimana jika saya menukar kaedah kelas ibu bapa untuk mengatakan saya mahu makan makanan kucing? Hasilnya tidak mengejutkan apabila mimi ingin makan makanan kucing.

Tetapi ini akan menyebabkan masalah Jika saya membuat kelas anjing dan kemudian memanggil kaedah makan, adakah anjing juga perlu makan makanan kucing? Ini akan menyebabkan masalah, kemudian kita boleh menulis kaedah makan dalam subkelas;

class Animal{
    public String name;//名字
    public int age;
    public void eat() {
        System.out.println(this.name+"要吃饭！！！");
    }
}
class Dog extends Animal{
    public void dark() {
        System.out.println("汪汪汪！！！");
    }
    public void eat() {
        System.out.println(this.name+"吃狗粮！！！");
    }
}
class Cat extends Animal{
    public void mew() {
        System.out.println("喵喵喵！！！");
    }
    public void eat() {
        System.out.println(this.name+"吃猫粮！！！");
    }
}
public class TestDemo1 {
    public static void main(String[] args) {
        //语法形式 : 父类 变量 = new 子类();
        Animal animal1 = new Cat();//父类对象的引用 引用子类对象--->向上转型
        Animal animal2 = new Dog();//父类对象的引用 引用子类对象--->向上转型
        animal1.name = "小猫";//访问父类属性
        animal2.name = "小狗";//访问父类属性
        animal1.eat();
        animal2.eat();
        // animal.mew();//访问子类特有的方法
    }
}

Pada masa ini, kelas anjing dicipta, dan kemudian dua kaedah makan dicipta dalam dua subkelas.

Kami mendapati ia menjadi sangat jelas pada masa ini bahawa kami mencapai kesan yang kami inginkan.

Tetapi kita harus memikirkannya sekali lagi, mengapa memanggil kaedah makan subkelas dan bukannya kelas induk?

Pengikatan dinamik dan pengikatan statik

Pengikatan dinamik sebenarnya berlaku pada masa ini Kita boleh melihat fail bytecode dan membuka tetingkap powershell

<. 🎜>Kita semua tahu bahawa untuk melaksanakan program, anda perlu menyusunnya terlebih dahulu dan kemudian menjalankannya Dalam kes ini, kaedah makan Haiwan dipanggil semasa menyusun, dan kaedah Cat dipanggil semasa menjalankan atau kita boleh katakan pengikatan dinamik.

Kemudian memandangkan terdapat pengikatan dinamik, mesti ada pengikatan statik juga.

Pengikatan dinamik adalah untuk memanggil kaedah pada masa penyusunan, dan kaedah akhir yang akan dipanggil ditentukan pada masa jalan, iaitu kaedah yang akan dipanggil ditentukan pada masa jalan.

Ikatan statik bermaksud kaedah untuk memanggil telah ditentukan semasa penyusunan.

Antaranya, wakil yang paling jelas bagi pengikatan dinamik ialah penulisan semula kaedah.

Wakil pengikatan statik yang paling jelas ialah kaedah terlebih beban.

Mari kita lihat kembali kaedah di atas ε=(´ο｀*)))...mengapa nilai pulangan, senarai parameter dan nama kaedah kaedah makan sebelumnya semuanya adalah Woolen yang sama kain? Mari kita lihat.

Penulisan semula kaedah

Kami telah mempelajari tentang kaedah terlebih muatan sebelum ini nilai adalah berbeza untuk membuat permintaan, senarai parameter adalah berbeza. Penulisan semula kaedah yang kami pelajari hari ini bermakna nilai pulangan adalah sama, nama kaedah adalah sama, dan senarai parameter adalah sama Ia dipanggil penulisan semula kaedah, tetapi ia juga boleh dipanggil penulisan ganti kaedah.

Terdapat beberapa keperluan untuk penulisan semula kaedah:

Penulisan semula kaedah mesti mempunyai nama kaedah yang sama, senarai parameter kaedah yang sama dan nilai pulangan kaedah yang sama.

Kami juga boleh menjana penulisan semula dengan satu klik

有几个注意事项：

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

不能重写被final修饰的方法。

子类的方法的访问权限一定要大于等于父类的访问权限。

重写的方法, 可以使用 @Override 注解来显式指定. 有了这个注解能帮我们进行一些合法性校验. 例如不小心将方法名字拼写错了 (比如写成eat）, 那么此时编译器就会发现父类中没有 aet 方法, 就会编译报错, 提示无法构成重写.

被static修饰的方法也不能被重写

总结方法重写的注意事项：

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

• 被staitc修饰的方法也不能被重写。

• @override 可以检查你重写的方法名是否正确，最好要加上。

• 方法重写一定满足方法名相同，参数列表相同，返回值相同。

对比方法重写与方法重载：

最后：重写不是进行在原来基础的修改，而是在原来基础上进行迭代和更新。

进一步认识和理解多态

场景：画一个图形

class Shape{//创建一个图形类---->作为多种图形的父类
    public int length;//图形的长
    public int wide;//图形的宽
    public int height;//图形的高
    public void draw() {
        System.out.println("我要画一个图形！！！");
    }
}
class rectangle extends Shape{//长方形
    @Override
    public void draw() {
        System.out.println("我要画一个长方形！！！");
    }
}
class square extends Shape{
    @Override
    public void draw() {
        System.out.println("我要画一个正方形！！！");
    }
}
class circular extends Shape{
    @Override
    public void draw() {
        System.out.println("我要画一个圆形！！！");
    }
}
public class TestDemo1 {
    public static void method(Shape shape) {
        shape.draw();
    }
    public static void main(String[] args) {
        Shape shape1 = new circular();
        Shape shape2 = new rectangle();
        Shape shape3 = new square();
        method(shape1);
        method(shape2);
        method(shape3);
    }
}

创建一个Shape(父类)，然后创建三个子类分别是square ,circular,rectangle,利用父类引用这三个子类，接着调用method方法。

这就是多态，不同的对象，调用同一个方法最后结果产生出不同的状态。

我们再来总结多态产生的条件：

• 要在继承体系下

• 子类要对父类的方法进行重写

• 通过父类的引用调用重写的方法 

也就是 在继承体系下  进行向上转型  和 方法重写

多态的优点

优点：

• 能够降低代码的 "圈复杂度", 避免使用大量的 if - else

• 如果使用多态, 则不必写这么多的 if - else 分支语句, 代码更简单.

• 可扩展能力更强

缺点：

• 代码的运行效率降低

还有一个重要点就是不要在构造方法中调用重写方法

Atas ialah kandungan terperinci Analisis contoh polimorfik berorientasikan objek Java. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!