第四周String 与 StringBuffer，无参构造作用

文章目录

• • 1. String 与 StringBuffer
  • 2. final
  • 3. 无参构造作用

1. String 与 StringBuffer

public class Test {
    public static void main(String [] args){
        String a = "123";
        a = "abc";
        a = "abd";
    }

• String :

  String 引用过程是，先检查字符常量池中是否存在该字符串，如果没有会在字符常量池中创建，再把地址传递给它

  这就导致每次引用改变字符串都会创建空间，效率底下，浪费空间

  

• StringBuffer：

StringBuffer是先new一个对象，每次对字符串操作，是对对象自身操作，不会开辟额外的空间，所以运行效率快与String

public  class Sb {
    public static void main(String [] args){
        StringBuffer sb = new StringBuffer();
        //添加字符串（"123"）
        sb.append("123");
        //在指定下标插入字符串("12993")
        sb.insert(2,"99");
        //删除指定区域（左闭右开）字符串,（"123"）
        sb.delete(2,4);
        //替换指定区域字符串（1288）
        sb.replace(2,3,"88");
        System.out.println(sb);
    }

}

2. final

​ fina关键字可以用来修饰类、方法、变量

• 修饰类

  被final关键字修饰的类，不能被继承

• 修饰方法

  被final修饰的方法不能被重写覆盖

public class test{
    public static void main(String [] args) {
        B te = new B();
        //调用子类重写方法
        te.f1();
        //调用父类方法
        te.f2();
    }
}

class A{
    public void f1(){
        System.out.println("父类方法一");
    }
     public final void f2(){
        System.out.println("父类方法二");
    }
}
//继承A
class B extends A{
    @Override
    //重写f1
    public void f1(){
        System.out.println("子类方法一");
    }
}

• 修饰变量

  被final修饰的变量在赋值后无法更改

  通常被static修饰的变量存储在方法区只有一份，加上final,就能形成一个常量

    static final double PI = 3.1415;
    static final double E = 2.71828;

3. 无参构造作用

public class Test02{
    public static  void main(String [] args) {
        Son a = new Son();
    }
}
class Father{
    public Father(int num){
        System.out.println("父类");
    }
}

class Son extends Father{
    public Son(){
        System.out.println("子类");
    }
}

如果父类没有无参构造，程序会报错

解决方法：

1. 在父类中添加无参构造

   public class Test02{
       public static  void main(String [] args) {
           Son a = new Son();
       }
   }
   class Father{
       public Father(){}
       public Father(int num){
           System.out.println("父类");
       }
   }
   
   class Son extends Father{
       public Son(){
           System.out.println("子类");
       }
   }
   

2. 在子类构造方法中加上super关键字调用父类的有参构造

   public class Test02{
       public static  void main(String [] args) {
           Son a = new Son();
       }
   }
   class Father{
       public Father(int num){
           System.out.println("父类");
       }
   }
   
   class Son extends Father{
       public Son(){
           super(100);
           System.out.println("子类");
       }
   }
   

原因：Java 程序在执行子类的构造方法之前，如果没有用 super()来调用父类特定的构造方法，则会调用父类中“没有参数的构造方法”。因此，如果父类中只定义了有参数的构造方法，而在子类的构造方法中又没有用 super()来调用父类中特定的构造方法，则编译时将发生错误。