构造方法，this关键字，static关键字，封装

1.构造方法

定义：构造方法是指实例化对象的方法

语法：[修饰符]  类名（参数）{    }      

根据有无参数分为有参构造和无参构造

1）有参构造

语法：[修饰符]  类名（type 实例变量，int age，String name......）{    }   

2）无参构造

语法：[修饰符]  类名（）{   }

无参构造没有定义时，jvm会自动分配一个无参构造。

注：在使用有参构造时，jvm不会再默认分配一个无参构造，这时我们要自己定义一个无参构造。（反射只能识别无参构造）

public Dog(){
        health = 100;
        love = 0;
    }
public Dog(String _name,int _health,int _love,String _strain){
        name = _name;
        health = _health;
        love = _love;
        strain = _strain;
    }

3）局部变量和成员变量同名时的优先级

局部变量大于成员变量，所以改变局部变量的变量名称改为_name   或者  将成员变量改为  this.name（推荐后一种方法）

4）有参构造和无参构造是方法重载

2.this关键字

方法调用内存图：

方法调用内存图

this表示对象本身，有一个引用功能，指引用本身对象

this可以调用

1）this 实例变量

　　this . 变量名  =  成员变量  （可以解决局部变量和成员变量同名）

public Dog2(String name,int health,int love,String strain){
System.out.println("this:"+this);
    this.name = name;
    this.health = health;
    this.love = love;
    this.strain = strain;
}

2）this 实例方法

　　this . 方法名

public Dog(String name,int health,int love,String strain){
        this.setName(name);
        this.setHealth(health);
        this.setLove(love);
        this.setStrain(strain);
        
        // showInfo();
        this.showInfo();
    }

3）this 构造方法

　　this（有参构造的参数） 或  this（）

this(arg1,arg2,…)


    public Dog(){
        
    }
    
    public Dog(String name,int health,int love){
        this.setName(name);
        this.setHealth(health);
        this.setLove(love);
    }
    
    public Dog(String name,int health,int love,String strain){
        //this.setName(name);
        //this.setHealth(health);
        //this.setLove(love);
        
        // this调用本类的其他构造方法
        // System.out.println("test");
        this(name,health,love);
        this.setStrain(strain);
        
        // showInfo();
        //this.showInfo();
    }

