#Java #polymorphism #Java11 #Programming #tutorial ## java 11 đa hình
Đa hình là một tính năng mạnh mẽ của Java cho phép bạn viết mã có thể được sử dụng với các loại dữ liệu khác nhau.Điều này có thể làm cho mã của bạn linh hoạt hơn và dễ bảo trì hơn.
Có hai loại đa hình trong Java:
*** Biên dịch đa hình thời gian **, còn được gọi là ** đa hình tĩnh **, xảy ra khi bạn có một phương pháp có cùng tên nhưng các chữ ký khác nhau.Trình biên dịch có thể xác định phương thức nào để gọi vào thời điểm biên dịch dựa trên loại đối tượng được truyền cho phương thức.
*** Đa hình thời gian chạy **, còn được gọi là ** đa hình động **, xảy ra khi bạn có một phương pháp có cùng tên nhưng các triển khai khác nhau trong các lớp khác nhau.Hệ thống thời gian chạy Java xác định phương thức nào sẽ gọi khi chạy dựa trên loại đối tượng được truyền cho phương thức.
## Biên dịch tính đa hình thời gian
Chúng ta hãy xem một ví dụ về tính đa hình thời gian biên dịch.Mã sau đây xác định một lớp `math` với hai phương thức:` add` và `subtract`.
`` `java
lớp công khai toán học {
public static int add (int a, int b) {
trả lại A + B;
}
công khai int int trừ (int a, int b) {
trả lại a - b;
}
}
`` `
Bây giờ, giả sử chúng ta có một lớp `number` mở rộng lớp` Object`.Sau đó, chúng ta có thể xác định một phương thức gọi là `print` trong lớp` number` in giá trị của đối tượng.
`` `java
Số lớp công khai mở rộng đối tượng {
public void print () {
System.out.println (this.toString ());
}
}
`` `
Bây giờ, chúng ta có thể tạo một đối tượng `Integer` và đối tượng` Double` và gọi phương thức `print` trên cả hai đối tượng.
`` `java
Số nguyên I = Số nguyên mới (10);
Double d = new Double (10.0);
i.print ();// In 10
D.Print ();// In 10.0
`` `
Trình biên dịch có thể xác định phương thức nào cần gọi trong trường hợp này vì các loại đối tượng được biết đến tại thời điểm biên dịch.
## Đa hình thời gian chạy
Chúng ta hãy xem một ví dụ về tính đa hình thời gian chạy.Mã sau đây xác định một lớp `xe` với một phương thức gọi là` di chuyển`.
`` `java
Xe lớp công cộng {
công khai void di chuyển () {
System.out.println ("Xe đang di chuyển.");
}
}
`` `
Bây giờ, giả sử chúng ta có một lớp `xe` mở rộng lớp` xe`.Sau đó, chúng ta có thể ghi đè phương thức `di chuyển` trong lớp` car` để in một thông báo nói rằng "chiếc xe đang di chuyển."
`` `java
Lớp học công cộng mở rộng xe {
@Ghi đè
công khai void di chuyển () {
System.out.println ("chiếc xe đang di chuyển.");
}
}
`` `
Bây giờ, chúng ta có thể tạo một đối tượng `xe` và gọi phương thức` di chuyển` trên nó.
`` `java
Xe c = xe mới ();
c.move ();// In "chiếc xe đang di chuyển."
`` `
Hệ thống thời gian chạy Java xác định phương thức nào sẽ gọi trong trường hợp này vì loại đối tượng không được biết đến tại thời điểm biên dịch.
## Lợi ích của đa hình
Đa hình có thể là một công cụ mạnh mẽ để viết mã linh hoạt và có thể duy trì hơn.Dưới đây là một số lợi ích của đa hình:
*** Tái sử dụng mã: ** Đa hình cho phép bạn viết mã có thể được sử dụng với các loại dữ liệu khác nhau.Điều này có thể giúp bạn tiết kiệm thời gian và công sức khi bạn cần viết mã hoạt động với nhiều loại dữ liệu.
*** Tính linh hoạt: ** Đa hình cho phép bạn thay đổi hành vi của mã của mình khi chạy.Điều này có thể hữu ích nếu bạn cần thay đổi hành vi của mã của bạn dựa trên các điều kiện khác nhau.
*** Khả năng duy trì: ** Đa hình có thể làm cho mã của bạn dễ bảo trì hơn.Điều này là do bạn có thể thay đổi việc triển khai một phương thức trong một lớp mà không phải thay đổi mã gọi phương thức trong các lớp khác.
##
=======================================
#Java #polymorphism #Java11 #Programming #tutorial ## Java 11 Polymorphism
Polymorphism is a powerful feature of Java that allows you to write code that can be used with different data types. This can make your code more flexible and easier to maintain.
There are two types of polymorphism in Java:
* **Compile-time polymorphism**, also known as **static polymorphism**, occurs when you have a method with the same name but different signatures. The compiler can determine which method to call at compile time based on the type of the object that is passed to the method.
* **Runtime polymorphism**, also known as **dynamic polymorphism**, occurs when you have a method with the same name but different implementations in different classes. The Java runtime system determines which method to call at runtime based on the type of the object that is passed to the method.
## Compile-time polymorphism
Let's look at an example of compile-time polymorphism. The following code defines a `Math` class with two methods: `add` and `subtract`.
```java
public class Math {
public static int add(int a, int b) {
return a + b;
}
public static int subtract(int a, int b) {
return a - b;
}
}
```
Now, let's say we have a `Number` class that extends the `Object` class. We can then define a method called `print` in the `Number` class that prints the value of the object.
```java
public class Number extends Object {
public void print() {
System.out.println(this.toString());
}
}
```
Now, we can create a `Integer` object and a `Double` object and call the `print` method on both of them.
```java
Integer i = new Integer(10);
Double d = new Double(10.0);
i.print(); // prints 10
d.print(); // prints 10.0
```
The compiler can determine which method to call in this case because the types of the objects are known at compile time.
## Runtime polymorphism
Let's look at an example of runtime polymorphism. The following code defines a `Vehicle` class with a method called `move`.
```java
public class Vehicle {
public void move() {
System.out.println("The vehicle is moving.");
}
}
```
Now, let's say we have a `Car` class that extends the `Vehicle` class. We can then override the `move` method in the `Car` class to print a message that says "The car is moving."
```java
public class Car extends Vehicle {
@Override
public void move() {
System.out.println("The car is moving.");
}
}
```
Now, we can create a `Car` object and call the `move` method on it.
```java
Car c = new Car();
c.move(); // prints "The car is moving."
```
The Java runtime system determines which method to call in this case because the type of the object is not known at compile time.
## Benefits of polymorphism
Polymorphism can be a powerful tool for writing more flexible and maintainable code. Here are some of the benefits of polymorphism:
* **Code reuse:** Polymorphism allows you to write code that can be used with different data types. This can save you time and effort when you need to write code that works with multiple data types.
* **Flexibility:** Polymorphism allows you to change the behavior of your code at runtime. This can be useful if you need to change the behavior of your code based on different conditions.
* **Maintainability:** Polymorphism can make your code easier to maintain. This is because you can change the implementation of a method in one class without having to change the code that calls the method in other classes.
##
Đa hình là một tính năng mạnh mẽ của Java cho phép bạn viết mã có thể được sử dụng với các loại dữ liệu khác nhau.Điều này có thể làm cho mã của bạn linh hoạt hơn và dễ bảo trì hơn.
Có hai loại đa hình trong Java:
*** Biên dịch đa hình thời gian **, còn được gọi là ** đa hình tĩnh **, xảy ra khi bạn có một phương pháp có cùng tên nhưng các chữ ký khác nhau.Trình biên dịch có thể xác định phương thức nào để gọi vào thời điểm biên dịch dựa trên loại đối tượng được truyền cho phương thức.
*** Đa hình thời gian chạy **, còn được gọi là ** đa hình động **, xảy ra khi bạn có một phương pháp có cùng tên nhưng các triển khai khác nhau trong các lớp khác nhau.Hệ thống thời gian chạy Java xác định phương thức nào sẽ gọi khi chạy dựa trên loại đối tượng được truyền cho phương thức.
## Biên dịch tính đa hình thời gian
Chúng ta hãy xem một ví dụ về tính đa hình thời gian biên dịch.Mã sau đây xác định một lớp `math` với hai phương thức:` add` và `subtract`.
`` `java
lớp công khai toán học {
public static int add (int a, int b) {
trả lại A + B;
}
công khai int int trừ (int a, int b) {
trả lại a - b;
}
}
`` `
Bây giờ, giả sử chúng ta có một lớp `number` mở rộng lớp` Object`.Sau đó, chúng ta có thể xác định một phương thức gọi là `print` trong lớp` number` in giá trị của đối tượng.
`` `java
Số lớp công khai mở rộng đối tượng {
public void print () {
System.out.println (this.toString ());
}
}
`` `
Bây giờ, chúng ta có thể tạo một đối tượng `Integer` và đối tượng` Double` và gọi phương thức `print` trên cả hai đối tượng.
`` `java
Số nguyên I = Số nguyên mới (10);
Double d = new Double (10.0);
i.print ();// In 10
D.Print ();// In 10.0
`` `
Trình biên dịch có thể xác định phương thức nào cần gọi trong trường hợp này vì các loại đối tượng được biết đến tại thời điểm biên dịch.
## Đa hình thời gian chạy
Chúng ta hãy xem một ví dụ về tính đa hình thời gian chạy.Mã sau đây xác định một lớp `xe` với một phương thức gọi là` di chuyển`.
`` `java
Xe lớp công cộng {
công khai void di chuyển () {
System.out.println ("Xe đang di chuyển.");
}
}
`` `
Bây giờ, giả sử chúng ta có một lớp `xe` mở rộng lớp` xe`.Sau đó, chúng ta có thể ghi đè phương thức `di chuyển` trong lớp` car` để in một thông báo nói rằng "chiếc xe đang di chuyển."
`` `java
Lớp học công cộng mở rộng xe {
@Ghi đè
công khai void di chuyển () {
System.out.println ("chiếc xe đang di chuyển.");
}
}
`` `
Bây giờ, chúng ta có thể tạo một đối tượng `xe` và gọi phương thức` di chuyển` trên nó.
`` `java
Xe c = xe mới ();
c.move ();// In "chiếc xe đang di chuyển."
`` `
Hệ thống thời gian chạy Java xác định phương thức nào sẽ gọi trong trường hợp này vì loại đối tượng không được biết đến tại thời điểm biên dịch.
## Lợi ích của đa hình
Đa hình có thể là một công cụ mạnh mẽ để viết mã linh hoạt và có thể duy trì hơn.Dưới đây là một số lợi ích của đa hình:
*** Tái sử dụng mã: ** Đa hình cho phép bạn viết mã có thể được sử dụng với các loại dữ liệu khác nhau.Điều này có thể giúp bạn tiết kiệm thời gian và công sức khi bạn cần viết mã hoạt động với nhiều loại dữ liệu.
*** Tính linh hoạt: ** Đa hình cho phép bạn thay đổi hành vi của mã của mình khi chạy.Điều này có thể hữu ích nếu bạn cần thay đổi hành vi của mã của bạn dựa trên các điều kiện khác nhau.
*** Khả năng duy trì: ** Đa hình có thể làm cho mã của bạn dễ bảo trì hơn.Điều này là do bạn có thể thay đổi việc triển khai một phương thức trong một lớp mà không phải thay đổi mã gọi phương thức trong các lớp khác.
##
=======================================
#Java #polymorphism #Java11 #Programming #tutorial ## Java 11 Polymorphism
Polymorphism is a powerful feature of Java that allows you to write code that can be used with different data types. This can make your code more flexible and easier to maintain.
There are two types of polymorphism in Java:
* **Compile-time polymorphism**, also known as **static polymorphism**, occurs when you have a method with the same name but different signatures. The compiler can determine which method to call at compile time based on the type of the object that is passed to the method.
* **Runtime polymorphism**, also known as **dynamic polymorphism**, occurs when you have a method with the same name but different implementations in different classes. The Java runtime system determines which method to call at runtime based on the type of the object that is passed to the method.
## Compile-time polymorphism
Let's look at an example of compile-time polymorphism. The following code defines a `Math` class with two methods: `add` and `subtract`.
```java
public class Math {
public static int add(int a, int b) {
return a + b;
}
public static int subtract(int a, int b) {
return a - b;
}
}
```
Now, let's say we have a `Number` class that extends the `Object` class. We can then define a method called `print` in the `Number` class that prints the value of the object.
```java
public class Number extends Object {
public void print() {
System.out.println(this.toString());
}
}
```
Now, we can create a `Integer` object and a `Double` object and call the `print` method on both of them.
```java
Integer i = new Integer(10);
Double d = new Double(10.0);
i.print(); // prints 10
d.print(); // prints 10.0
```
The compiler can determine which method to call in this case because the types of the objects are known at compile time.
## Runtime polymorphism
Let's look at an example of runtime polymorphism. The following code defines a `Vehicle` class with a method called `move`.
```java
public class Vehicle {
public void move() {
System.out.println("The vehicle is moving.");
}
}
```
Now, let's say we have a `Car` class that extends the `Vehicle` class. We can then override the `move` method in the `Car` class to print a message that says "The car is moving."
```java
public class Car extends Vehicle {
@Override
public void move() {
System.out.println("The car is moving.");
}
}
```
Now, we can create a `Car` object and call the `move` method on it.
```java
Car c = new Car();
c.move(); // prints "The car is moving."
```
The Java runtime system determines which method to call in this case because the type of the object is not known at compile time.
## Benefits of polymorphism
Polymorphism can be a powerful tool for writing more flexible and maintainable code. Here are some of the benefits of polymorphism:
* **Code reuse:** Polymorphism allows you to write code that can be used with different data types. This can save you time and effort when you need to write code that works with multiple data types.
* **Flexibility:** Polymorphism allows you to change the behavior of your code at runtime. This can be useful if you need to change the behavior of your code based on different conditions.
* **Maintainability:** Polymorphism can make your code easier to maintain. This is because you can change the implementation of a method in one class without having to change the code that calls the method in other classes.
##
