28 多态详解&对象的转型&StringBuffer

@一夜看尽长安花

于 2024-07-30 08:46:31 发布

阅读量431

点赞数 4

分类专栏： Java全栈 # java基础语法文章标签：开发语言 java String StringBuffer Casting 对象转型

本文链接：https://blog.csdn.net/ta683280/article/details/140787038

版权

Java全栈同时被 2 个专栏收录

77 篇文章 0 订阅

订阅专栏

java基础语法

30 篇文章 0 订阅

订阅专栏

欢迎来到@一夜看尽长安花博客，您的点赞和收藏是我持续发文的动力

对于文章中出现的任何错误请大家批评指出，一定及时修改。有任何想要讨论的问题可联系我：3329759426@qq.com 。发布文章的风格因专栏而异，均自成体系，不足之处请大家指正。

专栏：

java全栈
C&C++
PythonAI
PCB设计
Linux云计算&运维

文章概述：对多态&对象的转型&StringBuffer 的介绍

关键词：多态对象的转型 StringBuffer

本文目录：

多态(polymorphism)

对象的转型(casting)

String 类

StringBuffer 类

多态(polymorphism)

多态指的是同一个方法调用，由于对象不同可能会有不同的行为。现实生活中，同一个方法，具体实现会完全不同。比如：同样是调用人“吃饭”的方法，中国人用筷子吃饭，英国人用刀叉吃饭，印度人用手吃饭。

多态的要点：

多态是方法的多态，不是属性的多态（多态与属性无关）。
多态的存在要有3个必要条件：继承，方法重写，父类引用指向子类对象。
父类引用指向子类对象后，用该父类引用调用子类重写的方法，此时多态就出现了。

【示例】多态

class Animal {
    public void shout() {
        System.out.println("叫了一声！");
    }
}

class Dog extends Animal {
    public void shout() {
        System.out.println("旺旺旺！");
    }
    public void seeDoor() {
        System.out.println("看门中....");
    }
}

class Cat extends Animal {
    public void shout() {
        System.out.println("喵喵喵喵！");
    }
}

public class TestPolym {
    public static void main(String[ ] args) {
    Animal a1 = new Cat(); // 向上可以自动转型
    //传的具体是哪一个类就调用哪一个类的方法。大大提高了程序的可扩展性。
    animalCry(a1);
    Animal a2 = new Dog();
    animalCry(a2);//a2为编译类型，Dog对象才是运行时类型。
    
    // 有了多态，只需要让增加的这个类继承Animal类就可以了。
    //父类引用做方法
    static void animalCry(Animal a) {
        a.shout();
    }


    /* 如果没有多态，我们这里需要写很多重载的方法。
    * 每增加一种动物，就需要重载一种动物的喊叫方法。非常麻烦。
    static void animalCry(Dog d) {
        d.shout();
    }
    static void animalCry(Cat c) {
        c.shout();
    }*/
}

执行结果所示：

如上示例，给大家展示了多态最为多见的一种用法，即父类引用做方法的形参，实参可以是任意的子类对象，可以通过不同的子类对象实现不同的行为方式。

由此，我们可以看出多态的主要优势是提高了代码的可扩展性。但是多态也有弊端，就是无法调用子类特有的功能，比如，我不能使用父类的引用变量调用Dog类特有的seeDoor()方法。

那如果我们就想使用子类特有的功能行不行呢？行！这就是我下面要提到的：对象的转型。

多态指的是同一个方法调用，由于对象不同可能会有不同的行为。现实生活中，同一个方法，具体实现会完全不同。比如：同样是调用人“吃饭”的方法，中国人用筷子吃饭，英国人用刀叉吃饭，印度人用手吃饭。

多态的要点：

多态是方法的多态，不是属性的多态（多态与属性无关）。
多态的存在要有3个必要条件：继承，方法重写，父类引用指向子类对象。
父类引用指向子类对象后，用该父类引用调用子类重写的方法，此时多态就出现了。

总结：

这种方式让我们可以编写更灵活和可扩展的代码，通过统一的父类引用来处理不同的子类对象，而不需要知道具体的子类类型。这种特性在实现设计模式和处理复杂的对象结构时非常有用。

对象的转型(casting)

父类引用指向子类对象，我们称这个过程为向上转型，属于自动类型转换。
向上转型后的父类引用变量只能调用它编译类型的方法，不能调用它运行时类型的方法。这时，我们就需要进行类型的强制转换，我们称之为向下转型。

类型转换

class Animal {
    public void shout() {
    System.out.println("叫了一声！");
}
}

class Dog extends Animal {
public void shout() {
    System.out.println("旺旺旺！");
}
public void seeDoor() {
    System.out.println("看门中....");
}
}

class Cat extends Animal {
public void shout() {
    System.out.println("喵喵喵喵！");
}
}

public class TestPolym {
    public static void main(String[ ] args) {
    Animal a1 = new Cat(); // 向上可以自动转型
    //传的具体是哪一个类就调用哪一个类的方法。大大提高了程序的可扩展性。
    animalCry(a1);
    Animal a2 = new Dog();
    animalCry(a2);//a2为编译类型，Dog对象才是运行时类型。
    
    /*编写程序时，如果想调用运行时类型的方法，只能进行强制类型转换。
    * 否则通不过编译器的检查。*/
    Dog dog = (Dog)a2;//向下需要强制类型转换
        dog.seeDoor();
    }
        
