一、封装

1.1 封装的概念

隐藏对象的信息，留出访问的接口。

即，将类的某些信息隐藏在类内部，不允许外部程序直接访问；通过该类指定的方法，来实现对隐藏信息的访问。

生活案例：

用于存取款的ATM机，隐藏了肚子里的很多钞票，同时留出一些指定接口。用户必须按照指定方法操作才能取得钞票。

1.2 封装的特点

1.只能通过指定方法，来访问数据.

安全性高，不能修改私密数据。

2.隐藏类的实例细节，方便用户访问数据

1.3 代码实现封装的三步骤

访问修饰符private：只能在当前类内进行访问

get：获取。只能读取

set：赋值。只能写入，不能读取

0.以前的代码，存在逻辑隐患：

1.修改属性的可见性

2.创建get 和 set 方法

方式1：

自己写

方式2：

生成get 和 set 方法的快捷方法：右键--->Sourse--->Generate Getters and Setters

3.在方法中添加对属性的限定

（1）比如年龄必须大于0才符合常识，当用户输入负数时，就要给出异常的错误提示。

（2）以前：可以通过类的带参构造，来完成对象实例化时的属性设定。

因此，在构造方法中赋值时，也建议使用set方法赋值。

• 如果不使用set方法赋值，就会出现以下问题：

• 在构造方法中赋值时，使用set方法赋值：

​ 成功实现对属性的限定

1.4 注意

1.属性设置的两种方式比较：

带参构造：只能在对象初始化时，进行属性的设置。----------------一次性，集中设置

通过get/set方法：可以在对象完成后，进行后续修改。-------------单点狙击

2.return和break的比较

二、使用包管理多个类

2.1 两个作用

主要是基于大型应用程序，协同工作时：

2.2 创建包

1.包必须放在Java文件的第一行

2.一个Java源文件中只能有一个package语句

3.包的命名：

语法格式：package 包名。例如package com.imooc.animal;

包名的命名方式：域名倒序+模板+功能。

推荐全部英文小写

4.一个包下面，不能存在同名类

如果要想同时存储两个同名类，就必须存放在不同的包下。

5.建议包内的存储信息，功能单一

思考题：

如何让编译器知道，我调用的是那个包里的Cat.java呢？

2.3 导入包的三种方式

位置：写在class语句的上面

方式1：import 包名.*

package com.imooc.test;                // 定义包
import com.imooc.animal.*;            // 导入com.imooc.animal包下的所有类

public class Test {
    public static void main(String[] args) {
        
        Cat cat=new Cat();            // 可成功进行类的实例化
        CatTest test=new CatTest();  // 可成功进行类的实例化
    }
}

方式2：import 包名.类名

建议使用此方式，可提高效率

package com.imooc.test;                    // 定义包
import com.imooc.animal.Cat;            // 导入com.imooc.animal包下指定的Cat类

public class Test {
    public static void main(String[] args) {
        
        Cat cat=new Cat();                // 可成功进行类的实例化
        CatTest test=new CatTest();         // 报错❌
    }
}

两种方式的比较：

方式3：

package com.imooc.test;                    // 定义包
import com.imooc.animal.Cat;            // 导入com.imooc.animal包下指定的Cat类

public class Test {
    public static void main(String[] args) {
        
        Cat cat=new Cat();                // 可成功进行类的实例化
        com.imooc.animal.CatTest test=new com.imooc.animal.CatTest();// 直接在程序中写全 ，麻烦
    }
}

总结：

2.4 导包的优先级顺序

1.当分别以*和指定类名进行导入时，以类名导入的优先级最高

如果在以上基础上，还是想调用机器猫的类：

package com.imooc.test;                // 定义包
import com.imooc.mechanics.*;            // 导入com.imooc.animal包下的所有类
import com.imooc.animal.Cat;            // 导入com.imooc.animal包下指定的Cat类

public class Test {
    public static void main(String[] args) {
        
        com.imooc.mechanics.Cat test=new com.imooc.mechanics.Cat();        //只能写全了
        
    }
}

--->
我是一只机器猫~~~

2.只能加载包下直接的类，不会去找子包下的类

package com.imooc.test;                    // 定义包
import com.imooc.*;                        // 可以吗？

public class Test {
    public static void main(String[] args) {
        
        Cat cat=new Cat();                // 报错❌
        CatTest test=new CatTest();         // 报错❌
    }
}

2.5 常用的系统包

三、static关键字

static怎么用？修饰的信息有什么特征？

3.1 实例变量与类变量

• 普通的属性：实例变量

• 带static关键字的属性：类变量

  （注意：变成了斜体）

除了修饰上述的变量，总结如下：

static关键字，通常用于修饰属性、方法、代码块三种对象。

实际应用中，通常将频繁操作、通用型信息设置、公共组件封装等操作设置为static。

注意：

• 关键字，不能修饰类。
• 方法里定义的局部变量，前面不能加static。即，不允许在实例方法内部，定义静态局部变量。

3.2 实例方法与类方法

类方法中，只能直接调用类变量、类方法，不能直接调用实例的变量、方法。要想直接调用实例的变量、方法，必须实例化一个对象，用对象的方式调用。

类方法中，不能使用this。（因为this其实是对象的代词）

四、代码块

