【Java基础】第4章_面向对象（上）-2：封装与隐藏、构造器、this关键字、package关键字、import关键字

PPT链接：点击这里

5、面向对象特征之一：封装与隐藏

5.1、理解封装与隐藏

一、问题的引入

当我们创建一个类的对象以后，我们可以通过 “对象.属性” 的方式，对对象的属性进行赋值。这里，赋值操作要受到属性的数据类型和存储范围的制约。但除此之外，没有其他制约条件。但是实际问题中，我们往往需要给属性赋值加入额外限制条件。这个条件就不能在属性声明时体现，我们只能通过方法进行条件的添加，比如：setLegs。同时我们需要避免用户再使用 “对象.属性” 的方式对属性进行赋值。则需要将属性声明为私有的(private) → 此时，针对于属性就体现了封装性

二、封装性的体现

我们将类的属性私有化(private)，同时提供公共的(public)方法来获取(getXxx)和设置(setXxx)

拓展：封装性的体现：①如上； ②单例模式； ③不对外暴露的私有方法

三、封装性的体现，需要权限修饰符来配合

1. Java 规定的 4 种权限：(从小到大排序)private、缺省、protected、public

2. 4 种权限用来修饰 类及类的内部结构

3. 4 种权限都可以用来修饰 ①类的内部结构：属性、方法、构造器、内部类
   只能使用 缺省、public 修饰类

总结封装性：Java 提供了 4 中权限修饰符来修饰 类及类的内部结构，体现 类及类的内部结构 在被调用时的可见性的大小

public class AnimalTest {

	public static void main(String[] args) {
		Animal a = new Animal();
		a.name = "大黄";
//		a.age = 1;//错误,age已经被私有化
		a.show();
		
//		a.legs = -4;//The field Animal.legs is not visible;leg是用private修饰的，不能直接赋值
		a.show();
		
        a.setLegs(6);
//		a.setLegs(-6);
        
		System.out.println(a.name);//大黄
		System.out.println(a.getLegs());//6
	}
}
class Animal{
	
	String name;
	private int age;
	private int legs; //腿的个数
	
	//对于属性的设置
	public void setLegs(int l){//对腿做限制：正的偶数
		if(l >= 0 && l % 2 == 0){
			legs = l;
		}else{
			legs = 0;
		}
	}
	//对于属性的获取
	public int getLegs(){
		return legs;
	}
	
	public void eat(){
		System.out.println("动物进食");
	}
	
	public void show(){
		System.out.println("name = " + name + ",age = " + age + ",legs = " + legs);
	}
    
    //提供关于属性age的get和set方法
	public int getAge(){
		return age;
	}
	public void setAge(int a){
		age = a;
	}
}

5.2、练习

1.创建程序,在其中定义两个类：Person 和 PersonTest 类。
定义如下：用 setAge()设置人的合法年龄(0~130)，用 getAge()返回人的年龄。
2.在 PersonTest 类中实例化 Person 类的对象p，调用 setAge()和 getAge()方法，体会 Java 的封装性。

public class Person {
	private int age;
	
	public void setAge(int a){
		if(a < 0 || a > 130){
			System.out.println("传入的数据据非法");
			return;
		}
		age = a;
	}
    
	public int getAge(){
		return age;
	}
}

public class PersonTest {

	public static void main(String[] args) {
		Person p = new Person();
//		p.age = 1;	//编译不通过
		
		p.setAge(12);
		System.out.println("年龄为:" + p.getAge());
	}
}

6、类的成员之三：构造器（构造方法）

6.1、构造器的理解

一、构造器的作用

1. 创建对象

2. 初始化对象的属性

二、说明

• 如果没有显示的定义类的构造器的话，则系统默认提供一个空参的构造器
• 定义构造器的格式：权限修饰符 类名(形参列表) {}
• 一个类中定义的多个构造器，彼此构成重载
• 一旦显示的定义了类的构造器之后，系统不再提供默认的空参构造器（用到时就写空参构造器(用空参构造器造对象)，否则可以不写）
• 一个类中，至少会有一个构造器
• 构造器的权限和类的权限相同

public class PersonTest {

	public static void main(String[] args) {
		//创建类的对象:new + 构造器
		Person p = new Person();//Person()这就是构造器
		p.eat();
		
		Person p1 = new Person("Tom");
		System.out.println(p1.name);
	}
}
class Person{
	//属性
	String name;
	int age;
	
