Java(六)

最新推荐文章于 2024-04-30 12:12:17 发布
最新推荐文章于 2024-04-30 12:12:17 发布
阅读量110 收藏
点赞数
分类专栏： java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43182741/article/details/118559056
版权

知识点1：二维数组的使用

 *  数组，属于引用数据类型。
 *  数组的元素，可以是基本数据类型，或引用数据类型。
 *  > 数组A的元素，还可以是数组B。则构成了二维数组
 
 
 对于二维数组的理解，我们可以看成是一维数组array1又作为另一个一维数组array2的元素而存在。其实，从数组底层的运行机制来看，其实没有多维数组。


public class ArrayTest {
    public static void main(String[] args) {
        //  1. 二维数组的声明和初始化

        //静态初始化
        int[][] arr = new int[][]{{1,2,3},{4,5},{6,7,8},{9,8,6,4}};
        String[][] arr1 = new String[][]{{"陈伟霆","刘诗诗"},{"周笔畅","鹿晗","张艺兴"}};

//    int[][][] arr2 = new int[][][]{{{1,2,3},{3,4},{4,5}},{{3,4},{4,5,6,6}}};
        //动态初始化1
        int[][] arr3 = new int[4][3];
        //动态初始化2
        int[][] arr4 = new int[3][];

        //也是正确的格式：
        int arr5[] = new int[5];
        int arr6[][] = new int[5][7];
        int[] arr7[] = new int[5][7];

        //错误的：
//        int[][] arr8 = new int[][5];
//        int[][] arr9 = new int[5][7]{{1,2,3},{4,5},{6,7,8},{9,8,6,4}};

        // 2. 二维数组元素的调用:通过角标的方式
        System.out.println(arr[0][0]);
        System.out.println(arr[3][3]);
        System.out.println(arr1[1][1]);
        arr3[1][2] = 10;

//        arr4[0][0] = 10;//报空指针的异常

        // 3. 二维数组的长度
        System.out.println(arr3.length);//4
        System.out.println(arr3[0].length);//3
        System.out.println(arr1.length);//2
        System.out.println(arr1[1].length);//3
        System.out.println(arr4.length);//3
//        System.out.println(arr4[0].length);//报NullPointerException的错误
        // 4. 二维数组的遍历
        for(int i = 0;i < arr1.length;i++){
            for(int j = 0;j < arr1[i].length;j++){
                System.out.print(arr1[i][j] + "\t");

            }
            System.out.println();

        }


    }

}
  • 数组元素的默认值
package com.atguigu.java;

/**
 *
 * 测试二维数组的使用
 *   5. 二维数组元素的默认初始化值 （以动态初始化为例）
 *      动态初始化方式1：比如：int[][] arr1 = new int[4][3];
 *          外层元素的值：存储代表的一维数组的内存地址值。
 *          内层元素的值：
 *              整型数组，元素的默认初始化值为：0
 *              浮点型数组，元素的默认初始化值为：0.0
 *              字符型数组，元素的默认初始化值为：0
 *              boolean型数组，元素的默认初始化值为：false
 *              引用数组类型数组，元素的默认初始化值为：null
 *
 *      动态初始化方式2：比如：int[][] arr2 = new int[3][];
 *          外层元素的值：null
 *          内层元素的值：根本不存在。如果调用的话，报NullPointerException的错误
 *
 *  对于二维数组来说，约定称谓：
 *   > 外层元素：比如：arr1[0],arr1[1]
 *   > 内层元素：比如：arr1[0][1],arr[1][0]
 *
 *
 */
public class ArrayTest1 {
    public static void main(String[] args) {
        // 5. 二维数组元素的默认初始化值
        int[][] arr1 = new int[4][3];
        System.out.println(arr1[0]);//[I@1540e19d

        double[][] arr2 = new double[4][3];
        System.out.println(arr2[0]);//[D@677327b6


        System.out.println(arr1[0][0]);//0
        System.out.println(arr2[0][0]);//0.0

        System.out.println("######################");
        int[][] arr3 = new int[4][];
        System.out.println(arr3[0]);
        System.out.println(arr3[0][0]);//NullPointerException
        System.out.println("######################");
        arr3[0] = new int[4];
        arr3[1] = new int[]{1,2,3};
        arr3[2] = new int[5];
        arr3[3] = new int[6];

        String[][] classes = new String[4][];
        classes[0] = new String[40];
        classes[1] = new String[50];
    }
}
  • 二维数组的内存解析

