Java面向对象——封装

Java面向对象——封装

• 封装，也就是把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏
• 封装是将自然界中具有相似特征和行为的事务抽象成一个类，并尽可能的私有化属性的过程，对不可信的进行信息隐藏

类

• 类是自然界中描述具有相同 特征 （属性）和 行为 （方法）的事务的统称
• 类是抽象的

对象

• 万物皆为对象
• 对象是具体的

类和对象的关系

• 类是 对象的 模板，模板的作用就是构建对象的
• 对象是类的具体实现，一个类，可以有无数个对象

类的组成——类中的方法

• （）是方法的标识

     *构造方法
     *      特点：
     *          方法名和类名 完全一致
     *          方法名不能设置返回值类型（void 都不能写）
     *          构造方法通过 new 关键字来调用
     *          如果类中没有设置构造方法，JVM（Java虚拟机）会自动提供一个无参构造方法
     *          如果类中设置的有构造方法，那么JVM（Java虚拟机）不再提供任何额外的无参构造方法
     *          
     *      作用：
     *          	创建对象
     *          	有参构造可以对  属性 进行赋值
  

方法的重载：
在一个类中，具有多个相同的方法名，这种现象称为方法的重载

• 方法的重载 必须同时满足以下两个条件：

• 1.方法名 必须相同
• 2.参数列表 不同 （参数个数不同 或者 参数类型不同）

类的组成——this的调用

• 当局部变量（定义在方法中的变量）和成员变量（类中的变量 ）的名字冲突时，优先使用局部不变量的名字，成员变量的名字会被覆盖，如果此时需要使用成员变量（属性），那么通过 this 关键字进行访问
• this 在Java的类中，代表该类的对象 （调用该属性或者方法的对象）
• this 通过’ . ’ 可以调用属性，也可以调用成员方法
• this 还可以调用 构造方法 （在构造方法中，调用构造方法）
• this() ： 调用无参的构造方法
• this 在调用构造方法的时候，必须出现在构造方法中，作为第一个语句

类的组成——代码块

• 代码块一般用来做数据的初始化工作，它会在调用构造方法前执行
• 属性的声明在代码块之前，先对属性进行执行，属性在代码块之后，属性的声明会被调用在代码块之前
• 在代码块中无法使用有可能未被赋值的属性

类的组成——修饰符

权限修饰符

public （公有的）
protected （受保护的）
friendly（default）（缺省的）
private（私有的）

private 私有属性问题

• 私有属性想要使用，1.设置一个构造方法进行赋值（只能设置值，不能访问）2.设置防范（set/get 方法设置/获取值）
• 如果设置有参构造，同时推荐设置一个无参构造，没有无参构造，会在创建对象的时候需要直接设置属性

		//输出 person 对象
        System.out.println(person);
        //结果：com.qikux.day0726.Person@404b9385

field 属性

    /**
     * 姓名
     */
    private String name ;

property 属性

• 指的是 setter / getter 方法
  -去掉 get 或者 set ，然后首字母变小写，这样的属性成为 property 属性

    /**
     * 添加私有属性 name 的方法
     */
    public void setName(String name){
     //当前位置name是property属性
        this.name = name ;
    }

重写 equals 方法

    public double getMoney(){
     
        return this.money ;
    }
    public String toString(){
     
        return "姓名："+name+"\n年龄："+age+"\n性别："+sex+"\n身份证号："+id_number+"\n存款：" + money;
    }
    public boolean equals(Object obj) {
     

        //先判断地址是否相等，地址相等，内容也相等
        if(this == obj)return false ;

        //如果地址不相等，判断obj的地址是否为空
        if(obj == null)return false ;

        //如果地址不相等，比较两个对象是否是同一个类型，获取对象类型用getClass()
        if(this.getClass() != obj.getClass())return false ;

        Person02 p = (Person02) obj;

        //如果两个对象的类型相等，判断属性是否相等
        //Objects.equals(a,b);  比较两个对象的内容是否相等的工具类，解决了空指针的问题
        //如果名字不相等，判断下一项
        if(!Objects.equals(this.name,p.name))return false ;
        //如果性别不相等，判断下一项
        if(!Objects.equals(this.sex,p.sex))return false ;
        //如果年龄不相等，判断下一项
        if(this.age != p.age)return false ;
        //如果身份证号不相等，判断下一项
        if(!Objects.equals(this.id_number,p.id_number))return false ;
        return true ;


    }

}

static （静态）修饰符

• static 可以修饰 内部类
• static 可以修饰 属性，称为类属性
• static 可以修饰 方法，称为类方法
• static 可以修饰 代码块
  注：static 修饰的内容和对象没有关系，而是和对应的类有关系

public class Article {
     
    public static int count = 0;
    static {
     
        System.out.println("静态代码块");
    }   
        public static void read(){
     
        System.out.println("读取文章的内容");
    }
}

类的组成——类加载