	//构造器
	public Person(){//系统默认
		System.out.println("Person()......");
	}
	public Person(String n){//构造器之间构成重载
		name = n;
	}
	public Person(String n,int a){
		name = n;
		age = a;
	}
	
	//方法
	public void eat(){
		System.out.println("人吃饭");
	}
	public void study(){
		System.out.println("人可以学习");
	}
}

6.2、总结：属性赋值的先后顺序

属性赋值的先后顺序：① - ② - ③ - ④

① 默认初始化值

② 显式初始化

③ 构造器中赋值

④ 通过 “对象.方法” 或 “对象.属性” 的方式赋值

public class UserTest {
	public static void main(String[] args) {
		User u = new User();
		System.out.println(u.age);
		
		User u1 = new User(2);//③构造器中赋值
		u1.setAge(3);//④通过"对象.方法" 或 “对象.属性”的方式赋值
		System.out.println(u1.age);
	}
}
class User{
	String name;//①默认初始化值
	int age = 1;//②显式初始化
	
	public User(){
	}
	public User(int a){
		age = a;
	}
	
	public void setAge(int a){
		age = a;
	}
}

6.3、JavaBean 的使用

• JavaBean 是一种 Java 语言写成的可重用组件
• 所谓 javaBean，是指符合如下标准的 Java 类
  • 类是公共的
  • 有一个无参的公共的构造器
  • 有属性，且有对应的 get、set 方法

public class Customer {
	private String name;
    
	public Customer(){
	}
	
	public void setName(String n){
		name = n;
	}
	public String getName(){
		return name;
	}
}

6.4、UML 类图

• +表示 public 类型，-表示 private 类型，#表示 protected类型
• 方法的写法： 方法的类型(+、-) 方法名(参数名：参数类型)：返回值类型

6.5、练习

6.5.1、练习 1

在Person类中添加构造器，
1.利用构造器设置所有人的 age 属性初始值都为 18
2.利用构造器使得每次创建 Person 对象的同时初始化对象的 age 属性值和 name 属性值

【代码实现】

class Person {

	private int age;
	private String name;
	
	public Person(){
		age = 18;
	}
	public Person(String n,int a){
		name = n;
		age = a;
	}
	
	public void setName(String n){
		name = n;
	}
	public String getName(){
		return name;
	}
	
	public void setAge(int a){
		if(a < 0 || a > 130){
//			throw new RuntimeException("传入的数据据非法");
			System.out.println("传入的数据据非法");
			return;
		}
		age = a;
	}
	public int getAge(){
		return age;
	}
}

public class PersonTest {
	public static void main(String[] args) {
		
		Person p1 = new Person("Tom",21);
		System.out.println("name = " + p1.getName() + ",age = " + p1.getAge());
	}
}

6.5.2、练习 2

编写两个类，TriAngle 和 TriAngleTest，
其中 TriAngle 类中声明私有的底边长 base 和高 height，同时声明公共方法访问私有变量。
此外，提供类必要的构造器。另一个类中使用这些公共方法，计算三角形的面积。

【代码实现】

public class TriAngle {

	private double base;//底边长
	private double height;//高
	
	public TriAngle(){
	}
	public TriAngle(double b,double h){
		base = b;
		height = h;
	}
	
	public void setBase(double b){
		base = b;
	}
	public double getBase(){
		return base;
	}
	
	public void setHeight(double h){
		height = h;
	}
	public double getHeight(){
		return height;
	}
}

public class TriAngleTest {
	public static void main(String[] args) {	
		TriAngle t1 = new TriAngle();
		t1.setBase(2.0);
		t1.setHeight(2.5);
		System.out.println("base : " + t1.getBase() + ",height : " + t1.getHeight());
		
		TriAngle t2 = new TriAngle(5.1,5.6);
		System.out.println("面积 : " + t2.getBase() * t2.getHeight() / 2);
	}
}

7、关键字：this

7.1、this关键字的使用

• this 理解为：当前对象 或 当前正在创建的对象(当前对象：谁调用就是谁)

• this 用来修饰(调用)：属性、方法、构造器

this 修饰属性和方法

