Java面向对象之封装(二)

Java日报

部门： **大数据开发六部

姓名： cqmfx(阡陌飞絮)

日期： 2020.10.31

大纲

一、成员变量和局部变量的初始化

二、类的加载内存图

三、值传递和引用传递

四、方法的递归，斐波那契数列

五、包装类，自动拆装箱

六、封装超级数据

Java面对对象之封装（二）

一、成员变量和局部变量的初始化

在Java中，只要构造一个类，那么其“类体”中就有两个组成部分：成员变量和方法，方法中也包括两部分，局部变量和方法体,而方法又可以通过方法体对成员变量和局部变量进行操作

1、根据定义变量位置的不同，可以将变量分为成员变量和局部变量

（1） 成员变量是在类范围内定义的变量

​ （2）局部变量是在一个方法内定义的变量

2、成员变量可以分为：

​ 实例属性 （不用static修饰） 驼峰式命名

​ 随着实例属性的存在而存在

类属性 （static修饰） 全部大写，单词中间用_隔开

​ 随着类的存在而存在

成员变量无需显式初始化，系统会自动对其进行默认初始化

3、局部变量可分为：

​ 形参（形式参数）

​ 在整个方法内有效

​ 方法局部变量 （方法内定义）

​ 从定义这个变量开始到方法结束这一段时间内有效

​ 代码块局部变量 （代码块内定义）

​ 从定义这个变量开始到代码块结束这一段时间内有效

局部变量除了形参外，都必须显示初始化，也就是要指定一个初始值，否则不能访问。

Java允许局部变量和成员变量重名，局部变量会覆盖成员变量的值

二、类的加载内存图

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hKKmncPk-1604297204479)(E:\day++\day8\Java面向对象之封装(二)].assets\类的内存加载.png)

运行时，元数据区根据方法在栈生成栈帧，将包含静态的main方法的栈帧压入（压栈）栈底（入栈），生成定义的变量，如果还有有方法，再生成栈帧压入栈，以此类推，main方法里new的时候，会在堆里开辟一片内存空间，堆里存放具体的定义和数据，再指向元数据区中的数据；当方法执行完后，栈帧从上到下依次弹出栈（出栈），不需要Java的回收机制回收，弹栈直到栈清空，而堆则不会清空数据，需要Java的回收机制回收（引用计数法、根可达）；栈（栈帧）可以通过寻找地址（32位的地址，Java中64位的电脑将64位的地址压缩成32位了）找到堆中的数据（硬盘需要随机的转才能找到）

基础数据类型在栈中当时就存了，引用数据类型得到堆的空间里，存地址

栈是先进后出，先出后进
四位内存储存示意和地址： 高位内存一样（64位计算机和32位计算机）

三、值传递和引用传递

1、值传递

在方法被调用时， 实参 通过 形参 把它的内容副本传入方法内部，此时形参接收到的内容是实参值的一个拷贝，因此在方法内对形参的任何操作，都仅仅是对这个副本的操作，不影响原始值的内容。基础数据类型的值在栈中当时就传递了

2、引用传递

”引用” 也就是指向 真实 内容的地址值，在方法调用时，实参的地址通过方法调用被传递给相应的形参，在方法体内， 形参 和 实参 指向同一块内存地址，对形参的操作会影响的真实内容，通过地址，当方法中的形参（后压栈的栈帧）调用内存（引用）完成后，参与调用的栈帧消失，此时只剩下面的栈帧（main）在调用这片内存，只传递引用，不传递具体的值

3、实操

package opp.xinzhi;
/**
 * 2020/10/30
 * @author cqmfx(阡陌飞絮)
 */
public class Test {
    public static void main(String[] args) {
        int [] nums = {1,2,5,3,61,4};
        //调用普通方法必须new
        //引用传递
        Test test = new Test();
        test.sort(nums);
        for (int i = 0; i <nums.length; i++) {
            System.out.println(nums[i]);
        }

        System.out.println("————————————————");

        //值传递
        int i = 2;
        int j = 5;
        //静态方法能直接调用静态方法 plus()
        Test.plus(2,5);
        System.out.println(i);
    }

    public static int plus(int i , int j){
        i += j;
        return i;
    }

    public void sort(int [] array) {
        for (int i = 0; i < array.length - 1 ; i++) {
            for (int j = 0; j <array.length - 1 -i ; j++) {
                if (array [j] > array [ j + 1]) {
                    int temp = array [j];
                    array [j] =array [j + 1];
                    array [j + 1] = temp;
                }
            }
        }
    }
}