/**
     * 
     * 类加载：
     *      JVM`第一次` 读取一个类的时候，会将.class（字节码文件）读入到内存，这个过程，称为类加载
     *      
     *      一个类最多只会发生一次类加载，类加载的产物是类对象，用class类型来表示
     * 类加载的过程：
     * 	  1.递归的加载 所有父类的信息
     *       1.JVM 分配空间
     *       2.加载 静态属性，如果有赋值语句，同时完成赋值操作
     *       3.加载 静态代码块，并执行代码块中的语句
     *       4.如果有 静态属性 没有赋值，此时完成对静态属性的赋值
     *       5.将类中的静态方法全部压入 内存（此时方法是不会执行的）
     * 	  2.父类加载完成后，再进行自己的类加载（遵循以上五个步骤）
     * ***static***
     *  static 修饰方法（一般多用于工具类的编号）
     * 
     * static 修饰代码快（做数据的一次性初始化工具）
     * 
     * 静态属性，静态方法  可以使用类或对象来调用，推荐用类调用
     * 
     * 空对象引用，可以调用静态方法和静态属性，而不会产生空指针异常
     *null不能调用静态方法和静态属性
     */

rest 不定项参数

 * 不定项参数，必须出现在所有的参数的后面
 * 不定项参数，用来接收剩余的（rest）所有的参数
 * 不定项参数，如果和定义的某个方法，在某种场合 下冲突，那么优先使用最确定的算法，而非调用不定项参数
 * 不定项参数，如果没有接收到任何数据，会默认一个空数组，而非null

public static void main(String[] args) {
     
        int s = sum();		//不定项参数中，此时sum里面的参数可以是任意个数
        System.out.println(s);
    }
    //求至少两个数的和
    public static int sum (int ... c){
     		//此时的c是一个数组
        System.out.println("+++++"+c.length);
        return Arrays.stream(c).sum();
    }

final 修饰符

     * final 可以修饰
     *          方法、属性、类、局部变量
     *
     *      final 修饰属性，代表属性不允许修改，是一个常量
     *      final 修饰方法，代表方法不允许被重写
     *      final 修饰类，代表类不允许被继承
     *      final 修饰局部变量，代表是一个常量，（一般配合内部类）
     *      final 修饰属性，代表属性是一个常量，常量一旦赋值，不可被修改
     *
     *              a）final 修饰的属性没有默认值
     *              b）必须赋初值
     *                  1）声明并赋值
     *                  2）普通（实例）代码块
     *                  3）通过构造方法完成对final修饰的属性赋值
     *              c） 如果是静态常量，那么此时可以在以下位置进行赋值
     *                  1）声明并赋值
     *                  2）静态代码块
     *              d）final 修饰的属性名 要求全大写（）  `ctrl +shift +u`  切换选中内容的大小写
     *                  如果常量有多个单词，推荐使用 `下划线` 分割（_下划线命名称为蛇形标识）

类的组成——对象的创建

     * 对象的创建过程：
     *     1.分配空间
     *     2.初始化属性，如果有赋值操作，则进行赋值
     *     3.加载代码块
     *     4.对没有进行赋值的属性，进行赋值
     *     5.将类中的所有成员方法，加入到内存
     *     6.调用构造方法	

类的组成——内部类

public class ICBCBank {
     
    public void getMoney(int money){
     

        if(money <= 10000){
     
            System.out.println("请移步ATM机取款，柜台只进行10000元以上的业务办理");
        }
        System.out.println("在柜台取钱，取款金额为"+ money + " 元");
    }

    public class ATM{
     

        public void getMoney(int money){
     

            if (money > 10000){
     
                System.out.println("请前往柜台取款，ATM机只能进行不超过10000元的业务办理");
            }
            System.out.println("在ATM机取款，取款金额为"+ money + "元");
        }
    }
}

//import static com.qikux.day0727.ICBCBank.ATM;

public class ICBCBankTest {
     
    public static void main(String[] args) {
     

        //取2000，在ATM机上
        //先确定银行 ， 再 在银行下的某个ATM机上
        ICBCBank.ATM atm = new ICBCBank().new ATM();//（成员内部类）
        //ICBCBank.ATM atm = new ICBCBank.ATM();//静态内部类，在内部类创建时加static
        //atm.getMoney(2000);

		//ATM atm = new ATM();		//导包方式下的静态内部类

        atm.getMoney(2000);
        ICBCBank icbcBank = new ICBCBank();
        icbcBank.getMoney(100000);
    }
}

records （记录）类——JDK14 新特性

• 记录类中不能有实例属性

public record Point(int x , int y ) {
     
    public static String name ;
    public Point{
     
        System.out.println("这是构造方法"+ x * y);
    }

    public void test(){
     
        System.out.println("这是成员方法");
    }
    public static void test1(){
     
        System.out.println("静态方法");
    }
}
class A{
     
    public static void main(String[] args) {
     
        Point point = new Point( 5 , 8);
        point.test();
        point.test1();
        System.out.println(point.x());
        System.out.println(point.y());
    }
}

jar包

commons-lang3-3.12.0
lombok-1.18.20
Java中jar包及其他资源下载地址