构造方法与参数传递

构造方法
*java中没有构造函数的概念
构造方法是创建对象时调用的方法，不要理解为构造方法就是创建对象的方法，因为构造方法主要是用来加载和初始化类的一些资源，创建一个对象并不完全靠
构造方法完成，构造方法主要进行创建对象的收尾工作
构造方法的作用？
能够在创建对象的时候完成对属性的赋值
构造方法如下：
public class TestConstract1{
    public static void main(String[] args){
        Rect re = new Rect(45,32);
        re.showArea();
    }
}
class Rect{
    int length;
    int width;
    public Rect(int length, int width){
        this.length = length;
        this.width = width;
    }
    public void showArea(){
        System.out.println(length*width);
    }
}
java中只要是一个类，就一定有构造方法，即使程序员没有写，系统也会提供一个默认的构造方法，该方法无参且空体；
如果程序员写了自己的构造方法，那么系统就不再提供默认的构造方法，相当于中国的低保制度，没钱才领低保，有钱无论多少都不会领到低保

构造方法和普通方法的区别？
1：构造方法没有返回类型，连void都不能写
2：构造方法的名字需要和类名一模一样 -->构造方法名首字母大写

构造方法的首行默认是隐藏的super():
super():表示在执行本类构造方法之前，先去执行父类的构造方法
默认去找父类的无参构造方法：
public class TestConstract2{
    public static void main(String[] args){
        Son s = new Son();
    }
}
class GrandFather{
    public GrandFather(){
        //super()
        System.out.println("爷爷被创建出来了");
    }
}
class Father extends GrandFather{
    public Father(){
        //super()
        System.out.println("爸爸被创建出来了");
    }
}
class Son extends Father{
    public Son(){
        //super()
        System.out.println("儿子被创建出来了");
    }
}
打印的结果是：
爷爷被创建出来了
爸爸被创建出来了
儿子被创建出来了
--------------
在java中，GrandFather默认继承Object类，所以,在创建对象时也会执行super()，然后去执行Object类的构造方法
如果父类没有无参构造方法：
public class TestConstract3{
    public static void main(String[] args){
        Teacher tea = new Teacher("张三",29);
        System.out.println(tea.name);
    }
}
class Person{
    String name;
    int age;
    public Person(String name, int age){
        this.name = name;
        this.age = age;
    }
    //public Person(){}
}
class Teacher extends Person{
    //String name; int age 从父类继承得到
    public Teacher(String name,int age){
        this.name = name;
        this.age = age;
    }
}
此段程序执行会报错，因为Teacher类中默认会执行super()，去找父类Person的无参构造方法，而父类中没有无参构造方法，所以会报错
两种方法解决：
1.提供父类的无参构造方法
2.在super里面传参数，指定找父类的哪一个构造方法

构造方法首行还可以出现this():

public class TestConstract4{
    炒鸡蛋 cc = new 炒鸡蛋("西红柿");
}
class 炒鸡蛋{
    public 炒鸡蛋(){
        System.out.println("热锅 放油");
        System.out.println("打蛋 搅拌 放入锅中");
        System.out.println("翻炒鸡蛋");
    }
    public 炒鸡蛋(String x){// x-->佐料
        this();
        System.out.println("放入" + x);
        System.out.println("继续翻炒鸡蛋");
    }
}
该段程序执行结果：
热锅 放油
打蛋 搅拌 放入锅中
翻炒鸡蛋
放入西红柿
继续翻炒鸡蛋

this():表示要执行本构造方法之前，先去执行本类的其他构造方法，具体执行哪个构造方法，看this()里面的参数类型

下面是默认super()以及成员变量和局部变量区别的例子
public class TestConstract5{
    public static void main(String[] args){
        //Demo d1 = new Demo();
        //System.out.println(d1.str); //打印，"能做对么"

        //Demo d2 = new Demo("etoak");
        //System.out.println(d2.str); //打印,null

        Sample s = new Sample("etoak");
        System.out.println(s.str);  /／打印，"能做对么"
    }
}
class Demo{
    String str; //成员变量
    public Demo(){
        str = "能做对么？"; //成员变量 = "能做对么"
    }
    public Demo(String str){ //str：局部变量：etoak
        str = "还敢错么？"; //局部变量 = "还敢错么？"
    }//局部变量str消亡
}
class Sample extends Demo{
    //String str 继承得到成员变量str
    public Sample(String str){  //str局部变量 = etoak
        //super(); //成员变量 = 能做对么？
        str = "OK?" //局部变量 = OK？
    } //局部变量str消亡
}
下面是super调用父类有参构造方法实现代码共享的例子：
public class ExecConstract{
    public static void main(String[] args){
        Teacher tea = new Teacher("Tom",29,5000.0);
        System.out.println(tea.name);
    }
}
class Person{
    String name;
    int age;

