Kaedah statik

1. Kaedah statik

Selain pembolehubah statik, kelas juga boleh mempunyai kaedah statik.

Kaedah biasa terikat pada objek (contoh) kelas dan boleh merujuk kepada pembolehubah biasa (bukan statik) kelas (serta pembolehubah statik dan kaedah ). Kaedah statik terikat pada objek statik kelas dan hanya boleh mengakses pembolehubah statik dan/atau kaedah statik kelas lain.

Untuk memanggil kaedah biasa (bukan statik) pada kelas, anda mesti mencipta objek kelas dahulu dan kemudian memanggil kaedah pada objek. Anda tidak boleh memanggil kaedah biasa pada kelas dan bukannya objek.

Contoh:

public class DataInfo
{
   public int getValue()
   {
      return 100;
   }
}

public class Solution
{
   public static void main(String[] args)
   {
      System.out.println(DataInfo.getValue()); // This will generate an error!
   }
}

Tetapi untuk memanggil kaedah statik, cukup untuk objek statik kelas hanya wujud (dan ia sentiasa wujud selepas kelas dimuatkan ke dalam memori). Inilah sebabnya kaedah main() adalah statik. Ia terikat pada objek statik kelas, jadi anda tidak perlu mencipta sebarang objek untuk memanggilnya.

Untuk mengisytiharkan kaedah statik, anda perlu menulis kata kunci statik sebelum pengepala kaedah. Penampilan umum binaan ini adalah seperti berikut:

static Type name(parameters)
{
   method code
}

Contoh:

public class Solution
{
   public static void main(String args[])
   {
      test();
   }

   public static void test()
   {
      int d = 2/0;
   }
}

Untuk memanggil kaedah statik dari kelas lain, anda perlu menentukan nama kelas sebelum nama kaedah statik. Penampilan umum binaan ini adalah seperti berikut:

Type name = ClassName.methodName(arguments)

Contoh:

int x = Math.min(a, b);

int min(int a, int b)

Thread.sleep(200);

void sleep(long ms)

Path path = Path.of("c:\\readme.txt");

Path of(String str)

2. Kaedah statik vs biasa (bukan statik).

Apakah perbezaan antara kaedah statik dan kaedah biasa?

Kaedah biasa terikat pada objek biasa (contoh kelas), manakala kaedah statik tidak. Kaedah biasa boleh mengakses pembolehubah dalam contohnya, tetapi kaedah statik tidak boleh: ia hanya tidak mempunyai contoh yang berkaitan.

Perbezaan antara dua jenis kaedah dinyatakan dalam jadual berikut:

Mengapakah kaedah sedemikian diperlukan jika ia sangat terhad? Jawapannya ialah pendekatan ini juga ada kelebihannya.

Pertama, anda tidak perlu menghantar sebarang rujukan objek untuk mengakses kaedah dan pembolehubah statik.

Kedua, kadangkala anda perlu ada hanya satu contoh pembolehubah. Sebagai contoh, System.out( pembolehubah keluar statik kelas Sistem ).

Dan, ketiga, kadangkala anda perlu memanggil kaedah sebelum ia mungkin untuk mencipta objek. Sebagai contoh, mesin Java memanggil kaedah main() untuk memulakan pelaksanaan program walaupun sebelum contoh kelas dibuat.

Terikat kepada contoh kelas

Apabila kaedah biasa dipanggil, hujah - objek yang kaedah dipanggil - secara tersirat dihantar kepadanya. Parameter ini dipanggil this. Parameter tersirat ini (rujukan kepada objek yang kaedah dipanggil) membezakan kaedah biasa daripada kaedah statik.

Kaedah statik tidak mempunyai parameter tersirat ini, jadi anda tidak boleh menggunakan thiskata kunci dalam kaedah statik dan anda tidak boleh memanggil kaedah bukan statik dalam kaedah statik. Tiada tempat untuk mendapatkan rujukan kepada contoh kelas.

