Kuasai polimorfisme berorientasikan objek JAVA dalam satu artikel

Artikel ini membawakan anda pengetahuan yang berkaitan tentang java, yang terutamanya memperkenalkan isu berkaitan polimorfisme ialah ciri penting pengaturcaraan berorientasikan objek dan mempunyai berbilang bentuk pada masa yang sama merujuk kepada pelbagai bentuk objek Mari kita lihat bersama-sama.

Kajian yang disyorkan: "tutorial video java"

1. Konsep

Polymorphism ialah berorientasikan objek program Ciri penting reka bentuk (OOP) ialah entiti yang sama mempunyai pelbagai bentuk pada masa yang sama, iaitu objek yang sama mewakili objek berbeza pada masa yang berbeza, yang merujuk kepada pelbagai bentuk objek.

Anda boleh menganggap objek subkelas yang berbeza sebagai kelas induk, dengan itu melindungi perbezaan antara objek subkelas yang berbeza, menulis kod universal, membuat pengaturcaraan universal dan menyatukan piawaian panggilan.

Sebagai contoh, teman wanita anda meminta anda membeli buah-buahan Tidak kira apa yang anda beli adalah epal atau tembikai, asalkan ia buah, ini adalah manifestasi kepelbagaian dalam kehidupan

<.>Untuk contoh lain, Kita boleh mengklasifikasikan anak kucing, anak anjing, dan anak babi kepada haiwan kecil Setiap haiwan kecil perlu makan, jadi kita boleh menetapkan secara seragam bahawa mereka semua mesti makan, tetapi tabiat setiap haiwan kecil adalah berbeza, jadi ini adalah. Ia boleh ditetapkan kepada fungsi unik haiwan kecil Objek polimorfik hanya boleh memanggil fungsi yang ditindih dalam subkelas yang ditakrifkan dalam kelas induk, dan tidak boleh memanggil fungsi unik subkelas Ini mencapai penyatuan kod >

2. Ciri

Premis 1 polimorfisme: pewarisan

1. Premis 2 polimorfisme: kaedah mengatasi
2. mata rujukan kelas induk kepada Subkelas Objek, seperti sebagai: Animal a = new Cat();
3. Dalam polimorfisme, lihat ke kiri semasa menyusun, dan lihat ke kanan apabila berlari
4. 
   
3. Latihan: Kes Bermula Polimorfisme

Cipta pakej: cn.tedu.oop

Cipta kelas: TestDemo.java

4

package cn.tedu.oop2;/*本类用作多态的入门案例*/public class TestDemo {
    public static void main(String[] args) {
        //6.创建“纯纯的”对象用于测试
        Animal a = new Animal();
        Cat c = new Cat();
        Dog d = new Dog();
        a.eat();//小动物Animal吃啥都行~调用的是父类自己的功能
        c.eat();//小猫爱吃小鱼干~调用的是子类重写后的功能
        d.eat();//小狗爱吃肉骨头~调用的是子类重写后的功能
        /*2.父类对象不可以使用子类的特有功能*/
        //a.jump();//报错，Animal类里并没有这个方法
        //a.run();//报错，Animal类里并没有这个方法
        c.jump();//小猫Cat跳的老高啦~,子类可以调用自己的功能
        d.run();//小狗Dog跑的老快啦~,子类可以调用自己的功能

        //7.创建多态对象进行测试
        /*3.口诀1：父类引用指向子类对象
        * 解释：创建出来的子类对象的地址值，交给父类类型的引用类型变量来保存*/
        Animal a2 = new Cat();//Cat类对象的地址值交给父类型变量a2来保存
        Animal a3 = new Dog();//Dog类对象的地址值交给父类型变量a3来保存
        //8.测试多态对象
        /*4.口诀2：编译看左边，运行看右边
        * 解释：必须要在父类定义这个方法，才能通过编译，把多态对象看作是父类类型
        *      必须要在子类重写这个方法，才能满足多态，实际干活的是子类*/
        a2.eat();//小猫爱吃小鱼干~，多态对象使用的是父类的定义，子类的方法体
    }}/*1.多态的前提：继承+重写*///1.创建父类class Animal{
    //3.创建父类的普通方法
    public void eat(){
        System.out.println("小动物Animal吃啥都行~");
    }}//2.1创建子类1class Cat extends Animal{
    //4.1添加重写的方法
    public void eat(){
        System.out.println("小猫爱吃小鱼干~");
    }
    //5.1添加子类的特有功能
    public void jump(){
        System.out.println("小猫Cat跳的老高啦~");
    }}//2.2创建子类2class Dog extends Animal{
    //4.2添加重写的方法
    @Override
    public void eat(){
        System.out.println("小狗爱吃肉骨头~");
    }
    //5.2添加子类的特有功能
    public void run(){
        System.out.println("小狗Dog跑的老快啦~");
    }}