java程序中的语句使用大括号括起来的，大括号对就是代码块。

用途：功能的拆分

4.1 普通代码块

如果代码块的位置在方法中，那就是普通代码块。

特点：

（1）顺序执行。

（2）可以有很多个

• 在com.imooc.animal|Cat.java中：

package com.imooc.animal;

public class Cat {                                
    private String name;    
    private int month;
    private double weight;
    private String species;    
    public static int price;
    
    public Cat() {                                        // 无参构造
        System.out.println("我是宠物猫~~~");
    }
    
    public void run(String name) {
        {
            System.out.println("我是普通代码块1");
        }
        System.out.println(name+"快跑！");
        {
            System.out.println("我是普通代码块2");
        }
    }
}

• 在com.imooc.test|Test.java的主方法中调用：

package com.imooc.test;                    
import com.imooc.animal.Cat;            

public class Test {
    public static void main(String[] args) {
        Cat one=new Cat();
        one.run("花花");        
    }
}

--->
我是宠物猫~~~
    
我是普通代码块1
花花快跑！
我是普通代码块2

4.2 构造代码块

如果代码块的位置在类中，那就是构造代码块。

（1）也是创建对象时调用，优先于构造方法执行

（2）可以有多个

• 在com.imooc.animal|Cat.java中：

package com.imooc.animal;

public class Cat {                                
    private String name;    
    private int month;
    private double weight;
    private String species;    
    public static int price;
    
    {
        System.out.println("我是构造代码块1");            // 构造代码块1
    }
    
    {
        System.out.println("我是构造代码块2");            // 构造代码块2
    }
    
    public Cat() {                                    // 无参构造方法
        System.out.println("我是宠物猫~~~");
    }
    
    public void run(String name) {
        {
            System.out.println("我是普通代码块1");
        }
        System.out.println(name+"快跑！");
        {
            System.out.println("我是普通代码块2");
        }
    }
}

• 在com.imooc.test|Test.java的主方法中调用：

package com.imooc.test;                    
import com.imooc.animal.Cat;            

public class Test {
    public static void main(String[] args) {
        Cat one=new Cat();
        one.run("花花");        
    }
}

--->
我是构造代码块1
我是构造代码块2
我是宠物猫~~~
    
我是普通代码块1
花花快跑！
我是普通代码块2

4.3 静态代码块

如果代码块的位置在类中，那就是构造代码块。如果在构造代码块前面加个static，那么就是静态代码块。

（1）在类加载时调用，优先于构造代码块。优先级最高

（2）可以有多个

• 在com.imooc.animal|Cat.java中：

package com.imooc.animal;

public class Cat {                                
    private String name;    
    private int month;
    private double weight;
    private String species;    
    public static int price;
    
    {
        System.out.println("我是构造代码块1");            // 构造代码块1
    }
    
    static{
        System.out.println("我是静态代码块");            // 静态代码块
    }
    
    public Cat() {                                    // 无参构造
        System.out.println("我是宠物猫~~~");
    }
    
    public void run(String name) {
        {
            System.out.println("我是普通代码块1");
        }
        System.out.println(name+"快跑！");
        {
            System.out.println("我是普通代码块2");
        }
    }
}

• 在com.imooc.test|Test.java的主方法中调用：

package com.imooc.test;                    
import com.imooc.animal.Cat;            

public class Test {
    public static void main(String[] args) {
        Cat one=new Cat();
        one.run("花花");        
    }
}

--->
我是静态代码块
我是构造代码块1
我是宠物猫~~~
    
我是普通代码块1
花花快跑！
我是普通代码块2

4.4 对比执行次数

• 在com.imooc.animal|Cat.java中：

package com.imooc.animal;

public class Cat {                                
    private String name;    
    private int month;
    private double weight;
    private String species;    
    public static int price;
    
    {
        System.out.println("我是构造代码块");            // 构造代码块
    }
    
    static{
        System.out.println("我是静态代码块1");            // 静态代码块1
    }
    
    static{
        System.out.println("我是静态代码块2");            // 静态代码块2
    }
    
    public Cat() {                                    // 无参构造方
        System.out.println("我是宠物猫~~~");
    }

}

• 在com.imooc.test|Test.java的主方法中调用：

package com.imooc.test;                    
import com.imooc.animal.Cat;            

public class Test {
    public static void main(String[] args) {
        Cat one=new Cat();
        
        Cat two=new Cat();
    
    }
}

--->
我是静态代码块1
我是静态代码块2
    
我是构造代码块
我是宠物猫~~~
    
我是构造代码块
我是宠物猫~~~

4.5 对比变量赋值

毕竟静态代码块，是针对类来说，是类一级的。

构造代码块，是针对具体对象来说的，必须有依附于对象才能存在。

天庭上的神仙，天庭、人间都能自由穿梭；

但是人间的凡夫俗子，只能自由穿梭在人间，如果非去天庭，就得踩个筋斗云

4.6 代码块的变量应用

代码块{ }是一个独立的作用空间，

原理机制是：变量在空间内有效，空间外就会失效、被回收。

1.不算重名的情景

虽然变量名相同，但是是在两个不同的代码块内，所以语法是正确的，不叫重名。

在代码块{ }作用空间内，按照就近原则，寻找变量。

2.变量重名的报错情景：

练习题收获：