一、 package （包）
package 包 用于指定该文件中定义的类、接口等结构
像我们之前练习的代码，在顶部并没有定义package的关键字，这种就属于无名包
1、包 （java 库）
在java中的包，是一堆类和接口的集合，比方说我们把一辆汽车看作是一个包(package), 那么方向盘、车身、引擎、轮胎这些，我们都可以看作是包中所包含的多个类，我们可以通过调用存放多个类的这个包，来实现他下面具体的某个功能，通常来说包更像是写好的工具，比如扳手、钳子之类的类似，我们也会将这种常见的小工具都封装成具体的包中的类或接口来使用
2、包的分类
1、自带库
#即Java标准库（Java Standard Library），也称为Java核心库
#它是Java开发平台的一部分，自动包含在Java开发者工具包（JDK）中。
#Java标准库提供了丰富的类和接口，涵盖了各种领域的功能
#如集合框架、输入输出、多线程、网络通信、日期时间处理、图形界面等。
#开发人员可以直接使用这些类和接口，而不需要额外的配置或下载。
2、 第三方库
#它是由其他开发者或组织创建和维护的库，用于扩展Java的功能和提供特定领域的解决方案
#第三方库通常以JAR（Java Archive）格式提供，开发人员需要手动导入并配置到自己的项目中才能使用
#第三方库提供了各种功能，如数据库访问、日志记录、图像处理、Web开发、测试框架等
#一些知名的Java第三方库包括Apache Commons、Google Guava、Jackson、Hibernate等
3、Java库的使用步骤
1、导入库
#对于自带库，无需额外操作，只需要在代码中使用相应的类或接口即可
#对于第三方库，需要将库的JAR文件添加到项目的构建路径中，以便编译器可以找到库中的类
2、创建对象
#根据库文档或示例代码，实例化库中提供的类或接口对象，通常需要传入相应的参数
3、调用方法
#通过对象调用库中定义的方法来完成具体的功能。
#方法的使用方式和参数根据库的设计而定，可以在库文档中查找相应的使用示例和说明。
4、处理返回值
#根据方法的返回值类型，进行相应的后续处理或判断。
#有些方法可能返回特定类型的对象、集合或基本数据类型，开发人员需要根据具体情况进行逻辑处理。4、创建自定义包
首先，我们需要在项目的源代码目录下创建一个新的包目录。我们前面所有的代码都是直接在test1项目下，src目录下编写的.java文件， src目录就是我们的项目根目录
而关于包的名称，通常是会按照公司的反向域名来创建的，比如说我们公司的域名是www.baidu.com，我们可以选择在项目根目录下创建，因为是反向域名，并且会忽略www进行创建，最后的效果如下com.baidu.newpackage（新包的包命）
我们把前面些的两个Phone文件直接扔到这个newpackage的包下面，idea会自动重构代码所属包
这里我们因为是要从包的外部去调用属性，先将类的属性权限改成public公共，
package com.baidu.newpackage;
public class Phone{
//类的属性
public String name;
public double price;
//方法1
public void call(){
System.out.println("打电话");
}
//方法2
public void sendMessage(String message){
System.out.println("发消息"+ message);
}
//方法3
public void playGame(){
System.out.println("打游戏");
}
}然后在Main.java文件中去调用包中具体的Phone类方法
5、验证调用包内方法
vi Main.java
import com.baidu.newpackage.Phone; //导入包内的类
public class Main {
public static void main(String[] args) {
//创建Phone对象
//所有对象声明都是new开头
Phone p1 = new Phone();
//通过Phone的对象，调用其内部声明的属性或者方法
//格式： 对象.属性 或者对象.方法
p1.name = "huawei mate50";
p1.price = 6999;
System.out.println("name= " + p1.name + ",price " + p1.price);
//调用方法
p1.call();
p1.sendMessage("123123");
}
} 
6、常见第三方包
7、import导包关键字使用
8、不同包导入出现同名函数怎么办
需要使用全类名，带上包名下的类名
9、关于import static
有没有关注过之前的System.out.println命令，System是一个类，但是他没有new，我们就直接能用了，这个就是因为他做了一个static的操作
如果我们想要直接调用println，那么可以用import static java.lang.System.out;引用out.println
二、封装性
1、为什么要封装
所谓封装，就是把客观事物封装成抽象的类，并且类可以把自己的数据和方法只像可信的类或者对象开发，向没必要开发的类或者对象隐藏信息，通俗来说，把该隐藏的幺昵称，该暴露的暴露，就是封装
2、权限修饰符
private 私有的
缺省 默认
protected 受保护的
public 公共的我们可以使用4种权限修饰，来修饰类，以及类的内部成员，当成员被调用时，体现可见性的大小
3、属性私有化 及封装调用方法 （案例）
vi AnimalTest.java
public class AnimalTest{
public static void main(String[] args){
//调用Animal属性及方法
Animal animal1 = new Animal();
animal1.name = "兔子";
animal1.legs = 4;
System.out.println(animal1.name + animal1.legs);
animal1.eat();
}
}
class Animal{ //动物
//属性
String name; //名称
int legs; //腿个数
//方法
public void eat(){
System.out.println("动物迷失");
}
}返回
兔子4
动物迷失上面我们编写了一个没有修饰的类，可以直接调用类下所有的属性和方法，现在我们要给属性做一些限制，比如我们动物的腿数量不能为负数
public class AnimalTest{
public static void main(String[] args){
Animal animal1 = new Animal();
animal1.name = "兔子";
//当赋值之前去触发检查方法，检查成功后在赋值
animal1.setLegs(-2);
//animal1.legs = 4;
System.out.println(animal1.name + animal1.legs);
animal1.eat();
}
}
class Animal{ //动物
String name;
int legs;
//检查检测方法
public void setLegs(int l){
if(l >=0 && l %2 ==0){
legs = l;
}else {
System.out.println("非法");
}
}
//方法
public void eat(){
System.out.println("动物迷失");
}
}我们在Animal类下添加了setLegs 的入口方法，当想要调用的时候先去检查是否符合基本逻辑，这里我们虽然逻辑上让他去走检查了，但是如果用户没事乱点，（哎这块好像有个属性能用） 我们需要将属性私有化，必须让他走我们给他规划好的路线执行，
public class AnimalTest{
public static void main(String[] args){
Animal animal1 = new Animal();
animal1.name = "兔子";
//当赋值之前去触发检查方法，检查成功后在赋值
animal1.setLegs(-2);
//animal1.legs = 4;
System.out.println(animal1.name + animal1.legs);
animal1.eat();
}
}
class Animal{ //动物
String name;
//私有化变量
private int legs;
//检查检测方法
public void setLegs(int l){
if(l >=0 && l %2 ==0){
legs = l;
}else {
System.out.println("非法");
}
}
//方法
public void eat(){
System.out.println("动物迷失");
}
}private int legs; 我们私有化属性之后，就只能在类的内部进行调用了，即使外部知道属性是什么名称也无法访问，但是突然发现我们System.out.println(animal1.name + animal1.legs);无法调用了也无法输出值了，因为legs被设置私有权限了，那么我们就需要再编写一个查询用的方法
public class AnimalTest{
public static void main(String[] args){
Animal animal1 = new Animal();
animal1.name = "兔子";
//当赋值之前去触发检查方法，检查成功后在赋值
animal1.setLegs(-2);
//查看legs变量
System.out.println(animal1.name + animal1.getLegs());
animal1.eat();
}
}
class Animal{ //动物
String name;
private int legs;
//方法本身的权限是public公共的
public int getLegs(){
return legs;
}
public void setLegs(int l){
if(l >=0 && l %2 ==0){
legs = l;
}else {
System.out.println("非法");
}
}
//方法
public void eat(){
System.out.println("动物迷失");
}
}
4、封装修饰符权限大小图
三、构造器
vi Person
public class Person {
String name;
int age;
public void eat(){
System.out.println("Person-------------------");
}
}
vi PersonTest
public class PersonTest {
public static void main(String[] args) {
Person p1 = new Person();
p1.eat();
}
}
在上面的代码中其实我们已经使用过了构造器，上面的构造器具体就是
1、构造器的作用
1、 搭配new关键字创建类的对象
2、在创建对象的同时，能够给对象的相关属性赋值2、声明构造器
默认情况下构造器是隐式声明的，我们先将上面代码中的构造器写出来
vi Person.java
public class Person {
String name;
int age;
//显示声明构造器
public Person(){
System.out.println("我是Person的构造器");
}
public void eat(){
System.out.println("Person-------------------");
}
}
我们去执行一下PersonTest后发现我们在new声明对象的时候会自动去调用构造器下面的方法
注意:
如果不显示定义构造器，默认构造器权限和类权限一致
3、构建器使用说明
说白了，new 后面的类名 就是构造器的名称，圆括号就是给构建器函数传参的，构建器的作用主要是做一个初始化init的含义
4、综合案例 模拟存取款
vi Account.java
public class Account {
//定义成员变量
private int id;
private double balance;//余额
private double annualInterestRate; //年利率
//定义构造器，在new的时候触发，将传入的变量值交给类成员变量
public Account(int i, double b , double a){
id = i;
balance = b;
annualInterestRate = a;
}
//将传入的id交给类id
public void setId(int i){
id = i;
}
//获取类id值
public int getId(){
return id;
}
//接受传入值并修改
public void setBalance(double b){
balance = b;
}
public double getBalance(){
return balance;
}
public void setAnnualInterestRate(double a){
annualInterestRate = a;
}
public double getAnnualInterestRate(){
return annualInterestRate;
}
//上面是定义了3个变量修改值的方法，和获取值的方法
//取钱
public void withdraw(double amount){
if (amount <= balance){
balance -= amount;
System.out.println("取出" + amount);
}else {
System.out.println("余额不足");
}
}
//存钱
public void deposit(double amount){
if(amount > 0){
balance += amount;
System.out.println("存入"+ amount);
}
}
}
如上代码，我们定义了3个属性，账户id、余额、年利率
定义构造器，要求在new对象的时候必须传入这3个属性，并且给每个属性都添加读取get和写入set方法来获取基本信息
最后定义存钱和取钱方法，根据if判断存钱和取钱的逻辑是否合理
vi Customer.java
public class Customer {
private String firstName;
private String lastName;
private Account account; //这里定义的就是我们上面写的类的
//定义构造器
public Customer(String f, String l){
firstName = f;
lastName = l;
}
public String getFirstName(){
return firstName;
}
public String getLastName(){
return lastName;
}
public void setAccount(Account a){
account = a;
}
public Account getAccount(){
return account;
}
}
vi CustomerTest.java
public class CustomerTest{
public static void main(String[] args) {
//创建Customer实例
Customer customer = new Customer("张三", "李四");
//创建账号
//鼠标放到小括号内，ctrl +p 能查看传参
//传参值是 id 存款数量 年利率
Account account = new Account(1000, 2000, 0.0123);
//现在客户和账户是没关系的，我们需要关联
//我们客户信息中有一个账户的变量，这个我们没有定义，需要将用户传入进去交给customer下的account变量，因为是引用变量，会传入地址指向
customer.setAccount(account);
//setAccount是定义变量，将传入的变量赋值给类下的变量，这样一来customer账户就有了账户的地址信息了
//针对客户账户进行取钱和存前操作
//getAccount() 获取到地址信息，account
//因为account本身就是一个声明的类，那么可以调用account下面的子方法
//account下的子方法deposit 是存前 withdraw是取钱
customer.getAccount().deposit(1000);
customer.getAccount().withdraw(3001);
//创建匿名对象 这样定义的我们拿不到值，只能是一次性 的
new Account(1000, 2000, 0.0123).withdraw(1000);
}
}5、javabean
案例
满足以下条件的就是jvabean public 公共类