    // 有了多态，只需要让增加的这个类继承Animal类就可以了。
    //父类引用做方法
    static void animalCry(Animal a) {
        a.shout();
    }
}

示例：

str.charAt(0)

public class TestCasting {
    public static void main(String[ ] args) {
        Object obj = new String("小安的博客"); // 向上可以自动转型

        // obj.charAt(0) 无法调用。编译器认为obj是Object类型而不是String类型
        /* 编写程序时，如果想调用运行时类型的方法，只能进行强制类型转换。
         * 不然通不过编译器的检查。 */

        String str = (String) obj; // 向下转型
        System.out.println(str.charAt(0)); // 位于0索引位置的字符
        System.out.println(obj == str); // true.他们俩运行时是同一个对象
    }
}

在向下转型过程中，必须将引用变量转成真实的子类类型(运行时类型）否则会出现类型转换异常ClassCastException。如示例5-14所示。

public class TestCasting2 {
    public static void main(String[ ] args) {
        Object obj = new String("北京尚学堂");
        //真实的子类类型是String，但是此处向下转型为StringBuffer
        StringBuffer str = (StringBuffer) obj;
        System.out.println(str.charAt(0));
    }
}

向下的时候使用instance of 来检验

public class TestCasting3 {
    public static void main(String[ ] args) {
        Object obj = new String("小安的博客");
        if(obj instanceof String){
            String str = (String)obj;
            System.out.println(str.charAt(0));
        }else if(obj instanceof StringBuffer){
            StringBuffer str = (StringBuffer) obj;
            System.out.println(str.charAt(0));
        }
    }
}

`String` 类

不可变性：String 对象是不可变的。每当你对 String 对象进行修改时，实际上是在创建一个新的 String 对象。原始的 String 对象保持不变。
线程安全：由于不可变性，String 对象是线程安全的，可以在多个线程中共享。
内存管理：由于 String 是不可变的，每次创建新字符串时都会在内存中创建一个新的 String 对象。这可能导致较高的内存使用和性能开销，尤其是在进行大量字符串操作时。
性能：对于频繁的字符串连接操作，String 可能会导致性能问题，因为每次连接都会创建一个新的 String 对象。

`StringBuffer` 类

可变性：StringBuffer 对象是可变的。你可以在不创建新对象的情况下修改 StringBuffer 的内容。这使得它在需要频繁修改字符串内容时更高效。
线程安全：StringBuffer 是线程安全的。它的方法是同步的，这意味着它可以安全地在多个线程中使用。
内存管理：由于 StringBuffer 是可变的，所有的修改都在原始对象上进行，因此通常会比 String 更节省内存和提高性能，特别是在进行大量字符串操作时。
性能：在需要进行大量字符串操作（如连接、插入、删除等）时，StringBuffer 通常比 String 更高效。