Many State membenarkan kita menggunakan kaedah tertentu objek tanpa mengambil berat tentang jenis objek tertentu

Ia meningkatkan kebolehskalaan dan kebolehselenggaraan program

1. 5. Gunakan polimorfisme
2. Prasyarat: Objek polimorfik menganggap diri mereka sebagai jenis kelas induk

pembolehubah ahli: gunakan

ahli kelas induk Kaedah: Disebabkan oleh timpa ganti fenomena,

1. ahli statik subkelas digunakan: ia dimuatkan semasa kelas dimuatkan, dan sesiapa yang memanggilnya akan mengembalikan
2. 6. Latihan : Ahli polimorfik menggunakan ujian
3. Buat pakej: cn.tedu.oop

Cipta kelas: TestDemo2.java

7 Sambungan

package cn.tedu.oop2;/*本类用于测试多态成员的使用情况*/public class TestDemo2 {
    public static void main(String[] args) {
        //7.创建纯纯的子类对象
        Dog2 d = new Dog2();
        System.out.println(d.sum);//20,子类自己的属性
        d.eat();//小狗爱吃肉包子,子类自己的方法

        //8.创建多态对象
        /*口诀1：父类引用指向子类对象*/
        /*口诀2：编译(保存)看左边，运行(效果)看右边*/
        Animal2 a = new Dog2();
        /*多态中，成员变量使用的是父类的*/
        System.out.println(a.sum);//10
        /*多态中，方法的声明使用的是父类的，方法体使用的是子类的*/
        a.eat();//小狗爱吃肉包子
        /*多态中，调用的静态方法是父类的，因为多态对象把自己看作是父类类型
        * 直接使用父类中的静态资源*/
        a.play();//没有提示，玩啥都行~
        Animal2.play();
    }}//1.创建父类class Animal2{
    //3.创建父类的成员变量
    int sum = 10;
    //4.创建父类的普通方法
    public void eat(){
        System.out.println("吃啥都行~");
    }
    //9.1定义父类的静态方法play
    public static void play(){
        System.out.println("玩啥都行~");
    }}//2.创建子类class Dog2 extends Animal2{
    //5.定义子类的成员变量
    int sum = 20;
    //6.重写父类的方法
    @Override
    public void eat(){
        System.out.println("小狗爱吃肉包子");
    }
    //9.2创建子类的静态方法play
    //@Override
    /*这不是一个重写的方法，只是恰巧在两个类中出现了一模一样的两个静态方法
    * 静态方法属于类资源，只有一份，不存在重写的现象
    * 在哪个类里定义，就作为哪个类的资源使用*/
    public static void play(){
        System.out.println("小狗喜欢玩皮球~");
    }}

Kes Komprehensif Kereta Reka Bentuk 7.1

Buat pakej: cn.tedu.oopexec Cipta kelas: DesignCar.java

7.2 Polimorfisme untuk piawaian panggilan bersatu

package cn.tedu.oop2;/*本类用于完成汽车设计案例*/public class DesignCar {
    public static void main(String[] args) {
        //9.创建一个纯纯的父类对象进行测试
        Car c = new Car();
        System.out.println(c.getColor());//null
        c.start();
        c.stop();
        //c.swim();//报错，父类对象不可以调用子类的特有功能

        //10.创建纯纯的子类对象做测试
        BMW b = new BMW();
        System.out.println(b.color);//五彩斑斓的黑
        System.out.println(b.getColor());//null
        b.start();//都让开，我的车要起飞啦~
        b.stop();//唉呀妈呀熄火了~

        //11.创建多态对象进行测试
        Car c2 = new TSL();
        //System.out.println(c2.color);
        System.out.println(c2.getColor());
        c2.stop();
        c2.start();
        //c2.swim();
    }}//1.通过分析，抽象形成一个汽车类class Car{
    //2.定义并封装汽车类的属性--成员变量
    private String brand;//品牌
    private String color;//颜色
    private int id;//编号
    private double price;//价格

    //3.定义功能
    public void start(){
        System.out.println("我的小车车启动啦~");
    }
    public void stop(){
        System.out.println("唉呀妈呀熄火了~");
    }

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public String getColor() {
        return color;
    }

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

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }}//4.创建子类class BMW extends Car{
    String color = "五彩斑斓的黑";
    //5.重写父类的方法
    @Override
    public void start(){
        System.out.println("都让开，我的车要起飞啦~");
    }}//6.创建子类2class TSL extends Car{
    //7.重写父类的方法
    @Override
    public void stop(){
        System.out.println("唉呀妈，怎么停不下来呢");
    }
    //8.添加子类的特有功能
    public void swim(){
        System.out.println("没想到吧，我还是个潜水艇");
    }}

