java：构造方法：无参构造/有参构造 this static关键字 静态变量 静态方法 代码块 封装 静态常量。

//大家可以关注一下我的博客  我的博客所有随笔都是我从基础开始学习java的所有知识点

/*构造方法是一种特殊的方法，专门用于构造/实例化对象，
形式:[修饰符] 类名(){ }
构造方法根据是否有参数分为无参构造和有参构造*/
public class Dog {                 //创建Dog类
String name;
int health;
int love;
String sex;
/*
无参方法（一般没有构造方法，系统默认无参方法，
同时可以直接在上面属性声明后面赋值，如果没有赋值，系统自动输入默认值）
但是加有参方法时，建议一定要把无参加上
修饰符+类名（）{}*/
public Dog(){
health=90;
love=10;
}


public void showOf(){
System.out.println("我的名字叫"+name);
System.out.println("健康值:"+health);
System.out.println("亲密度:"+love);
System.out.println("性别:"+sex);
}
}

public class Penguin {      //创建Penguin类
     String name;
     int health=100;           //属性
     int love=0;
     String kind;
     public void pay(){             //方法
         System.out.println("我的名字叫"+name);
          System.out.println("健康值"+health);
           System.out.println("亲密度"+love);
            System.out.println("品种"+kind);
     }
}

import java.util.Scanner;
public class Pet {
    public static void main(String [] ages){
        Scanner arr=new Scanner(System.in);
    System.out.println("请输入宠物的名字");
             String name=arr.next();
            
            
            System.out.println("请选择宠物类型1.企鹅2.狗狗");
            int a=arr.nextInt();
    if (a==1){
        Penguin sc=new Penguin();      //插入Penguin包
        sc.name=name;                   //赋值（从输入录入的值）
        
        System.out.println("请选择性别1.Q女2.Q男");
        int b=arr.nextInt();
        if (b==1) {
            sc.kind="Q女";            //赋值
        sc.pay();
        }else {
            sc.kind="Q男";
            sc.pay();
        }
    }else {
        Dog sc=new Dog();
        sc.name=name;
        System.out.println("请选择狗的种类1.土狗2.腊肠");
        int b=arr.nextInt();
        if (b==1){
            sc.sex="雄性";
            sc.showOf();
        }else {
            sc.sex="雌性";
            sc.showOf();
        }
    }
    }
}

4种结果

有参构造

/*构造方法是一种特殊的方法，专门用于构造/实例化对象，
形式:[修饰符] 类名(){ }
构造方法根据是否有参数分为无参构造和有参构造*/
public class Dog {
     String name;
     int health=10;
     int love=10;
     String sex;
    
     public Dog(){
         }
     
/*当构造一个对象时可以直接在构造方法中传递参数,
但是加有参方法时，建议一定要把无参加上
this 是一个关键字 表示对象本身，本质上是对象的地址，用来引用对象，
this用于访问本对象属性，同时解决局部变量和成员变量同名的问题。
通过打印this中的引用，可以看出对象dog和this指向同一内存。
一般而言，dog(在下面提取Dog类可见)用于类的外部，this用于类的内部。
因为类的内部根本不知道dog变量名的存在。
修饰符 类名（是属于Pet的属性）{}
this可以调用属性也可以调用方法和本类的构造方法（再下面代码有讲调用方法）
*/


    /* 如果没有赋值
    public Dog(String name,int health,int love,String sex){  //在Pet赋值
         this.name=name;    //pet先赋值给括号里的属性
         this.health=health;// this.Dog类的属性=括号内的属性
         this.love=love;
         this.sex=sex;
     }*/     
    //如果已经赋值，可以这样写
    public Dog(String name,String sex){  //在Pet赋值
         this.name=name;    //pet先赋值给括号里的属性
         this.sex=sex;// this.Dog类的属性=括号内的属性
         
         
     }
    

     public void showOf(){
         System.out.println("我的名字叫:"+this.name);
          System.out.println("健康值:"+this.health);
           System.out.println("亲密度:"+this.love);
            System.out.println("性别:"+this.sex);
     }
}