在这里插入图片描述

说明：其他内存解析的图，见ppt

知识点2：数组中的常见算法

1. 数组元素的赋值

  • 杨辉三角
package com.atguigu.exer;

import java.util.concurrent.ForkJoinPool;

/**
 *
 * 使用二维数组打印一个 10 行杨辉三角。
 *
 * 【提示】
 *  1. 第一行有 1 个元素, 第 n 行有 n 个元素
 *  2. 每一行的第一个元素和最后一个元素都是 1
 *  3. 从第三行开始, 对于非第一个元素和最后一个元素的元素。即：
 * yanghui[i][j] = yanghui[i-1][j-1] + yanghui[i-1][j];
 */
public class ArrayDemo {
    public static void main(String[] args) {
        //1.二维数组的动态初始化
        int[][] yangHui = new int[10][];

        //2.二维数组的外层元素的动态初始化
        for(int i = 0;i < yangHui.length;i++){
            yangHui[i] = new int[i + 1];
        }

        //3. 给二维数组的内层元素赋值
        for(int i = 0;i < yangHui.length;i++){
            //3.1 每一行的首末元素赋值为1
            yangHui[i][0] = yangHui[i][i] = 1;
            //3.2 每一行的非首末元素赋值。规律为：yanghui[i][j] = yanghui[i-1][j-1] + yanghui[i-1][j];
            //if(i >= 2){
                for(int j = 1;j < yangHui[i].length - 1;j++){
                    yangHui[i][j] = yangHui[i-1][j-1] + yangHui[i-1][j];
                }
            //}

        }

        //4. 遍历二维数组
        for (int i = 0; i < yangHui.length; i++) {
            for (int j = 0; j < yangHui[i].length; j++) {
                System.out.print(yangHui[i][j] + "  ");
            }
            System.out.println();
        }
    }
}
  • 回形数（略）
  • 附随机数问题
创建一个长度为6的int型数组，要求数组元素的值都在1-30之间，且是随机赋值。同时，要求元素的值各不相同。  Math.random()

2. 数值型数组的特征值的计算

package com.atguigu.homework;

/**
 *
 * 定义一个int型的一维数组，包含10个元素，分别赋一些随机整数，
 * 然后求出所有元素的最大值，最小值，和值，平均值，并输出出来。
 * 要求：所有随机数都是两位数。
 *
 * 提示：如何获取指定范围的随机数:[10,99]
 *  (int)(Math.random() * 90 + 10)
 *
 *  {34,43,65,35,67,45,76,87}
 */
public class HomeWork01 {

    public static void main(String[] args) {
        //1.创建int[]数组，并初始化数组元素
        int[] arr = new int[10];
        for(int i = 0;i < arr.length;i++){
            arr[i] = (int)(Math.random() * 90 + 10);
        }

        //遍历数组
        for(int i = 0;i < arr.length;i++){
            System.out.print(arr[i] + " ");
        }
        System.out.println();
        //2. 求特征值：最大值、最小值、总和、平均数
        //最大值：
        int max = arr[0];
        for(int i = 1;i < arr.length;i++){
            if(max < arr[i]){
                max = arr[i];
            }
        }
        System.out.println("最大值为：" + max);

        //最小值
        int min = arr[0];
        for(int i = 1;i < arr.length;i++){
            if(min > arr[i]){
                min = arr[i];
            }
        }
        System.out.println("最小值为：" + min);

        //总和
        int sum = 0;

        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];
        }
        System.out.println("总和为:" + sum);

        //平均数
        double avg = (double)sum / arr.length;
        System.out.println("平均数为：" + avg);
    }
}

3. 数组的复制、反转、查找（或搜索）

package com.atguigu.java;

/**
 *
 * 测试：数组的复制、反转、查找(线性查找、二分法查找)
 */
