java Note 2021.7.21

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

文章目录

java Note 2021.7.21

1、方法

1.1、 没有返回值也没有形参的方法
1.2、 没有返回值有形参的方法
修饰符 返回值类型 方法名(形参列表){
	方法体;
}

形参：执行方法的那一方需要调用方提供的数据
    举例：  XX去给我炒一个青椒肉丝   --->  相当于我 调用 XX 烹饪的功能
    那么XX需要我提供青椒还有肉丝，那么这个青椒和肉丝就是XX的烹饪功能的形参
    
    那么在定义方法的时候，必须声明自己需要的数据：   形参
    在调用方法的时候，必须将对应的数据给这个方法：   实参
  
    对应到java中，形参其实就是声明变量
                实参就是具体的值
    			它们的关系就是：将实参赋值给形参
1.3、调用有形参的方法：
类名.方法名(实参列表)

public class Demo1 {
    public static void main(String[] args) {        
    //调用add方法        
    Demo1.add(3,2);
       }   
        /*    
        定义add方法时，指定了两个形参a 与 b    
        它们至少空的变量，是没有值的    
        但是可以在方法体中使用它们,因为要执行方法体，就必须调用方法    
        而调用有形参的方法的时候，必须给形参赋值    
        结果：执行方法体的时候，形参是一定有值的
             */    
             public static void add(int a, int b){        
             System.out.println(a + b);  
              }
}

提示：这里可以添加系列文章的所有文章的目录，目录需要自己手动添加
例如：第一章 Python 机器学习入门之pandas的使用

练习

1.调用方法打印乘法表，有一个参数，决定乘法表的行数

	/*
	1.调用方法打印乘法表，有一个参数，决定乘法表的行数 
	*/
public class Practise1 {
    public static void main(String[] args) {        
    mt(34);
       }    
    public static void mt(int n){
            for (int i = 1; i <= n; i++) {           
             for (int j = 1; j <= i ; j++) {                
             System.out.print(j + "x" + i + "=" + i*j +" "); 
                       }            
          System.out.println();      
           }  
            }
}

2.调用方法打印星号(矩形)，有两个参数，分别决定星号的行数与列数

public class Practise2 {
    public static void main(String[] args) {        
    stars(5,7);
       }    
    public static void stars(int rows, int cols){        
    for (int i = 0; i < rows; i++) {            
    for (int j = 0; j < cols; j++) {                
    System.out.print("* ");  
             }            
     System.out.println();  
          }  
           }
}
1.4、有返回值的方法
修饰符 返回值类型 方法名(形参列表){ 
					方法体; 
					return 值;//就是指定某个值为 返回值
		}
		注意： 返回值类型 一定要与 返回值的类型匹配

调用有返回值的方法:

注意：如果一个方法有返回值，则可以将调用该方法的代码直接当做值来使用

变量 = 类名.方法名(形参列表);
System.out.println(类名.方法名(形参列表));

public class Demo2 {
    public static void main(String[] args) {
        int result = add(3, 2);
        System.out.println("结果值为:" + result);
    }

    /*
    返回值类型不是void  表示这个方法一定要有返回值
    也就是方法体中必须有return 值.

     方法体中return 值。就是这个方法的返回值
     表示如果你调用add方法，则你会得到两个形参的和
     */
    public static int add(int a, int b){
        return a + b;
    }
}
练习

定义方法，形参接收3个数字，返回最大的那一个

/*
定义方法，形参接收3个数字，返回最大的那一个
 */
public class Practise3 {
    public static void main(String[] args) {
        System.out.println(getMax(9, 8, 5));
    }

    public static int getMax(int a, int b, int c){
//        return a>b?(a>c?a:c):(b>c?b:c);
        if(a > b){
            if(a > c){
                return a;
            }else{
                return c;
            }
        }else {
            if(b > c){
                return b;
            }else{
                return c;
            }
        }

    }
}

