Day07 --构造方法 static Math对象

 a.
    构造方法
        概念：
            给对象的数据（属性）进行初始化。
    
        作用：
            【在最终决定输出结果前或方法前，可在构造方法中做一切对象的数据（属性）进行的修改。从而改变最终值答案】
    
        特点：
            * 方法名和类名相同，大小写一致；
            * 没有返回值，连void都没有；
            * 没有具体的返回值的 return；【系统会默认给出return，但没有具体的返回值】
            * 构造方法先于new方法前执行。
    
        格式
            class Person{
                //构造方法    
                public Person(){
                    //在此处可对对象的属性进行初始化；
                    return ;
                }
            } 
    【【注意事项】】
            a.没有具体的返回值类型的return 【构造方法也有return。系统会默认给出，格式是return; 】
            b.不能实例化对象进行调用，即new的时候，系统会在实例化对象之前去调用构造函数，但要看实例对象的参数列表，来决定调用哪个构造函数。（p.构造方法() 是错误的。）
            c.在一创建对象时，系统默认帮我们调用了构造方法（一创建对象的时候，系统会优先实例化对象之前去调用构造函数。    
）
            d.构造函数也可重载

    p.s.
        1）一般函数和构造函数的区别?
            构造函数：对象创建后，就会调用与之对应的构造函数，对对象进行初始化。
            一般函数：对象创建后，需要函数功能是才调用。
            
            构造函数：对象创建后，会调用并只调用一次。
            一般函数：对象创建后，可以被调用多次。
    
        2）创建对象都必须通过构造方法初始化。
            一个类中如果没有定义过构造函数，那么该类就会提供一个默认的空参构造函数，
            如果在类中调用了指定的构造函数，那么类就不提供默认的空参构造函数，但建议我们还是自己手动加上。
        
        3）多个构造函数都是以重载的形式存在的。

例子：

    class Demo1_构造方法 {
    public static void main(String[] args) {
        
        Person p = new Person(); //在创建对象的时候，系统就帮我们在普通方法前调用了构造方法。
        p.show();
        System.out.println("普通方法："+p.getName() +"   "+ p.getAge());
        
        //执行顺序：构造方法，show()方法，普通方法();

Person p2 = new Person("呵呵",4);//【new出来有参对象后，系统会去调用有参构造方法，并输出有参构造里的一切语句。】
p2.show();//【在这之前会先去执行有参构造方法】


    }
}

    class Person {
        private String name;
        private int age;
        
    //无参构造方法
        public Person(){
            //给对象中的数据（属性）进行初始化
            this.setName("舒服点"); //这个和下面的方式都可以
            this.age = 3;
            System.out.println("构造方法："+this.getName() +"..."+ this.getAge());
            return;
        }
    
    //有参构造方法
        public Person(String name, int age){
            this.name = name;
            this.age = age;
        }
    
        public void setName(String name){
            this.name = name ;
        }
    
        public String getName(){
            return name;
        }
    
        public void setAge(int age){
            this.age = age ;
        }
    
        public int getAge(){
            return age;
        }
        
        public void show(){
            System.out.println("show方法："+ name +"..."+ age);
        }
    
    }
    
    重载：
        方法名与类名相同，与返回值类型无关，只看参数列表（参数类型，参数个数）。
        * 其实还有一种，就是参数顺序不同，但实际意义不大，开发中很少使用。
    
    构造方法的重载
        方法名相同，与返回值类型无关（构造方法没有返回值）， 只看参数列表（参数个数，参数类型）。
    
    注意事项
        * 如果我们没有明确给出构造方法，系统会给我们自动提供一个无参的构造方法。
        * 如果我们给出了构造方法，系统就不会再给我们提供无参的构造方法了。
            * 注意：这个时候，如果我们还想使用无参的构造方法，就必须自己写出来无参构造，建议每次都自己给出。
    
    成员变量赋值的几种方式：
        * 构造方法赋值
        * setXXX()方法赋值 在开发中这个用的比较多        
    区别： 使用第二种setXXX()方法更方便，因为不用创建很多次的新方法，即new出来很多新对象，去占用内存空间，从而达到节省内存空间的作用。     
    
    成员变量获取的几种方式：    
        * 构造方法获取
        * getXXX()方法获取
    区别： 使用get方法更方便，因为不用创建更多的新方法，即new出来很多新对象，去占用内存空间，从而到达节省内存空间的作用。


    普通show()方法 和 get()方法获取值的区别：
        * show方法，只是打印出结果。
        * 而get方法获取到的值，即可打印，还可以继续参与后面程序的运算，做其他操作使用。

