Apakah kegunaan dan prinsip polimorfisme Java dan kelas abstrak

Kami mengetahui tiga ciri utama Java: enkapsulasi, pewarisan dan polimorfisme. Dua yang pertama telah disebut sebelum ini dalam Pengenalan kepada Java (6). Sekarang mari kita bercakap tentang ciri polimorfisme.

Apakah polimorfisme?

Polymorphism, seperti namanya, bermaksud pelbagai bentuk

Makna polimorfisme dalam Java:

• Hantar mesej kepada objek dan biarkan ini Objek memutuskan sendiri tingkah laku yang akan diterima pakai sebagai tindak balas kepada mesej ini

• Rujukan objek subkelas diberikan kepada pembolehubah rujukan kelas induk untuk melaksanakan panggilan kaedah dinamik

Prasyarat untuk polimorfisme dalam Java:

• Warisan

• Mengatasi kaedah kelas induk

• Transformasi Ke Atas

Penjelasan saya tentang polimorfisme:

Sebagai contoh, kita adalah manusia, pelajar, dan orang muda saya boleh melakukan sesuatu sebagai manusia . , anda juga boleh menggunakan identiti anda sebagai pelajar untuk membeli tiket pelajar, atau anda boleh menggunakan identiti anda sebagai orang muda untuk beramal, supaya kita boleh melakukan perkara yang berbeza dalam bentuk yang berbeza. Adakah ini lebih difahami?

Nota:

Prasyarat polimorfik: mesti ada hubungan kelas anak-ibu bapa.

Apabila memanggil kaedah menggunakan pembolehubah rujukan kelas induk polimorfik, kaedah ganti subkelas akan dipanggil.

Takrifan dan format penggunaan polimorfisme:

Nama pembolehubah jenis kelas induk = jenis subkelas baharu ();

Ciri-ciri ahli dalam polimorfisme:

• Pembolehubah ahli polimorfik: Lihat ke kiri semasa menyusun dan menjalankan

• Kaedah ahli polimorfik: Lihat ke kiri semasa menyusun dan kanan semasa menjalankan

Transformasi polimorfik:

• Transformasi polimorfik terbahagi kepada dua jenis: transformasi ke atas dan transformasi ke bawah

• Transformasi ke atas: berbilang Keadaan itu sendiri ialah proses transformasi menaik

• Format penggunaan: nama pembolehubah jenis kelas induk=jenis subkelas baharu ();

• Senario yang berkenaan : Apabila tidak perlu menghadapi jenis subkelas, operasi yang sepadan boleh diselesaikan dengan meningkatkan kebolehlanjutan atau menggunakan fungsi kelas induk.

• Penukaran ke bawah: Objek subkelas yang telah ditukar ke atas boleh menggunakan format penukaran jenis paksa untuk menukar jenis rujukan kelas induk kepada jenis rujukan subkelas

• Format penggunaan: nama pembolehubah jenis subkelas = (jenis subkelas) pembolehubah jenis kelas induk;

• Penjelasan kod:

  public class Person {     //人类，作为父类使用
      public void speak(){
          System.out.println("我们都是一个人");
      }
  }
  
  
  
  public class Student extends Person{    //继承父类，相当于我们是学生，有人的方法
      @Override
      public void speak(){
          System.out.println("我是人类中的学生");
      }
  }
  
  
  
  public class Child extends Person{   //继承父类，相当于我们是孩子，有孩子的行为
      @Override
      public void speak(){
  
          System.out.println("我是人类中的孩子");
      }
  }
  
  
  
  
  //测试类
  public class TestMain {
      public static void main(String[] args) {
  
  		//父类类型 变量名=new 子类类型();
          Person p = new Student();   //子类对象的引用赋值给父类 
          p.speak(); //多态 相当于这里使用的是Student的方法。输出我是人类中的学生
          //我作为人，我用学生的身份，说出：我是人类中的学生
  
  
  		Person p = new Child(); 
  		p.speak();  //输出：我是人类中的孩子
  		//我作为人，用孩子的身份，说出我是人类中的孩子
  
      }
  }
  
  //这段代码，我们用到了 继承，重写，向上转型，因为多态本来就是向上转型的过程

Peranan polimorfisme:

Selepas memperkenalkan polimorfisme, apakah kegunaan polimorfisme? Mengapa polimorfisme boleh dianggap sebagai tiga ciri utama Java. Mesti ada sebab:

Tingkatkan kebolehgunaan semula kod

• Kurangkan gandingan antara modul

• Di sini saya ingin memperkenalkan kepada anda apakah mekanisme polimorfik? Bagaimanakah bahasa Java melaksanakan polimorfisme? (Ia mungkin agak sukar untuk difahami, dan saya tidak memahami kandungan sepenuhnya, tetapi ini juga merupakan soalan dalam temu bual)

