12.24学习Java的day08【封装、权限修饰符、包、代码块、构造器】

day08【面向对象基础–中】

今日内容

• 封装
• 权限修饰符
• 包
• 构造器
• 代码块

教学目标

• 理解封装的概念
• 掌握权限修饰符的使用
• 掌握属性的封装
• 理解包的作用
• 掌握包的声明与导入
• 掌握构造器的声明与使用
• 掌握this关键字的使用
• 会声明标准的JavaBean

第六章 面向对象基础–中

6.1 封装

6.1.1 封装概述

1、为什么需要封装？

• 我要用洗衣机，只需要按一下开关和洗涤模式就可以了。有必要了解洗衣机内部的结构吗？有必要碰电动机吗？
• 我们使用的电脑，内部有CPU、硬盘、键盘、鼠标等等，每一个部件通过某种连接方式一起工作，但是各个部件之间又是独立的
• 现实生活中，每一个个体与个体之间是有边界的，每一个团体与团体之间是有边界的，而同一个个体、团体内部的信息是互通的，只是对外有所隐瞒。

面向对象编程语言是对客观世界的模拟，客观世界里每一个事物的内部信息都是隐藏在对象内部的，外界无法直接操作和修改，只能通过指定的方式进行访问和修改。封装可以被认为是一个保护屏障，防止该类的代码和数据被其他类随意访问。适当的封装可以让代码更容易理解与维护，也加强了代码的安全性。

随着我们系统越来越复杂，类会越来越多，那么类之间的访问边界必须把握好，面向对象的开发原则要遵循“高内聚、低耦合”，而“高内聚，低耦合”的体现之一：

• 高内聚：类的内部数据操作细节自己完成，不允许外部干涉；
• 低耦合：仅对外暴露少量的方法用于使用

隐藏对象内部的复杂性，只对外公开简单的接口。便于外界调用，从而提高系统的可扩展性、可维护性。通俗的讲，把该隐藏的隐藏起来，该暴露的暴露出来。这就是封装性的设计思想。

2、如何实现封装呢？

访问控制修饰符来控制相应的可见边界，边界有如下：

（1）类

（2）包

（3）模块：Java9之后引入

（4）系统

3、访问控制修饰符

通俗的讲，封装就是把该隐藏的隐藏起来，该暴露的暴露出来。那么暴露的程度如何控制呢？就是依赖访问控制修饰符，也称为权限修饰符来控制。

对于类的成员：四种权限修饰符都可以使用

对于外部的类：只能使用public和缺省两种

6.1.2 成员变量/属性私有化问题

1、属性封装的目的

• 隐藏类的实现细节
• 让使用者只能通过事先预定的方法来访问数据，从而可以在该方法里面加入控制逻辑，限制对成员变量的不合理访问。
• 可以进行数据检查，从而有利于保证对象信息的完整性。
• 便于修改，提高代码的可维护性。

2、实现步骤

1. 使用 private 修饰成员变量

private 数据类型 变量名 ；

代码如下：

public class Chinese {
    private static String country;
    private String name;
  	private int age;
}

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

public class Chinese {
  	private static String country;
    private String name;
  	private int age;
    
    public static void setCountry(String c){
        country = c;
    }
    
    public static String getCountry(){
        return country;
    }

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

    public String getName() {
        return name;
	}

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

    public int getAge() {
        return age;
    }
}

3、如何解决局部变量与成员变量同名问题

当局部变量与类变量（静态成员变量）同名时，在类变量前面加“类名."；

当局部变量与实例变量（非静态成员变量）同名时，在实例变量前面加“this.”

public class Chinese {
  	private static String country;
    private String name;
  	private int age;
    
    public static void setCountry(String country){
        Chinese.country = country;
    }
    
    public static String getCountry(){
        return country;
    }

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

    public String getName() {
        return name;
	}

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

    public int getAge() {
        return age;
    }
}

4、 练习

（1）定义矩形类Rectangle，

​ 声明静态变量sides，初始化为4，表示矩形边长的总数量；

​ 声明实例变量长和宽

​ 全部私有化，并提供相应的get/set方法

（2）在测试类中创建Rectangle对象，并调用相应的方法测试

（2）测试类ObjectArrayTest的main中创建一个可以装3个学生对象的数组，并且按照学生成绩排序，显示学生信息

6.1.3 包（Package）