定义方法，形参接收两个数字，判断是否相等

/*
定义方法，形参接收两个数字，判断是否相等
 */
public class Practise4 {
    public static void main(String[] args) {
        System.out.println(equals(5,5));
    }
    public static boolean equals(int a, int b){
//        return a==b;
        if(a==b){
            return true;
        }
        return false;

    }
}
注意事项

一个有返回值的方法，方法体中的return必须被执行

2、方法的重载

方法的重载：

在同一个类中，多个方法的方法名一致，但是形参列表不一致

形参列表不一致：

1.类型不一致

2.数量不一致

3.顺序不一致

以上三个条件，满足了任意一个，都形成方法的重载

2.1、没有使用方法的重载
public class Demo3 {
    public static void main(String[] args) {
        //计算两个数字的和
        
        /*
        这种情况下，定义方法与调用方法实质上是没有问题的
        但是对于调用方法，压力很大。因为调用方法需要记住方法名与形参的对应的关系
        如果方法的数量很多，则记起来就很麻烦
        
        解决方案：能不能所有功能类似的方法使用同一个名称
        向这种如果  方法名相同，但是形参列表不一样的情况，就是方法的重载
         */
        add2(3, 2);
        add3(3, 4, 5);
        add4(4,7,1,3);
    }
    public static int add2(int a, int b){
        return a + b;
    }
    public static int add3(int a, int b, int c){
        return a + b + c;
    }
    public static int add4(int a, int b, int c, int d){
        return a + b + c + d;
    }
}
2.2、使用方法的重载
public class Demo3 {
    public static void main(String[] args) {
        add(3, 2);
        add(3, 4, 5);
        add(4,7,1,3);
    }
    /*
    以下三个方法形成了方法的重载
    因为三个方法都叫做add  但是形参列表都不一致
     */
    public static int add(int a, int b){
        return a + b;
    }
    public static int add(int a, int b, int c){
        return a + b + c;
    }
    public static int add(int a, int b, int c, int d){
        return a + b + c + d;
    }
}
练习

定义plus方法形成重载，可以接收两个int参数或者两个string参数，如果是两个int参数打印两个数的和，

如果是两个String参数，打印拼接起来的结果

定义方法打印矩形的星号形成重载，如果只有一个参数，则该参数决定了矩形的行和列

如果有两个参数，则第一个参数决定行，第二个参数决定列

/*
定义方法打印矩形的星号形成重载，如果只有一个参数，则该参数决定了矩形的行和列
如果有两个参数，则第一个参数决定行，第二个参数决定列
 */
public class Practise6 {
    public static void main(String[] args) {
        stars(5);
        stars(2,6);
    }

    public static void stars(int n){
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                System.out.print("* ");
            }
            System.out.println();
        }
    }

    public static void stars(int m, int n){
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                System.out.print("* ");
            }
            System.out.println();
        }
    }
}

3、数组

数组就相当于一个容器，可以同时存放多个数据

优点：对自己存放的多个数据可以统一管理

在这里插入图片描述

4、初始化数组

4.1、动态初始化

只声明数组的长度，而不给数组的元素赋值

数据类型[] 变量名 = new 数据类型[长度];
4.2、静态初始化

声明数组的长度的同时也指定每一个元素的值

数据类型[] 变量名 = new 数据类型[]{数据1,数据2....};

也可以简写为：
数据类型[] 变量名 = {数据1,数据2....};

注意：这个简写只对初始化有效

5、获取数组的信息

5.1、获取长度
数组名.length;
5.2、获取数组指定元素的值
数组名[索引];
5.2、遍历数组

取出数组的每一个元素

