八、Java中有关类的构造方法、Static关键字以及静态的main方法

Java中有关类的构造方法、static关键字以及静态的main方法和API文档（八）

大数据学习要循序渐进，打好基础，加油。

---

一、构造方法

1、构造方法作用概述

给对象的数据进行初始化

2、构造方法格式

（1）方法名与类名相同
（2）没有返回值类型，连void都没有
（3）没有具体的返回值

package com.shujia.wxl.day09;
class Student {
    private String name;
    private int age;

    //定义一个构造方法
    Student(){
        System.out.println("这是一个构造方法");
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

public class StudentDemo1 {
    public static void main(String[] args) {
        //创建Student类的对象
        //调用的是无参构造方法创建对象
        Student s1 = new Student();
        Student s2 = new Student();
//        System.out.println(s1.getName()+"---"+s1.getAge());
    }
}

3.注意事项

我们之前在类中从来都没有写过构造方法，但是我们依旧可以创建对象，
请问用的是哪里的构造方法呢？

        注意：
            1、如果我们没有给出构造方法，JVM会自动提供一个无参空方法体的构造方法
            2、如果我们给出了一个构造方法，还会提供嘛？
                如果我们提供了一个构造方法，系统就不会再提供默认的无参空方法体的构造方法
            3、构造方法可以发生重载

       给成员变量赋值的方式：
            1、使用setXxx(...)的方式给私有成员变量赋值
            2、使用带参数的构造方法给私有的成员变量赋值，这里需要与this关键字配合使用

4.类的初始化时机

首先我们创建一个Cat类，之后再画图分析初始化的先后次序

package com.shujia.wxl.day09;

class Cat{
    private String name = "小白";
    private int age = 3;
    private String kind = "英短";

    //生成构造方法，get,set方法的快捷键
    //alt + Insert
    public Cat() {
    }
    public Cat(String name, int age, String kind) {
        this.name = name;
        this.age = age;
        this.kind = kind;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getKind() {
        return kind;
    }

    public void setKind(String kind) {
        this.kind = kind;
    }

    public void show(){
        System.out.println(name+"---"+age+"---"+kind);
    }

}
public class CatDemo {
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.show();
    }
}

如图所示

二、Static关键字

1、引出Static

首先我们先定一个Human类

代码如下（示例）：

package com.shujia.wxl.day09;


class Human {
    //姓名
    private String name;
    //年龄
    private int age;
    //国籍
//    private String country;
    private static String country;

    public Human() {
    }

    public Human(String name,int age){
        this.name = name;
        this.age = age;
    }

    public Human(String name, int age, String country) {
        this.name = name;
        this.age = age;
        this.country = country;
    }

    //getXxx()和setXxx(...)


    public void setCountry(String country) {
        Human.country = country;
    }

    public void show() {
        System.out.println("姓名：" + name + ",年龄：" + age + ",国籍：" + country);
    }

}

public class HumanDemo {
    public static void main(String[] args) {
        //创建第一个对象
        Human h1 = new Human("张杰", 42, "中国");
        h1.show();

        //创建第二个对象
        Human h2 = new Human("彭于晏", 38);
        h2.show();

        //创建第三个对象
        Human h3 = new Human("蔡徐坤", 22);
        h3.show();

        h3.setCountry("加拿大");
        h1.show();
        h2.show();
        h3.show();



    }
}

定义一个人的类
        我们定义完并使用后发现，姓名和年龄不一样，是变化的，我们可以理解，因为每个人的姓名和年龄都不一样。
        但是，到目前位置，我们选的几个人都是中国人，他们的国籍都一样，都是中国。
        一样的国籍，我们每次在创建的时候，都会在堆内存中开辟这样的成员变量的空间。
        当一样国籍的人非常多的时候，这样就会造成内存浪费了，怎么办呢？
        针对于多个对象有着共同的成员变量，值是一样的时候。
        java就提供了一个关键字给我们使用，这个关键字叫做：static

        static:静态的
        它可以修饰成员变量和成员方法，它的作用是可以让所有的对象共享一个成员变量

2、特点

static关键字的特点：它可以修饰成员变量和成员方法

（1）随着类的加载而加载
        观察main方法
（2）优先于对象而存在的。
（3）被类的所有对象共享：
        举例：所有中国人的国籍信息都是中国都是一样。
        什么时候使用静态static关键字呢？
            如果某个成员变量是被所有的对象共享的，值是一样的，那么它就应该被定义为static静态的。
        举例现实生活的案例：
            哈罗共享单车（可以用静态的修饰）
            自己的水杯（不可以用静态的修饰）

（4）可以通过类名直接调用
        一般情况下，只要我们看到一个类中有静态修饰的成员变量或者是成员方法
        我们一律推荐使用 类名.静态成员 
        这种方式去使用静态修饰的内容我们一般称之为：类成员，与类相关的。

接下来看一个简单的例子感受下Staticz这个关键字

package com.shujia.wxl.day09;
class Student2{
    //非静态的成员变量
    int num = 20;

    //静态的成员变量
    static int num2 = 30;
}

public class StaticDemo1 {
    public static void main(String[] args) {
        Student2 s1 = new Student2();
        System.out.println(s1.num);
//        System.out.println(s1.num2);
        System.out.println(Student2.num2);
    }
}

3、Static关键字注意事项

(1)在静态方法中是没有this关键字的
   this代表的是当前调用该方法的对象，而被static修饰的成员是优先于对象而存在的。
   被static修饰的成员是随着类的加载而加载，这时候，还没有对象产生，也就说明没有this关键字
   所以在静态方法中无法使用this关键字。

(2)将成员方法分成两类：
   静态的成员方法：
           访问的内容：
                    成员变量：只能访问静态的成员变量
                    成员方法：只能访问静态的成员方法
  非静态的成员方法：
           访问的内容：
                    成员变量：既可以访问非静态的成员变量，也可以访问静态的成员变量
                    成员方法：既可以访问非静态的成员方法，也可以访问静态的成员方法

            如果你实在记不住这些，总结一句话：
               静态的只能访问静态的。

看一个具体实例：

package com.shujia.wxl.day09;

class Student3 {
    private String name;
    private int age;
    private static int a;

    public Student3() {
    }

    public Student3(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

//    public static int getAgeAgain(){
//        return this.age;
//    }
    public static void fun1(){
        //尝试访问非静态的成员变量name
        //无法从静态上下文中引用非静态 变量 name
        //静态的成员方法不能访问非静态的成员变量
//        System.out.println(name);

        //尝试访问静态的成员变量a
        //静态的成员方法可以访问静态成员变量
        System.out.println(a);

        //尝试访问非静态的成员方法show()
        //无法从静态上下文中引用非静态 方法 show()
        //静态的成员方法不能访问非静态的成员方法
//        show();

        //尝试方法静态的成员方法function()
        //静态的成员方法可以访问静态的成员方法
        function();

    }

    public void fun2(){
        //尝试访问非静态的成员变量name
        //非静态的成员变量可以访问非静态的成员方法
        System.out.println(name);

        //尝试访问静态的成员变量a
        //非静态的成员方法可以访问静态成员变量
        System.out.println(a);

        //尝试访问非静态的成员方法show()
        //非静态的成员方法可以方法非静态的成员方法
        show();

        //尝试方法静态的成员方法function()
        //非静态的成员方法可以访问静态的成员方法
        function();

    }

    public static void function(){

    }

    public void show() {
        System.out.println(name + "---" + age);
    }
}

public class StaticDemo2 {
    public static void main(String[] args) {

    }
}

三、静态的main方法

main方法的格式讲解：
public static void main(String[] args){…}

public: 公共的，访问权限是最大的，因为main是由JVM调用的，所以权限要足够大
static: 静态的，不需要创建对象，通过类名直接调用，方便JVM访问
void: 表示无返回值，因为我们直接说过返回值，是返回给调用者的，而调用main
方法是由JVM调用的，返回给它没有意义
  String[] args: 参数是是一个字符串数组，数组形参名叫args?
                这个东西怎么用？如果传参呢？值去哪里的呢？
                早期JDK1.5之前，没有Scanner键盘录入的时候，那时候
                程序员如何给程序传参呢？就是借助这里的args传参
                怎么用呢？
                    1、IDEA可以直接传参
                    2、命令传参
                        java MainDemo hello world java