Java封装

什么是封装？

封装，就是将类的某些信息隐藏在类的内部，不允许外部程序直接访问，只能通过该类提供的方法来实现对隐藏信息的操作和访问。

封装隐藏的是属性，留出可以访问的接口就是访问方法。

封装的特点

1. 只能通过规定的方法访问数据
2. 隐藏类的实例细节，方便修改和实现

封装的实现
为了实现良好的封装，需要从两个方面考虑

1. 把字段（成员变量）和实现细节隐藏起来，不允许外部直接访问
2. 把方法暴露出来，让方法控制这些成员变量进行安全的访问和操作

步骤：

1. 修改属性的可见性

public class Person {
//将属性的访问控制修饰符修改为private-限定只能在当前类内被访问
	private String name;
  }

2. 创建公有的get/set方法

public class Person {
//获取属性方法
public String getName() {
		return name;
	}
  //修改属性方法
public void setName(String name) {//传入相同的参数名与属性形成对照
		this.name = name;
	}
  }

get + 首字母大写的属性名() ：get 方法一般都是具有和属性数据类型一致的返回值，并且是没有形参的。
set + 首字母大写的属性名(参数)：set 方法一般都是具有和属性数据类型一致的方法参数，返回值一般是 void。

3. 在get/set方法中加入属性控制

加入属性控制，是为了对数据进行合理的修改和判断，对成员变量（对象属性）进行更精确的控制。

/**
 * 针对年龄范围作出合理限制
 * @param month
 */
public void setAge(int age) {
	if(age < 0 || age >= 240) {
        System.out.println("年龄不合理，暂定为1");
		this.age = 1;
	} else {
		this.age = age;
	}
}

在另一个类中的访问和操作

public class Test {
	public static void main(String[] args) {
		Cat one = new Cat();
		one.setName("张三");
		System.out.println("名字：" + one.getName());
	}
}

带参构造器中的属性控制

使用带参构造器可以实现对象实例化时候的属性设定。
如：

public class Person {
		private int age;
		public Person() {
		}
		public Person(int age) {
		this.age = age;
		}
    public void setAge(int age) {
				if(age < 0 || age >= 240) {
        		System.out.println("年龄不合理，暂定为1");
						this.age = 1;
					} else {
						this.age = age;
					}
			}
}

public class Test {
		public static void main(String[] args) {
		Person person = new Person(-3);
		System.out.println(person.getAge());
		}
}

我们发现上述代码执行之后，并没有完成对属性值的限制，这是因为在构造器中，我们直接对属性值进行了操作。所以，我们可以利用set方法中的属性限制，完成代码逻辑。

public Person(int month) {
	//this.age = age;
	this.setAge(age);
}

static关键字

1. static代表着静态信息，被static修饰的成员属于类，不属于单个这个类的某个对象，被类中所有对象共享，可以并且建议通过类名调用。被static声明的成员变量属于静态成员变量，静态变量存放在 Java 内存区域的方法区。
2. static表示静态的，static修饰的属性称之为【类变量，静态变量】，方法称之为【类方法，静态方法】。
3. 在Java程序中，static修饰的成员具有这样一个特征，无论该类最终实例化出来多少对象，静态成员都会共用一块静态空间。也就是说，如果调用一个静态属性，无论是哪个对象去调用修改，两者都在针对同一块内存空间进行操作。

普通成员和静态成员的区别：

1. 对普通成员而言：当这个类的对象产生的时候，它的相关成员会产生，而当这个对象销毁的时候，这些成员就会进行资源释放；
2. 对静态成员而言：从类第一次加载的时候，静态成员就会产生，一直到这个类不在有任何对象被使用。也就是它彻底销毁的时候，静态资源才会进行资源的释放。所以静态成员的生命周期比较长。

静态资源有着如下的特性：

1. 类对象共享
2. 类加载时产生，销毁时释放，生命周期长

静态资源的访问方式：