Apa yang dipanggil polimorfisme merujuk kepada jenis khusus yang ditunjukkan oleh pembolehubah rujukan ditakrifkan dalam atur cara dan jenis khusus yang ditunjuk oleh rujukan Panggilan kaedah yang dikeluarkan oleh pembolehubah tidak ditentukan semasa pengaturcaraan, tetapi ditentukan semasa menjalankan program Iaitu, objek contoh kelas yang akan ditunjukkan oleh pembolehubah rujukan kepada, dan panggilan kaedah yang dikeluarkan oleh pembolehubah rujukan ialah kaedah yang dilaksanakan di mana kelas , mesti ditentukan semasa pelaksanaan program. Kerana kelas khusus ditentukan hanya apabila program sedang berjalan, pembolehubah rujukan boleh terikat kepada pelbagai pelaksanaan kelas tanpa mengubah suai kod program sumber, menyebabkan kaedah khusus yang dipanggil oleh rujukan berubah dengan sewajarnya, iaitu, ia tidak perlu diubah suai. Kod atur cara boleh menukar kod tertentu yang terikat pada atur cara semasa ia dijalankan, membolehkan atur cara memilih berbilang keadaan berjalan. Ini adalah polimorfisme. Polimorfisme terbahagi kepada polimorfisme masa kompilasi dan polimorfisme masa larian. Antaranya, polimorfisme masa pengeditan adalah statik dan terutamanya merujuk kepada kaedah yang berlebihan Ia membezakan fungsi yang berbeza berdasarkan senarai parameter yang berbeza, ia akan menjadi dua fungsi yang berbeza. Polimorfisme masa larian adalah dinamik, dan ia dicapai melalui pengikatan dinamik, yang kita panggil polimorfisme.

Untuk memahami polimorfisme, anda juga boleh merujuk kepada sekeping kod:

class People{     //父类
    public void eat(){
        System.out.println("我们会吃饭");
    }
}


class Student extends People{  //继承父类
    @Override
    public void eat(){
        System.out.println("我会吃肉");
    }
    public void study(){
        System.out.println("我们要好好学习");
    }
}


class Teacher extends People{     //继承父类
    @Override
    public void eat(){
        System.out.println("老师会吃蔬菜");
    }
    public void teach(){
        System.out.println("老师要认真上课");
    }
}

//测试类：
public class TestMain {
    public static void main(String[] args) {
        People p=new Stu();      //子类对象的引用赋值给父类 
        p.eat();       //输出： 我会吃肉
    }
}

Kelas abstrak:

Apakah itu kelas abstrak?

Kelas sepunya ialah kelas berfungsi lengkap yang boleh menjana objek termaktub secara langsung dan boleh mengandungi pembina, kaedah biasa, kaedah statik, pemalar dan pembolehubah, dsb. Kelas abstrak merujuk kepada komponen yang menambah kaedah abstrak kepada struktur kelas biasa.

Kaedah abstrak:

Akan ada "{}" di atas semua kaedah biasa, yang mewakili badan kaedah Kaedah dengan badan kaedah boleh digunakan secara langsung oleh objek. Kaedah abstrak merujuk kepada kaedah tanpa badan kaedah, dan kaedah abstrak juga mesti diubah suai dengan kata kunci abstrak. Dalam erti kata lain, kaedah abstrak dalam kelas abstrak tidak perlu ditulis, dan kemudian ditulis semula selepas ia diwarisi.

Kata kunci pengisytiharan kelas abstrak: abstracat

Tentukan kelas abstrak:

public abstract class studnet{//定义一个抽象类
	
	public void study(){                         //普通方法
		System.out.println("我会学习");
	}
	
	public abstract void eat();         //抽象方法，没有方法体，有abstract关键字做修饰
	
}

//注意： 有抽象方法，这个类必须是抽象的！！！

Contoh penjelasan:

Kelas bentuk Bentuk perlu disediakan untuk mengira luas dan kaedah sum Perimeter, tetapi bentuknya sendiri belum ditentukan, maka kaedah pengiraan perimeter dan luas tidak dapat ditentukan Pada masa ini kita perlu menggunakan kelas abstrak dan kaedah abstrak.

由于Shape类计算周长和面积的方法无法确定，那么就可以将这样的方法声明为抽象的，以便在具体的子类中进行实现。

//定义一个shape类，但是没有具体的形状，所以我们定义成抽象类
public abstract class Shape {
    
    private int a;
    public abstract void area(){}     //求面积的方法
    public abstract void perimeter();   //求周长的方法

    public Shape() {    //无参构造
    }

    public Shape(int a) {
        this.a = a;
    }
}

//计算圆形面积的子类

public  abstract class shape {    //有抽象方法的类，则一定是抽象类，需要关键字abstract修饰

        private int a;
        public abstract void area();     //求面积的方法，没有方法体的方法，需要关键字abstract修饰
        public abstract void perimeter();   //求周长的方法
}


//创建计算圆面积和周长的子类，并继承抽象类shape,并重写shape内的方法
public class Circle extends shape{

    public static double pi = 3.14;
    private double r;  //半径


    @Override
    public void area() {
        System.out.println("圆的面积："+Circle.pi*this.r*this.r);
    }

    @Override
    public void perimeter() {
        System.out.println("圆的周长为："+2*Circle.pi*this.r);
    }

    public Circle() {
    }

    public Circle(double r) {  //
        this.r = r;
    }

}


//测试类：
public class TestMain {
    public static void main(String[] args) {
        Circle c = new Circle(5);        //传入半径为：5
        c.area();
        c.perimeter();

    }

}

//输出结果： 圆的面积：78.5
// 圆的周长为：31.400000000000002

抽象方法和抽象类的注意事项：

• 抽象类中是可以有构造函数的，并且构造函数的写法和其它类没有区别，只不过它真正跑起来是因为子类构造函数的super调用，毕竟我们没办法new一个抽象类对象出来，只能把抽象类的构造函数交给子类的构造函数去使用。

• 抽象类中不一定包含抽象方法，但是有抽象方法的类一定是抽象类。

• 抽象类的子类，必须重写父类中所有的抽象方法，如果有一个抽象方法没有重写，都会出现编译错误不给过，这时也可以把子类也声明为抽象类，报错就会消失。

Atas ialah kandungan terperinci Apakah kegunaan dan prinsip polimorfisme Java dan kelas abstrak. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!