7.3 Perbezaan antara pembolehubah statik dan pembolehubah contoh

package cn.tedu.oop2;public class TestFruit {
    public static void main(String[] args) {
        Fruit f = new Fruit();
        Apple a = new Apple();
        Orange o = new Orange();
        get(f);
        get(a);
        get(o);
    }
    //只需要创建一个方法，就可以执行截然不同的效果
    //忽略子类对象的差异统一看作父类类型
    public static void get(Fruit f){
        f.clean();
    }}class Fruit{
    public void clean(){
        System.out.println("水果要洗洗再吃");
    }}class Apple extends Fruit{
    @Override
    public void clean(){
        System.out.println("苹果需要削皮");
    }}class Orange extends Fruit{
    @Override
    public void clean(){
        System.out.println("橙子需要剥皮");
    }}

Perbezaan dalam definisi sintaks: pembolehubah statik mesti didahului oleh kata kunci statik, manakala pembolehubah contoh Jangan tambahkannya sebelum ini. Perbezaan apabila atur cara dijalankan: Pembolehubah instance tergolong dalam atribut objek Suatu objek instance mesti dibuat sebelum pembolehubah instance di dalamnya akan diperuntukkan ruang, dan kemudian pembolehubah instance ini boleh digunakan. Pembolehubah statik bukan milik objek contoh, tetapi ke dalam kelas, jadi ia juga dipanggil pembolehubah kelas Selagi program memuatkan kod bait kelas tanpa mencipta sebarang objek contoh, pembolehubah statik akan diperuntukkan ruang, dan pembolehubah statik. pembolehubah statik boleh digunakan. Ringkasnya, pembolehubah contoh mesti mencipta objek sebelum ia boleh digunakan melalui objek ini, manakala pembolehubah statik boleh dirujuk terus menggunakan nama kelas.

7.4 Transformasi ke atas dan transformasi ke bawah

Dalam JAVA, pewarisan ialah ciri penting Melalui kata kunci lanjutan, subkelas boleh menggunakan semula fungsi kelas induk , jika kelas induk tidak dapat memenuhi keperluan subkelas semasa, subkelas boleh mengatasi kaedah dalam kelas induk untuk melanjutkannya. Kemudian terdapat aplikasi polimorfik dalam proses ini. Terdapat dua cara transformasi, iaitu: transformasi ke atas dan transformasi ke bawah. Transformasi ke atas: Anda boleh menganggap objek subkelas yang berbeza sebagai kelas induk, dengan itu melindungi perbezaan antara objek subkelas yang berbeza, menulis kod universal, membuat pengaturcaraan universal dan menyatukan piawaian panggilan.

Contohnya: kelas induk Parent, subclass Child

Rujukan kelas induk menunjuk pada objek subclass: Parent p=new Child();
Nota: Apabila transformasi ke atas, objek subclass dianggap sebagai objek kelas induk, hanya Boleh memanggil fungsi kelas induk Jika subkelas mengatasi kaedah yang diisytiharkan dalam kelas induk, badan kaedah melaksanakan fungsi subkelas yang ditindih. Tetapi pada masa ini, objek menganggap dirinya sebagai jenis induk, jadi sumber lain masih menggunakan jenis induk.
Contohnya: Hua Mulan menyertai tentera untuk bapanya tidak dibenarkan memakai solek di kem tentera.

Transformasi ke bawah (kurang): Rujukan subkelas menunjuk kepada objek subkelas, dan transformasi paksa mesti diterima pakai dalam proses. Ini kerana objek subkelas yang telah diubah ke atas sebelum ini masih mahu melaksanakan fungsi unik subkelas, jadi ia perlu dipulihkan kepada objek subkelas
Induk p = new Child();//transformasi ke atas, pada kali ini, p ialah jenis Parent
Child c = (Child)p;//Pada masa ini, tukar jenis Parent p kepada jenis kecil Child
Malah, ia bersamaan dengan mencipta objek subkelas. Anda boleh menggunakan kelas induk atau My own
Nota: Transformasi ke bawah adalah untuk memudahkan penggunaan kaedah khas subkelas Maksudnya, apabila fungsi kaedah subkelas dikembangkan, fungsi subkelas boleh digunakan secara langsung.
Contohnya: Selepas perang Hua Mulan tamat, dia tidak perlu lagi dianggap sebagai bapanya, dan dia boleh “melihat cermin kuning”

Kajian yang disyorkan: "tutorial video java "

Atas ialah kandungan terperinci Kuasai polimorfisme berorientasikan objek JAVA dalam satu artikel. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!