1、包的作用

（1）可以避免类重名：有了包之后，类的全名称就变为：包.类名

（2）分类组织管理众多的类

例如：

• java.lang----包含一些Java语言的核心类，如String、Math、Integer、 System和Thread等，提供常用功能
• java.net----包含执行与网络相关的操作的类和接口。
• java.io ----包含能提供多种输入/输出功能的类。
• java.util----包含一些实用工具类，如集合框架类、日期时间、数组工具类Arrays，文本扫描仪Scanner，随机值产生工具Random。
• java.text----包含了一些java格式化相关的类
• java.sql和javax.sql----包含了java进行JDBC数据库编程的相关类/接口
• java.awt和java.swing----包含了构成抽象窗口工具集（abstract window toolkits）的多个类，这些类被用来构建和管理应用程序的图形用户界面(GUI)。

（3）可以控制某些类型或成员的可见范围

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

2、声明包的语法格式

package 包名;

注意：

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

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

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

例如：com.atguigu.xxx;

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

3、如何在命令行编译和运行声明包的Java文件（了解）

编译格式：

javac -d class文件存放路径 源文件路径名.java

例如：

package com.atguigu.demo;

public class TestPackage {
	public static void main(String[] args) {
		System.out.println("hello package");
	}
}

编译：

javac -d . TestPackage.java

其中 . 表示在当前目录生成包目录

运行：

java com.atguigu.demo.TestPackage

定位到com目录的外面才能正确找到这个类

使用类的全名称才能正确运行这个类

4、如何跨包使用类

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

（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。一个使用全名称，一个使用简名称

示例代码：

package com.atguigu.bean;

public class Student {
	// 成员变量
	private String name;
	private int age;

	// 构造方法
	public Student() {
	}

	public Student(String name, int age) {
		this.name = name;
		this.age = age;
	}

	// 成员方法
	public void setName(String name) {
		this.name = name;
	}

	public String getName() {
		return name;
	}

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

	public int getAge() {
		return age;
	}
}

package com.atguigu.test;

import java.util.Scanner;
import java.util.Date;
import com.atguigu.bean.Student;

public class Test{
    public static void main(String[] args){
        Scanner input = new Scanner(System.in);
        Student stu = new Student();
        String str = "hello";
        
        Date now = new Date();
        java.sql.Date d = new java.sql.Date(346724566);        
    }
}

6.2 初始化

6.2.1 成员变量初始化问题

我们知道类中成员变量都有默认值，但是有时候我们想要为它们赋值一些指定值，那么此时我们该怎么办呢？

（1）显式赋值

public class Student{
	private static String school = "尚硅谷";
	private String name;
	private char gender = '男';
}

（2）初始化块

如果成员变量想要初始化的值不是一个硬编码的常量值，而是需要通过复杂的计算或读取文件等方式才能获取的一些值，该怎么办呢？

public class Student{
	private static String school;
	private String name;
	private char gender;
	
	static{
		//获取系统属性，这里只是说明school的初始化过程可能比较复杂
		school = System.getProperty("school");
		if(school==null) {
			school = "尚硅谷";
		}
	}
	{
		String info = System.getProperty("gender");
		if(info==null) {
			gender = '男';
		}else {
			gender = info.charAt(0);
		}
	}
	public static String getSchool() {
		return school;
	}
	public static void setSchool(String school) {
		Student.school = school;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public char getGender() {
		return gender;
	}
	public void setGender(char gender) {
		this.gender = gender;
	}

}

6.2.2 初始化块（代码块）

1、初始化块的语法格式

静态初始化块：为静态变量初始化

【修饰符】 class 类名{
    static{
		静态初始化
	}
}

实例初始化：为实例变量初始化

【修饰符】 class 类名{
    {
		实例初始化块
	}
}

2、作用

静态初始化块：为静态类变量初始化用的

实例初始化块：为非静态实例变量初始化用的

3、执行特点

静态初始化块：在类初始化时由类加载器调用执行，每一个类的静态初始化只会执行一次，早于实例对象的创建。

实例初始化块：每次new实例对象时自动执行，每new一个对象，执行一次。

public class InitDemo{
	static{
		System.out.println("静态初始化块1");
	}
    {
		System.out.println("实例初始化块1");
	}
    static{
		System.out.println("静态初始化块2");
	}
    {
		System.out.println("实例初始化块2");
	}
    
