构造方法，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）同步代码块（多线程讲解）

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