封装/前线修饰符/Idea项目结构/package/impore

[1. 封装的情景引入](#1. 封装的情景引入)

[2. 封装的体现](#2. 封装的体现)

[3. 权限修饰符](#3. 权限修饰符)

[4. Idea 项目结构](#4. Idea 项目结构)

[5. package 关键字](#5. package 关键字)

[6. import 关键字](#6. import 关键字)

[7. 练习](#7. 练习)

程序设计：高内聚，低耦合；

高内聚：将类的内部操作"隐藏"起来，不需要外界干涉；

低耦合：将方法需要暴露的展示出来，以便于使用即可；

1. 封装的情景引入

体验封装的作用：

java 复制代码

class FengZh{
    String name;//名字
    int age;//年龄
    int legs;//腿
    public void show(){
        System.out.println("name="+name+","+"age="+age+","+"legs="+legs);
    }
}
class FZD{
    public static void main(String[] args) {
        FengZh f = new FengZh();
        f.name = "团团";
        f.age = 1;
        f.legs = 3;//动物腿为 3 条，不符合逻辑
        f.show();
    }
}

动物的腿为奇数或负数，不符合逻辑，于是我们通过调用方法进而限制 legs 的赋值；

java 复制代码

//封装
class FengZh{
    String name;//名字
    int age;//年龄
    int legs;//腿

    public void show(){
        System.out.println("name="+name+","+"age="+age+","+"legs="+legs);
    }

    public void setLegs(int i){
        if(i >= 0 && i %2 ==0){
            legs = i;
        }else System.out.println("legs 赋值不正确");
    }
}
class FZD{
    public static void main(String[] args) {
        FengZh f = new FengZh();
        f.name = "团团";
        f.age = 1;
        f.legs = 3;//动物腿为 3 条，不符合逻辑
        f.setLegs(9);//通过调用方法进而限制 legs 的赋值；
        f.show();
    }
}

可是，我们仍然可以通过直接调用其属性对 "legs" 属性进行赋值；

java 复制代码

class FZD{
    public static void main(String[] args) {
        FengZh f = new FengZh();
        f.name = "团团";
        f.age = 1;
        f.setLegs(9);//通过调用方法进而限制 legs 的赋值；
        f.legs = 3;//仍可以通过直接调用其属性对 "legs" 属性进行赋值；
        f.show();
    }
}

java 复制代码

legs 赋值不正确
name=团团,age=1,legs=-4

我们仍然通过方法限制属性的赋值，以确保数据的安全性，另一方面，禁止对象直接调用属性进行赋值（声明对象时，加上 private 即可）；

java 复制代码

class FengZh{
    String name;//名字
    int age;//年龄
    private int legs;//加上权限修饰符

    public void show(){
        System.out.println("name="+name+","+"age="+age+","+"legs="+legs);
    }

    public void setLegs(int i){
        if(i >= 0 && i % 2 ==0){
            legs = i;
        }else System.out.println("legs 赋值不正确");
    }
}
class FZD{
    public static void main(String[] args) {
        FengZh f = new FengZh();
        f.name = "团团";
        f.age = 1;
        f.setLegs(9);//通过调用方法进而限制 legs 的赋值；
        f.legs = 3;//这里冒红会报错！！！
        f.show();
    }
}

虽然我们通过一系列方法完成了对属性正确的赋值，但是我们却无法调用属性（如下，仍采用原先调用方法会报错）；

因此，仍需要增加一个方法专门调用属性值；

java 复制代码

    public int getLegs( ){
        return legs;
    }
}

结合以上情景，可以发现：

当创建一个类后，可以使用类的对象通过" 对象. 属性"的方式给对象的属性赋值，且赋值除数据类型外没有任何限制；但在实际问题中，还需要对属性的取值进行限制，因此需要添加方法来进行限制；为了避免通过" 对象. 属性"的方式直接给对象的属性赋值而绕开增加的方法，在属性声明时必须增加权限修饰符" private "！

此时，对属性的操作实现了封装；

2. 封装的体现

以上案例中，我们将类的" legs "属性增加权限修饰符 private ,禁止通过对象. 属性的方式直接赋值和输出，于是又增加 set... 和 get... 方法对赋值进行限制和输出，这就是封装性的很好体现；

3. 权限修饰符

封装需要使用权限修饰符，因此有必要了解他们的作用范围；

4 种权限都可以用来修饰类的属性，方法，构造器，内部类；

4. Idea 项目结构

Idea 的项目结构分为：项目（project），模块（mudle），包（package），类（class）；

新建项目：

新建项目的模块;

新建项目模块的包：

包的命名一般为公司域名反写 + 包的作用；

新建项目模块包的类:

Idea 自动保存，自动编译，手动运行；

5. package 关键字

概述：为了便于管理项目中的多个类，提出包的概念；

作用：使用 package 在首行声明类或接口所属的包；

命名：package 的命名属于标识符，应遵循标识符命名规范（全小写）；

6. import 关键字

作用：在源文件声明包与声明类之间显示使用 import 导入指定包下的类、接口；

使用：Idea 中会自动导包，多个包并列使用；

特殊情况：如果省略的是 java,lang 包与本包下的类或接口，可以省略不写；

若使用该包下的子包，仍需显式声明导包结构；

若 import static xxx：导入指定类或接口中的静态结构：属性，方法（了解即可）；

若使用不同包下的同名类：

如下，

46 行用的是本包的类；

48 行用的是不同包下的同名类，只有实用其全类名（包名.类名）才可以继续使用：

在实际使用中，可能会出现不同包下的类名相同，同时使用时，需要使用全类名的形式；

7. 练习

定义：Account 类。

属性：账号 id ,余额 balance ,年利率 interest；

方法：访问器方法（set/get方法），取款方法 withdow() , 存款方法 disposite( );

定义：Couster 类。

属性：firstName , lastName，Account；

方法：访问器方法（set/get方法）；

定义测试类：CousterTest

创建 Customer,名称为：Jane Smith,账户为 1000，余额 2000 元，年利率 1.23% 的账户；

对 Jane Smith 存取操作操作；

java 复制代码

//银行存取钱
class Account{
//    属性
    private int id;//账号
    private double balance;//余额
    private double interest;//利率
//    构造器
    public Account(){};
    public Account(int id,double balance,double interest){
        this.id = id;
        this.balance = balance;
        this.interest = interest;
    }
//    set/get方法
    public void setId(int id){
        this.id = id;
    }
    public int getId(){
        return id;
    }
    public void setBalance(double balance){
        this.balance = balance;
    }
    public double getBalance(){
        return balance;
    }
    public void setInterest(double interest){
        this.interest = interest;
    }
    public double getInterest(){
        return interest;
    }

    public void withdraw(double amount){//取钱
        if(amount > balance){
            System.out.println("余额不足,只剩下"+balance+"元");
            return;
        }
        balance -= amount;
        System.out.println("账户余额:"+balance);
    }
    public void deposit(double amount){//存钱
        if(amount > 0){
            balance += amount;
            System.out.println("" + "成功存入" + amount + ",\n" + "账户余额为:" + balance);
        }
    }
}

class Customer{
    private String firstName;
    private String lastName;
    private Account account;

    public Customer(){

    }
    public Customer(String firstName,String lastName){
        this.firstName = firstName;
        this.lastName = lastName;
    }

    public void setFirstName(String firstName){
        this.firstName = firstName;
    }
    public String getFirstName(){
        return firstName;
    }
    public void setLastName(String lastName){
        this.lastName = lastName;
    }
    public String getLastName(){
        return lastName;
    }
    public void setAccount(Account account){
        this.account = account;
    }
    public Account getAccount(){
        return account;
    }
}

class CustomerTest{
    public static void main(String[] args) {
        Customer c = new Customer("Jane","Smith");
        Account a = new Account(1000,2000.0,0.0123);
        c.setAccount(a);
        c.getAccount().deposit(100);
        c.getAccount().withdraw(3000);
    }
}

理解：

账户（a）是客户（c）的一个属性，但实质上也是一个类，自身也有属性和方法；

2013 - 2015：客户通过 set方法将账户的成员赋到客户类中的账号属性中，进而通过 get 方法调用账户的属性和方法；