public class Demo1 {
    public static void main(String[] args) {
        //动态初始化数组
        int[] ary1 = new int[5];//表示创建一个元素类型为int,长度为5的数组
        int[] ary2 = new int[]{1,3,5,7};//表示创建一个指定元素的数组
        int[] ary3 = {2,4,6,8};
        //ary3 = {1,2};会报错  因为这不是对ary3初始化  所以不能使用简写

        //获取数组的长度
        System.out.println(ary2.length);//4
        //获取数组指定索引的元素
        System.out.println(ary3[2]);//6

        //遍历ary2数组
        for (int i=0;i<ary2.length;i++){
            int cell = ary2[i];
            System.out.print(cell + ",");
        }
    }
}
练习

创建一个类，声明一个方法，参数是int[],方法返回包含了该数组每一个元素的字符串

/*
创建一个类，声明一个方法，参数是int[],方法返回包含了该数组每一个元素的字符串
 */
public class ArrayUtil {

    /**
     * 将指定的数组转换为字符串
     * @param ary 指定的数组
     * @return 数组的元素组成的字符串
     */
    public static String toString(int[] ary){
        String str = "";

        //1.遍历数组取出每一个元素
        for (int i = 0; i < ary.length; i++) {
            int cell = ary[i];
            //2.将取出的每一个元素都拼接到字符串上
            str += cell;
            //3.如果不是最后一个元素，则向字符串拼接一个逗号
            if(i!=ary.length-1){//任何一个数组的最后一个元素的索引，一定是这个数组的长度-1
                str += ",";
            }
        }
        return str;
    }
}

public class Demo2 {
    public static void main(String[] args) {
        int[] ary2 = new int[]{1,3,5,7};
        int[] ary3 = {2,4,6,8};

        //注意：调用方法与声明方法不在同一个类，所以不能省略类名了
        String str1 = ArrayUtil.toString(ary2);//调用方法 遍历ary2数组
        System.out.println(str1);

        System.out.println(ArrayUtil.toString(ary3));//调用方法遍历ary3数组
    }
}

6、不同类型的数组的默认值问题

public class Demo3 {
    public static void main(String[] args) {
        /*
        所有的整型数组的元素的默认值都是0
         */
        int[] ary1 = new int[5];
        System.out.println(ArrayUtil.toString(ary1));
        byte[] ary2 = new byte[3];
        for (int i = 0; i < ary2.length; i++) {
            System.out.print(ary2[i] + " ");
        }
        System.out.println();

        /*
            所有浮点型数组的元素的默认值都是0.0
         */
        double[] ary3 = new double[4];
        for (int i = 0; i < ary3.length; i++) {
            System.out.print(ary3[i] + " ");
        }
        System.out.println();
        /*
        字符型数组的元素的默认值是数字0对应的那个字符
         */
        char[] ary4 = new char[4];
        for (int i = 0; i < ary4.length; i++) {
            System.out.print(ary4[i] + " ");
            System.out.print((int)ary4[i]);
        }
        System.out.println();

        /*
        布尔类型数组的元素的默认值是false
         */
        boolean[] ary5 = new boolean[4];
        for (int i = 0; i < ary5.length; i++) {
            System.out.print(ary5[i] + " ");
        }
        System.out.println();

        /*
        所有的引用类型数组的元素的默认值是null
         */
        String[] ary6 = new String[4];
        for (int i = 0; i < ary6.length; i++) {
            System.out.print(ary6[i] + " ");
        }
        System.out.println();
    }
}

7、数组索引的范围问题

public class Demo4 {
    public static void main(String[] args) {
        //创建一个长度为5的数组  索引的范围是:0~4
        int[] ary = new int[5];

        /*
        取出数组中索引为5的元素
        因为该数组没有值为5的索引  所以这里使用的索引越界了
        会出现ArrayIndexOutOfBoundsException
        当程序出现异常，则程序会在出现异常的那一行代码被中断
         */
        System.out.println(ary[5]);

        System.out.println("------------------");
    }
}

8、数组元素的操作

8.1、查找元素

查找指定元素： 数组名[索引]

查找所有元素：遍历数组

8.2、修改元素的值

