重学java 11 封装

少想，多做，没人会知道你过程中经历了什么

人人都只看结果

                                                ——24.1.25

回顾与重点

回顾：

1.面向对象：

        是java的核心编程思想，自己的事情找对象帮我们去做

        有很多功能，别人帮我们实现好了，我们只需要找来这个对象，就可以调用这个对象中实现好的功能

        a、啥时候使用面向对象思想编程：在一个类中想访问另外一个类的成员（成员变量，成员方法）

        b、怎么使用：new 对象，点成员

                特殊：类名直接调用 -> 调用的成员中必须带static关键字

2.类和对象：

        a、类：实体类

                属性（成员变量） 行为（成员方法，不带static的方法）

        b、对象：

                导包：两个类在同一个包下，使用对方的成员不需要导包，相反需要导包

                        lang包下的类使用时不需要导包

                创建对象：想要使用哪个类中的成员，就new哪个类的对象

                                  类名 对象名 = new 类名（）

                调用：想要使用哪个类中的成员，就用哪个类的对象调用哪个成员

                                  对象名.成员

3.匿名对象：没有等号左边的代码只有new

        a、注意：涉及到赋值不要轻易使用

4.成员变量和局部变量的区别

        a、定义位置不同

                成员：类中方法外

                局部：方法中或者参数位置

        b、初始化值不同

                成员：有默认值

                局部：没有默认值

        c、作用范围不同

                成员：作用于整个类

                局部：只作用于方法内部

        d、内存位置不同

                成员：在堆中，跟着对象走

                局部：在栈中，跟着方法走

        e、生命周期不同

                成员：随着对象的创建而创建，随着对象的消失而消失

                局部：随着方法的调用而产生，随着方法的调用完毕而消失

重点：

1.会使用private关键字修饰成员，直到被private修饰之后作用是什么

2.会使用set方法为属性赋值，使用get方法获取属性值

3.会利用this关键字区分重名的成员变量和局部变量

4.会利用空参构造创建对象，并知道空参构造作用

5.会使用有参构造创建对象，并未属性赋值

6.会快速生成一个标准的javabean类

一、封装的介绍和使用

将一个物品封装起来，外界不能直接使用，提高了物品的安全性

1.面向对象三大特性：封装        继承        多态

2.什么是封装思想

        将细节隐藏起来，不让外界随便使用，但是我们可以提供一个公共的接口，让外界间接使用隐藏起来的细节——>封装思想

    public static void main(String[] args) {
        int[] arr = {1,2,3,4};
        //找来了Arrays这个对象，调用了toString的方法，实现功能
        //将实现toString功能的细节封装隐藏起来，对外提供了一个公共的接口，使外界间接使用封装起来的细节
        System.out.println(Arrays.toString(arr));
    }

1.例

    public static void main(String[] args) {
        int[] arr = {1,2,3,4};
        method(arr);
    }
    public static void method(int[] arr){
        System.out.print("[");
        for (int i = 0; i < arr.length; i++) {
            if(i== arr.length-1){
                System.out.print(arr[i]+"]");
            }else{
                System.out.print(arr[i]+",");
            }
        }
    }

2.问题1：

        定义成员变量，只要是new出来对象，就可以随便调用，随便赋值，哪怕是不合理的值我们也挡不住，怎么办？

        将属性封装起来（隐藏细节）

        a、关键字：private（私有化的） -> 被private修饰的成员只能在本类中使用，在别的类中使用不了

        b、注意：

                将代码放到一个方法中，也是封装的体现

                一个成员被private修饰也是封装的体现，只不过private最具代表性

        c、private的使用：

                修饰成员变量：private 数据类型 变量名

                修饰方法：将public改成private，其他的都一样

3.封装后的表现

二、get/set方法的使用

1.问题2：

属性被私有化了，外界直接调用不了了，那么此时属性不能直接赋值取值，所以需要提供公共的接口，get/set方法

set方法：为属性赋值

get方法：获取属性值

封装的方法体：

public class Demo76Person03 {
    private String name;
    private int age;

    //为name提供get、set方法
    public void setName(String xingming) {
        name = xingming;
    }

    public String getName(){
        return name;
    }

    //为age提供get、set方法
    public void setAge(int nianling){
        if(nianling>120||nianling<0){
            System.out.println("您输入错误了");
        }
        age = nianling;
    }
    public int getAge(){
        return age;
    }
}

 main函数中的调用

    public static void main(String[] args) {
        Demo76Person03 person = new Demo76Person03();
        person.setName("涛哥");
        person.setAge(18);
        System.out.println(person.getName());
        System.out.println(person.getAge());
    }

