【Java基础】第4章_面向对象（上）-2：封装与隐藏、构造器、this关键字、package关键字、import关键字
文章目录
- 5、面向对象特征之一：封装与隐藏
-
- 5.1、理解封装与隐藏
- 5.2、练习
- 6、类的成员之三：构造器（构造方法）
-
- 6.1、构造器的理解
- 6.2、总结：属性赋值的先后顺序
- 6.3、JavaBean 的使用
- 6.4、UML 类图
- 6.5、练习
-
- 6.5.1、练习 1
- 6.5.2、练习 2
- 7、关键字：this
-
- 7.1、this关键字的使用
- 7.2、练习
- 8、关键字：package
- 9、关键字：import
- 10、实验题
-
- 10.1、实验1
- 10.2、实验2
PPT链接：点击这里
5、面向对象特征之一：封装与隐藏
5.1、理解封装与隐藏
一、问题的引入
当我们创建一个类的对象以后，我们可以通过 “对象.属性” 的方式，对对象的属性进行赋值。这里，赋值操作要受到属性的数据类型和存储范围的制约。但除此之外，没有其他制约条件。但是实际问题中，我们往往需要给属性赋值加入额外限制条件。这个条件就不能在属性声明时体现，我们只能通过方法进行条件的添加，比如：setLegs。同时我们需要避免用户再使用 “对象.属性” 的方式对属性进行赋值。则需要将属性声明为私有的(private) → 此时，针对于属性就体现了封装性
二、封装性的体现
我们将类的属性私有化(private)，同时提供公共的(public)方法来获取(getXxx)和设置(setXxx)
拓展：封装性的体现：①如上； ②单例模式； ③不对外暴露的私有方法
三、封装性的体现，需要权限修饰符来配合
-
Java 规定的 4 种权限：(从小到大排序)private、缺省、protected、public
-
4 种权限用来修饰 类及类的内部结构
-
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、构造器的理解
一、构造器的作用
-
创建对象
-
初始化对象的属性
二、说明
- 如果没有显示的定义类的构造器的话，则系统默认提供一个空参的构造器
- 定义构造器的格式：
权限修饰符 类名(形参列表) {} - 一个类中定义的多个构造器，彼此构成重载
- 一旦显示的定义了类的构造器之后，系统不再提供默认的空参构造器（用到时就写空参构造器(用空参构造器造对象)，否则可以不写）
- 一个类中，至少会有一个构造器
- 构造器的权限和类的权限相同
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
}
}
物竞天择，适者生存，加油吧 ！！！
