Java类（无参、有参构造方法、静态变量）

构造方法

作用：

初始化成员变量的

注意：

1.构造方法 没有返回值 甚至不写返回值的类型
2.构造方法的方法名 与类名 相同

书写：

关键字 构造方法名（）{
}

举例：

创建cat类：

public class Cat {
    private String name;  //猫名
    private String color; //颜色
    private String kind;     //种类

    //  构造方法
    public Cat() {
        name = "小不花";
        color = "不花色";
        kind = "中华不田园猫";
        System.out.println("我是猫类的构造方法");
    }

    //  获取猫名
    public String getName() {
        return this.name;
    }
    //  修改猫名
    public void setName(String name) {
        this.name = name;
    }

    //  获取颜色
    public String getColor() {
        return this.color;
    }
    //  修改颜色
    public void setColor(String color) {
        this.color = color;
    }

    //  获取种类
    public String getKind() {
        return this.kind;
    }
    //  修改种类
    public void setKing(String kind) {
        this.kind = kind;
    }

    //  会吃鱼
    public void eat() {
        System.out.println("会吃鱼");
    }

    //  会卖萌
    public void cute() {
        System.out.println("会卖萌");
    }

    //  会抓老鼠
    public void catchMouse() {
        System.out.println("会抓老鼠");
    }

    //  介绍自己
    public void sayHi() {
        System.out.println(name);
        System.out.println(color);
        System.out.println(kind);
    }
}

测试类：

public static void main(String[] args) {
    //  构造方法 如何调用
    //  构造方法是不用咱们调用的
    //  当你创建对象时 系统会帮你调用构造方法
    Cat cat = new Cat();
    //cat.setName("小花");
    //cat.setColor("花色");
    //cat.setKing("中华田园猫");
    cat.sayHi();

    Cat cat1 = new Cat();
    cat1.sayHi();
}

有参构造方法

注意：

不存在无参构造方法时 系统会提供无参构造方法

无参构造方法：

注意：

存在有参的构造方法时 系统不会提供无参的构造方法

书写：

成员变量 -> 无参有参构造方法 -> set/get方法 -> 成员方法

举例：

class Car{
    String name;
    int num;
    /*
     * 构造方法的重载：只跟参数有关
     * 当类中成员变量 需要计算时 可以在构造方法中完成
     */
    //  无参 构造方法
    public Car() {
        System.out.println("我是无参的构造方法");
    }

    //  有参 构造方法
    public Car(String name, int num) {
        //  初始化成员变量
        this.name = name;
        this.num = num;
        System.out.println("我是有参的构造方法");
    }

    public void sayHi() {
        System.out.println(name + "..." + num);
    }

    public void fun() {
        System.out.println("哈哈");
    }
}

测试：

public static void main(String[] args) {
    Car car = new Car();
    car.name = "法拉利";
    car.num = 911;
    car.sayHi();

    //  使用有参方法创建对象
    Car car2 = new Car("吉利金刚", 10);
    System.out.println(car2.name);

    //  在赋值成员变量时 使用哪种方法好？
    //  set方法 和 有参构造方法
    Car car3 = new Car("吉利美人豹", 11);
    //  使用构造方法修改车的名字 和 型号
    car3.sayHi();
}

举例：

需求：

创建一个矩形类
计算周长 和 面积（都是整数就行）

要求：

无参有参构造方法 set/get方法

class Square {
    private int length;    //  长
    private int width;     //  宽
    private int perimeter; //  周长
    private int area;      //  面积

    //  无参构造
    public Square() {       
    }   
    //  有参构造
    public Square(int length, int width) {
        this.length = length;
        this.width = width;
        //  计算周长 和 面积
        this.perimeter = (this.length + this.width) * 2;
        this.area = this.length * this.width;
    }

    //  长 get方法
    public int getLength() {
        return this.length;
    }   
    //  长 set方法
    public void setLength(int length) {
        this.length = length;
    }

