Java基础面向对象封装

属性封装

将属性隐藏起来，若需要访问某个属性，提供公共方法对其访问

属性封装的目的

• 隐藏类的实现细节

• 让使用者只能通过事先预定的方法来访问数据，从而可以在该方法里面加入控制逻辑，限制对成员变量的不合理访问。

• 可以进行数据检查，从而有利于保证对象信息的完整性。

• 便于修改，提高代码的可维护性。

实现

使用 `private` 修饰成员变量
private 数据类型 变量名 ；

代码：
public class Student {
  private String name;
  private int age;
}

提供 getXxx方法 / setXxx 方法，可以访问成员变量，代码如下：、

public class Student {
  private String name;
  private int age;

  public void setName(String n) {
    name = n;
  }

  public String getName() {
    return name;
  }

  public void setAge(int a) {
    age = a;
  }

  public int getAge() {
    return age;
  }
}

权限修饰符

class Test22_Exer_2{
    public static void main(String[] args){
        //创建一个可以装3个学生对象的数组
        Student[] arr = new Student[3];//只是申明这个数组，可以用来装3个学生，此时里面没有学生对象
        
        //从键盘输入
        java.util.Scanner input = new java.util.Scanner(System.in);
        for(int i=0;i<arr.length; i++){
            System.out.println("请输入第" + (i+1) + "个学生信息：");
//添加说明见备注
            arr[i] = new Student();
            
            System.out.print("姓名：");
            String name = input.next();
            arr[i].setName(name);
            
            System.out.print("成绩：");
            arr[i].setScore(input.nextInt());
        }
        
        //先显示一下目前的顺序
        for(int i=0; i<arr.length; i++){
            System.out.println(arr[i].getInfo());
        }
        
        System.out.println("------------------------------------------");
        //冒泡排序
        for(int i=1; i<arr.length; i++){
            for(int j=0; j<arr.length-i; j++){
                //arr[j] > arr[j+1]//错误的
                if(arr[j].getScore() > arr[j+1].getScore()){
                    //交换两个元素，这里是两个学生对象，所以temp也得是Student类型
                    Student temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
        //再显示一下目前的顺序
        for(int i=0; i<arr.length; i++){
            System.out.println(arr[i].getInfo());
        }
    }
}
class Student{
    private String name;
    private int score;//使用int或double都可以
    
    //get/set方法，
    public void setName(String n){
        name = n;
    }
    public String getName(){
        return name;
    }
    public void setScore(int s){
        score = s;
    }
    public int getScore(){
        return score;
    }
    
    public String getInfo(){
        return "姓名：" + name +"，成绩：" + score;
    }
}

/*for循环体中的i称为父作用域，当循环全部结束之后，i释放消失
student是子作用域，对于该变量内存的释放有两种解释（1）每次循环进行申请和释放（2)每次循环进行申请，释放得等回收机制
当函数不大的时候，并且变量的右边没有new，即没有在堆中新建内存的时候，推荐使用局部变量。因为不需要创建额外的栈空间，节省时间和空间。

当函数非常大，并且会有new堆内存的时候，这两种声明方式花销的时间和空间差不多，但是依着作用域最小化原则，推荐使用循环结构中声明变量的形式。
*/

构造器（Constructor)

 格式

【修饰符】 构造器名(){
    // 实例初始化代码
}
【修饰符】 构造器名(参数列表){
	// 实例初始化代码
}

public class Student {
    private String name;
    private int age;
    // 无参构造
      public Student() {} 
     // 有参构造
      public Student(String n,int a) {
        name = n;
        age = a; 
    }
    //此处其他代码省略
}

注意事项

1. 构造器名必须与它所在的类名必须相同。

2. 它没有返回值，所以不需要返回值类型，甚至不需要void

3. 如果你不提供构造器，系统会给出无参数构造器，并且该构造器的修饰符默认与类的修饰符相同

4. 如果你提供了构造器，系统将不再提供无参数构造器，除非你自己定义。

5. 构造器是可以重载的，既可以定义参数，也可以不定义参数。

6. 构造器不能被static、final、synchronized、abstract、native修饰

7. 在实例化对象时，调用！实例化一次调用一次

封装类(JavaBean)
必备的三要素

• a. 私有的属性
• b. 公有的get/set方法
• c. 公有的无参构造器

一般的情况

• a. 私有的属性
• b. 公有的get/set方法
• c. 全参构造器(所有属性值的初始化)
• d. 显示的创建无参构造器
• e. getInfo()方法--->toString()

this的使用

this代表当前对象的引用（地址值），即对象自己的引用。

• this可以用于构造器中：表示正在创建的那个实例对象，即正在new谁，this就代表谁

• this用于实例方法中：表示调用该方法的对象，即谁在调用，this就代表谁。

this使用格式

1、this.成员变量名

当方法的局部变量与当前对象的成员变量重名时，就可以在成员变量前面加this.，如果没有重名问题，就可以省略this.

this.成员变量名；

2、this.成员方法

调用当前对象自己的成员方法时，都可以加"this."，也可以省略，实际开发中都省略

【变量=】this.成员方法(【实参列表】);

3、this()或this(实参列表)

当需要调用本类的其他构造器时，就可以使用该形式。

要求：

必须在构造器的首行

如果一个类中声明了n个构造器，则最多有 n - 1个构造器中使用了"this(【实参列表】)"，否则会发生递归调用死循环

包（Package）

包的作用

1、可以避免类重名

有了包之后，类的全名称就变为：包.类名

2，可以控制某些类型或成员的可见范围

如果某个类型或者成员的权限修饰缺省的话，那么就仅限于本包使用

声明包的语法格式

package 包名;

注意：

(1)必须在源文件的代码首行

(2)一个源文件只能有一个声明包的语句

包的命名规范和习惯： （1）所有单词都小写，每一个单词之间使用.分割 （2）习惯用公司的域名倒置

例如：com.google.xxx;

建议大家取包名时不要使用“java.xx"包

使用其他包的类

前提：被使用的类或成员的权限修饰符是>缺省的

（1）使用类型的全名称

例如：java.util.Scanner input = new java.util.Scanner(System.in);

（2）使用import 语句之后，代码中使用简名称

import语句告诉编译器到哪里去寻找类。

import语句的语法格式：

import 包.类名;
import 包.*;
import static 包.类名.静态成员; //后面补充

注意：

使用java.lang包下的类，不需要import语句，就直接可以使用简名称

import语句必须在package下面，class的上面

当使用两个不同包的同名类时，例如：java.util.Date和java.sql.Date。一个使用全名称，一个使用简名称