四、方法的递归，斐波那契数列

1、定义

斐波那契数列（Fibonacci sequence），又称黄金分割数列、因数学家莱昂.纳多.斐波那契（Leonardoda Fibonacci）以兔子繁殖为例子而引入，故又称为“兔子数列”，指的是这样一个数列：0、1、1、2、3、5、8、13、21、34、……在数学上，斐波那契数列以如下被以递推的方法定义：F(0)=0，F(1)=1, F(n)=F(n - 1)+F(n - 2)（n ≥ 2，n ∈ N*）——从第三个数字开始，每一位上的数字是前面两个数字相加的和

递归： 自己调用自己

2、实操

package opp.xinzhi;

/**
 * 2020/10/30
 *
 * @author cqmfx(阡陌飞絮)
 */
public class Fibonacci {
    public static void main(String[] args) {
        System.out.println(fibonacci(6));
    }

    public static int fibonacci(int count) {
        if (count == 0){
            return 0;
        }
        if (count == 1) {
            return 1;
        }
        if (count < 2) {
            System.out.println("false");
            return -1;
        }
        return fibonacci(count - 1) + fibonacci(count - 1);
    }

}

五、包装类，自动拆装箱

1、基本类型

基本数据类型	对应的包装类
byte	Byte
short	Short
int	Integer
long	Long
char	Character
float	Float
double	Double
boolean	Boolean

Java 语言是典型的面向对象编程语言，但其中的八种基本数据类型并不支持面向对象编程，基本类型的数据不具备“对象”的特性——不携带属性、没有方法可调用。 沿用它们只是为了迎合人类根深蒂固的习惯，并的确能简单、有效地进行常规数据处理。

这种借助于非面向对象技术的做法有时也会带来不便，比如引用类型数据均继承了 Object 类的特性，要转换为 String 类型（经常有这种需要）时只要简单调用 Object 类中定义的 toString( ) 即可，而基本数据类型转换为 String 类型则要麻烦得多。为解决此类问题 ，Java为每种基本数据类型分别设计了对应的类，称之为 包装类(Wrapper Classes) ，也有教材称为外覆类或数据类型类。

每个包装类的对象可以 **封装一个 **相应的基本类型的数据，并提供了其它一些有用的方法。包装类对象一经创建，其内容（所封装的基本类型数据值）不可改变。

包装类在堆里面存放

包装类最好放在方法里，在方法里就定义了，如果没有赋值，就可以打印出 null

基本类型和对应的包装类可以相互装换：

• 由基本类型向对应的包装类转换称为装箱，例如把 int 包装成 Integer 类的对象；
• 包装类向对应的基本类型转换称为拆箱，例如把 Integer 类的对象重新简化为 int。

2、常见类型

八个包装类的使用比较相似

1) 实现 int 和 Integer 的相互转换

可以通过 Integer 类的构造方法将 int 装箱，通过 Integer 类的 intValue 方法将 Integer 拆箱。

1. int m = 100;
2. Integer obj = new Integer(m); // 手动装箱

2) 将字符串转换为整数

只含数字的才能转成整数，含其他的转不成整数

Integer 类有一个静态的 parseInt() 方法，可以将字符串转换为整数，语法为：

parseInt(String s, int radix);

s 为要转换的字符串，radix 为进制，可选，默认为十进制。

3) 将整数转换为字符串

Integer 类有一个静态的 toString() 方法，可以将整数转换为字符串

1. int m = 20;
2. String s = Integer.toString(m);

3、自动拆箱和装箱

自动拆箱装箱，也就是在进行基本数据类型和对应的包装类转换时，系统将自动进行

自动装箱：基本类型自动转为包装类（int >> Integer）

自动拆箱：包装类自动转为基本类型（Integer >> int）

.equals 是比较两个值时候 满足条件(n >= n1) 为true 不满足(n < n1)为false

package opp.xinzhi;

/**
 * 2020/11/1
 *
 * @author cqmfx(阡陌飞絮)
 */
public class Demo {
    public static void main(String[] args) {
        int m = 50;
        Integer n = m;
        int i = n;
        System.out.println("n = "+n);
        Integer n1 = 50;
        System.out.println("i1 和 n等价吗 " + n.equals(n1));
    }
}

六、包装超级数组

超级数组会另发一贴，可能会和超级链表、多态超级集合（用多态将超级数组和超级链表集合到一块儿），泛型超级数值（超级集合引入泛型和超级数值）一块儿发，请关注！！！