数组名[索引] = 值;

练习

创建int数组，添加100个元素，值为1~100范围的随机数

然后将每一个元素的值都+1

import java.util.Random;
public class Demo5 {
    public static void main(String[] args) {
        Random random = new Random();

        int[] ary = new int[100];
        //设置数组的元素为1~100范围内的随机整数
        for (int i = 0; i < ary.length; i++) {
            ary[i] = random.nextInt(100) + 1;
        }
        System.out.println(ArrayUtil.toString(ary));

        //将每一个元素的值加1
        for (int i = 0; i < ary.length; i++) {
            ary[i] += 1;
        }
        System.out.println(ArrayUtil.toString(ary));
    }
}

public class Practise {
    public static void main(String[] args) {
        String[] ary = {"周杰伦","昆凌","侯佩岑"};
        //将ary数组的每一个元素值后面加上"同志"两个字
    }
}

public class Practise {
    public static void main(String[] args) {
        String[] ary = {"周杰伦","昆凌","侯佩岑"};
        //将ary数组的每一个元素值后面加上"同志"两个字
        for (int i = 0; i < ary.length; i++) {
            ary[i] += "同志";
        }
        for (int i = 0; i < ary.length; i++) {
            System.out.println(ary[i]);
        }
    }
}
8.3、向数组中添加元素

数组的长度是不可更改的

所以如何才能向一个数组中添加元素呢？

答案：创建一个长度更大的新数组，将原数组的元素复制到新数组中，再向新数组中添加元素

public class Demo6 {
    public static void main(String[] args) {
        int[] ary = {1,3,5,7};
        int value = 9;
        /*
        将调用append方法得到的新数组赋值给ary变量
        ary变量之前存放的是原数组  现在存放的变成了新数组
        这么做的好处：对于使用ary变量的用户来说，给它的感觉是ary数组变大了
         */
        ary = append(ary, value);

        for (int i = 0; i < ary.length; i++) {
            System.out.print(ary[i] + " ");
        }

    }

    /**
     * 将指定值添加到指定的数组的末尾
     * @param ary 指定的数组
     * @param value 指定的值
     * @return 添加了元素的新数组
     */
    public static int[] append(int[] ary, int value){
        //1.创建容量为ary.length+1的新数组
        int[] newAry = new int[ary.length + 1];
        //2.将原数组中的所有元素复制一份到新数组中
        for (int i = 0; i < ary.length; i++) {
            //将原数组的元素复制给新数组的元素
            newAry[i] = ary[i];
        }
        //3.将指定值添加到新数组的末尾
        newAry[newAry.length - 1] = value;
        return newAry;
    }
}

9、数组作为方法的参数

10、 创建数组变量的内容图

public static void methodName(){
    int i = 5;
    int[] ary = {1,3,5,7};
}

在这里插入图片描述

可以发现创建的数组变量，实际上存放的数组的地址值

每次使用这个变量，其实是根据存放的地址值到堆内存中找到对应的数组进行操作

10.1、 java只有值传递

如果将一个基本数据类型的变量赋值给另一个变量，是将这个变量本身的值复制一份给另一个变量

int i = 5;
int j = i;

如果将一个引用类型的变量赋值给另一个变量，是将这个变量存放的地址值复制一份给另一个变量

int[] ary = {1,2,3};
int[] ary2 = ary;
练习
public class Practise2 {
    public static void main(String[] args) {
        int i = 5;
        int[] ary = {1,2,3};

        test1(i);
        System.out.println(i);//5

        test2(ary);
        System.out.println(ary[0]);//2
    }
    public static void test1(int i){
        i++;
    }

    public static void test2(int[] ary){
        ary[0]++;
    }
}

在这里插入图片描述

11添加元素的内存图

在这里插入图片描述

12、删除数组元素