• 在类的方法中，我们可以使用 “this.属性” 或 “this.方法” 的方式，调用当前对象属性和方法。通常情况下，我们都选择省略this.。特殊情况下，如果方法的形参和类的属性同名，我们必须显式的使用 “this.变量” 的方式，表明此变量是属性，而非形参
• 在类的构造器中，我们可以使用 “this.属性” 或 “this.方法” 的方式，调用正在创建的对象属性和方法。通常情况下，我们都选择省略this.。特殊情况下，如果构造器的形参和类的属性同名，我们必须显式的使用 “this.变量” 的方式，表明此变量是属性，而非形参

this 调用构造器

• 我们可以在类的构造器中，显式的使用 this(形参列表) 的方式，调用本类中重载的其他的构造器
• 构造器中不能通过 this(形参列表) 的方式调用自己
• 如果一个类中声明了n个构造器，则最多有n -1个构造器中使用了 this(形参列表)
• this(形参列表) 必须声明在类的构造器的首行
• 在类的一个构造器中，最多只能声明一个 this(形参列表)

public class PersonTest {
	public static void main(String[] args) {
		Person p1 = new Person();
		p1.setAge(1);
		System.out.println(p1.getAge());
		p1.eat();
		
		Person p2 = new Person("Jerry",20);
		System.out.println(p2.getAge());
	}
}

class Person{
	private String name;
	private int age;
	
	public Person(){
		this.eat();//调用方法
		String info = "Person初始化时，需要考虑如下的1,2,3,4...(共40行代码)";
		System.out.println(info);
	}
	public Person(String name){
		this();//调用无参构造器
		this.name = name;
	}
	public Person(int age){
		this();//调用无参构造器
		this.age = age;
	}
	public Person(String name,int age){
		this(age);//调用构造器3
		this.name = name;
		//this.age = age;
		//Person初始化时，需要考虑如下的1,2,3,4...(共40行代码)
	}
	
	public void setName(String name){
		this.name = name;
	}
	public String getName(){
		return this.name;
	}
    
	public void setAge(int age){
		this.age = age;
	}
	public int getAge(){
		return this.age;
	}
	//方法
	public void eat(){
		System.out.println("人吃饭");
		this.study();
	}
	public void study(){
		System.out.println("人学习");
	}
}

7.2、练习

【代码实现】

public class Boy {
	private String name;
	private int age;
	
	public Boy() {
	}
	public Boy(String name) {
		this.name = name;
	}
	public Boy(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;
	}
	
	public void marry(Girl girl){
		System.out.println("我想娶" + girl.getName());
	}
	
	public void shout(){
		if(this.age >= 22){
			System.out.println("你可以去合法登记结婚了！");
		}else{
			System.out.println("先多谈谈恋爱~~");
		}
		
	}
}

public class Girl {
	private String name;
	private int age;
	
	public Girl() {
	}
	public Girl(String name, int age) {
		this.name = name;
		this.age = age;
	}
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	
	public void marry(Boy boy){
		System.out.println("我想嫁给：" + boy.getName());
		boy.marry(this);//男孩要娶的是"这个女孩"，因为Girl的对象调用marry(Boy boy),this就表示该女孩对象---"这个女孩"
		//boy.marry(new Girl());//错误的，新new的对象就不是同一个人了
	}
	
	/**
	 * @Description 比较两个对象的大小
	 * @param girl
	 * @return  正数：当前对象大；负数：当前对象小；0：当前对象与形参对象相等
	 */
	public int compare(Girl girl){
//		if(this.age > girl.age){
//			return 1;
//		}else if(this.age < girl.age){
//			return -1;
//		}else{
//			return 0;
//		}
		//或
		return this.age - girl.age;
	}
}

public class BoyGirlTest {
	public static void main(String[] args) {
		Boy boy = new Boy("罗密欧", 21);
		boy.shout();
		
		Girl girl = new Girl("朱丽叶", 18);
		girl.marry(boy);
		
		Girl girl1 = new Girl("祝英台",19);
		int compare = girl.compare(girl1);
		if(compare > 0){
			System.out.println(girl.getName() + "大");
		}else if(compare < 0){
			System.out.println(girl1.getName() + "大");
		}else{
			System.out.println("一样大");
		}
	}
}

8、关键字：package

