Java-封装-构造器

目录
封装
构造器
属性赋值的先后顺序
this使用

• this的基本使用
• this调用构造器

package import

封装

封装 与 隐藏是面向对象的特性之一。
程序追求的是高内聚， 低耦合。
封装的作用： 隐藏内部的复杂性；只公开简单的接口；方便调用；从而提高可用性，扩展性；通俗的说就是隐藏该隐藏的， 暴露该暴露的。这就是封装的思想。

在对象的属性赋值的时候， 除了属性的数据类型，存储范围之外， 实际中还需要加上别的限制条件，但是又不能在声明属性的时候设置， 需要通过方法进行限制条件的添加。比如，setNama() 这样的方法 进行设置。 避免用户使用对象.属性的方式设置属性， 需要将属性设置修饰权限, private等方式。 这就体现了封装性。

封装性的体现：

1. 将属性XXX私有化，设置为private，再通过公共的方法(public)获取(getXXX)该属性和设置(setXXX)该属性。
2. 不对外暴露私有的方法
3. 单例模式

封装性的体现需要权限修饰符。
权限修饰符是置于类成员属性之前的，用于限制对象对成员属性的访问权限。
4种权限可以修饰属性，方法， 构造器，内部类。

修饰符	类内部	同一个包	不同包的子类	同一个工程
private	可用
缺省(default)	可用	可用
protected	可用	可用	可用
public	可用	可用	可用	可用

对于class的权限只能用public和default（缺省）修饰 。

修饰符	范围
public	任何地方都能访问
default（缺省）	只能被同一个包内部访问

示例代码：

package demo;
/*
*
* 封装性
*
* */
public class demo_7 {
    public static void main(String[] args) {
        Animal a = new Animal();

        a.setAge(50);
        System.out.println(a.getAge());
    }
}

class Animal{
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    private String name;
    private int age;

    public void setAge(int n){
        if(n > 10){
            age = n * 10;
        }else {
            age = -1;
        }
    }

    public int getAge(){
        return age;
    }
}

构造器

任何一个类都有构造器（构造方法）。
construct, construction, constructor

一 . 构造器作用：

1. 创建对象
2. 给对象做初始化 ；类似python的__init__方法。

二. 说明
3. 如果没有显示的定义一个构造器， 则系统默认定义一个空参的构造器；
4. 定义构造器的格式： 权限修饰符 类名（形参列表）{}
5. 构造器方法可以存在多个， 形参不同的。这叫做构造器的重载。
6. 一旦显示的定义了构造器， 系统不再提供默认的空构造器了。需要自己写了
7. 一个类至少有一个构造器。
8. 构造器默认的权限和类的权限是一样的

构造方法和方法还是不一样的， 使用来造对象的。 可以认定为相当于python
中的__init__， __new__方法。

属性赋值的先后顺序

1. 默认初始化值
2. 显示初始化
3. 构造器中赋值
4. 通过对象.属性的方法赋值

this使用

this的基本使用

this的作用： 修饰和调用属性，方法，构造器。
this修饰方法和属性，this可以理解为当前对象。

再累的方法中，我们可以使用this.属性， this.方法的方式调用属性或者方法，但是通常都会省略this。 但是特殊情况下不能省略。 如果方法的形参和属性同名了，我们必须的显示的表明该变量是属性， 使用this.变量的形式，而非形参。
示例代码：

package demo;

public class demo_9 {
    public static void main(String[] args) {
        Person1 p = new Person1();
        System.out.println(p);

        p.eat();

    }
}
class Person1{

    //    构造方法
    public Person1(){
        this.eat();
    }

//    构造方法
    public Person1(int age){
        this.age = age;
    }
    
    public String getName() {
//        return this.name;
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
//        return this.age;
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    private String name;
    private int age;

    public void eat(){
        System.out.println("吃饭");
        study();
//        this指的是当前的对象，是谁调用的eat方法，也会去调用studty方法。
//        比如是p对象调用的eat方法， 那也是p对象调用的study方法。
        this.study();  //  和上一行是一样的，this是省略的。

    }
    public void study(){
        System.out.println("学习");
    }
}

this调用构造器

这样的话降低代码的冗余。
在类的构造器可以显示的使用this.形参列表的方式，调用本类的中指定的其他构造器。
构造器不能通过this的方式调用自己， 会造成死循环。
规定：this（形参）必须在构造器内的首行。
构造器内部只能声明1个this（形参）。

package demo;

public class demo_9 {
    public static void main(String[] args) {
        Person1 p = new Person1(100,"assd");
        System.out.println(p);

//        p.eat();

    }
}
class Person1{

    //    构造方法
    public Person1(){
//        this.eat();
        System.out.println("我是空参构造器");
    }

//    构造方法
    public Person1(int age){
        this();
        System.out.println("我是age构造");
        this.age = age;
    }

    //    构造方法
    public Person1(String name){
        this();
        this.name = name;
        System.out.println("我是name构造");
    }

    //    构造方法
    public Person1(int age, String name){
        this(name);
        System.out.println("我是name age 构造器");
//        this(name);
//        this.name = name;
//        this.age = age;
    }
    
    public String getName() {
//        return this.name;
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
//        return this.age;
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    private String name;
    private int age;

    public void eat(){
        System.out.println("吃饭");
        study();
//        this指的是当前的对象，是谁调用的eat方法，也会去调用studty方法。
//        比如是p对象调用的eat方法， 那也是p对象调用的study方法。
        this.study();  //  和上一行是一样的，this是省略的。

    }

    public void study(){
        System.out.println("学习");
    }

}

package import

1. 为了更好的项目管理，提供报的概念。
2. 使用package声明类或者接口所属的包，声明在首行；
3. 包数标识符； 要遵循标识符的命名规范；
4. 每 “.” 一次都是一层文件目录 ；
5. 同一个包下， 不能命名同名的类， 接口；

---

import:

1. 导入指定包的下类
2. 声明在类的上面