Boleh memanggil kaedah biasa kelas

Kaedah biasa sentiasa mempunyai thisparameter tersirat, jadi anda sentiasa mempunyai rujukan kepada objek yang kaedah dipanggil. Setiap kali anda memanggil kaedah biasa dalam kaedah biasa lain, thisparameter tersirat digunakan untuk membuat panggilan itu. Contoh

int min(int a, int b)
{
   return a < b ? a : b;
}

int min(int a, int b, int c)
{
   int t = min(a, b);
   return min(t, c);
}

int min(int a, int b)
{
   return a < b ? a : b;
}

int min(int a, int b, int c)
{
   int t = this.min(a, b);
   return this.min(t, c);
}

Itulah sebabnya anda tidak boleh memanggil kaedah biasa daripada kaedah statik. Tiada pembolehubah tersirat yang dinamakan thisdi dalam kaedah statik.

Atau bayangkan situasi lain: belum ada satu pun objek kelas kami yang dicipta dalam program kami. Bolehkah kita memanggil kaedah statik kelas kita? ya. Dan bolehkah kaedah statik ini memanggil kaedah biasa (bukan statik)?

Nah, objek apa yang akan kita panggil? Lagipun, belum ada satu pun contoh kelas kami yang wujud!

Boleh memanggil kaedah statik kelas

Kaedah statik boleh dipanggil dari mana-mana — dari mana-mana tempat dalam program. Ini bermakna bahawa mereka boleh dipanggil dari kedua-dua kaedah statik dan yang biasa. Tiada sekatan di sini.

Boleh mengakses pembolehubah biasa kelas

Anda boleh mengakses pembolehubah biasa kelas daripada kaedah biasa, kerana ia boleh mendapatkan rujukan dengan mudah kepada contoh kelas melalui thisparameter tersirat.

Kaedah statik tidak mengetahui contoh kelas yang harus digunakan untuk mendapatkan nilai pembolehubah biasa. Dan secara amnya, kita boleh dengan mudah mempunyai situasi di mana kaedah statik dipanggil tetapi belum ada satu contoh kelas pun dicipta dalam atur cara.

Akibatnya, kaedah statik tidak boleh mengakses pembolehubah biasa kelas.

Katakan kaedah statik memanggil kaedah biasa. Apakah objek yang harus dipanggil kaedah biasa itu?

Tiada sesiapa yang tahu! Itulah sebabnya anda tidak boleh memanggil kaedah biasa daripada kaedah statik tanpa memberikan rujukan kepada objek!

Boleh mengakses pembolehubah statik kelas

Situasi dengan panggilan kepada pembolehubah statik adalah sama seperti dengan panggilan kepada kaedah statik. Pembolehubah statik boleh diakses dari mana-mana dalam program. Ini bermakna anda boleh mengaksesnya daripada kaedah statik dan biasa.

Boleh dipanggil pada objek

Kedua-dua kaedah statik dan biasa boleh dipanggil pada objek. Panggilan kaedah biasa mungkin — sememangnya, itulah satu-satunya cara untuk memanggil kaedah biasa. Kaedah statik juga boleh dipanggil pada objek: dalam kes ini pengkompil sendiri menentukan jenis pembolehubah dan memanggil kaedah statik berdasarkan jenisnya:

Thread th = Thread.current();
th.sleep(1000);

Thread th = Thread.current();
Thread.sleep(1000);

Integer i = 1;
int x = i.parseInt("12");

Integer i = 1;
int x = Integer.parseInt("12");

"".valueOf(12);

String.valueOf(12);

Boleh dipanggil masuk kelas

Anda hanya boleh memanggil kaedah statik pada kelas. Untuk memanggil kaedah biasa, anda memerlukan rujukan kepada contoh kelas. Oleh itu, anda tidak boleh memanggil kaedah biasa menggunakan binaan ini:ClassName.methodName(arguments)