封装，this关键字，构造器，static关键字

 封装：

封装的目的：提高数据安全性，通过封装，可以实现对属性的访问控制权限控制，同时增加了程序的可维护性。

什么是封装？将属性私有化，使用private关键字完成属性私有化，这种属性只有本类能访问。一般对每一个私有属性提供公共的public的set和get这种方法供外界来访问私有属性。

private是私有化的意思，public的权限是所有类都可以访问具体的封装实现：

class Cat{
    //定义成员变量，也就是属性，然后进行封装(定义私有的属性)
    
    private String name;
    private int age;
    private double weight;
    
    //当对封装过的属性在别的类中进行调用的时候需要给外部一个方法进行调用和插入值
    //定义一个set方法把值赋给对象的属性
    public void setName(String name){
        this.name = name;
        }
        
    public void setAge(int age){
        this.age = age;
        }
        
  public void setWeight(double weight){
      this.weight = weight;
      }
    
        
        //定义一个get方法让别的类对对象的属性进行取值
        public String getName(){
            return name;
            }
            
        public int getAge(){
            return age;
            }
        
        public double getWeight(){
            return weight;
            }
        
    }
    
    //定义一个测试类
    class TestCat{
        public static void main(String[] args){
            //实例化一个对象，对对象的属性进行调用
            //使用set方法对私有属性进行赋值操作
            Cat cat = new Cat();
            cat.setName("大黑");
            cat.setAge(1);
            cat.setWeight(0.8);
            //使用get方法得到私有的属性值
            String name = cat.getName();
            int age = cat.getAge();
            double weight = cat.getWeight();
            
            System.out.println("姓名："+name+"    年龄："+age+"     体重："+weight);
            
            }
        }

this关键字：

this可以在方法内区分同类的类的属性和参数名，有this的一定是属性，没有this的一定是参数名。在上图代码中，this.name中的name就是属性，后面的name是参数，然后把参数值赋给了属性。

this只能在类的对象方法中使用。this代表当前调用这个方法的对象的本身。如下的代码，两个打印出的结果一致：

class Cat{
    //定义属性
    int age ;
    
    //定义一个方法
    public void eat(){
        System.out.println(this);
        }
        
}
//定义一个测试类
class TestCat{
    public static void main(String[] args){
        //声明一个对象
        Cat cat = new Cat();
        System.out.println(cat);
        System.out.println("-----------");
        cat.eat();
        }
    }

构造器：

构造器的特点：

1.方法名和类名一致

2.方法没有返回值，没有void

3.参数可有可无

构造器的语法：

public   类名（数据类型   参数值，.......）{

}

构造器的目的：创建对象。

class Cat{
    String name;
    int age;
    double weight;
    //定义一个构造器
    public Cat(String name){
        this.name = name;
        }
        
        /**
        *通过this（实参列表）可以调用本类中的构造器，但是对this的调用必须是本类中的
        *第一个语句
        */
        
    public Cat(String name, int age){
        
        /**
        *或者直接在第一行使用this关键字调用一个参数本类的构造器
        this(name);
        */
        this.name = name;
        this.age = age;
        }
        
    public Cat(String name, int age, double weight){
        /**
        *或者直接在第一行使用this关键字调用两个参数本类的构造器
        this(name,age);
        */
        this.name = name;
        this.age = age;
        this.weight = weight;
        }
    
}

//定义一个测试类
class TestCat{
    public static void main(String[] args){
        //调用构造器构造一只猫
        Cat cat1 = new Cat("大黑");
        System.out.println(cat1.name);
        System.out.println(cat1.age);
        System.out.println(cat1.weight);
        System.out.println("------------------------");
        
        Cat cat2 = new Cat("二黑", 21 );
        System.out.println(cat2.name);
        System.out.println(cat2.age);
        System.out.println(cat2.weight);
        System.out.println("------------------------");
        
        Cat cat3 = new Cat("喵喵", 3, 2.1);
        System.out.println(cat3.name);
        System.out.println(cat3.age);
        System.out.println(cat3.weight);
        System.out.println("------------------------");
        
        }
    }

注意：如果类中没有带有参数的构造器，就可以使用一个隐藏的默认构造器来创建对象，如果一旦有带有参数的构造器，默认的构造器就会被覆盖。可以显式的定义出来默认构造器就可以使用了。

static关键字

1.修饰在属性上

   定义类属性：    static   数据类型    变量名

类属性访问：

     使用类名调用类属性（推荐使用）：类名.类属性名（）；

     使用对象来调用类属性（不建议）：对象名.类属性名（）；

class User{
    
    String username;
    
    String password;
    
    /**
     * 类属性
     */
    static int userCount;
    
    
    public void introduce(){
        System.out.println("用户名："+username+"    密码："+password);
    }
}

class TestUser{
    /**
         类：        模板
         对象：    样本
     
     */
    public static void main(String [] args){
        //创建一个user对象
        User user = new User();
        //把类属性做加一,类名.类属性
        User.userCount++;
        //再次创建user对象
        User user1 = new User();
        //使用类名来调用类属性（建议）
        User.userCount++;
        
        User user2 = new User();
        //使用对象来调用类属性（不建议这么用）
        user2.userCount++;
        
        System.out.println("人数："+User.userCount);
        
        
    }
}

类属性的生命周期：

User.class加载到JVM中时类属性就产生了，JVM消失时类属性就消失。（类属性在数据共享区）

对象属性：

当对象被创建的时候就产生了，当对象所在的方法执行完毕就会被垃圾回收器回收掉。

static修饰在方法上（类方法或静态方法）

语法：

public   static   返回值类型[void]     方法名（数据类型   参数名，.......）{

      方法体

      return   结果；

}

类方法的调用：

类名.类方法名（）；（推荐使用）

对象.类方法名（）；（不推荐使用）

class Cat{
    String name;
    int age;
    double weight;
    //定义一个类属性
    static int catCount;
    /**
    对象的方法，每一只猫的实例都可以调用
    */
    public void eat(){
        System.out.println(this.name+"在吃鱼");
    }
        
    /**
    类方法
    */
    public static void sleep(){
        System.out.println(catCount+"在睡觉");
        }
        
        
    }
class TestCat{
    public static void main(String[] args){
    Cat cat = new Cat();
    cat.name = "大黑";
    //调用对象的方法
    cat.eat();
    //使用类名调用类方法
    Cat.sleep();
    //使用对象名来调用类方法
    cat.sleep();
    }
}

在类方法中不能使用对象的属性，类方法只能使用类属性。