public class ArrayTest2 {
    public static void main(String[] args) {
        //1. 复制操作
        int[] arr1 = new int[]{3,4,5,3,6,23,6,84,4};

        int[] arr2 = new int[arr1.length];
        for (int i = 0; i < arr2.length; i++) {
            arr2[i] = arr1[i];
        }

        //2. 反转操作
        //方式1：
//        for(int i = 0;i < arr1.length / 2;i++){
//            int temp = arr1[i];
//            arr1[i] = arr1[arr1.length - 1 - i];
//            arr1[arr1.length - 1 - i] = temp;
//        }
        //方式2：
        for(int x = 0,y = arr1.length - 1;x < y;x++,y--){
            int temp = arr1[x];
            arr1[x] = arr1[y];
            arr1[y] = temp;
        }

        //遍历操作
        for (int i = 0; i < arr1.length; i++) {
            System.out.print(arr1[i] + "  ");
        }
        System.out.println();

        //3. 查找之线性查找
        int[] arr3 = new int[]{3,14,5,13,6,23,16,84,4};
        int target = 166;
//        boolean isFlag = false;
        int i = 0;
        for(;i < arr3.length;i++){
            if(target == arr3[i]){
                System.out.println("在索引为" + i + "的位置找打了指定的元素");
//                isFlag = true;
                break;
            }
        }
        if(i == arr3.length){
            System.out.println("不好意思，没有找到指定的元素");
        }
//        if(!isFlag){
//            System.out.println("不好意思，没有找到指定的元素");
//        }

        //4. 查找之二分法查找
        //二分法查找：要求此数组必须是有序的。
        int[] arr4 = new int[]{-99,-54,-2,0,2,33,43,256,999};
        boolean isFlag = true;
        int number = 256;
        number = 333;
        int head = 0;//首索引位置
        int end = arr4.length - 1;//尾索引位置
        while(head <= end){
            int middle = (head + end) / 2;
            if(arr4[middle] == number){
                System.out.println("找到指定的元素，索引为：" + middle);
                isFlag = false;
                break;
            }else if(arr4[middle] > number){
                end = middle - 1;
            }else{//arr4[middle] < number
                head = middle + 1;
            }
        }

        if(isFlag){
            System.out.println("未找到指定的元素");
        }

    }
}
  • 练习1
package com.atguigu.exer;

/**
 *
 * 使用简单数组
 * (1)创建一个名为ArrayDemo1的类，在main()方法中声明array1和array2两个变量，
 * 他们是int[]类型的数组。
 *
 * (2)使用大括号{}，把array1初始化为8个素数：2,3,5,7,11,13,17,19。
 * (3)显示array1的内容。
 * (4)赋值array2变量等于array1，修改array2中的偶索引元素，
 * 使其等于索引值(如array[0]=0,array[2]=2)。打印出array1。
 *
 * 思考：array1和array2是什么关系？
 * 拓展：修改题目，实现array2对array1数组的复制   见【ArrayDemo2.java】
 */
public class ArrayDemo1 {
    public static void main(String[] args) {
        int[] array1,array2;

        array1 = new int[]{2,3,5,7,11,13,17,19};

        //显示array1的内容
        System.out.println("显示array1的内容:");
        for (int i = 0; i < array1.length; i++) {
            System.out.print(array1[i] + "  ");
        }
        System.out.println();

        //赋值array2变量等于array1
        //此操作不能称为数组的复制。
        array2 = array1;

        //修改array2中的偶索引元素，使其等于索引值(如array[0]=0,array[2]=2)
        for(int i = 0;i < array2.length;i++){
            if(i % 2 == 0){
                array2[i] = i;
            }
        }
        //打印出array1
        System.out.println("显示array1的内容:");
        for (int i = 0; i < array1.length; i++) {
            System.out.print(array1[i] + "  ");
        }
        System.out.println();


    }
}

对应的图示：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lpmS6rVs-1625668172940)(assets/1595925751381.png)]

  • 练习2：
package com.atguigu.exer;