    //  宽 get方法
    public int getWidth() {
        return this.width;
    }
    //  宽 set方法
    public void setWidth(int width) {
        this.width = width;
    }

    //  周长 get方法
    //  建议：不要修改set和get方法的 写法
    public int getPerimeter() {
        return this.perimeter;
    }
    //  周长 set方法
    public void setPerimeter(int perimeter) {
        this.perimeter = perimeter;
    }

    //  面积 get方法
    public int getArea() {
        return this.area;
    }
    //  面积 set方法
    public void setArea(int area) {
        this.area = area;
    }

    /*
    //  计算周长
    public int getPerimeter() {
        return(this.length + this.width) * 2;
    }
    //  计算面积
    public int getArea() {
        return this.length * this.width;
    }
    */
}

静态变量和静态方法

特点：

使用static修饰

静态变量：

静态变量保存在方法区的静态区（共享区）
静态变量是共享的区间

调用：

1.对象调用
2.类名调用（推荐）
  推荐原因：只要加载了.class文件 就加载静态变量 这时还没有对象产生

静态变量（类变量）和 非静态变量的（对象变量）区别

1.调用方式不同
  静态变量：  对象或类名去调用（推荐 类名）
  非静态变量：只能使用对象去调用
2.内存中存在位置不同
  静态变量：  方法区的静态区
  非静态变量：堆内存
3.加载的是不同
  静态变量：随着类的加载而加载（不依赖对象而加载）
  非静态变量：随着对象的创建而创建（依赖对象）
4.生命周期不同
  静态变量：  随着类的销毁而销毁（相当于程序结束）
  非静态变量：随着对象销毁而销毁

举例：

创建类

class Girl{
    String name;     //  姓名
    static String country;  //  国籍

    public void sayHi() {
        System.out.println(this.name + "..." + Girl.country);
    }
}

main中测试

public static void main(String[] args) {
    Girl girl1 = new Girl();
    girl1.name = "夏可可";
    Girl.country = "中国";
    girl1.sayHi();

    Girl girl2 = new Girl();
    girl2.name = "伊柯";
    girl2.sayHi();
}

图片分析：

总结步骤：

1.加载.class文件（字节码文件）到方法区
2.main方法入栈
3.要创建Girl的对象 先要加载 Girl.clss
  Girl.clss中分为 静态区和非静态区
  这时初始化静态变量country初始值为null
4.创建对象（堆内存开辟空间）
5.把对象地址 赋值给 girl 变量 保存
6.通过类名 修改 类变量的值
7.sayHi方法入栈 打印
8.sayHi出栈
9.main出栈

静态方法

特点：

使用static修饰的方法

非静态方法：
1.可以使用静态变量 和 非静态变量
2.可以使用静态方法 和 非静态方法

静态方法：
1.只能使用静态变量
2.只能使用静态方法

举例：

class Man {
    int num1 = 10;
    static int num2 = 5;
    //  非静态方法 可以访问 静态变量 和 非静态变量
    //  静态方法 可以访问啥？（加上静态 相当于 随着类改变 跟对象没关系）
    public void fun() {
        System.out.println(num1);
        System.out.println(num2);
        //  调用静态方法（类方法）推荐使用 类名调方法
        Man.sayHi();
    }

    public static void sayHi() {
        System.out.println("我是sayhi");
    }

    //  静态方法
    //  静态方法中 不能访问 非静态变量（因为加载类的时候 还没有对象）
    //  简单记：静态只能使用静态的
    public static void fun1() {
        //System.out.println(this.num1);
        System.out.println(Man.num2);
        sayHi();
    }
}

public static void main(String[] args) {
    Man man = new Man();
    man.fun();
    Man.fun1();

    /* 系统静态方法
     * Math.random();
     * Arrays.toString();
     */
}

main解析

main就是为了让jvm去调用的方法
public jvm调用这个方法 要使用最大权限
static jvm调用时是不需要创建对象 直接使用类名调就行
main 不是关键字 jvm只认识main这个词
String[] args 接收键盘输入的值