删除数组中指定索引处的元素删除的思路：
1.将数组中需要被删除的元素后面的所有元素，向前移动一位
2.创建一个容量为原数组的长度-1的新数组
3.将原数组的元素(长度-1个)复制到新数组中

public class Demo7 { 
   public static void main(String[] args) {
           int[] ary = {1,3,5,7,9};        ary = delete(ary,0);
           //调用方法删除ary数组中索引为1的元素        
           for (int i = 0; i < ary.length; i++) {            
           System.out.print(ary[i] + " "); 
                 } 
  }   
  				 /**     
  				 * 删除指定数组中指定索引处的元素    
  				 *  * @param ary 指定的数组     
  				 * * @param index 指定的索引     
  				 * * @return 删除元素之后的效果的新数组
  				 *      */    
  		     public static int[] delete(int[] ary,int index){        
  		     //1.将原数组中需要被删除的元素后面的所有元素向前移动一位       
  		      for (int i = index+1; i < ary.length; i++) {
  		                  ary[i-1] = ary[i]; 
  		                        }        
  		         //2.创建长度为原数组的长度-1的新数组        
  		         int[] newAry = new int[ary.length-1];        
  		         //3 将元素值的元素复制到新数组        
  		         for (int i = 0; i < newAry.length; i++) {
  							newAry[i] = ary[i];
  							       }        
  							       return newAry; 
  							         }
}

在这里插入图片描述

练习

生成100个1~100范围的随机整数，将偶数放入一个数组，将奇数放入一个数组将每一个数组中5的倍数都删除


public class demo1 {
    public static void main(String[] args) {
    int[] arr=new int[100];

        Random random=new Random();
        int o=0,j=0;
        for (int i = 0; i < 100; i++) {
            arr[i]=random.nextInt(100)+1;
            if (arr[i]%2==0)
                o++;
            else
                j++;
        }
        System.out.println("===========================");
        System.out.println("得到的原数组为：");
        System.out.println(toString(arr));
        System.out.println("\n===========");
        int[] ji=getJi(arr,j);
        System.out.println("得到的奇数数组为：");
        System.out.println(toString(ji));
        System.out.println("\n===========");
        int[] ou=getOu(arr,o);
        System.out.println("得到的偶数数组为：");
        System.out.println(toString(ou));
        System.out.println("===========================");
        System.out.println("去掉5的倍数后：");
        System.out.println("\n===========");
       ji=getNewArr(ji);
        System.out.println("得到的奇数数组为：");
        System.out.println(toString(ji));
        System.out.println("\n===========");
         ou=getNewArr(ou);
        System.out.println("得到的偶数数组为：");
        System.out.println(toString(ou));
    }
    //除去5的倍数得到的数组
    public static  int[] getNewArr(int[] arr){
        int k=0;
        for (int i = 0; i < arr.length; i++) {
            if (arr[i]%5!=0) {
                k++;//获取不是5的倍数数组的个数作为新数组的长度
            }else
                arr[i] = 0;//将5的倍数置为0
        }
        int[] newArr=new int[k];
        int k1=0;
        for (int i = 0; i < arr.length; i++) {
            if (arr[i]!=0){
            newArr[k1]=arr[i];
            k1++;
            }
        }
        return newArr;
    }
    //获取奇数数组
    public  static int[] getJi(int[] arr,int count){
        int[] newArr=new int[count];
        int k=0;
    for (int i = 0; i < arr.length; i++) {
        if (arr[i]%2!=0){
            newArr[k]=arr[i];
            k++;
        }
    }
    return newArr;
}
	//获取偶数数组
    public  static int[] getOu(int[] arr,int count){
        int[] newArr=new int[count];
        int k=0;
        for (int i = 0; i < arr.length; i++) {
            if (arr[i]%2==0){
                newArr[k]=arr[i];
                k++;
            }
        }
        return newArr;
    }
	//将数组变成字符串输出
    public static String toString(int[] arr){
        String str="";
        for (int i = 0; i < arr.length; i++) {
            str+=arr[i]+" ";
            if ((i+1)%10==0){
                str+="\n";
            }
        }
        return str;
    }
}