    public static void main(String[] args){
        InitDemo i1 = new InitDemo();
        InitDemo i2 = new InitDemo();
    }
}

运行结果：

静态初始化块1
静态初始化块2
实例初始化块1
实例初始化块2
实例初始化块1
实例初始化块2

6.2.3 构造器（Constructor)

我们发现，实例初始化块为每一个实例对象的实例变量初始化的都是相同的值，那么我们如果想要不同的实例对象初始化为不同的值，怎么办呢？此时我们可以考虑使用构造器。

1、构造器的作用

在创建对象的时候为实例变量赋初始值。

注意：构造器只为实例变量初始化，不为静态类变量初始化

2、构造器的语法格式

构造器又称为构造方法，那是因为它长的很像方法。但是和方法还有有所区别的。

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

代码如下：

public class Student {
	private String name;
	private int age;
	// 无参构造
  	public Student() {} 
 	// 有参构造
  	public Student(String name,int age) {
		this.name = name;
    	this.age = age; 
	}
  	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
}

注意事项：

1. 构造器名必须与它所在的类名必须相同。
2. 它没有返回值，所以不需要返回值类型，甚至不需要void
3. 如果你不提供构造器，系统会给出无参数构造器，并且该构造器的修饰符默认与类的修饰符相同
4. 如果你提供了构造器，系统将不再提供无参数构造器，除非你自己定义。
5. 构造器是可以重载的，既可以定义参数，也可以不定义参数。
6. 构造器的修饰符只能是权限修饰符，不能被其他任何修饰

3、练习

（1）声明一个员工类，

• 包含属性：编号、姓名、薪资、性别，要求属性私有化，提供get/set，
• 提供无参构造器和有参构造器
• 提供getInfo()

（2）在测试类的main中分别用无参构造和有参构造创建员工类对象，调用getInfo

public class TestEmployee {
	public static void main(String[] args){
		//分别用无参构造和有参构造创建对象，调用getInfo
		Employee e1 = new Employee();
		System.out.println(e1.getInfo());
		
		Employee e2 = new Employee("1001","张三",110000,'男');
		System.out.println(e2.getInfo());
		
		e2.setSalary(120000);
		System.out.println(e2.getInfo());
		
		System.out.println("e1薪资：" + e1.getSalary());
	}
}
class Employee{
	private String id;
	private String name;
	private double salary;
	private char gender;
	
	//提供无参构造器和有参构造器
	public Employee(){
		
	}
	public Employee(String id, String name){
		this.id = id;
		this.name = name;
	}
	public Employee(String id, String name, double salary, char gender){
		this.id = id;
		this.name = name;
		this.salary = salary;
		this.gender = gender;
	}
	
	public String getId() {
		return id;
	}
	public void setId(String id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public double getSalary() {
		return salary;
	}
	public void setSalary(double salary) {
		this.salary = salary;
	}
	public char getGender() {
		return gender;
	}
	public void setGender(char gender) {
		this.gender = gender;
	}
	
	//提供getInfo()
	public String getInfo(){
		return "编号：" + id + "，姓名：" + name + "，薪资：" + salary + "，性别：" +gender;
	}
}

6.2.4 多种初始化方式的顺序问题

1、类初始化

如果一个静态类变量，既有显式赋值，又有静态初始化块，那么是什么结果呢？

public class TestClinit {
	static {
		System.out.println("静态初始化块1");
	}
	
	private static int num = init();
	
	static {
		System.out.println("静态初始化块2");
	}
	
	private static int init() {
		System.out.println("init()：num = " + num);
		return 1;
	}
	
	public static void main(String[] args) {
		
	}
}

1572416947787.png
结论：显式赋值与静态初始化按顺序执行

剖析：

其实Java编译器在编译Java类的时候，对类的代码做了处理的，编译器会将Java类的静态变量的显式赋值语句与静态初始化的语句合并组装成一个()的类初始化方法。

2、实例初始化

如果一个非静态的实例变量，既有显式赋值，又有实例初始化块，还有构造器，那么是什么结果呢？

public class TestInit {
	public TestInit(){
		System.out.println("无参构造");
	}
	public TestInit(int num){
		System.out.println("有参构造");
		this.num = num;
	}
	{
		System.out.println("实例初始化块1");
	}
	private int num = init();
	{
		System.out.println("实例初始化块2");
	}
	