/**
 *
 * 使用简单数组
 * (1)创建一个名为ArrayDemo1的类，在main()方法中声明array1和array2两个变量，
 * 他们是int[]类型的数组。
 *
 * (2)使用大括号{}，把array1初始化为8个素数：2,3,5,7,11,13,17,19。
 * (3)显示array1的内容。
 * (4)赋值array2变量等于array1，修改array2中的偶索引元素，
 * 使其等于索引值(如array[0]=0,array[2]=2)。打印出array1。
 *
 * 思考：array1和array2是什么关系？
 * 拓展：修改题目，实现array2对array1数组的复制
 */
public class ArrayDemo2 {
    public static void main(String[] args) {
        int[] array1,array2;

        array1 = new int[]{2,3,5,7,11,13,17,19};

        //显示array1的内容
        System.out.println("显示array1的内容:");
        for (int i = 0; i < array1.length; i++) {
            System.out.print(array1[i] + "  ");
        }
        System.out.println();

        //复制array1
        array2 = new int[array1.length];
        for(int i = 0;i < array2.length;i++){
            array2[i] = array1[i];
        }

        //修改array2中的偶索引元素，使其等于索引值(如array[0]=0,array[2]=2)
        for(int i = 0;i < array2.length;i++){
            if(i % 2 == 0){
                array2[i] = i;
            }
        }
        //打印出array1
        System.out.println("显示array1的内容:");
        for (int i = 0; i < array1.length; i++) {
            System.out.print(array1[i] + "  ");
        }
        System.out.println();


    }
}

对应的图示

在这里插入图片描述

4. 数组的排序

  • 排序的概念
排序：假设含有n个记录的序列为{R1，R2，...,Rn},其相应的关键字序列为{K1，K2，...,Kn}。将这些记录重新排序为{Ri1,Ri2,...,Rin},使得相应的关键字值满足条Ki1<=Ki2<=...<=Kin,这样的一种操作称为排序。
通常来说，排序的目的是快速查找。
  • 排序算法的衡量标准
1.时间复杂度：分析关键字的比较次数和记录的移动次数
2.空间复杂度：分析排序算法中需要多少辅助内存
3.稳定性：若两个记录A和B的关键字值相等，但排序后A、B的先后次序保持不变，则称这种排序算法是稳定的。
  • 常见的十大排序算法

在这里插入图片描述

红色：重要的 (建议：会手写)

黄色：次重要的 （明白排序思想）

  • 冒泡排序
package com.atguigu.java;


/**测试冒泡排序
 */

public class ArrayTest3 {
    public static void main(String[] args) {
        int[] arr1 = new int[]{3,14,5,13,6,23,16,84,4};

        for(int i = 0;i < arr1.length - 1;i++){

            for(int j = 0;j < arr1.length - 1 - i;j++){

                if(arr1[j] > arr1[j + 1]){
                    int temp = arr1[j];
                    arr1[j] = arr1[j + 1];
                    arr1[j + 1] = temp;

                }
            }
        }

        //遍历
        for (int i = 0; i < arr1.length; i++) {
            System.out.print(arr1[i] + " ");
        }
    }
}
  • 快速排序

在这里插入图片描述

知识点3：Arrays工具类的使用

  • Arrays是操作数组的工具类
  • 熟悉常用的方法

在这里插入图片描述

  • 代码演示
package com.atguigu.java1;

import java.util.Arrays;

/**
 * Arrays:操作数组的工具类。
 *
 */
public class ArraysTest {
    public static void main(String[] args) {
        int[] arr1 = new int[]{1,2,3,4,5};
        int[] arr2 = new int[]{1,2,4,3,5};
        System.out.println(arr1 == arr2);
        //1. equals()
        System.out.println(Arrays.equals(arr1,arr2));
        //2. toString()
        System.out.println(arr1);
        System.out.println(Arrays.toString(arr1));

        //3. fill()
        Arrays.fill(arr1,10);
        System.out.println(Arrays.toString(arr1));

        //4. sort()
        int[] arr3 = new int[]{3,14,5,13,6,23,16,84,4};
        Arrays.sort(arr3);
        System.out.println(Arrays.toString(arr3));

        //5.binarySearch()
        //前提：数组必须有序
        int index = Arrays.binarySearch(arr3, 23);
        if(index >= 0){
            System.out.println("找到了指定元素，位置为：" + index);
        }else{
            System.out.println("未找到");
        }

    }
}

知识点4：数组中的常见异常