Person p2 = new Person("呵呵",4);//【new出来有参对象后，系统会去调用自己写的有参构造方法，并输出有参构造里的一切语句。】
p2.show();//【在这之前会先去执行有参构造方法】



b.
    分析一个对象在内存中的执行流程：
例子：
    具体请参考，G:\CSDN_Android_\Code\day07\一个对象在内存中的执行步骤 完整版 张舰总结.png的图片和文字说明。 必须要看。

【【虽然采用有参构造的方式赋值，代码量减少了，但是在堆内存中，又创建了一个新的对象，造成了不必要的内存空间浪费，所以建
议还是使用set方法赋值，因为还可将值做其他程序的使用。】】



c.
    static关键字
        概念
            * 被static修饰的成员，被称为静态成员，静态成员都在方法区（的静态区）中，被所有对象所共享。    
            * 用于修饰成员（成员变量和成员方法）。
        
        在内存中的位置
            在方法区中，方法区又称为静态区（共享区），里面存储的是.class 和 static。


.class文件进入方法区中，.class文件进入方法区中占用一定的内存空间，该空间里面分静态区和非静态区。
* 静态区中： 有main(因为main被static修饰的)和被static修饰的成员。
* 非静态区： 有普通成员变量和普通成员方法
  ​    
      特点 （3个）
          * 随着类的加载而加载（因为静态成员在类被加载时，会执行一次初始化，只要类加载就会被初始化。）
          * 优先于对象而存在（因为他是随着字节码文件的加载而加载的。）
          * 被类中的所有对象所共享。（因为static修饰的成员都在方法区中的静态区）
          * 可以直接类名调用，比平时的调用多了一种调用方式。
      当所有对象都使用到到他，他就可以被定义为共享，例如：老师，饮水机。
      
      好处
          提高代码的高效性，节省内存空间。

【共性用静态，特性用非静态】当类中的属性共性时，用静态，特性时，用非静态。
​        
        如何调用
            静态
                * 类名.调用。 （因为他先与对象先存在，所以可以直接 类名.调用。好处不用创建对象了）
                * 对象名.调用。
            非静态
                普通成员，只能通过对象名.调用；    

静态修饰的内容，我们一般称为，与类相关的，如：类成员方法或类成员变量，因为静态都是优先于对象而先存在嘛。


注意事项：
    * 静态方法中没有this，super关键字的。
        * 因为静态是随着类的加载而加载的，而this是随着对象的创建而存在的。
        * 静态优先于对象先存在。
    * 静态方法只能访问静态变量和静态方法。 （因为静态是随着类的加载而加载，而非静态是随着对象的创建而存在）
        * 静态方法：
            * 成员变量： 只能访问静态变量 （在静态方法中，所有的成员变量都只能是静态）
            * 成员方法： 只能访问静态方法 （在静态方法中，所有的方法，也都只能是静态的）
        * 非静态方法：
            * 成员方法： 在非静态方法中，变量既可以是静态的，也可以不是静态的。
            * 成员变量： 在非静态方法中，方法可以是静态的，也可以不是静态的。  