	public int init() {
		System.out.println("init()：num = " + num);
		return 1;
	}
	
	public static void main(String[] args) {
		TestInit t1 = new TestInit();
        System.out.println("------------------------");
		TestInit t2 = new TestInit(2);
	}
}

运行结果：

实例初始化块1
init()：num = 0
实例初始化块2
无参构造
------------------------
实例初始化块1
init()：num = 0
实例初始化块2
有参构造

结论：

（1）显式初始化与实例初始化块，无论你通过哪个构造器创建实例对象，它们都会执行

（2）显式赋值与实例初始化块按顺序执行

（3）对应构造器的代码最后执行

剖析：

其实Java编译器在编译Java类的时候，对类的代码做了处理的，编译器会将Java类的实例变量的显式赋值语句与实例初始化、构造器的语句合并组装成一个个(…)的实例初始化方法，你声明了几个构造器，最后就有几个对应的实例初始化方法，如果类中没有声明任何构造器，那么就默认有一个无参构造，即对应也就有一个无参的实例初始化方法。

构造器和实例初始化块

从某种程度上来看，非静态代码块（实例初始化块）是对构造器的补充，非静态代码块总是在构造器执行之前执行。与构造器不同的是，非静态代码块是一段固定执行的代码，它不能接收任何参数。因此非静态代码块对同一个类的所有对象所进行的初始化处理完全相同。基于这个原因，不难发现非静态代码块的基本用法，如果有一段初始化处理代码对所有对象完全相同，且无须接收任何参数，就可以把这段初始化处理代码提取到非静态代码块中。

即如果每个构造器中有相同的初始化代码，且这些初始化代码无须接收参数，就可以把它们放在非静态代码块中定义。通过把多个构造器中相同代码提取到非静态代码块中定义，能更好地提高初始代码的复用，提高整个应用的可维护性。

3、类初始化与实例初始化的顺序

类初始化一定优先于实例初始化，而且每个类的类初始化只会发生一次，而实例初始化是看每次new对象都要执行一次。

6.3 标准JavaBean

JavaBean 是 Java语言编写类的一种标准规范。符合JavaBean 的类，要求：

（1）类必须是具体的和公共的，

（2）并且具有无参数的构造方法，

（3）成员变量私有化，并提供用来操作成员变量的set 和get 方法。

public class ClassName{
  //成员变量
    
  //构造方法
  	//无参构造方法【必须】
  	//有参构造方法【建议】
  	
  //getXxx()
  //setXxx()
  //其他成员方法
}

编写符合JavaBean 规范的类，以学生类为例，标准代码如下：

public class Student {
	// 成员变量
	private String name;
	private int age;

	// 构造方法
	public Student() {
	}

	public Student(String name, int age) {
		this.name = name;
		this.age = age;
	}

	// get/set成员方法
	public void setName(String name) {
		this.name = name;
	}

	public String getName() {
		return name;
	}

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

	public int getAge() {
		return age;
	}
    
    //其他成员方法列表
    public String getInfo(){
        return "姓名：" + name + "，年龄：" + age;
    }
}

测试类，代码如下：

public class TestStudent {
	public static void main(String[] args) {
		// 无参构造使用
		Student s = new Student();
		s.setName("柳岩");
		s.setAge(18);
		System.out.println(s.getName() + "---" + s.getAge());
        System.out.println(s.getInfo());

		// 带参构造使用
		Student s2 = new Student("赵丽颖", 18);
		System.out.println(s2.getName() + "---" + s2.getAge());
        System.out.println(s2.getInfo());
	}
}

me;
this.age = age;
}

// get/set成员方法
public void setName(String name) {
	this.name = name;
}

public String getName() {
	return name;
}

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

public int getAge() {
	return age;
}

//其他成员方法列表
public String getInfo(){
    return "姓名：" + name + "，年龄：" + age;
}

}

测试类，代码如下：

```java
public class TestStudent {
	public static void main(String[] args) {
		// 无参构造使用
		Student s = new Student();
		s.setName("柳岩");
		s.setAge(18);
		System.out.println(s.getName() + "---" + s.getAge());
        System.out.println(s.getInfo());

		// 带参构造使用
		Student s2 = new Student("赵丽颖", 18);
		System.out.println(s2.getName() + "---" + s2.getAge());
        System.out.println(s2.getInfo());
	}
}