• 为了更好的实现项目中类的管理，提供包的概念
• 使用 package 声明类或接口所属的包，声明在源文件的首行
• 包，属于标识符，遵循标识符的命名规则、规范(xxxyyyzzz)、“见名知意”
• 每.一次,就代表一层文件目录
• 补充：
  • 同一个包下，不能命名同名接口或同名类
  • 不同包下，可以命名同名的接口、类

9、关键字：import

• 在源文件中显式的使用 import结构 导入指定包下的类、接口
• 声明在包的声明和类的声明之间
• 如果需要导入多个结构，则并列写出即可
• 如果使用的类或接口是 java.lang包 下定义的(java核心包)，则可以省略import结构(可以不导包)
• 如果使用的类或接口是本包下定义的，则可以省略 import结构
• 如果在源文件中，使用了不同包下的同名的类，则必须至少有一个类需要以全类名的方式显示
• 使用xxx.*方式表明可以调用 xxx包 下的所有结构。但是如果使用的是xxx子包下的结构，则仍需要显式导入
• import static：导入指定类或接口中的静态结构：属性或方法

import java.lang.reflect.Field;
import java.util.*;

import com.atguigu.exer4.Account;
import com.atguigu.exer4.Bank;
import com.atguigu.java2.java3.Dog;

import static java.lang.System.*;//到类中的结构
import static java.lang.Math.*;

public class PackageImportTest {
	public static void main(String[] args) {
		//import java.util.*;
		String info = Arrays.toString(new int[]{1,2,3});
		ArrayList list = new ArrayList();
		HashMap map = new HashMap();
		Scanner s = null;
        
		//lang包，可以不导包
		System.out.println("hello!");
        
		Bank bank = new Bank();
		Person p = new Person();
		Account acct = new Account(1000);
		//全类名的方式显示
		com.atguigu.exer3.Account acct1 = new com.atguigu.exer3.Account(1000,2000,0.0123);
		Date date = new Date();
		java.sql.Date date1 = new java.sql.Date(5243523532535L);
        
		//用xxx包下的子包，要导包
		Dog dog = new Dog();
		Field field = null;//lang包的子包也要导包
        
		//import static java.lang.System.*;//到类中的结构
		System.out.println("hello");
		out.println("hello");
		long num = Math.round(123.434);
        long num = round(123.434);
	}
}

10、实验题

10.1、实验1

实验1：Account_Customer.pdf

【代码实现】

public class Account {
	private int id;//账号
	private double balance;//余额
	private double annualInterestRate;//年利率
	
	public Account (int id, double balance, double annualInterestRate ){//创建账户时直接规定账号 余额 年利率
		this.id = id;
		this.balance = balance;
		this.annualInterestRate = annualInterestRate;
	}

	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}

	public double getBalance() {
		return balance;
	}
	public void setBalance(double balance) {
		this.balance = balance;
	}

	public double getAnnualInterestRate() {
		return annualInterestRate;
	}
	public void setAnnualInterestRate(double annualInterestRate) {
		this.annualInterestRate = annualInterestRate;
	}
    
	//在提款方法withdraw中，需要判断用户余额是否能够满足提款数额的要求，如果不能，应给出提示。
	public void withdraw (double amount){//取钱
		if(balance < amount){
			System.out.println("余额不足，取款失败");
			return;
		}
		balance -= amount;
		System.out.println("成功取出：" + amount);
	}
	
	public void deposit (double amount){//存钱
		if(amount > 0){
			balance += amount;
			System.out.println("成功存入：" + amount);
		}
	}
}

public class Customer {
	
	private String firstName;//名
	private String lastName; //性
	private Account account; //注意Account类型，顾客是有账户的
	
	public Customer(String f,String l){//创建对象时直接起名字
		this.firstName = f;
		this.lastName = l;
	}

	public Account getAccount() {
		return account;
	}
	public void setAccount(Account account) {//顾客开账户
		this.account = account;
	}

	public String getFirstName() {
		return firstName;
	}

	public String getLastName() {
		return lastName;
	}
}

