Java 多播(多次类型转换)难题

简介

Java 多播也称为多次类型转换。它是将值从一种数据类型转换为另一种数据类型的过程，涉及多次类型转换。它允许我们更改变量的数据类型以执行其他方式无法实现的操作。

让我们讨论 Java 中的多播。我们将讨论数字多播以在数字数据类型之间进行转换。我们还将讨论对象多播以将子类对象视为超类对象。我们还将提供简单的编程示例以轻松理解此主题。

Java 中的数字多播

在此编程示例中，我们将看到 Java 中的数字多播。

示例

public class first 
{
   public static void main (String args [])
   {
        // 首先，我们将 int 转换为 byte
        int num1 = -1;
        byte num2 = (byte) num1;
        System.out.println("步骤 1 - int 转换为 byte:");
        System.out.println("num1 (int) = " + num1);
        System.out.println("num2 (byte) = " + num2);
        
        // 其次，我们将 byte 转换为 char
        char char1 = (char) num2;
        System.out.println("\n步骤 2 - byte 转换为 char:");
        System.out.println("char1 (char) = " + (int) char1);
        
        // 然后，我们将 char 转换为 int
        int num3 = char1;
        System.out.println("\n步骤 3 - char 转换为 int:");
        System.out.println("num3 (int) = " + num3);
        
        // 然后我们将 int 转换为 short
        short num4 = (short) num3;
        System.out.println("\n步骤 4 - int 转换为 short:");
        System.out.println("num4 (short) = " + num4);
        
        // 我们将 short 转换为 byte
        byte num5 = (byte) num4;
        System.out.println("\n步骤 5 - short 转换为 byte:");
        System.out.println("num5 (byte) = " + num5);
        
        // 将 byte 转换为 long
        long num6 = (long) num5;
        System.out.println ("\n步骤 6 - byte 转换为 long:");
        System.out.println ("num6 (long) = " + num6);
        
        // 将 long 转换为 double
        double num7 = (double) num6;
        System.out.println("\n第 7 步 - long 转 double:");
        System.out.println("num7 (double) = " + num7);
   }
}

输出

Step 1 - int to byte:
num1 (int) = -1
num2 (byte) = -1

Step 2 - byte to char:
char1 (char) = 65535

Step 3 - char to int:
num3 (int) = 65535

Step 4 - int to short:
num4 (short) = -1

Step 5 - short to byte:
num5 (byte) = -1

Step 6 - byte to long:
num6 (long) = -1

Step 7 - long to double:
num7 (double) = -1.0

首先，我们定义了一个名为 first 的类，并在该类中调用了 main() 函数。在 main() 函数中，我们必须将整数转换为字节。为此，我们分别声明了两个名为"num1"和"num2"的变量。"num1"是整数类型，"num2"是字节类型变量。-1 被分配给变量"num1"，在下一行中，我们将"num1"的类型转换为字节类型。

int num1 = -1;
byte num2 = (byte) num1;

然后我们只需打印这个值即可。

System.out.println ("步骤 1 - int 到 byte:");
System.out.println ("num1 (int) = " + num1);
System.out.println ("num2 (byte) = " + num2);

之后，我们将字符转换为整数。为此，我们声明了一个名为"char1"的字符，并将字节转换为字符。

char char1 = (char) num2;

然后我们简单地打印这个类型转换值。

