【JavaSE】P33~P113 方法，重载，数组，对象，构造器，this关键字，数组和对象的内存图，JavaBean

2024-01-14 09:20
文章标签 java se 数组 方法 内存 重载 对象 构造 bean 关键字 p33 p113

本文主要是介绍【JavaSE】P33~P113 方法，重载，数组，对象，构造器，this关键字，数组和对象的内存图，JavaBean，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

练习

  • 1 方法
    • 方法定义及调用
    • JShell简单使用（要求Java9以上）
    • 方法语句流程控制及注意事项
      • 选择
      • 循环
    • 方法的重载
  • 2 数组
    • 三种初始化方式
    • 数组在内存中的存储内存图
  • 3 对象
    • 对象内存图
    • Getter/Setter快捷写法
    • this 关键字
    • 构造方法
    • JavaBean的四个标准
    • 对象数组
  • 二、编程练习计算
    • 1、流程语句，方法的使用
      • 用 if 替换三元运算符，int max = a > b ? a : b;
      • switch case 语句判断对错并修改
      • swith case 判断运行结果
      • 求1~100之间的偶数和
      • 打印一个矩阵用方法 public static void rectangle();
      • 打印指定次数hello world，带参数方法
      • 写重载方法，比较两数是否相同，参数类型，两个byte，两个int，两个long
      • 判断哪些是重载关系
    • 2、数组
      • 写3种初始化数组的方式，并且分为两步
      • 打印数组，1，自己写，数组作为参数 2，用系统方法
      • 写一个方法将数组中@都改为￥
      • 分析下列程序运行过程中，内存图存储情况，画图
      • 改变数组arr1的长度和内容,画内存图
      • 求数组中最值
      • 数组元素反转
    • 3、对象
      • 创建一个Phone类并使用，分析内存情况，两对象使用同一个成员方法
      • 使用对象类型作为方法的参数，分析内存图
      • 使用对象类型作为方法的返回值，分析内存图
      • 成员变量和局部变量区别
      • this关键字，判断输出结果
    • 4、构造器
      • 判断new 对象是否成功及原因

1 方法

方法定义及调用

  • 方法名命名规则和变量一样，小驼峰。
public static void 方法名（）{
方法体
}

修饰符 返回值类型 方法名称（参数类型 参数名称，……）{方法体；return 返回值；
}

参数列表，逗号隔开
注意：
1.方法定义的先后顺序无所谓
2.方法不能嵌套包含
3.方法定义好以后，不会执行的，如果想执行，一定要进行方法的调用。
方法调用

  • 调用方法格式：
方法名称（）；

JShell简单使用（要求Java9以上）

注意：jshell里不能复制粘贴，但可以鼠标选中之前的部分指令，然后右键在当前输入行点击会自动粘贴
win+R打开搜索cmd
敲：

jshell
System.out.println("Hello JShell");
int b = 20;
System.out.println("结果是：" + b * 10);
/exit

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

方法语句流程控制及注意事项

选择

表达式只分true或false

if(表达式){语句；
}else{语句；
}

if(表达式){语句；
}else if(表达式){语句；
}else if(表达式){语句；
}……

其中（）的值只能是基本类型：byte/short/int/char,引用类型：String字符串，enum枚举。
case后的常量必须与（）的值类型一致，其中整型和char可以兼容