输出结果：

在这里插入图片描述

IT_JAVA_123
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java.note.zip
06-12
"Java.note.zip"很可能是一个包含了关于Java学习笔记的压缩文件，它可能包括了各种主题，如基础语法、面向对象编程、集合框架、异常处理、多线程、I/O流、网络编程、数据库连接以及Java高级特性等。 首先，Java的...
Java_Note.zip_Java笔记
09-24
这份"Java_Note.zip"压缩包包含了一份详细的Java笔记，对于初学者来说，它是一份宝贵的资源，可以帮助理解语言基础，掌握核心概念，并通过实例加深理解。 笔记可能会涵盖以下几个主要知识点： 1. **Java基础**：这...
Java 对象 note
mygodhome的专栏
01-06 147
创建对象 声明 不为对象分配内存空间，而只是分配一个引用。eg.String name; 实例化 为对象分配内存空间和初始化对象。eg. String name; name = new String("Hi V"); //new分配内存空间，然后调用String 的构造方法，并传递参数“Hi V" 空对象 一个引用变量没有通过new 分配内存空间，这个对象就叫空对象。eg.表示为：...
java Note 2021.7.19
qq_51300373的博客
07-22 102
java Note 2021.7.19 1、计算机 是可以进行高速计算的机器 特点： 1.计算的效率非常高 2.不会出错 2、如何操作计算机 输入命令： 一定要计算机能够听懂 计算机能够听懂的命令： 使用 编程语言： 编程语言也分很多种： c/c++ c# java python php kotlin go ruby… 我们学习java语言： java性价比最高, 第一：因为学习的难度的适中的。 第二：市场的需求最大。 第三：薪资还可以。 3、编程语言 java是最好的语言！ 4、java语言 是Sun公司
java Note 2021.7.20
qq_51300373的博客
07-22 64
java基础笔记 文章目录java基础笔记1、注释单行注释多行注释文档注释2、IDE1、创建java程序2、执行java程序3、关键字4、标识符5、变量5.1创建变量的语法6、数据类型7、创建变量 1、注释 单行注释 //注释的内容 特点：注释的内容只能在当前行 多行注释 /*注释的内容 注释的内容 注释的内容 */ 文档注释 /** 注释的内容 */ 效果： 1.支持多行注释的效果 2.注释的内容 会自动生成到文档中 我们现在要执行一个java程序，是不是很麻烦 体现的
Android Studio Bumblebee | 2021.1.1 Patch 2 修复BUG
热门推荐
安卓开发&音视频开发
03-15 2万+
一般修复和功能 此更新解决了以下问题： Android Gradle 插件 问题 #213534628：Android Gradle 插件 7.1.0-rc01 在单元测试期间无法执行 ASM 字节码转换 问题 #210484302：Android Studio 2021.1.1 beta5。Gradle 同步失败并显示“无法加载类 'com.android.build.api.extension.AndroidComponentsExtension'”。 问题 #19
Java8 Collections.sort()的底层源码分析
weixin_45673033的博客
08-15 947
Collections.sort()的底层原理源码分析
java.lang.IllegalArgumentException: Invalid character found in method name
qq_46070108的博客
06-18 650
2021-06-18 10:52:25.189 INFO 7268 --- [0.0-8080-exec-5] o.apache.coyote.http11.Http11Processor : Error parsing HTTP request header Note: further occurrences of HTTP request parsing errors will be logged at DEBUG level. java.lang.IllegalArgumentExcepti
GeneralUpdate 2021.08.14更新公告
dotNET跨平台
08-16 347
GeneralUpdate是基于.net standard2.0开发的一款（c/s应用）自动升级程序。该组件将更新的核心部分抽离出来方便应用于多种项目当中目前适用于wpf，控制台应用，wi...
JDK(jdk1.7与1.8)源码剖析之 java.util.HashMap
未来工厂的博客
12-12 891
JDK(jdk1.7与1.8)源码剖析之 java.util.HashMap
java.lang.IllegalArgumentException: Invalid character found in the request target. The valid charact
HaC 的博客
02-02 7541
报错： java.lang.IllegalArgumentException: Invalid character found in the request target. The valid characters are defined in RFC 7230 and RFC 3986 02-Feb-2021 09:08:32.817 信息 [http-nio-8080-exec-1] org.apache.coyote.http11.AbstractHttp11Processor.process E
java-note.rar_记事本
09-19
"java-note.rar_记事本" 这个标题暗示了这是一个与Java编程语言相关的项目，它创建了一个简易的记事本应用程序。".rar" 是一种常见的压缩文件格式，通常用于打包和分享多个文件。在这个案例中，"java-note.rar" 指的...
java_note.zip_javascript
09-24
这个名为"java_note.zip_javascript"的压缩包显然包含了关于JavaScript学习的笔记或教程，旨在帮助初学者逐步掌握这门语言。JavaScript不同于Java，尽管它们名字相似，但它们在语法和用途上有着显著的区别。...
红米Note7|lineage18.1| 安卓11.0|红米Note7.zip
05-31
标题中的“红米Note7|lineage18.1| 安卓11.0|红米Note7.zip”表明这是一个针对红米Note7手机的系统固件更新，基于LineageOS 18.1定制，适配Android 11操作系统。LineageOS是一款开源的Android定制系统，它提供了许多...
12. Hibernate 模板设计模式
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 1216
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
Java-Lambda
lizhiwei21的博客
07-21 506
lambda表达式可以理解为对匿名内部类的一种简化 , 但是本质是有区别的面向对象思想 :强调的是用对象去完成某些功能函数式编程思想 :强调的是结果 , 而不是怎么去做。
Promise 详解（原理篇）
山重水复疑无路，柳暗花明又一村。
07-20 804
Promise 是一种异步编程的解决方案。在异步操作中，callback 会导致回调地狱的问题，Promise 解决了这个问题。一个 Promise对象有以下三种状态:pending：初始状态，既不是成功，也不是失败状态。：意味着操作成功完成。rejected：意味着操作失败。当 new Promise() 被实例化后，即表示 Promise 进入 pending 初始化状态，准备就绪，等待运行。
Java读取文件中多个JSON对象，并且16进制字符串和byte相互转换，将byte转为16进制字符串并写入json文件
最新发布
weixin_43561432的博客
07-24 284
【代码】Java读取文件中多个JSON对象，并且16进制字符串和byte相互转换，将byte转为16进制字符串并写入json文件。
noteexpress.zip
12-28
NoteExpress.zip 是一个压缩文件，里面包含了 NoteExpress 软件的安装文件及相关资源。NoteExpress 是一款文献管理软件，能够帮助用户管理、整理、搜索和引用学术文献。用户可以使用该软件建立自己的文献数据库，方便对文献进行分类和管理。 NoteExpress.zip 文件的内容可能包括软件的安装程序、用户手册、帮助文档、示例数据库等。安装文件可以帮助用户在电脑上安装 NoteExpress 软件，用户手册和帮助文档可以帮助用户了解软件的使用方法和功能特点，示例数据库则可以帮助用户快速上手并体验软件的功能。 使用 NoteExpress.zip 文件的方法是，首先需要解压缩该文件，然后双击安装程序按照提示操作进行安装。安装完成后，用户可以根据用户手册和帮助文档来学习软件的使用方法，也可以通过示例数据库来熟悉软件的操作界面和功能。 总的来说，NoteExpress.zip 是一个方便用户下载和安装 NoteExpress 软件的压缩文件，对于需要进行学术文献管理的用户来说，是一个非常实用的工具。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值