System.out.println("\nStep 2 - byte to char:");
System.out.println("char1 (char) = " + (int) char1 ");

之后，我们将一个整数转换为一个短整型。为此，我们声明了一个名为"num4"的整数，并将整数转换为短整型。

short num4 = (short) num3;

然后，我们只需打印此类型转换值即可。

System.out.println("\nStep 4 - int to short:");
System.out.println("num4 (short) = " + num4);

之后，我们将一个短整型转换为一个字节。为此，我们声明了一个名为"num5"的字节，并将短整型转换为字节。

byte num5 = (byte) num4;

然后我们只需打印此类型转换值即可。

System.out.println("\nStep 5 - short to byte:");
System.out.println("num5 (byte) = " + num5);

之后我们将 short 类型转换为字节。为此，我们声明了一个名为"num5"的字节，并将 short 类型转换为字节。

byte num5 = (byte) num4;

然后我们只需打印此类型转换值即可。

System.out.println("\nStep 5 - short to byte:");
System.out.println("num5 (byte) = " + num5);

之后，我们将字节转换为长整型。为此，我们声明了一个名为"num6"的长整型，并将短整型转换为字节。

long num6 = (long) num5;

然后我们只需打印此类型转换值即可。

System.out.println ("\nStep 6 - byte to long:");
System.out.println ("num6 (long) = " + num6);

之后，我们将 long 转换为 double。为此，我们声明了一个名为"num6"的 double，并将 long 转换为 double。

double num7 = (double) num6;

然后，我们只需打印此类型转换值即可。

System.out.println("\n第 7 步 - long 转换为 double:");
System.out.println("num7 (double) = " + num7

然后我们在屏幕上得到了结果输出。

Java 中的对象多播

在这个编程示例中，我们将看到 Java 中的对象多播。

示例

class Zoo
{
   void makeSound()
   {
      System.out.println("Some random noise");
   }
}
class Dog extends Zoo 
{
   void makeSound() 
   {
      System.out.println("Bark!!");
   }
}
class Cat extends Zoo
{
   void makeSound() 
   {
      System.out.println("Meow!!");
   }
}
class Tiger extends Zoo 
{
   void makeSound() 
   {
      System.out.println("Roar!!");
   }
}
public class MulticastPuzz
{
   public static void main(String args [])
   {
        // 使用超类引用进行对象多播
        Zoo zoo1 = new Dog();
        Zoo zoo2 = new Cat();
        Zoo zoo3 = new Tiger();
        
        // 通过使用多态性，我们可以访问子类方法
        Dog dog = (Dog) zoo1;
        dog.makeSound();
        ((Cat) zoo2).makeSound();
        ((Tiger) zoo3).makeSound();
        
        // 对象多播
        Zoo[] zoos = new Zoo[3];
        zoos[0] = new Dog();
        zoos[1] = new Cat();
        zoos[2] = new Tiger();
   }
}

输出

Bark!!
Meow!!
Roar!!

首先，我们定义了一个名为 Zoo 的类，并在该类中调用了 makeSound () 函数。现在 dog 类扩展了 zoo 类。在 dog 类中，我们通过继承属性调用了 makeSound ()。

class Dog extends Zoo 
{
   void makeSound() 
   {
      System.out.println("Bark!!");
   }

现在 cat 类扩展了 zoo 类。在 dog 类中，我们通过继承属性调用了 makeSound()

class Cat extends Zoo 
{
   void makeSound() 
   {
      System.out.println("Meow!!");
   }

现在，类 tiger 扩展了类 zoo。在 tiger 类中，我们通过继承属性调用了 makeSound()。

class Tiger extends Zoo 
{
   void makeSound() 
   {
      System.out.println("Roar!!");
   }
}

现在，类 tiger 扩展了类 zoo。在 tiger 类中，我们通过继承属性调用了 makeSound()。

class Tiger extends Zoo 
{
   void makeSound() 
   {
      System.out.println("Roar!!");
   }
}

现在我们定义了一个名为 MultiCastPuzz 的类，并在该类中调用了 main () 函数。在 main () 函数中，我们使用超类引用进行对象多播。

Zoo zoo1 = new Dog();
Zoo zoo2 = new Cat();
Zoo zoo3 = new Tiger();

之后 // 通过使用多态性，我们可以访问子类方法。

dog.makeSound();
((Cat) zoo2).makeSound();
((Tiger) zoo3).makeSound();

最后，我们对对象进行了多播。

Zoo[] zoos = new Zoo[3];
zoos[0] = new Dog();
zoos[1] = new Cat();
zoos[2] = new Tiger();

结论

在本文中，我们学习了很多有关如何在 Java 中进行多播或在 Java 中进行多次类型转换的知识。此过程有助于程序员减少代码编写量和精力。这是 Java 的一个独特功能，与不支持此类机制的其他语言相比，它是一种更智能的语言。

相关文章

• Java 中 IdentityHashMap、WeakHashMap 和 EnumMap 之间的区别
• Java 中继承和接口的区别
• Java 中 InputStream 和 OutputStream 之间的区别
• Java 中 HashSet 、LinkedHashSet 和 TreeSet 之间的区别和相似之处
• Java 中 HashMap 和 IdentityHashMap 之间的区别
• Java 中 Hashtable 和同步映射之间的区别
• 如何在 Java 中迭代 LinkedHashMap?
• 如何使用反射动态地通过名称调用 Java 中的方法?
• 如何在 Java 中以相反的顺序迭代向量元素?
• 如何在 Java 中以反向顺序迭代 LinkedHashMap?