/*
写一个测试程序。
（1）	创建一个Customer ，名字叫 Jane Smith, 他有一个账号为1000，余额为2000元，年利率为 1.23％ 的账户。
（2）	对Jane Smith操作。
存入 100 元，再取出960元。再取出2000元。
打印出Jane Smith 的基本信息

成功存入 ：100.0
成功取出：960.0
余额不足，取款失败
Customer [Smith, Jane] has a account: id is 1000, annualInterestRate is 1.23％, balance is 1140.0
 */
public class CustomerTest {
	public static void main(String[] args) {
		Customer cust = new Customer("Jane", "Smith");//造一个顾客
		Account acct = new Account(1000, 2000, 0.0123);//造一个账户
		cust.setAccount(acct);//顾客开账户

        //【注意】存钱时用acct.deposit(100); 是给所有的账户都存100，显然是不对的。要记住存钱是 一定是人在存钱，人要拿住账户去存钱
        //存钱
//		Account account = cust.getAccount();//1.顾客存钱，顾客先得到自己的账户对象
//		account.deposit(100);               //2.用账户对象调用存钱方法
		//或者
		cust.getAccount().deposit(100);
        
		cust.getAccount().withdraw(960);
		cust.getAccount().withdraw(2000);
		
		System.out.println("Customer[" + cust.getLastName() + "," + cust.getFirstName() + 
				"] has a account: id is " + cust.getAccount().getId() + ",annualInterestRate is "+
		cust.getAccount().getAnnualInterestRate() * 100 + "% ,balance is " + cust.getAccount().getBalance());
	}
}

10.2、实验2

实验2：Account_Customer_Bank.pdf

【代码实现】

public class Account {
	private double balance;//余额

	public double getBalance() {
		return balance;
	}

	public Account(double init_balance){
		this.balance = init_balance;
	}
	
	//存钱操作
	public void deposit(double amt){
		if(amt > 0){
			balance += amt;
			System.out.println("存钱成功");
		}
	}
	
	//取钱操作
	public void withdraw(double amt){
		if(balance >= amt){
			balance -= amt;
			System.out.println("取钱成功");
		}else{
			System.out.println("余额不足");
		}
	}
}

public class Customer {
	private String firstName;
	private String lastName;
	private Account account;
	
	public Customer(String f, String l) {
		this.firstName = f;
		this.lastName = l;
	}

	public Account getAccount() {
		return account;
	}
	public void setAccount(Account account) {
		this.account = account;
	}

	public String getFirstName() {
		return firstName;
	}
    
	public String getLastName() {
		return lastName;
	}
}

public class Bank {
	private Customer[] customers;// 存放多个客户的数组
	private int numberOfCustomers;// 记录客户的个数

	public Bank() {
		customers = new Customer[10];//给数组初始化，也可以写上面显示的给数组初始化
	}

	// 添加客户
	public void addCustomer(String f, String l) {
		Customer cust = new Customer(f, l);//造客户
		customers[numberOfCustomers] = cust;
		numberOfCustomers++;
	}

	// 获取客户的个数
	public int getNumOfCustomers() {
		return numberOfCustomers;
	}

	// 获取指定位置上的客户
	public Customer getCustomer(int index) {
		// return customers[index];//可能报异常
		if (index >= 0 && index < numberOfCustomers) {//指定位置上的用户需要考虑到当前用户的数量
			return customers[index];
		}
		return null;
	}
}

public class BankTest {
	public static void main(String[] args) {
		
		Bank bank = new Bank();//1.先创建银行对象
		bank.addCustomer("Jane", "Smith");//2.添加客户
		//问题：customers[]没有的初试化，里面为null，不能存放元素，所以customers[numberOfCustomers++] = cust;会出现空指针异常      
        //解决办法：给数组进行初始化(可以在构造器中进行初始化，也可以显示初始化)
        
		//连续操作
		bank.getCustomer(0).setAccount(new Account(2000));//用bank.getCustomer(0)先找到顾客，顾客开账户
		bank.getCustomer(0).getAccount().withdraw(500);//取500
		
		double balance = bank.getCustomer(0).getAccount().getBalance();//打印余额
		System.out.println("客户：" + bank.getCustomer(0).getFirstName() + "的账户余额为：" + balance);
		
		System.out.println("***********************");
		bank.addCustomer("万里", "杨");
		
		System.out.println("银行客户的个数为：" + bank.getNumOfCustomers());//银行客户的个数为：2
	}
}

物竞天择，适者生存，加油吧 ！！！