public class Pet {
    public static void main(String [] ages){
        //如果没有赋值这样写
    //Dog dog=new Dog("黑狗",50,50,"雄");
    //如果已经赋值这样写
    Dog dog=new Dog("黑狗","雄");//类是用new引入
    System.out.println("dog:"+dog);//对象的地址
    dog.showOf();//用Dog类的方法输出
        }
    }
    

两种结果

 对象初始化内存图

Car car  = new Car(…);

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

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

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

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

方法的调用内存图

被 static 修饰的静态方法可以访问实例，而实例不可以访问静态，因为静态在类中被先访问（因为在类中，静态优先访问）
如果类中所以都是静态的，那么可以在测试类中使用静态导入  import static ，这样在使用这个类时可以直接使用

/*需求：统计宠物店有几只狗
统计宠物店有几只狗的功能应该放在类功能上，不应该属于某个对象
声明一个变量用于统计个数，这个变量应该被类的实例共享。
被类的实例共享的区域在方法区(Car.class)
用static关键字声明这样的变量

static 关键字表示静态，可以修饰变量，也可以修饰方法。
静态变量 
static 修饰的变量称为静态变量/静态属性，形式  ：static 类型 变量名称 [= 初始值]
被static修饰的变量称为静态变量，归类所有，
分配在方法区(共享区)中的静态区，可以被类的实例共享访问。

*/
public class Dog {
     String name;
     int health;
     int love;
     String sex;
    static int count=0;
    /*静态变量归类所有，也叫类变量，访问方式
      [1] 类名.静态变量(推荐)
       [2] 对象.静态变量*/
     public Dog(){
         Dog.count++;
         }//必须两种构造都写

    public Dog(String name,int health,int love,String sex){  
         this.name=name;    
         this.health=health;
         this.love=love;
         this.sex=sex;
        Dog.count++;//必须两种构造都写
     }

     public void showOf(){
         System.out.println("我的名字叫:"+this.name);
          System.out.println("健康值:"+this.health);
           System.out.println("亲密度:"+this.love);
            System.out.println("性别:"+this.sex);
            System.out.println("我是第"+Dog.count+"只狗");
     }

      //实例方法可以访问静态成员。
       //静态方法不能访问非静态成员。
       //[修饰符] static 返回值类型 方法名(arg…){}

       //static 修饰的方法称为静态方法，形式

       public static int jiaoDog(){

        return Dog.count;
       }

}

public class Pet {
    public static void main(String [] ages){
    Dog dog1=new Dog("黑狗",50,50,"雄");
    dog1.showOf();
    Dog dog2=new Dog("白狗",60,20,"雌");
    dog2.showOf();
    Dog dog3=new Dog("黑狗",60,50,"雄");
    dog3.showOf();
    
    
    System.out.println(Dog.count);
    System.out.println(dog2.count);
    //类名.静态变量 对象.静态变量  都得到狗的总数
      // 所以建议选 类名.静态  因为选对象容易误会成这是第几只狗 其实所以德对象都是一样的

//静态方法归类所有，调用形式
//[1] 类名.方法名() (推荐)
//[2] 对象.方法名()
//得出来结果同上
System.out.println(Dog.jiaoDog());
System.out.println(dog2.jiaoDog())；

      }
    }

 

代码块通过{}声明，根据其位置可以分为普通代码块、静态代码块、构造代码块、同步代码块(多线程讲解)

 

 

静态代码块

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

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

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

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

/*封装：将类的某些信息隐藏在类内部，不允许外部程序直接访问，
而是通过该类提供的方法来实现对隐藏信息的操作和访问。
封装的步骤
[1]属性私有化
[2]提供公共的设置器和访问器
[3]在设置器和访问器中添加业务校验逻辑
private 私有的，对外不可见
*/
public class Dog {
    private String name;  //private 私有的，对外不可见
     private int health;   //private 私有的，对外不可见
     private  int love;    //private 私有的，对外不可见
     private String sex;   //private 私有的，对外不可见
    static int count=0;
    //提供公共的设置器（setter）(设置访问条件，不同条件有不同的应对)和访问器（getter）
    //设置器在下面被调用并赋值
     public void setName(String name){
         if(name.equals("")){
             System.out.println("姓名不能为空");
         }else {
             this.name=name;
         } 
         }
         //用public修饰的成员变量和方法称为共有变量和共有方法：
         //因为上面已经私有化了，所以调用Dog类只能通过这个来返回值
         public String getName(){
        return this.name;
    }
    