简单记：静态只能访问静态，非静态既可以访问静态的，也能访问非静态的。静态想要访问非静态，只能创建对象后才能访问。
​    
​            
​            
问？ 静态成员方法为什么不能访问非静态的。
* 因为静态是随着类的加载而加载的，而非静态是随着对象的创建而存在的。作用域不同。静态优先于对象而先存在。    
* 作用域：静态在方法区中，非静态在堆内存中（只有创建对象，非静态才能在堆内存中）。

  静态变量和成员变量的区别 （4种）
      所属不同
          * 静态成员： 静态是属于类的，所以也叫类变量。
          * 成员变量： 成员变量是属于对象的，所以也叫对象变量（即实例变量）
      
      内存中的位置不同
          * 静态变量： 静态变量存储在方法区的静态区，所以也叫对象的共享数据 （在内存中，多个对象共享一份）
          * 成员变量： 成员变量存储在堆内存中，所以也叫对象的特有数据            （在内存中，new几个对象，就存在几份）    
          
      内存中出现的时机不同
          * 静态变量： 是随着类的加载而加载的，随着类的消失而消失。
              * 【【【随着类的消失而消失？？
                          跟JAVA的底层算法有关。【先进先出】】】】
          
          * 成员变量： 是随着对象的创建而存在，随着对象变成垃圾而消失。
      
      调用方式不同
          * 静态变量： 两种调用方式： 类名.调用  和  对象名.调用
          * 成员变量： 只能通过对象名.调用。
      
      p.s.
          静态什么时候用？
              静态变量：
                  * 当分析对象中成员变量的值都是相同的时候，都可以定义为静态的。
                  * 只要数据在对象中都是不同的，就是对象的特有数据，必须存储在对象中，且是非静态的。
                  * 如果是相同的数据，对象不需要做修改，只需要使用即可，不需要存储在对象中，定义为静态的即可。
      
              静态方法：
                  * 函数是否用静态修饰，就只考虑这一点，就是该函数功能是否需要访问对象中特有的数据，
                  * 简单的说，从源代码看，该功能是否需要访问非静态的成员变量，如果需要该功能就是非静态的。
                  * 如果不需要，就可以将该功能更定义为静态的。也可以定义为非静态的，但是非静态是需要被对象调用的。
                  * 如果没有访问特有数据的方法，该对象的创建就是没有意义的。  


d.
main主方法格式的详细解释：
​    
        public static void main(String[] args){

             System.out.println(args.length); //现在是0    命令行运行完后 是4
                for (int i =0; i<args.length; i++) {// 现在 没有结果，因为条件不满足，所以不进入for循环
                
                   System.out.println(args[i]);  //  命令行运行完后 是22 44 55 66 
        } 
    
        p.s.
        主函数是静态的，主函数特殊之处：
            格式固定。
            被jvm所识别和调用。
    
        主函数调用分析：
            public： 权限必须最大，被jvm识别和调用。
            static：不需要对象调用，而是直接用主函数所属类名调用即可。命令行中直接：java StaticDemo，实际上就是在执行StaticDemo.main()。
            void：主函数没有具体的返回值。
            main：函数名，不是关键字，是一个被jvm识别的固定主程序入口名称。
            String[] args：这是主函数的参数列表，是一个数组类型的参数，而且元素都是字符串类型，因为字符串数组能够接受任意的字符。        



/*如何演示原来String[] args是作为键盘录入用的。
    1) 找到该文件的路径，在该文件路径下，点shift 和右键 选择这此打开命令窗口
    2）输入： java Demo1_mainMetho  22 44 55 66  后回车即可，就能看到答案，即for循环遍历后的结果
    3) 结果：
        数组有几个元素
                    4
        for循环后结果（元素都是什么）：
                    22 
                    44
                    55
                    66
        
    这就是原来为什么说String[] args 是作为键盘录入用的。
*/

}

public： 因为是被jvm调用的，所以权限必须足够大，public表示公共，他是权限修饰符。
static： 因为被jvm调用，不需要创建对象，直接类名.调用。 表示静态修饰，每个对象都被共享的、
            * 因为是被jvm调用，所以不需要创建对象，就可直接调用。
            * 而不被static修饰的成员或类，必须要创建对象后，才能够使用。

void：    被jvm调用，不需要有任何返回值来接收结果。
main：  只能这样写，才能被jvm识别为主方法（其实是编写jvm的人定义的），即程序的入口， main不是关键字，因为关键字是不能作为方法名使用的。
String[] args： 原来是用作键盘录入的， 而现在我们使用Scanner来作为键盘录入的对象。 args是数组名，可任意写，不是唯一，但标准是args。