注调用其他构造方法时，必须将其写在第一句，如

 public Dog(String name,int health,int love,String strain){
         
        // this调用本类的其他构造方法
        this(name,health,love);
         this.setStrain(strain);

 3.静态关键字（static）

需求:统计汽车工厂生成了多少量车？

     - 统计工厂生成了多少量汽车的功能应该放到类功能上，不应该属于某个对象。

      -声明一个变量用于统计个数，这个变量应该被类的实例共享。

      -被类的实例共享的区域在方法区(Car.class)

      -用static关键字声明这样的变量

static关键字表示静态，可以修改变量，也可以修饰方法。

1）静态变量（类变量）

语法：static 变量名 [ =初始化]      static int count = 0;

被static修饰的变量成为静态变量，归类所有，也称为类变量（count），存储与方法区中的静态区，可以被类的实例共享访问。

访问方式

-类名.静态变量（推荐）  Car.count;

-对象名.静态变量

2）静态方法（类方法）

 语法：public static 返回值类型 方法名（）{ 

                   return 返回值 ；

             }

public static int getCarCount(){

       return Car.count;

    }

 访问方式

-类名.静态方法名   （推荐）

 -对象。静态方法名

3）访问权限（类中包含静态成员[  静态变量和静态方法 ]  和实例成员[  实例变量和实例方法    ]）

静态方法不能访问非静态类成员；实例方法可以访问静态成员（为何如此？）

           类加载机制

              Car car  = new Car(…);

              当实例化一个对象时，jvm首先把Car.class加载到方法区

　　　    [1]读取Car.class 根据声明的成员变量计算申请内存需要的字节数

　　　　[2]读取Car.class 中的静态成员,给静态变量分配空间并初始化。

　　　　new Car 申请内存得到一个car对象，此时才有对象的空间。showInfo才可以通过car对象调用。

 4.封装

定义：将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问。

步骤

-1.将变量私有化

-2.提供公共的设置器和访问器

-3.在设置器和访问器中添加业务校验逻辑

public class Dog{
    
    // 【1】private 私有的，对外不可见
    private String name;
    private int health;
    private int love;
    private String strain;

    // 【2】提供公共的设置器(setter)和访问器(getter)
    public void setName(String name){
        // 【3】逻辑校验
        if(name.equals("")){
            System.out.println("姓名不能为空.");
        }else{
            this.name = name;
        }
    }
    public String getName(){
        return this.name;
    }
    
    public void setHealth(int health){
        if(health < 0){
            System.out.println("健康值不合法.");
            this.health = 0;
        }else{
            this.health = health;
        }
    }
    public int getHealth(){
        return this.health;
    }
    
    public void setLove(int love){
        if(love < 0){
            System.out.println("亲密度不合法.");
            this.love = 0;
        }else{
            this.love = love;
        }
    }
    public int getLove(){
        return this.love;
    }
    
    public void setStrain(String strain){
        if(strain.equals("")){
            System.out.println("品种不能为空.");
        }else{
            this.strain = strain;
        }
    }
    public String getStrain(){
        return this.strain;
    }
    
    
    public Dog(){
        
    }

    public Dog(String name,int health,int love,String strain){
        this.setName(name);
        this.setHealth(health);
        this.setLove(love);
        this.setStrain(strain);
    }
    
    public void showInfo(){
        System.out.print("我的名字叫"+this.name);
        System.out.print(",健康值"+this.health);
        System.out.print(",亲密度"+this.love);
        System.out.println(",我是一只"+this.strain);
    }
}

5.静态常量

定义：在程序运行中，如果有一个变量不会发生改变，可以声明一个静态常量，用static final 修饰。

public class Penguin{
    
    private String name;
    private int health;
    private int love;
    private String gender;
    // gender为Q仔     将Q仔改为雄
    static final String SEX_MALE = "雄";
    static final String SEX_FEMALE = "雌";
    
    public class Test02{
    public static void main(String[] args){
        
        Penguin penguin = new Penguin("大脚",100,0,Penguin.SEX_MALE);

　　　　　//用　Penguin.SEX_MALE 而不用Q仔，好处是更新程序时便于更改
    }
}

6.代码块

1）普通代码块

普通代码块一般存在于方法或者类、方法等的定义中，普通代码块形成一个作用域。

public class Test03{
    
    public static void main(String[] args){
        
        int count_1 = 10;
        
        // 普通代码块
        {
            int count_2 = 20;
            //System.out.println("count_1:"+count_1);
            //System.out.println("count_2:"+count_2);
        }
        
        // error
        System.out.println("count_2:"+count_2);
        
    }
}

2）构造代码块

构造代码块位于类中。构造代码块在构造方法前执行。构造一个对象执行一次。

public class Person{
    String name;
    int age;
    
    // 构造代码块
    {
        System.out.println("构造代码块");
    }
    
    public Person(){
        System.out.println("构造方法");
    }
    public Person(String name,int age){
        this.name = name;
        this.age = age;
    }
}

3）静态代码块

静态代码块位于类中，归类所有，用static修饰。在类加载时执行，在构建多个对象时只执行一次

public class Person{
    String name;
    int age;
    
    static{
        System.out.println("静态代码块");
    }
    
    public Person(){
        System.out.println("构造方法");
    }
    public Person(String name,int age){
        this.name = name;
        this.age = age;
    }
}

 4）同步代码块（多线程讲解）

      总结：静态代码块一般用于初始化静态资源，构造代码块一般用于初始化实例成员。