目录
[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 方法调用账户的属性和方法；