1. 对象.静态成员
2. 类.静态成员

static能用来修饰方法和属性。

静态内容与非静态内容的访问限制

1. 在普通成员方法中，可以直接访问类中静态成员（对象.静态资源）
2. 静态方法中不能直接访问同一个类的非静态成员，只能直接调用同一个类中的静态成员，如果想要访问非静态成员，只能通过对象实例化后，对象.成员方法/属性的方式访问
3. static修饰的方法中不能出现this

关于代码块的执行顺序

在Java中，如果在语句当中出现{}，这样的大括号对这就叫代码块。

1. 普通代码块——顺序执行
2. 构造代码块——创建对象时调用，优先于构造方法执行；多个构造代码块顺序执行；
3. 静态代码块——static修饰的代码块，优于构造代码块执行，多个静态代码块顺序执行；无论产生多少个实例，只调用一次。

总结：

1. 仅希望执行一次的代码就可以放到静态代码块中，这样可以提高代码的执行效率。
2. 在普通代码块中可以操作类成员，但是在静态代码块中只能操作静态成员，如果想用需要先实例化对象，通过对象.成员调用。

相关练习

一、选择

B

A

ABC

A

A

A

A

A

D

AC

二、编程

public class Book {
	//私有属性：书名、作者、出版社、价格
	private String bookName = "黄金时代";
	private String bookWriter = "王小波";
	private String bookPress;
	private int bookPrice;
	
	
	/*通过公有的get/set方法实现属性的访问，其中：
    1、限定图书价格必须大于10，如果无效需进行提示，并强制赋值为10
    2、限定作者、书名均为只读属性
   */
	public String getBookName() {
		return bookName;
	}
	public String getBookWriter() {
		return bookWriter;
	}

	public String getBookPress() {
		return bookPress;
	}
	public void setBookPress(String bookPress) {
		this.bookPress = bookPress;
	}
	public int getBookPrice() {
		return bookPrice;
	}
	public void setBookPrice(int bookPrice) {
		if(bookPrice < 10) {
			this.bookPrice = 10;
			return;
		}
		this.bookPrice = bookPrice;
	}
	
	//通过构造方法实现属性赋值
	public Book() {
		
	}
	public Book(String bookPress, int bookPrice) {
		super();
		this.setBookPress(bookPress);
		this.setBookPrice(bookPrice);
	}
	
	//信息介绍方法，描述图书所有信息
	public String info() {
		String str;
		str = "书名：" + this.bookName;
		str += "\n作者：" + this.bookWriter;
		str += "\n出版社：" + this.bookPress;
		str += "\n价格：" + this.bookPrice;
		return str;
	}
}

/**
 * 用户信息类
 * @author Administrator
 *
 */
public class Users {
	//用户名
	private String name;
	//密码
	private int password;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getPassword() {
		return password;
	}
	public void setPassword(int password) {
		this.password = password;
	}
	
	public Users() {
		
	}
	public Users(String name,int password) {
		this.setName(name);
		this.setPassword(password);
	}
	//用户信息展示
	public String info() {
		String str;
		str = "用户名:" + this.name;
		str += "\n密码：" + this.password;
		return str;
	}
}

/**
 * 用户信息管理类
 * @author Administrator
 *
 */
public class UserManage {

	public void manage(String str1,String str2,int x,int y){
		if(str1.equals(str2) && x == y) {
			System.out.println("用户名和密码一致");
		}else {
			System.out.println("用户名或密码不一致");
		}
	}
}

/**
 * 测试类
 * @author Administrator
 *
 */
public class Test {
	public static void main(String[] args) {
		Users user1 = new Users("Lucy",123456);
		Users user2 = new Users("Mike",123456);
		System.out.println(user1.info());
		System.out.println(user2.info());
		System.out.println("======================");
		UserManage um = new UserManage();
		um.manage(user1.getName(), user2.getName(),user1.getPassword(),user2.getPassword());
	}
}