package com.atguigu.java1;

/**
 * 测试数组中的常见异常
 */
public class ArrayExceptionTest {
    public static void main(String[] args) {
        //1. 数组角标越界异常：ArrayIndexOutOfBoundsException
        int[] arr = new int[10];//0-9
        System.out.println(arr[9]);
//        System.out.println(arr[10]);//越界
//        System.out.println(arr[-10]);//越界

        //2. 空指针异常：NullPointerException
        //情况1：
//        int[] arr1 = new int[10];
//        arr1 = null;
//        System.out.println(arr1[0]);

        //情况2：
//        int[][] arr2 = new int[5][];
//        System.out.println(arr2[0][0]);


        //情况3：
        String[] arr3 = new String[5];
        System.out.println(arr3[0].toString());
    }
}

知识点5：了解面向对象

爱学习的老冰棍
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
【总结】一维数组、二维数组的声明和初始化
qq_45555403的博客
03-01 976
【总结】一维数组、二维数组的声明和初始化 1.一维数组的声明和初始化： 　1.1静态初始化：数组的初始化和数组元素的赋值操作同时进行 　1.2动态初始化：数组的初始化和数组元素的赋值操作分开进行 　 　　　　　　　　　　数组一旦初始化完成，其长度就确定了。 示范代码： int num;//声明 num = 10;//初始化 int id = 1001;//声明 +初始化 int[] ids;//声明 //1.1静态初始化：数组的初始化和数组元素的赋值操作同时进行 ids = new int[]{100
java里什么是索引_面试官：什么是索引？
weixin_42492543的博客
02-27 5782
索引是什么？索引是依靠某些数据结构和算法来组织数据，最终引导用户快速检索出所需要的数据。工作方式： 利用b+树，链表，二分法查找，做到了快速定位目标数据，快速范围查找。索引有2个特点：通过数据结构和算法来对原始的数据进行一些有效的组织通过这些有效的组织，可以引导使用者对原始数据进行快速检索索引的本质：通过不断地缩小想要获取数据的范围来筛选出最终想要的结果，同时把随机的事件变成顺序的事件，也就是说，...
java中索引的定义
Breth的博客
08-12 617
是数组容器中空间的编号,可以用来标识数组中元素的位置 特点: a. 从0开始 b. 索引是连续的 c. 逐个加1
java中的 索引 的定义_索引数据结构
weixin_32860759的博客
02-27 566
MySQL官方对索引的定义为：索引(Index)是帮助 MySQL 高效获取数据的数据结构。白话文：索引就像书的目录一样可以非常快速的定位到书的页码。如果向mysql发出一条sql语句请求，查询的字段没有创建索引的话，可能会导致全表扫描，这样的话查询效率非常低。1、Hash算法哈希表(Hash table，也叫散列表)，是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过...
Java-笔记7
weixin_30421809的博客
05-12 131
public class ArrayExer1 { public static void main(String[] args) { int[][] arr = new int[][]{{3,5,8},{12,9},{7,0,6,4}}; int sum = 0;//记录总和 for(int i =...
java六大必须理解的问题 文档
01-31
java六大必须理解的问题、内容比较详细、写的比较具体
JAVA六大原则代码.zip
07-31
这个压缩文件包含了与JAVA编程相关的六大原则的实例代码。这些原则被称为SOLID原则，是Robert C. Martin等软件工程师提出的一组设计原则。它们的目标是使代码更具可读性、可维护性和可扩展性，从而提高软件质量。 ...
java六大设计原则 个人见解层次分明
05-20
java六大设计原则 个人见解层次分明
极简java六:反射注解
06-18
极简java六:反射注解
Java随机生成六位验证码
03-07
随机验证码。 - 随机生成十组六位字符组成的验证码。 - 验证码由大小写字母、数字字符组成。
java索引值什么意思_[Java教程]jquery获取元素索引值index()
weixin_42353805的博客
02-28 539
[Java教程]jquery获取元素索引值index()0 2016-01-26 09:00:14jquery获取元素索引值index()方法实例。jquery获取元素索引值index()方法：jquery的index()方法 搜索匹配的元素，并返回相应元素的索引值，从0开始计数。如果不给 .index() 方法传递参数，那么返回值就是这个jQuery对象集合中第一个元素相对于其同辈...
3-4Java数组----数组中涉及到的常见算法（2）--赋值&复制
wp_886的博客
01-17 92
3.数组的赋值、反转、查找（线性查找、二分法查找）。 使用简单数组 创建一个名为ArrayTest的类，再main（）方法中声明array1和array2两个变量，他们是int【】类型的数组。 使用大括号{}，把array1初始化为8个素数：2，3，5，7，11，13，17，19. 现实array1的内容。 赋值array2变量等于arrgy1，修改arrgy2中的偶索引元素，使其等于索引值（如array【0】 = 0，array【2】 = 2）。打印出array1. 思考：array1和array2的使
Java基础——3、数组（下）——二维数组
强子的博客
10-27 394
接上一章 一维数组的使用 目录1、二维数组的理解2、二维数组的使用：2.1、声明和初始化2.2、如何调用数组的指定位置的元素2.3、如何获取数组的长度2.4、如何遍历数组元素2.5、数组元素的默认初始化值2.5、总结：2.6、二维数组的内存解析2.6、二维数组练习3、数组涉及到的算法：3.1、求数组元素的最大值3.2、求数组元素的最小值3.3、求数组元素的总和3.4、数组的复制（赋值array2变量等于array1）3.4.1、内存解析3.4、数组的真正复制3.5、数组的反转3.6、数组的查找3.6.1、数
java方法重写（重点讲），方法重载
weixin_46281068的博客
04-27 938
一、方法重载定义：一个类中，出现多个方法的名称相同，但是它们的形参列表是不同的，那么这些方法就称为方法重载了。注意：一个类中，只要一些方法的名称相同、形参列表不同，那么它们就是方法重载了，其它的都不管（如:修饰符，返回值类型是否一样都无所谓）。形参列表不同指的是:形参的个数、类型、顺序不同，不关心形参的名称。应用场景：开发中我们经常需要为处理一类业务，提供多种解决方案，此时用方法重载来设计是很专业的。
Day25-Java基础之常用类1
m0_46053885的博客
04-27 882
同时我们发现Math类中的方法都是静态的，因此在使用的时候我们可以直接通过类名去调用。对于计算机而言，其实是没有数据类型的概念的，都是0101010101，数据类型是编程语言自己规定的，所以在实际存储的时候，先把具体的数字变成二进制，每32个bit为一组，存储在数组中。比较内存地址值一般情况下是没有意义的，我们希望比较的是对象的属性，如果两个对象的属性相同，我们认为就是同一个对象；如果我们的数据是一个浮点类型的数据，有的时候计算机并不会将这个数据完全转换成一个二进制数据，而是将这个将其转换成一个无限的。
Lambda表达式特点
weixin_57763462的博客
04-24 802
**API 设计**：Lambda 表达式鼓励使用函数式接口的设计模式，这改变了 Java 库的设计，例如 `java.util.function` 包下的一系列函数式接口。- **函数式编程**：Lambda 表达式引入了函数式编程的理念，使得 Java 更接近于函数式编程语言，如 Scala 和 Clojure。- **并发编程**：Lambda 表达式与 Java 8 新增的 Stream API 结合使用，可以简化并发编程，特别是与集合的操作相关。
MSE实现全链路灰度实践
云计算、数据库、大数据、深度学习、NLP、Python
04-24 421
待更新。
Java | 冒泡排序算法实现
yingzix688的博客
04-24 890
题目描述 编写一个Java程序，实现冒泡排序算法。程序需要能够接收一个整型数组作为输入，并输出排序后的数组。 冒泡排序是一种简单的排序算法，它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。
【限流】基于springboot（拦截器） + redis（执行lua脚本）实现注解限流
最新发布
qq_43209531的博客
04-30 165
基于springboot（拦截器） + redis（执行lua脚本）实现注解限流
java六大设计原则
10-05
Java六大设计原则包括：单一职责原则、开闭原则、里氏替换原则、依赖倒置原则、接口隔离原则和迪米特法则。 1. 单一职责原则：一个类应该只有一个引起它变化的原因，即一个类应该只负责一项职责。 2. 开闭原则：一...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值