Java学习路程之构造方法、静态变量、静态方法

一.构造方法
1.作用:对成员变量进行初始化
2.结构:关键字 类名(){};
注意:构造方法没有返回值,构造方法是系统调用的,并且每创建一个对象只创建一次.

public class Day06 {
    public static void main(String[] args) {
    //系统会根据你传入的参数来选择调用哪个方法
        Car c1 = new Car();
        c1.sayHi();
        //输出结果:
        {
            我是无参数的构造方法
            name:保时捷
            color:红色
        }
        Car c2 = new Car("保时捷", "黑色");
        c2.sayHi();
        //输出结果
        {
            我是有参数的构造方法
            name:保时捷
            color:黑色
        }
    }
}
//创建一个车的类
/*类的书写顺序:
 1.成员变量
 2.构造方法
 3.set/get方法
 4.成员方法*/   
class Car{
    private String name;
    private String color;
    //无参数的构造方法
    public Car(){
        //对成员变量进行初始化
        name = "保时捷";
        color = "红色";
        System.out.println("我是无参数的构造方法");
    }
    //有参数的构造方法
    //构造方法的重载,可以重名(只跟参数有关)
    public Car(String name,String color){
        this.name = name;
        this.color = color;
        System.out.println("我是有参数的构造方法");
    }
    //set/get方法
    public void setName(String name){
        this.name = name;
    }
    public String getName(){
        return name;
    }
    public void setColor(String color){
        this.color = color;
    }
    public void getColor(){
        return color;
    }
    //成员方法
    public void sayHi(){
        System.out.println("name:" + name);
        System.out.println("color:" + color);
    }
}

3.构造方法有无参数

public class Day06 {
    //如果不写无参数的构造方法,那么系统就会提供一个无参数的构造方法,如果写了就不会再提供
    注意:一般写类时都会写有参数和无参数的两种构造方法
    public static void main(String[] args) {
        Phone p1 = new Phone();
        p1.sayHi();
    }
}
//手机类
class Phone{
    private String name;
    //无参数构造方法
    public Phone() {
    }
    //有参数构造方法
    public Phone(String name) {
        this.name = name;
    }
    public void sayHi() {
        System.out.println(name);
    }
}

4.练习

/*需求:
 * 创建一个长方形的类
 * 设计 
 * 成员变量 长 宽 周长 面积 
 * 方法
 * 计算周长和面积
 * */
 public class Day06 {
    public static void main(String[] args) {
        Rectangle rectangle = new Rectangle(20,10);
        System.out.println("周长:" + rectangle.getGirth());//60
        System.out.println("面积:" + rectangle.getArea());//200
    }
 }
 class Rectangle{
     private int lang;
     private int height;
     private int girth;
     private int area;
     //构造方法
     public Rectangle(){

     }
     public Rectangle(int lang,int height){
        this.lang = lang ;
        this.height = height;
        //可以通过计算赋值成员变量
        this.girth = (lang + height) * 2;
        this.area = lang * height;  
        //get/set方法
        public void setLang(int lang) {
        this.lang = lang;
        }
        public int getLang() {
            return lang;
        } 
        public void setHeight(int height) {
            this.height = height;
        }
        public int getHeight() {
            return height;
        }
        //选择性提供set/get方法
        //用户不能随意设置周长和面积,所以只提供get方法
        public int getGirth() {
            return girth;
        }
        public int getArea() {
            return area;
        } 
        //介绍自己的方法
        public void SayHi() {
            System.out.println(lang);
            System.out.println(height);
        }
     }
 }

二.静态变量
1.静态变量（被所有对象共享）
关键词：static(修饰成员变量/方法)
好处：节省内存空间
2.调用方法
1）使用 对象 变量名 调用
2）直接使用类名调用(系统推荐)
3.成员变量和静态变量的区别
1).生命周期
成员变量：随着对象的创建而创建，销毁而销毁
静态变量：随着。class文件的加载而创建，程序的结束而销毁
2).所属不同
成员变量：属于对象
静态变量：属于类
3).内存位置
成员变量：保存在堆区
静态变量：保存在方法区的静态区
4).调用方法
成员变量：使用对象调用
静态变量：可以使用对象和类名调用（推荐）
注意:类是优先对象存在的

public class Day06 {
    public static void main(String[] args) {
        AVGirl girl1 = new AVGirl();
        girl1.girlName = "苍老师";
        AVGirl.country = "日本";
        girl1.sayHi();

        AVGirl girl2 = new AVGirl();
        girl2.girlName = "波老师";
        //girl2.country = "日本";
        girl2.sayHi();
    }
}

class AVGirl{
    //static修饰成员变量,该成员变量会存储在方法区的静态区
    String girlName;
    static String country;
    public void sayHi() {
        System.out.println(girlName +" "+ country);
    }
}
//静态变量在内存中的表现：
1.加载main函数所在的类的.class文件,Day06.class加载进入方法区
2.创建AVgirl对象,先把AVgirl.class文件加载,
3.然后创建girl1对象,该内存保存了成员变量,把系统生成的内存地址返回给girl1保存
4.通过girl1赋值成员变量
5.通过类名赋值静态变量
6.sayHi方法出入栈
7.main执行完毕

三.静态方法

public class Day06 {
/*
 * main方法解析
 * public 方法的使用权限(公开的)
 * static JVM可以直接使用类名调用main方法
 * main   不是关键字 但是名字不能换 JVM运行代码时就是找类中main这个静态方法
 * String[]可以接收用户的输入,
 * main方法中只有args可以更改
 * 
 * */
    public static void main(String[] args) {

    }
}
class Test{
    int num1 = 10;
    static int num2 = 20;
/*
 * 成员方法中可以使用成员变量也可以使用静态变量
 * */   
    public void fn1() {
        int num2 = 15;
        System.out.println(num1);
        //调用静态变量
        System.out.println(Test.num2);
        //在本类中调用本类的方法,可以省略this或类名
        fn2();
    }
    /*静态变量(类变量)
     * 静态方法(类方法)
     * 
     * 静态方法也是进栈执行
     * 跟静态变量一样被加载到方法区的静态区
     * 静态方法也是随着类的加载而加载
     * 
     * 注意:静态方法中不可以使用成员变量(静态方法被加载时还没有对象产生,成员变量也就不存在),也不可以使用this关键字
     * 
     * 静态方法的调用:使用对象(不推荐)或类名(推荐)
     * 成员方法中可以调用成员方法和静态方法
     * 静态方法中不能调用成员方法,但是可以调用静态方法
     * 
     * 总结:静态的只能使用静态的
     * */
    public static void fn2() {

    }
}