2.封装：

是将原先模糊的赋值取值，包装成为一个方法，用户在使用时，可以直接调用方法，方便快捷高效

三、小结

用private将属性封装起来，外界不能直接调用，保护了属性

对外提供一套公共的接口（set/get方法），让外界通过公共的接口间接使用封装起来的属性

四、this关键字的基本使用

1.this的介绍

        1.如果成员变量和局部变量重名（同名）时，我们遵守“就近原则”，先访问局部变量

在idea中可以通过关键字的颜色来区分局部变量还是成员变量

        2.this概述：代表的是当前对象

        3.作用：this可以区分重名的成员变量和局部变量

                      this.出来的一定是成员变量

        4.this代表当前对象，那么具体代表哪个对象呢？

                哪个对象调用的this所在的方法，this就代表哪个对象

如果不使用this关键字：

public class Demo78This01Person {
    String name;

    public void speak(String name){
        System.out.println(name+"你好，我是"+name);
    }
}

public class Demo79ThisTest02 {
    public static void main(String[] args) {
        Demo78This01Person person = new Demo78This01Person();
        person.name = "小明";
        person.speak("小红");
    }
}

使用this关键字：

public class Demo78This01Person {
    String name;

    public void speak(String name){
        System.out.println(this.name+"你好，我是"+name);
    }
}

public class Demo79ThisTest02 {
    public static void main(String[] args) {
        Demo78This01Person person = new Demo78This01Person();
        person.name = "小明";
        person.speak("小红");
    }
}

哪个对象调用的this所在的方法，this就代表哪个对象

2.正确的this关键字在封装中的使用：

//正确的this关键字在封装中的使用：
public class Demo80PrivatePerson01 {
    private String name;
    private int age;

    //为name提供get，set方法
    public void setName(String name){
        this.name = name;
    }

    public String getName(){
        return name;
    }

    //为age提供get，set方法
    public void setAge(int age){
        this.age = age;
    }

    public int getAge(){
        return age;
    }
}

public class Demo81PrivateTest02 {
    public static void main(String[] args) {
        Demo80PrivatePerson01 person = new Demo80PrivatePerson01();
        person.setName("小亮");
        person.setAge(16);
        System.out.println(person.getName()+"……"+person.getAge());
    }
}

五、构造方法的定义和使用

Demo80PrivatePerson01 person = new Demo80PrivatePerson01();

类名 变量名 = new 构造方法（）;

构造方法名 = 类名

1.概述：方法名和类名一致并且能初始化对象的方法

2.分类：

        a、无参构造：没有参数

        b、有参构造：有参数，参数是为指定的属性赋值

        c、满参构造：给所有属性赋值

以上构造记得有参和无参的构造就可以了

3.特点：

        a、方法名和类名一致

        b、没有返回值，连void都没有

3.1 空参构造

1.格式：

        public 类名(){
 

        }

2.作用：

        new对象使用

3.特点：

        每个类默认都有一个无参构造，不写也有，jvm虚拟机自动创建

4.使用：new对象就是在调用构造方法

3.2 有参构造

1.格式：

        public 类名（形参）{
                为属性赋值
        }

2.作用：

        a、new对象

        b、为属性赋值

3.特点：

        jvm虚拟机不会自动提供有参构造，但是将有参构造手写出来，jvm将不再提供无参构造，所以建议有参、无参构造都写上

public class Demo82ConstructorPerson01 {
    private String name;
    private int age;

    //无参构造
    public Demo82ConstructorPerson01(){
        System.out.println("我是无参构造");
    }

    //有参构造
    public Demo82ConstructorPerson01(String name,int age){
        this.name = name;
        this.age = age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getAge() {
        return age;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

}

public class Demo83ConstructTest02 {
    public static void main(String[] args) {
        Demo82ConstructorPerson01 person = new Demo82ConstructorPerson01();
        Demo82ConstructorPerson01 person01 = new Demo82ConstructorPerson01("涛哥", 18);
        Demo82ConstructorPerson01 person011 = new Demo82ConstructorPerson01();
        person011.setName("lcl");
        person011.setAge(21);
        System.out.println(person011.getName()+"…"+person011.getAge());
        System.out.println(person01.getName()+"…"+person01.getAge());
    }
}

六、JavaBean的使用

1.标准javaBean

JavaBean是Java语言编写类的一种标准规范，复合JavaBean的类，要求：

        ①类必须是具体的（非抽象 abstract）和公共的，public class 类名

        ②并且具有无参数的构造方法，有参构造

        ③成员变量私有化，并提供用来操作成员变量的set和get方法