switch（一个值）{case 常量：语句；break;default: //break;}
  • switch
  1. 格式
switch(变量）{
case 常量值1：语句1；break;
case 常量值2：语句2；break;
case 常量值3：语句3；break;
case 常量值4：语句4；break;
default:语句5；break;
}
  1. 穿透的switch语句
  • 多个case后的数不可重复（编译错）
  • switch小括号内只能是下列数
    基本：byte/short/char/int
    引用：String字符串，enum枚举
  • 格式灵活，前后顺序可颠倒，break可省略
    省略后不会跳出switch直到穿透下一个顺位case有break再跳出

匹配哪一个case就从哪一个位置向下执行，直到遇到了break或整体结束

循环

size控制循环次数

for(int i = 0; i < size; i++){语句；
}

while(表达式){语句；
}

do{语句；
}while(表达式);

  • switch case 匹配到哪一个case就从哪一个位置向下执行，直到遇到break或整体结束

  • 三种循环里(for,while,do-while)，若条件从未满足，do -while 至少会执行一次

  • 在IDEA中，delete一个Module，外部打开project打开还是存在的，怎么导入一个外部保存的Module
    file-project structure + import module setup sdk即可

  • 方法的三种调用形式，单独调，打印调，赋值调。void返回值类型只能单独调

  • 一个方法中可以有多个return，但必须保证同时只走一个return

  • ❤重载： 多个方法的名称一样，但参数列表不一样（数据类型or顺序） 与参数名称无关，与返回值类型无关。调用时，通过参数列表区分

  • break语句，在switch中用，执行后switch语句结束。在循环中用，执行后打破循环

  • continue语句，继续，一旦执行立刻跳过当前次循环内容，马上开始下一次循环

方法的重载

重载：对于功能类似的方法，参数列表不同
多个方法的名称一样，但参数列表不一样
调用时，以不同参数区分

方法重载与下列因素相关：
1.参数个数不同
2. 参数类型不同
3. 参数的多类型顺序不同
无关因素：
1.与参数名称无关
2.与返回值类型无关

2 数组

三种初始化方式

  • 动态初始化（指定长度）、静态初始化（指定内容）、省略式静态初始化
    静态初始化可以省略写，但不可分为两步写。另外两个可以分为两步写
		int[] array1 = new int[3];int[] array11;array11 = new int[4];int[] array2 = new int[]{3,4,5};int[] array22;array22 = new int[]{3,4,5};int[] array3 ={1,2,3};
  • 打印数组的方法 Arrays.toString(arr) 格式：[1,2,3]
  • 光定义没有new就是没初始化
  • 数组一旦创建，程序运行期间，长度不可改变
  • String也是，不会改变，属于常量，如果改变一定是引用改变了指向的地址
  • 数组作为参数和返回值都是传递地址

访问数组元素进行获取，直接打印数组名称，得到的是数组对应的，内存地址哈希值。访问数组名称：数组名称[索引值]
访问数组元素进行赋值，没赋值默认

整数：0
浮点：0.0
字符：‘\u0000’
boolean： false
引用：null

数组在内存中的存储内存图

  • ❤方法的运行要进栈，存放局部变量，方法的参数，或者是方法{}内部的变量。局部变量不赋值无法使用，没有默认值
  • 凡是new出来的东西，都在堆当中，堆内存中的东西都有一个地址值，16进制，都有默认值
  • 方法区：存储.class信息，包含方法的信息。
  1. 定义数组并赋值时的内存图
 int[] arr = new int[3];//只规定长度，动态初始化System.out.println(arr);System.out.println(arr[0]);System.out.println(arr[1]);System.out.println(arr[2]);arr[1] = 10;arr[2] = 20;System.out.println(arr[0]);System.out.println(arr[1]);System.out.println(arr[2]);

在这里插入图片描述

2.两个引用指向同一个数组

 //两个引用指向同一个数组的内存图int[] arr2 = new int[]{1, 2, 3, 4};System.out.println(arr2[0]);System.out.println(arr2[1]);System.out.println(arr2[2]);System.out.println(arr2[3]);int[] arr3 = arr2;System.out.println(arr3[0]);System.out.println(arr3[1]);System.out.println(arr3[2]);System.out.println(arr3[3]);

在这里插入图片描述

  • 数组一旦创建，运行期间不可改变。
int[] arrC = new int[3];
arrC = new int[5];//长度改变
//等于创建了一个新的数组

3 对象

面向过程：需要实现一个功能的时候，详细处理每一个细节
面向对象：找一个已经具有该功能的人，来帮我做事

  • 成员变量是直接定义在类当中的，在方法外边
  • 对象的创建及使用
    1.导包，import 包名称.类名称对于和当前类属于同一个包的情况，省略导包语句不写。注意：使用同一个包下类中的静态方法时若不想写类名.方法名调用，要导包import static 包名称.类名称.方法名或*指所有方法。但静态方法中调用非静态方法，一定要通过对象调用
    2.创建，格式： 类名称 对象名 = new 类名称();
    3.使用，对象名.成员变量名，对象名.成员方法名（参数）
    在这里插入图片描述
    在这里插入图片描述

对象内存图

  • 一个手机类及其测试练习
public class Phone {public String brand;public double price;public String color;public Phone() {}public Phone(String brand, double price, String color) {this.brand = brand;this.price = price;this.color = color;}//成员方法public void call(String who){System.out.println("给"+who+"打电话");}public void sendMessage(){System.out.println("发信息");}
}

public class Demo01PhoneOne {public static void main(String[] args) {Phone one = new Phone();one.brand = "苹果";one.price = 8799.0;one.call("小明");one.sendMessage();System.out.println(one.brand);System.out.println(one.price);System.out.println(one.color);}
}

在这里插入图片描述
运行结果：

给小明打电话
发信息
苹果
8799.0
null

  • 两个对象使用同一个方法
    根据调用方法的顺序，依次压栈运行方法，栈中后调用的方法在main方法之上（main方法没运行完，所以还在栈中）。若方法体运行完毕则出栈
    可见两对象调用同一个方法时，不产生任何联系，
    要产生联系：两个对象名称（对象的引用名）指向同一个对象（对象空间），即one和two指向的地址相同，相当于一个对象两个名称。
    在这里插入图片描述

  • 使用对象作为方法的参数或返回值同理
    传递的都是对象的地址，每次new一个对象都在堆中，栈中运行方法要赋值或用到对象，就赋值为该对象空间的地址，根据地址访问到对象空间进行使用。

    Getter/Setter快捷写法

  • Code -> Generate或者alt + Insert

在这里插入图片描述

  • Generate -> Constructor 为构造器
    -> Getter 方法
    -> Setter 方法

在这里插入图片描述
无参构造选 select none，全参构造 ctrl多选所有参数
在这里插入图片描述

  • Getter同理，生成哪个成员变量的方法选哪个变量。Ctrl多选

在这里插入图片描述

this 关键字

  • 当方法的局部变量和累的 成员变量重名时，“就近原则”优先使用局部变量
  • 要访问本类当中成员变量，用 this.成员变量名
  • 通过谁调用的方法，谁就是this

构造方法

是专门用来创造对象的方法，当用new来创建对象时，就是在调用构造方法
格式：

public 类名称（参数类型  参数名称）{方法体
}

1.构造方法的名称必须和所在类名完全一样
2.构造方法不要写返回值类型，void都不写
3.不能return一个具体的返回值，可以return;表结束
4.如果没写任何构造方法，编译器会默认送一个构造方法，没有参数，方法体什么都不做
5.一旦编写了至少一个构造方法，那么编译器将不再送这个默认无参构造。
6.构造方法可重载

JavaBean的四个标准

  1. 所有成员变量都要使用private修饰
  2. 编写一个无参数的构造方法
  3. 写一个全参构造器，一个无参构造器
  4. 每一个成员都要写一对getter,setter

对于基础类型boolean写getter方法需要写为isXxx，其他都写为getXxx，setter统一写setXxx

对象数组

array[1].getName(); 写法正确，根据数组用到对象的方法✔

二、编程练习计算

1、流程语句，方法的使用

用 if 替换三元运算符，int max = a > b ? a : b;

A:

int max;int a = 5, b = 8;if(a > b){max = a;}else{max = b;}

switch case 语句判断对错并修改

String str1 = "哈哈";String str2 = "呵呵";char ch = '9';switch(ch){case 4:break;case 4:break;case '%':break;case str1:break;default:break;}

A:

		String str1 = "哈哈";String str2 = "呵呵";char ch = '9';switch(ch){case 4: //正确，因为字符有ascii码，可以互通break;● case 4: //多个case后的数不可以重复break;case '%':break;● case str1: //错，表达式类型时char ，case后只能跟char或者整数类型break;default:break;}

swith case 判断运行结果

		char ch = '4';switch(ch){case 4:System.out.println(4);case 5:System.out.println(5);break;case '%':break;case '9':System.out.println(9);default:break;}

A：输出

4
5

穿透switch，从匹配的case中进入，但break才退出

求1~100之间的偶数和

public int evenSum(){int sum = 0;for(int i = 1; i <= 100; i++){if(i % 2 != 0){continue;}sum += i;}return sum;}

打印一个矩阵用方法 public static void rectangle();

public static void rectangle(){for(int i = 0; i < 8; i++){System.out.printf("*");}System.out.println();for(int i = 0; i < 6; i++){//6行System.out.printf("*");for(int j = 0; j < 6; j++){//6列空格System.out.printf(" ");}System.out.println("*");}for(int i = 0; i < 8; i++){System.out.printf("*");}System.out.println();}

打印指定次数hello world，带参数方法

A:

public static void helloTime(int times){for(int i = 0; i < times; i++){System.out.println("Hello,World");}}

helloTime(5);

写重载方法，比较两数是否相同，参数类型，两个byte，两个int，两个long

A:

	public static boolean isEquals(byte num1, byte num2){return num1 == num2 ? true : false;}public static boolean isEquals(int num1, int num2){return num1 == num2 ? true : false;}public boolean isEquals(long num1, long num2){return num1 == num2 ? true : false;}

		System.out.println(isEquals(5,5));//trueSystem.out.println(new Code01().isEquals(345L,1234L));//falsebyte s1 = 8, s2 = 0;System.out.println(isEquals(s1, s2));//false

判断哪些是重载关系

public boolean isEquals(int num1, byte num2);
public int isEquals(byte num2, int num1);
public void isEquals(int num1, int num2)
public static boolean isEquals(int num1, int num2)
public boolean isEquals(long num1, long num2)public static void open()
public static void open(int a)
stats void open(int a, int b)
public static void open(souble a, int b)
public statc void open(int a, double b)
public void open (int i, double d)
publid static void OPEN()
public static void open(int i, int j)

A:
方法重载与下列因素相关：
1.参数个数的不同
2.参数类型的不同
3.参数的多类型顺序不同
无关因素：
1.与参数名称无关
2.与返回值类型无关

public boolean isEquals(int num1, byte num2)//正确重载
public int isEquals(byte num2, int num1)//正确重载
public void isEquals(int num1, int num2)//错误，和第4行冲突
public static boolean isEquals(int num1, int num2)//和第3行冲突
public boolean isEquals(long num1, long num2)//正确7 public static void open()//正确重载
8 public static void open(int a)//正确
9 static void open(int a, int b)//错误，与14行冲突
10 public static void open(double a, int b)//正确
11 public statc void open(int a, double b)//错误，与12行冲突
12 public void open (int i, double d)//和11行冲突，重复方法，不是重载
13 publid static void OPEN()//方法名不同，不重载，独立方法
14 public static void open(int i, int j)//和9行冲突，重复方法

2、数组

写3种初始化数组的方式，并且分为两步

A:
动态初始化，即只定义长度，后续一个个填充元素内容 int[] arr1 = new int[6]; arr[0] = 1; arr[2] = 8;分两步 int[] arr1; arr1 = new int[6];
静态初始化 int[] arr2 = new int[]{3,4, 52 ,54,32};分两步int[] arr2; arr2 = new int[]{34,34,32,4};
静态初始化省略写法int[] arr3 = {2,3,4};不可分为两步

打印数组，1，自己写，数组作为参数 2，用系统方法

A:
系统的

System.out.println(Arrays.toString(arr3));

自己写
for each是只能访问数组元素，不能访问下标值

	for(int n : arr3){System.out.print(n + ",");}System.out.println();

	for (int i = 0; i < arr2.length; i++) {System.out.print(arr2[i]);if(i == arr2.length - 1) {System.out.println();continue;}System.out.printf(",");}

写一个方法将数组中@都改为￥

A:注意，数组长度在运行期间不可改变，但可以改变元素内容
没赋值的数组元素为默认值，boolean为false,引用为null，字符‘\u0000’
静态初始化其实也有默认值的过程，只不过系统自动马上将默认值替换成了大括号中的具体数值

 public static void changeChar(char[] arr){for(int i = 0; i < arr.length; i++){if(arr[i] == '@'){arr[i] = '￥';}}}

 		char[] arr = {'3','@',54,89,'~','@',34};changeChar(arr);System.out.println(Arrays.toString(arr));

分析下列程序运行过程中，内存图存储情况，画图

		char[] arr = new char[3];//只规定长度，动态初始化arr[1] = '9';System.out.println(arr);System.out.println(arr[0]);System.out.println(arr[1]);arr[1] = 'y';

A:
在这里插入图片描述

改变数组arr1的长度和内容,画内存图

A:
数组长度不可改变，如果改变说明数组引用指向了另一个数组，等于创建了一个新的数组
类似如图，只是两个数组引用名称指向同一个内存空间

在这里插入图片描述

求数组中最值

A:

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

数组元素反转

A:

		int tmp;for (int i = 0; i < arr1.length/2; i++) {tmp = arr1[i];arr1[i] = arr1[arr1.length - i - 1];arr1[arr1.length - i - 1] = tmp;}System.out.println(Arrays.toString(arr1));

3、对象

创建一个Phone类并使用，分析内存情况，两对象使用同一个成员方法

包含属性 品牌，价格和颜色，两个构造器一个无参一个全参，成员方法，1.给who打电话，2.发信息。
创建两个该对象，两对象使用同一个方法，调用初始化属性打印并调用方法，
画该过程内存图
A:

public class Phone {//包含属性 品牌，价格和颜色，两个构造器一个无参一个全参，成员方法，1.给who打电话，2.发信息。private String brand;private double price;private String color;public Phone(){}Phone(String brand, double price, String color){this.brand = brand;this.price = price;this.color = color;}public static void call(String who){System.out.println("给" + who + "打电话");}public static void send(){System.out.println("发短信");}public void setBrand(String brand) {this.brand = brand;}public void setPrice(double price) {this.price = price;}public void setColor(String color) {this.color = color;}public String getBrand() {return brand;}public double getPrice() {return price;}public String getColor() {return color;}
}
public class Demo01Phone {public static void main(String[] args) {//创建两个该对象，两对象使用同一个方法，调用初始化属性打印并调用方法，//画该过程内存图Phone one = new Phone();Phone two = new Phone("三星", 7999.0, "白");one.setPrice(3999.0);System.out.println(one.getBrand());System.out.println(one.getPrice());System.out.println(two.getBrand());one.call("barbie");two.call("ken");}
}

在这里插入图片描述
分析内存中过程：
方法区：类的.java文件编译后生成.class的字节码文件，包含方法的信息

栈：方法的运行就是进栈，存放局部变量，方法的参数，或者是方法{}内部的变量。局部变量不赋值无法使用，没有默认值。运行语句到调用方法，该方法体进栈，是对象的方法，所以从堆中new的对象里找方法信息，堆中方法又从方法区找方法信息。方法运行完毕就出栈，再依次执行后续的方法，进栈出栈。

堆：堆内存的东西都有一个地址值，16进制，都有默认值

在这里插入图片描述
两对象使用同一个成员方法时，两对象不产生任何联系。
两个对象要产生联系，可以两个对象名称（对象的引用名）指向同一个对象（对象空间）。

Phone one = new Phone();
Phone two = one;

使用对象类型作为方法的参数，分析内存图

在这里插入图片描述

使用对象类型作为方法的返回值，分析内存图

在这里插入图片描述

public static void method1(Phone param){System.out.println(param.getBrand());System.out.println(param.getPrice());System.out.println(param.getColor());}public static Phone method2(String brand){Phone p = new Phone(brand, 0.0, null);return p;}public static void main(String[] args) {//正常生成对象Phone p1 = new Phone("华为", 7999.0, "曜石黑");//对象作为方法参数,打印对象的成员变量method1(p1);//对象作为方法返回值Phone p2 = method2("苹果");System.out.println(p2.getBrand());}

成员变量和局部变量区别

1.定义的位置不一样
局部：在方法内部
成员：在类中，方法外
2.作用范围不一样
局部：只有方法中
成员：整个类中
3.默认值不一样
局部：无默认值
成员：有默认值

this关键字，判断输出结果

4、构造器

判断new 对象是否成功及原因

不同类的构造器写法

public class Class0 {
}

public class Class1 {public Class1() {System.out.println("类Class1的无参构造");}
}
public class Class2 {private Class2(){System.out.println("类Class2的无参构造");}
}

public class Class3 {public Class3(){System.out.println("类Class3无参构造");}public Class3(int num){System.out.println("类Class3的有参构造" + num);}
}

public class Class4 {public Class4(int num){System.out.println("类Class4的有参构造" + num);}
}

判断new的使用构造器对错

Class0 c0 = new Class0();
Class1 c1 = new Class1();
Class2 c2 = new Class2();
Class3 c3 = new Class3();
Class3 c33 = new Class3(99);
Class4 c4 = new Class4();

A:

		Class0 c0 = new Class0();//正确，因为啥构造器都没写，系统默认一个方法体空的无参构造器Class1 c1 = new Class1();//正确，输出无参//Class2 c2 = new Class2();//错误，因为构造器修饰符private，只能在类内部使用Class3 c3 = new Class3();//正确，输出无参Class3 c33 = new Class3(99);//正确，输出有参//Class4 c4 = new Class4();//错误，只写了有参构造，系统就不默认赠送无参构造，就没有无参构造器

这篇关于【JavaSE】P33~P113 方法，重载，数组，对象，构造器，this关键字，数组和对象的内存图，JavaBean的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/604682。

相关文章

Java实现删除文件中的指定内容

Java实现删除文件中的指定内容

《Java实现删除文件中的指定内容》在日常开发中,经常需要对文本文件进行批量处理,其中,删除文件中指定内容是最常见的需求之一,下面我们就来看看如何使用java实现删除文件中的指定内容吧... 目录1. 项目背景详细介绍2. 项目需求详细介绍2.1 功能需求2.2 非功能需求3. 相关技术详细介绍3.1 Ja
阅读更多...
springboot项目中整合高德地图的实践

springboot项目中整合高德地图的实践

《springboot项目中整合高德地图的实践》：本文主要介绍springboot项目中整合高德地图的实践,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教... 目录一：高德开放平台的使用二：创建数据库（我是用的是mysql）三：Springboot所需的依赖（根据你的需求再
阅读更多...
spring中的ImportSelector接口示例详解

spring中的ImportSelector接口示例详解

《spring中的ImportSelector接口示例详解》Spring的ImportSelector接口用于动态选择配置类,实现条件化和模块化配置,关键方法selectImports根据注解信息返回... 目录一、核心作用二、关键方法三、扩展功能四、使用示例五、工作原理六、应用场景七、自定义实现Impor
阅读更多...
SpringBoot3应用中集成和使用Spring Retry的实践记录

SpringBoot3应用中集成和使用Spring Retry的实践记录

《SpringBoot3应用中集成和使用SpringRetry的实践记录》SpringRetry为SpringBoot3提供重试机制,支持注解和编程式两种方式,可配置重试策略与监听器,适用于临时性故... 目录1. 简介2. 环境准备3. 使用方式3.1 注解方式 基础使用自定义重试策略失败恢复机制注意事项
阅读更多...
SpringBoot整合Flowable实现工作流的详细流程

SpringBoot整合Flowable实现工作流的详细流程

《SpringBoot整合Flowable实现工作流的详细流程》Flowable是一个使用Java编写的轻量级业务流程引擎,Flowable流程引擎可用于部署BPMN2.0流程定义,创建这些流程定义的... 目录1、流程引擎介绍2、创建项目3、画流程图4、开发接口4.1 Java 类梳理4.2 查看流程图4
阅读更多...
一文详解如何在idea中快速搭建一个Spring Boot项目

一文详解如何在idea中快速搭建一个Spring Boot项目

《一文详解如何在idea中快速搭建一个SpringBoot项目》IntelliJIDEA作为Java开发者的‌首选IDE‌,深度集成SpringBoot支持,可一键生成项目骨架、智能配置依赖,这篇文... 目录前言1、创建项目名称2、勾选需要的依赖3、在setting中检查maven4、编写数据源5、开启热
阅读更多...
Python常用命令提示符使用方法详解

Python常用命令提示符使用方法详解

《Python常用命令提示符使用方法详解》在学习python的过程中,我们需要用到命令提示符(CMD)进行环境的配置,：本文主要介绍Python常用命令提示符使用方法的相关资料,文中通过代码介绍的... 目录一、python环境基础命令【Windows】1、检查Python是否安装2、 查看Python的安
阅读更多...
C++高效内存池实现减少动态分配开销的解决方案

C++高效内存池实现减少动态分配开销的解决方案

《C++高效内存池实现减少动态分配开销的解决方案》C++动态内存分配存在系统调用开销、碎片化和锁竞争等性能问题,内存池通过预分配、分块管理和缓存复用解决这些问题,下面就来了解一下... 目录一、C++内存分配的性能挑战二、内存池技术的核心原理三、主流内存池实现：TCMalloc与Jemalloc1. TCM
阅读更多...
Java对异常的认识与异常的处理小结

Java对异常的认识与异常的处理小结

《Java对异常的认识与异常的处理小结》Java程序在运行时可能出现的错误或非正常情况称为异常,下面给大家介绍Java对异常的认识与异常的处理,本文给大家介绍的非常详细,对大家的学习或工作具有一定的参... 目录一、认识异常与异常类型。二、异常的处理三、总结 一、认识异常与异常类型。（1）简单定义-什么是
阅读更多...
SpringBoot项目配置logback-spring.xml屏蔽特定路径的日志

SpringBoot项目配置logback-spring.xml屏蔽特定路径的日志

《SpringBoot项目配置logback-spring.xml屏蔽特定路径的日志》在SpringBoot项目中,使用logback-spring.xml配置屏蔽特定路径的日志有两种常用方式,文中的... 目录方案一：基础配置（直接关闭目标路径日志）方案二：结合 Spring Profile 按环境屏蔽关
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2