          public void setHealth(int health){
              if (health<0){
                 System.out.println("健康值不合法");  
              }else {
                  this.health=health;
              }
              }
              public int getHealth(){
        return this.health;
    }
             public void setLove(int love){
                 if (love<0){
                     System.out.println("亲密度不合法");
                 } else {
                     this.love=love;
                 }
                      }
                     public int getLove(){
                         return this.love;
                     }
                      public void setSex(String sex){
                        if (sex.equals("")){
                             System.out.println("性别不能为空");
                        }  else{
                            this.sex=sex;
                        }
                      }
                      public String getSex(){
                          return this.sex;
                      }
    //无参构造
     public Dog(){
         Dog.count++;
     }
    //有参构造                  
    public Dog(String name,int health,int love,String sex){  
         this.setName(name); 
         this.setHealth(health)//this调用本类的构造方法 this（）
         this.setLove(love);
//this.showOf();   this调用方法

//注意:this调用其他构造方法必须写到构造方法的第一句。

this.setSex(sex);
        Dog.count++;
     }

     public void showOf(){
         System.out.print("我的名字叫:"+this.name+"	");
          System.out.print("健康值:"+this.health+"	");
           System.out.print("亲密度:"+this.love+"	");
            System.out.print("性别:"+this.sex+"	");
            System.out.println("我是第"+Dog.count+"只狗");
     }

public class Pet {
    public static void main(String [] ages){
    Dog dog1=new Dog("黑狗",50,50,"");
    dog1.showOf();
    Dog dog2=new Dog("",60,20,"雌");
    dog2.showOf();
    Dog dog3=new Dog("黑狗",-10,50,"雄");
    dog3.showOf();

    }
    }
    

1.1 静态常量

在程序运行过程中，如果一个量的值不会发生改变，可以把该量声明为静态常量，用static final修饰。

public class Dog {
    private String name;  //private 私有的，对外不可见
     private int health;  
     private  int love;    
       private String sex;
   
    /*静态常量一般用于狗的数量过多，而性别就这么两个，为了方便更改而设立
    假如我想把狗的性别雄改为（旺男），我只需要在静态常量这改，然后怎么总体都会改
    不需要一个个的去改，适合版本升级*/
    static final String SEX_MALE="雄";//常量名所有字母全部大写，链接单词时必须下划线
    static final String SEX_FEMALE="雌";
     public void setName(String name){
         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("健康值不合法");  
              }else {
                  this.health=health;
              }
              }
              public int getHealth(){
        return this.health;
    }
             public void setLove(int love){
                 if (love<0){
                     System.out.println("亲密度不合法");
                 } else {
                     this.love=love;
                 }
                      }
                     public int getLove(){
                         return this.love;
                     }
                     public void setSex(String sex){ 
                     this.sex=sex;
                     }
                      public String getSex(){
                          return this.sex;
                      }
    //无参构造
     public Dog(){
         
     }/*public Dog(String name,int health,int love,String sex){  
         this.setName(name);     
          this.setHealth(health);
         this.setLove(love);    
         this.setSex(sex)
         */
     //写法改变 但效果一样
     public Dog(String name,String sex){  
    this.setName(name);
    this.setSex(sex);
    
        
     }
                  
    public Dog(String name,int health,int love,String sex){  
    this(name,sex);   //this调取方法
    this.setHealth(health);
    this.setLove(love);    
    
        
     }

     public void showOf(){
         System.out.print("我的名字叫:"+this.name+"	");
          System.out.print("健康值:"+this.health+"	");
           System.out.print("亲密度:"+this.love+"	");
            System.out.print("性别:"+this.sex+"	");
            
     }
    
}

public class Pet {
    public static void main(String [] ages){
    Dog dog1=new Dog("黑狗",50,50,Dog.SEX_FEMALE);//静态常量的提取必须      类.常量名
    dog1.showOf();
    Dog dog2=new Dog("白狗",60,20,Dog.SEX_MALE);
    dog2.showOf();
    Dog dog3=new Dog("黑狗",10,50,Dog.SEX_FEMALE);
    dog3.showOf();

    }
    }