    public Person(String name, int age){
        this.name = name;
        this.age = age;
    }
}
class Teacher extends Person{
    //name age
    double salary;
    public Teacher(string name,int age,double salary){
        super(name,age);
        this.salary = salary;
    }
}
*：构造方法的首行只能出现this()/super()中的一个
有super()就不能有this()
有this()就不能有super()
面试题：
1.构造方法能不能方法重载？
可以
2.构造方法能不能进行方法覆盖？
方法覆盖的前提：需要子类先继承得到
但是父类的构造方法子类不能继承，所以没办法进行方法覆盖
参数传递
    参数传递有两种说法，一种是java中只有值传递，另一种是java中的基本数据类型传值，引用数据类型传地址
public class TestArgs1{
    public static void main(String[] args){
        int a = 10;
        change(a);
        System.out.println(a); //打印结果：10
    }

    public static void change(int x){
        //int x = a; 隐含的一句代码
        x = 55;
    }
}
内存图：


public class Testargs2{
    public static void main(String[] args){
        int a = 56;
        int b = 90;
        change(a,b);
        System.out.println(a); //56
        System.out.println(b); //90
    }
}
public static void change(int x , int y){
    //int x = a; int y = b;
    int z = x;
    x = y;
    y = z;
}//x, y, z是局部变量
内存图：


public class TestArgs3{
    public static void main(String[] args){
        String str1 = new String("O");
        String str2 = new String("K");
        change(str1,str2);

        System.out.println(str1); //O
        System.out.println(str2); //K
    }
    public static void change(String x , String y){
        //String x = str1,String y = str2;
        String z = x;
        x = y;
        y = z;
    }//x,y,z是局部变量
}
java中，任何一个字符串底层都是char[]字符数组实现的
内存图：


public class TestArgs4{
    public static void main(String[] args){
       Student x = new Student(30);
       change(x);
       System.out.println(x.age); //打印，55
    }

    public static void change(Student stu){
        //Student stu = x ;
        stu.age = 55;
    }
}
class Student{
    int age;
    public Student(int age){
        this.age = age;
    }
}
内存图：


public class TestArgs5{
    public static void main(String[] args){
        Student x = new Student(30);
        change(x);
        System.out.println(x.age);  //打印，30
    }

    public static void change(Student stu){
        //Student stu = x;
        stu = new Student(55);
    }
}
class Student{
    int age;
    public Student(int age){
        this.age = age;
    }
}
内存图：


String类的两个常见面试题：
1.new和不new之间的区别？
    String str1 = "etoak";
    String str2 = new String("etoak");
    不new方式涉及到常量池查找机制
public class TestString1{
    public static void main(String[] args){
        String str1 = "etoak";//执行时，先到常量池寻找是否有"etoak"，有，则不用创建对象；没有，则开辟内存空间，创建"etoak"对象，并将其存入常量池
        String str2 = "etoak";//执行时，常量池中已经有"etoak"，所以直接指向"etoak"
        System.out.println(str1 == str2);   //true

        String str3 = new String("etoak");
        String str4 = new String("etoak");
        System.out.println(str3 == str4);   //false
    }
}
2.String StringBuffer StringBuilder都表示字符串，它们三者之间的区别？
A：String和StringBuffer／StringBuilder之间的区别？
字符串的底层都是通过char[]字符数组实现的
String str = new String("etoak");
//[5]有5个字符，所以会开辟5个字符大小空间，当想要在其后再追加一个字符，则需要再申请开辟6个字符大小空间，并将etoak复制到新的空间，
以后每追加字符串都需要重新申请开辟空间并复制，效率较低
StringBuffer buffer = new StringBuffer("etoak");
//[5+16]有5个字符，因为StringBuffer／StringBuilder在创建对象时会预留16块缓冲区，
当不断字符串里面追加元素的时候，先使用缓冲区，缓冲区也装满之后，如果再追加n个字符，会申请开辟[21+n]*2大小的空间，以后再装满都按照这种机制扩充
当不断字符串里面追加元素的时候，尽量使用StringBuffer／StringBuilder
追加方法：buffer.append();
效率对比：
public class Speed{
    public static void main(String[] args){
        //String +=
        //StringBuffer append
        String str1 = new String();//""
        StringBuffer buffer = new StringBuffer();//""

        long time1 = System.currentTimeMillis();
        for(int x = 1; x <= 10000 ; x++){
            str1 += x;
        }
        long time2 = System.currentTimeMillis();
        System.out.println(time2 - time1);

        long time3 = System.currentTimeMillis();
        for(int x = 1; x <= 10000; x++){
            buffer.append(x);
        }
        long time4 = System.currentTimeMillis();
        System.out.println(time4 - time3);
    }
}
B:StringBuffer和StringBuilder的之间的区别？
    StringBuffer同一时间只允许一个线程进行访问，效率较低，但是不会出现并发错误
    StringBuilder同一时间允许多个线程进行访问，效率较高，但可能会出现并发错误