【this关键字的注意事项】
    a.
        this为什么在构造方法中合法呢？
            * 因为this代表的是当前对象的引用，即谁调用我，我就代表谁。
            * 在调用构造方法之前，该对象早经存在于堆内存中，并且已经经过了默认初始化和显式初始化。所以该对象的地址值早已存在。
            * 而this指的就是这个地址值，所以在构造方法中可以使用this来表示地址值，来指向堆内存中对应的对象，即this在构造方法中可用，合法。    //而创建对象时，会默认调用他自己的构造方法，而构造方法又可重载。所以在无参或有参的构造方法是都能使用this的。
    b.
        this内存中分配？
            this是在内存中的栈内存中。因为this是随着对象的存在而存在。
            而方法都在栈内存中。
    p.s.
    this关键字
        * this代表其所在函数所属对象的引用，也就是说this代表本类对象的引用。
        * 当成员变量和局部变量重名的时候，可以用关键字this来区分，this就是所属函数对象的引用。
        * 简单的说，哪个对象调用了this所在的函数，this就代表哪个对象，一般方法调用默认都加this。 
    什么时候用this？
        * 当在方法内需要用到调用该方法的对象的时候，就用this。
    
        this也可以用于在构造函数中调用其他构造函数。当在构造函数中调用构造函数时，只能定义在构造函数的第一行，因为初始化动作要先执行，否则就会报错。



e.
    工具类
        数组工具类：
            将一个类中的所有方法都加静态，且该类是静态类，而且还有将该类的构造方法给私有化，不让其他类去创建对象成功，即可完成类名.调用，
        所有的工具类都是这样定义的。


如果一个类中的所有方法都是静态的话，我们要将构造方法给私有，为了防止其他类去创建他,如果不私有构造方法，其他类还能通过 对象名().调用。 如果私有其构造方法的话，就不能创建对象成功，而只能通过类名.调用了，目的是不让其他类去创建该类的对象。
由此可知，所有的工具类都是静态的，如Math类等。
​    

f.
    说明书的制作过程
    * A:对工具类加入文档注释
    * B:通过javadoc命令生成说明书
        * @author(提取作者内容)
        * @version(提取版本内容)
        * @param arr 参数名称//形式参数的变量名称 arr是可以接收什么样的数组
        * @return 函数运行完返回的数据 
        * 
* 在命令中javadoc -d 指定的文件夹目录 -author -version ArrayTools_工具类.java
* javadoc -d api -author -version ArrayTools_工具类.java
* 编译成功后，会在 ArrayTools_工具类.java所在的路径下生成一个api文件夹，里面的index.html就是了。
* 
  即 public class ArrayTools_工具类{

}


h.
    Math类
        概念
            用于执行基本数学运算的类。
        特点
            * 该类在java.lang包下，所以不用导包，而Scanner在java.util包下，所以必须要导包。
            * 因为该类中的所有方法都是私有的，所以要私有构造函数，防止其他类去创建该类的对象。
        
        获取随机数的方法
        random()方法,该方法是返回带正号的double类型的值， 该值范围是大于等于0.0且小于1.0
        
        问？要获取一个1~100之间是随机数该怎么办？

//求10个1~100之间的随机数
分析：
    1） Math.random() 的范围在0.000000 ~ 0.999999
    2） Math.random()*100 的范围在 0.00000 ~ 99.9999
    3）（int）(Math.random) *100 该值就变成了一个int值，即砍掉了所有的小数。范围在 0~99 之间
    4）（int）(Math.random) * 100 + 1 就是1~100的随机数了。

关键代码：
    for (int i=0;i<10 ;i++ ) {    
       System.out.print((int)(Math.random()*100) +1+" ");
    }     


猜数字小游戏 
参考：G:\CSDN_Android_\Code\day07 构造方法 static Math对象\08_Math类\Demo2_猜数字小游戏_数据在1到100之间.java
​    
【完整版 一个对象在内存中执行步骤】
    class Test{
        public static void main(String[] args) {
            Person p = new Person();  
        }，这段代码在内存中做了哪些事情？
    }
    
    1）Test.class字节码文件加载到内存，因为该Test中有main主方法，即程序的入口，所以main方法进栈。
    2）main进栈，且压入栈低，
    3) Person.class字节码文件也进入方法区，
    3）在栈内存中创建一个Person对象的引用p，
    4）在堆内存中创建一个Person实例化对象，先默认初始化值，再显示初始化值（有的情况下），
    5）因为在堆内存中创建的是一个无参对象，所以Person()的无参构造方法进栈，对成员变量进行赋值，赋值完后，该方法弹栈，
    6）将堆内存中对象的地址值给Person的引用p,通过p的地址值，就能够找到堆内存中对应的对象了。
    7) 整个对象创建完毕。