面向对象二 匿名、静态

最新推荐文章于 2023-09-21 11:21:20 发布
最新推荐文章于 2023-09-21 11:21:20 发布 93 收藏
文章标签： java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42398916/article/details/109657926
版权

一、匿名对象

1、匿名对象：没有名字的对象

2、定义格式：new 类名();

3、匿名对象的使用场景：
(1)如果某个对象在创建之后，其方法只调用一次，就可以使用匿名对象来调用。因为使用匿名对象会节约一定的内存空间
(2)匿名对象可以作为实际参数进行传递，在传递的过程中，匿名对象也可以发生变化，变成有名字的对象
(3)匿名对象可以作为返回值进行返回，在返回的过程中，匿名对象也可以发生变化，变成有名字的对象

4、注意事项：
匿名对象可给成员变量赋值，但是没有必要。因为匿名对象没有声明引用，使用一次之后就无法继续使用了，所以给成员变量赋值之后，匿名对象就会变成系统垃圾被回收，所以赋值也没有任何意义。

代码示例

public class Demo01_NoNameInstance {

public static void main(String[] args) {
	new People().name = "zhangsan";
	new People().age = 23;
	
	System.out.println(new People().name + "..." + new People().age);//null...0
	
}

public static void test3() {
	/*
	 * 匿名对象可以作为返回值进行返回，在返回的过程中，
	 * 匿名对象也可以发生变化，变成有名字的对象
	 * 
	 * */
	Mobile m = productMobile();
}

public static Mobile productMobile() {
	/*Mobile m = new Mobile();
	
	return m;*/
	
	return new Mobile();
}

/**
 *  匿名对象可以作为实际参数进行传递，
	在传递的过程中，匿名对象也可以发生变化，变成有名字的对象
 */
public static void test2() {
	
	/*Mobile m = new Mobile();
	
	updateMobile(m);*/
	
	updateMobile(new Mobile());
}

/**
 * 给手机贴牌定价
 * 
 *  匿名对象可以作为实际参数进行传递，
 	在传递的过程中，匿名对象也可以发生变化，变成有名字的对象
 */
public static void updateMobile(Mobile m) {//Mobile m = new Mobile();
	m.brand = "紫米";
	m.price = 29;
	
	m.show();
}

/**
 * 匿名对象的使用格式示范代码
 */
public static void test1() {
	
	/*Test t = new Test();
	
	t.test();*/
	
	new Test().test();
	
	/*
	 * 茫茫多的代码
	 * 
	 * 
	 * */
}
}

class People {
String name;
int age;
}


class Test {

public void test() {
	System.out.println("1234567");
}
}

class Mobile {
String brand;
int price;

public void show() {
	System.out.println(brand + "..." + price);
}
}

二、封装

（一）封装的概述

1、封装：隐藏事物的实现细节，对外提供公共的访问方式

2、封装好处：
(1)隐藏事物的实现细节
(2)提高了代码的复用性
(3)提高了安全性

3、封装的原则：
(1)隐藏事物的属性
(2)隐藏事物的实现细节
(3)对外提供公开的访问方式

（二）private关键字

1、private，关键字，含义：私有的；权限修饰符：规定了被修饰的代码在哪里可以被访问哪里不能被访问

2、可以修饰的内容：
(1)修饰成员变量
(2)修饰成员方法
(3)修饰构造方法
(4)修饰内部类

3、修饰之后的效果：
只能在本类中进行访问，本类之外的地方一律不能访问

4、private关键字的注意事项：
private只是封装思想的一种体现形式，封装还可以使用其他的修饰符来完成

代码示例

public class Demo02_Private {

public static void main(String[] args) {
	/*Person p = new Person();
	
	p.name = "刘能";
	p.age = 55;
	
	System.out.println(p.name + "..." + p.age);*/
}
}

/**
* 人类
 * */

class Person {
private String name;
private int age;

public void show() {
	System.out.println(name + "..." + age);
}
}

（三）Getter和Setter

1、当成员变量私有化之后，外界无法直接访问，所以需要提供对外公开的访问方式，来获取成员变量值和设置成员变量值。

2、方式：通过方法来实现
(1)方法外界可以访问
(2)方法和成员变量同属于一个类型，方法能访问自己类型中私有的成员变量
(3)外界访问方法，方法访问成员变量，从而达成间接访问

3、一般使用set方法设置值，get方法获取值

4、一般情况下，书写类，属性都要用private修饰，个别情况根据需求修改；一般情况下，私有的成员变量都有配套的get、set方法

代码示例

public class Demo02_Private {

public static void main(String[] args) {
	Person p = new Person();
	
	//p.name = "刘能";
	p.setName("赵四");
	System.out.println(p.getName());
	
	p.setAge(-3);
	System.out.println(p.getAge());
	
	
	/*p.age = 55;
	
	System.out.println(p.name + "..." + p.age);*/
	
}
}

/**
 * 人类
 * */
class Person {
private String name;
private int age;

//Getter和Setter，get、set方法

//set方法：用于设置值
public void setName(String n) {
	name = n;
}

//get方法：用于获取值
public String getName() {
	return name;
}

public void setAge(int a) {
	if (a >= 0 && a <= 150) {
		age = a;
	} else {
		age = 18;
	}
}

public int getAge() {
	return age;
}
}

（四）set方法图示

在这里插入图片描述

（五）变量访问原则和this关键字

1、变量访问原则：就近原则

2、this关键字：
(1)作用：表示当前类型当前对象的引用
(2)哪个对象来调用this关键字所在的方法，this就指代哪个对象
(3)在set方法中，this该关键字在见名知意的前提下，用于区分哪个是对象的成员变量，剩下的一个按照就近原则，就是局部变量。所以在set方法中，使用this.成员变量名的变量，一定是成员变量，没有使用age的变量，就会按照就近原则去寻找。

代码示例

public class Demo03_This {

public static void main(String[] args) {
	/*
	 * 表示当前类型的当前对象的引用
	 * this:这个
	 * this：指代当前对象
	 * 
	 * this写在方法中，哪个对象来调用方法，就指代哪个对象
	 * 
	 * */
	Animal a = new Animal();
	
	a.setAge(3);
	System.out.println(a.getAge());
	
}
}

class Animal {
private String color;
private int age;//0

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

public int getAge() {
	return age;
}
}

（六）构造方法概述

1、构造方法，又叫做构造函数，构造器，Constructor

2、**作用：用于给成员变量赋值！**在创建对象的过程中，会自动调用构造方法，等对象创建完毕的时候，对象中的成员变量就已经通过构造方法赋好值了。

3、构造方法的定义格式：
修饰符 方法名称(形式参数) {
方法体;
}

4、说明：
(1)构造方法没有返回值，连void都没有
(2)方法名称：和所在类型的名称保持完全一致
(3)构造方法可以有return;语句，仅仅用于是结束方法，但是没有必要书写

5、构造方法的其他说明：
(1)构造方法不能手动调用，在创建对象的过程中由JVM自动调用
(2)因为一个对象只能被创建一次，所以构造方法针对于同一个对象，只能被调用一次
(3)构造方法可以重载

代码示例

public class Demo04_Constructor {

public static void main(String[] args) {
	Car c = new Car("红色", 4);
	
	System.out.println(c.getColor() + "..." + c.getNum());
	
	Car c1 = new Car();
	Car c2 = new Car("黑色");
}
}

class Car {
private String color;
private int num;

/*
 * 修饰符 方法名称(参数列表) {
 * 		方法体
 * }
 * 
 * 构造方法会在对象创建的过程中由JVM自动调用，为成员变量赋值
 * */

public Car() {}//空参构造

public Car(String color) {//有参构造
	this.color = color;
}

public Car(int num) {//有参构造
	this.num = num;
}

public Car(String color, int num) {//有参构造，满参构造
	System.out.println("构造方法执行了");
	this.color = color;
	this.num = num;
}

public void setColor(String color) {
	this.color = color;
}

public String getColor() {
	return color;
}

public void setNum(int num) {
	this.num = num;
}

public int getNum() {
	return num;
}
}

（七）构造方法的注意事项

1、构造方法可以有参数，也可以没有参数
如果构造方法没有参数，创建对象的时候，对象的小括号没有必要书写任何的参数，对应的构造方法，也不会为任何成员变量赋值
如果构造方法有参数，创建对象的时候，就需要根据构造方法的情况，传入对应的实际参数，构造就会在创建对象的过程中，为成员变量赋值

2、当一个类中没有手动提供任何的构造方法时，在编译时系统会为我们自动添加空参构造

3、当我们手动添加了任何构造方法的时候，系统就不再会为我们添加任何构造方法了

4、系统为我们自动添加的构造方法，会随着类的修饰符产生变化，如果类是public class添加的构造方法权限也是public，如果类什么都没写，自动添加的构造方法也是什么都不写的权限

代码示例

public class Demo05_ConstructorWarning {

//public Demo05_ConstructorWarning() {}

public static void main(String[] args) {
	//Fruit f = new Fruit("红色", "甜的", 100);
	Fruit f1 = new Fruit();
	
}
}

/*
 * 在一个.java文件中，可以存在多个class但是只能有一个public class
 * 每一个类都会编译生成一个独立的.class文件
 * class的名称可以随意定义，在一个包中不能重复
	* public class的类名必须和所在的.java文件保持完全一致 * 
 * 
 * */

class Fruit {
private String color;
private String taste;
private int weight;

//Fruit() {}

public Fruit() {}

public Fruit(String color, String taste, int weight) {
	this.color = color;
	this.taste = taste;
	this.weight = weight;
}
}

（八）set方法和构造方法的比较

1、构造方法和set方法都是用于给成员变量赋值的。我们不希望外界直接访问成员变量，所以将成员变量私有化，通过外界访问公开的方式，通过公开的方式又访问到私有成员变量，从而达成外界间接访问私有成员变量。

2、区别：
(1)构造方法在对象创建时被JVM自动调用，用于给成员变量赋值，针对一个对象有且仅有一次执行机会
(2)set方法在对象创建之后被对象调用，用于给成员变量赋值或者修改值，针对同一个对象可以调用无数次

3、场景比较：
(1)set方法一般使用更加灵活和频繁
(2)构造方法针对同一个对象有且仅有一次调用机会，可以为成员变量进行赋值，使代码更加简洁。一旦对象创建出来，就不能继续针对这个对象调用构造方法了

（九）创建对象的内存理解

1、创建对象的时候，成员变量经历了三个初始化的步骤：
(1)默认初始化
(2)构造方法初始化
(3)显式初始化

2、三者顺序：默认初始化 > 显式初始化 > 构造方法初始化
3、图示：
在这里插入图片描述

代码示例

public class Demo06_NewInstance {

public static void main(String[] args) {
	Police p = new Police(99);
	
	//默认初始化 > 显式初始化 > 构造方法初始化
	System.out.println(p.getAge());
}
}

class Police {
private String name;
private int age = 22;

public Police() {
	System.out.println("空参构造执行了");
}

public Police(int age) {
	this.age = age;
}

public int getAge() {
	return age;
}
}

三、静态

（一）静态概述

1、没有静态：如果所有对象，都具有一个共同的属性值，没有静态的情况下，每个对象都有一份这样的数据，分别随着每个对象开辟在堆内存中，如果后续这个属性值要修改，那么所有人的属性都需要挨着修改，十分不利于后期维护；并且每个对象中都有一份这个数据的话，每个数据都需要独立的存储空间，十分浪费系统资源
图示：
在这里插入图片描述

2、有静态：如果所有对象，都具有一个共同的属性值，那么在这个属性值的顶以上加上一个static，就会让该变量从原本对象的空间内，改为存储在方法区的静态区中，从每个对象都有一份变成了所有对象共享一份，其中任何一个对象对这个属性值作出修改，其他的对象独到的都是修改后的内容，就提高了代码的可维护性；将原本每个对象中开辟空间，变为了在方法区的静态区中只开辟一块空间，节约了系统资源
图示：
在这里插入图片描述

（二）静态变量的特点

1、static，关键字，含义：静态。被static修饰的成分，就是静态的

2、静态：不会随着对象的变化而变化
3、加载时机：随着类的加载而加载。
4、静态变量优先于对象存在。

5、静态变量被所有当前类型对象共享。

6、代码层面：
(1)可以通过对象访问，格式：对象名.静态变量名
(2)可以通过静态访问，格式：类名.静态变量名
(3)总结：静态变量可以通过对象或者类名的方式来访问。在不创建对象的前提下，仍然可以访问静态变量。

代码示例

public class Demo09_StaticField {

public static void main(String[] args) {
	StaticTest st = new StaticTest();
	System.out.println(st.num);
	
	System.out.println(StaticTest.num);
}
}

class StaticTest {
static int num = 111;
}

（三）静态访问的注意事项

1、静态方法：在方法的声明上加上static关键字进行修饰，就是静态方法

2、静态方法不能访问非静态变量
原因：静态成员随着类的加载而加载优先于对象存在，当静态方法存在的时候，对象很可能还没有创建，非静态变量又是随着对象的创建而创建的，所以静态方法不能访问非静态变量

3、静态方法不能访问非静态方法
原因：因为静态方法存在的时候，对象都很有可能不存在，而非静态方法有需要对象来调用，所以静态方法不能调用非静态方法

4、静态方法中不能使用this
原因：this指代对象，而静态优先于对象存在，静态方法如果要去执行，对象很可能还没创建，this就指代不到任何内容

5、总结：静态不能访问非静态

6、静态方法的调用格式：
(1)对象名.静态方法名
(2)类名.静态方法名（推荐）

代码示例

public class Demo10_StaticMethod {

public static void main(String[] args) {
	StaticMethodTest s = new StaticMethodTest();
	
	//s.test2();
	StaticMethodTest.test2();
}
}

class StaticMethodTest {
int num = 10;
static String str = "abc";

//非静态方法只能由对象来调用
/*
 * 1.非静态方法既能够访问非静态变量，也能够访问静态变量
 * 2.非静态方法能既能够调用非静态方法，也能够调用静态方法
 * 
 * 结论：非晶态方法什么成分都能调用
 * */
public void show1() {
	System.out.println(num);
	System.out.println(str);
	show2();
	test2();
}

public void show2() {
	System.out.println("show2方法执行了");
}

/*
 * 1.静态方法只能调用静态变量
 * 	原因：非静态变量随着对象的创建而创建在堆内存中，而静态方法随着类的加载而存在，优先于对象
 * 		静态方法存在的时候，非静态变量很有可能还不存在，所以无法访问
 * 2.静态方法只能调用静态方法
 * 	原因：因为静态方法存在的时候，对象都很有可能不存在，而非静态方法有需要对象来调用，
 * 		所以静态方法不能调用非静态方法
 * 
 * */
public static void test1() {
	//System.out.println(num);
	System.out.println(str);
	
	//show2();
	test2();
}

public static void test2() {
	System.out.println("test2方法执行了");
}
}

（四）静态变量和非静态变量的区别

1、概念上，所属不同：
(1)非静态变量属于对象
(2)静态变量属于类

2、内存空间不同，存储位置不同：
(1)非静态变量随着对象存储在堆内存中
(2)静态变量随着类创建在方法区的静态区中

3、内存时间不同，生命周期不同：
(1)非静态变量随着对象的创建而创建，随着对象的消亡而消亡
(2)静态变量随着类的加载而加载，随着类的消亡而消亡

4、访问方式不同：
(1)所有非静态成员都需要通过对象来访问
(2)所有静态成员既可以通过类名来访问，也可以通过对象名来访问

（五）主方法的解释

1、主方法：public static void main(String[] args) {}

2、public，关键字，权限修饰符，含义：公共的、公开的，所有情况下都可以访问
主方法由JVM自动调用，语言和语言之间的相互调用，需要使用最高的权限

3、static，关键字，含义：静态
主方法由JVM自动调用，设置为静态可以不用对象调用，并且在调用main方法的时候也来不及创建对象，所以只能用静态；JVM是C语言写的，C语言面向过程，没有对象，所以也只能是静态

4、void，关键字，含义：无返回值类型
主方法由JVM自动调用，JVM是C语言写的，C是面向过程，并且就算有返回值返回，返回给虚拟机也没有任何意义

5、main，不是关键字，含义：主要的
在JVM中，需要执行某个类的时候，只执行main方法，在JVM的代码中，已经将要访问的方法，作为程序的唯一入口写死了。我们在代码中起名字的时候，不要写main

（六）工具类的编写
1、工具类：在一个类中，没有成员变量，定义的全部都是经常使用的功能的方法，当我们需要使用这些功能的时候，直接拿来使用即可，就不用再重复定义了
2、名称：ArrayUtils
3、作用：提供操作数组的常规的各种方法
4、功能：
(1)数组的遍历
(2)获取数组最大值
(3)获取数组最小值
(4)交换数组中指定两元素的位置
(5)反转数组
5、方法都是静态的，不需要创建对象就可以调用，创建对象浪费系统资源。希望外界也不能创建对象——方式：构造方法私有化。

代码示例

public class ArrayUtils {

//为了让外界使用类名调用，我们可以限制外界创建对象
//1.创建对象的时候，对应的构造方法会被自动调用
//2.使用private修饰构造方法，外界无法访问，外界也就不能创建对象
//3.当手动书写任何构造，系统就不会再自动添加任何构造，杜绝了外界一切创建对象的可能
private ArrayUtils() {}

//数组的遍历
public static void printArr(int[] arr) {
	for (int i = 0; i < arr.length; i++) {
		System.out.print(arr[i] + " ");
	}
	
	System.out.println();
}

//获取数组最大值
public static int getMax(int[] arr) {
	int max = arr[0];
	
	for (int i = 0; i < arr.length; i++) {
		if(max < arr[i]) {
			max = arr[i];
		}
	}
	
	return max;
}

//获取数组最小值
public static int getMin(int[] arr) {
	int min = arr[0];
	
	for (int i = 0; i < arr.length; i++) {
		if(min > arr[i]) {
			min = arr[i];
		}
	}
	
	return min;
}

//数组两元素的交换
public static void swap(int[] arr, int index1, int index2) {
	int temp = arr[index1];
	arr[index1] = arr[index2];
	arr[index2] = temp;
}

//数组的反转
public static void reverse(int[] arr) {
	for (int i = 0, j = arr.length - 1; i < j; i++, j--) {
		swap(arr, i, j);
	}
}
}

（七）帮助文档制作

1、在工具类编写好之后，编译生成一个.class文件，但是.class文件人类无法阅读，我们如果使用别人的.class文件时，就需要有配套的使用说明，就是帮助文档

2、文档注释：用于给代码生成帮助文档的注释

3、帮助文档注释的书写：需要结合注解
(1)注解：在将来生成帮助文档的时候，可以解析为特定的格式
(2)作者：@author
(3)版本：@version
(4)从那个版本开始：@since
(5)参数：@param 参数名称 对参数的解释
(6)返回值：@return 对返回值的解释

4、生成帮助文档：javadoc -d ArrayUtilsDoc -author - version 源代码文件

代码示例

/**
 * 此类提供了一些简单的操作数组的方法，诸如：数组的遍历、数组最值的获取、数组的反转等
 * 
* @author Zihuatanejo
 * @version 1.0
 *
 */
public class ArrayUtils {

//文档注释：alt + shift + J
//为了让外界使用类名调用，我们可以限制外界创建对象
//1.创建对象的时候，对应的构造方法会被自动调用
//2.使用private修饰构造方法，外界无法访问，外界也就不能创建对象
//3.当手动书写任何构造，系统就不会再自动添加任何构造，杜绝了外界一切创建对象的可能
private ArrayUtils() {}

/**
 * 数组的遍历
 * 
 * @param arr int类型一维数组
 */
public static void printArr(int[] arr) {
	
	for (int i = 0; i < arr.length; i++) {
		System.out.print(arr[i] + " ");
	}
	
	System.out.println();
}

/**
 * 获取数组最大值
 * 
 * @param arr int类型一维数组
 * @return 数组的最大值
 */
public static int getMax(int[] arr) {
	int max = arr[0];
	
	for (int i = 0; i < arr.length; i++) {
		if(max < arr[i]) {
			max = arr[i];
		}
	}
	
	return max;
}

/**
 * 获取数组最小值
 * 
 * @param arr int类型一维数组
 * @return 数组的最小值
 */
public static int getMin(int[] arr) {
	int min = arr[0];
	
	for (int i = 0; i < arr.length; i++) {
		if(min > arr[i]) {
			min = arr[i];
		}
	}
	
	return min;
}

/**
 * 数组两元素的交换
 * 
 * @param arr int类型的一维数组
 * @param index1 待交换位置元素的索引
 * @param index2 待交换位置元素的索引
 */
public static void swap(int[] arr, int index1, int index2) {
	int temp = arr[index1];
	arr[index1] = arr[index2];
	arr[index2] = temp;
}

/**
 * 数组的反转
 * 
 * @param arr int类型的一维数组
 */
public static void reverse(int[] arr) {
	for (int i = 0, j = arr.length - 1; i < j; i++, j--) {
		swap(arr, i, j);
	}
}
}
阅读终点，创作起航，您可以撰写心得或摘录文章要点写篇博文。去创作
瘾力
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
java中的静态与匿名内部类总结
CollapseToDespair的博客
02-09 683
Java语言允许在类中再定义类，这种在其它类内部定义的类就叫内部类。内部类又分为：常规内部类、局部内部类、匿名内部类和静态嵌套类四种。 1、静态内部类定义 静态内部类，定义在类中，任何方法外，用static定义；静态内部类只能访问外部类的静态成员。 生成（new）一个静态内部类不需要外部类成员：这是静态内部类和成员内部类的区别。静态内部类的对象可以直接生成：Outer.Inner in=
详解Java的静态匿名内部类(呕心沥血制作)
superliug的博客
11-27 1148
Java的静态内部类就是在定义的类中添加一个static，此时就是静态内部类了，下面用一个例子来详细的讲解Java的匿名内部类 package com.zzuli.JavaSe; /** * @author liugang * @version 1.0 * @date 2020/11/27 10:40 */ public class Outer { //定义一个实例变量和一个静态变量 private int a; private static int b;
JAVA 静态匿名块
weixin_44895008的博客
04-24 446
静态匿名块（当前类被装载时执行一次） 一个类不管创建多少对象，类只会被装载一次 注意：static所定义的属性和方法，会在一个方法区里开辟空间存储，一个类里一个static变量只开辟一片空间 方法区里存储static 和 类里的信息 （本地方法栈 native） ...
静态、非静态，有名、匿名内部类访问静态、非静态属性方法
qq_41083450的博客
08-06 206
非静态内部类 public class Body { //非静态内部类 class Heart{ void work() { System.out.println("do"); } } public void get1() { Heart heart0 = new Heart(); Heart heart1 = new Body().new Heart(); ...
JAVA—面向对象
12-22
匿名对象 两种使用情况 封装： 概念： 好处： 封装的原则： 如何实现？ 构造函数 特点： 作用： 隐藏机制： 构造函数和一般函数的不同 构造代码块： 作用： 特点： 构造代码块和构造函数的区别： this： Static...
JAVA面向对象详细资料
03-19
Java面向对象 1 1 学习方法与要求 1 2 面向对象语言与面向过程语言的区别 7 3 面向对象？什么对象？ 8 4 什么是类？ 9 5 如何创建一个类Class？ 10 6 如何使用类创建对象 10 7 引用与实例 11 8 实例属性与实例方法 ...
Java大数据之路--修饰符Static（附上对象创建时调用的顺序证明）
Normcore的博客
07-09 170
Static（关键字修饰符：变量、方法、代码块、内部类） 修饰变量（静态变量） 静态变量随着类加载（方法区的静态常量池），而加载到方法区的静态区，静态区会对存储的静态变量进行系统默认初始值的赋值，静态变量与类同级，也叫类变量。 两种调用方式：可以通过类名.静态变量来调用，也可以通过创建对象调用。 静态变量所在的类创建的所有对象都拥有唯一一个静态变量所在区域的地址值，从而得出结论：所有的对象...
Java面向对象编程
weixin_64308540的博客
09-15 820
目描述：二货小易有一个W*H的网格盒子，网格的行编号为0~W-1，网格的列编号为0~H-1。已知表达式int m[]={0，1，2，3，4，5，6}；( (x1-x2) * (x1-x2) + (y1-y2) * (y1-y2) ) 的算术平方根。输入描述：每组数组包含网格长宽W,H，用空格分割.(1 ≤ W、H ≤ 1000)有六个元素6,5,4,3,2,1顺序入栈,问下列哪一个不是合法的出栈序列?C. 抽象类中可以没有抽象方法，最终类中可以没有最终方法。进阶：空间复杂度 O(1)时间复杂度 O(N)
delphi 面向对象基础示例
05-27
delphi 面向对象基础示例 接口，覆盖，重载多态，抽象 静态方法 匿名事件属性 属性封装 事件属性 调用其他单元的函数不加类名前缀 程序间互传消息获取其它程序句柄 结构体复制 结构体也可以封装 结构体也可以过程或...
06_javaSE复习之面向对象准备阶段
04-24
什么是面向对象、如何定义类、如何定义对象、成员变量、局部变量、静态变量、匿名对象、Math.randon()/this/static 代码块(局部代码块、构造代码块、静态代码块、同步代码块) 、java内存结构
MYSQL 窗体汇总函数
L___Ping的博客
09-14 222
如果我们想要汇总当天数据，当月数据，当年数据的。如果不懂窗体函数，可能会比较费劲，那小编就说了，我用java处理同样可以达到效果啊。可问题是。明明有现成的函数，为啥要用java处理，当然同时，java会不停的判断时间范围，严重影响性能。当我们掌握了一下函数使用时，①,提高工作效率②,防止过多bug③,提升项目性能④, 适用于各种大屏汇总等场景。
java视频压缩亲测有效，无需插件
weixin_62108279的博客
09-14 251
原文链接：https://blog.csdn.net/qq_43619832/article/details/124062598。注：一个800M的文件可以压缩到400M左右；我本地测试压缩时间为30分钟左右。是因为代码来设置了 setCodec；默认不传也可以压缩。linuxu环境没有测试；可参考以下文章进行配置。前端接收的文件格式为：MultipartFile。picName不要和文件重名；后端需要转换为：File。
Java 反射
小康2022的博客
09-15 169
Java 反射是一种强大的特性，它允许在运行时动态地获取和操作类、对象、字段和方法的信息，可以说是强化版的自省（有点类似于 Python 的自省）。说简单点，就是可以在调用某个类的时候，能够获取和修改这个类一些东西。这也是 Java 被认为是半静态半动态语言的重要原因。
控制循环break、return、continue
最新发布
Chuk
09-21 61
continue表示跳过当前这一次循环，执行循环之后的操作语句，进入下一次循环操作。return表示结束当前循环所在的方法，方法都结束了，循环也就结束了。观察上述程序运行结果，分析return和break的区别。注意：break之后的语句执行不了，所以不能编写。需求：从1输出到10，当迭代变量为7，就停止循环。break表示结束当前所在的循环体。需求：从1输出到10，不要输出4。
深入了解==和equals的区别
BeALittleCat的专栏
09-16 218
= 可以比较基础数据类型和引用类型，比较基础数据类型的数据时比较的是值，比较引用对象时比较的是引用的地址。所以，重写后hashCode 是重新散列而来，散列算法一样，属性值也一样，所以hashCode相同。equals比较引用类型，默认比较的是两个引用对象的引用地址，重写后可以比较属性值是否相同。Object的hashCode 是native的，底层用C++写的，看不到源码。equals方法默认是Object的equals方法，比的还是引用地址。== 不能重写，因为它只是简单的运算符。
Mybatis的分页插件
weixin_55772633的博客
09-20 76
hasPreviousPage/hasNextPage：是否存在上一页/下一页。navigatepageNums：导航分页的页码，[1,2,3,4,5]isFirstPage/isLastPage：是否为第一页/最后一页。navigatePages：导航分页的页码数。pageSize：每页显示的条数。size：当前页显示的真实条数。nextPage：下一页的页码。pageNum：当前页的页码。prePage：上一页的页码。total：总记录数。
【Java】JDK8 jvm参数配置及说明
smallbirdnq的专栏
09-18 165
jvm8参数配置
Springboot整合规则引擎
名字好难想
09-15 170
在 LHS 当中，可以包含 0~n 个条件，多个pattern之间可以采⽤“&&” （and） 、 “||”(or)和“,”(and) 来实现，也可以不写，默认连接为and。如果 LHS 部分为空的话，那么引擎会⾃动添加⼀个 eval(true)的条件，由于该条件总是返回 true，所 以 LHS 为空的规则总是返回 true。LHS(Left Hand Side)：是规则的条件部分的通⽤名称。在 Drools当中共提供了⼗⼆种类型的⽐较操作符， 分别是： >、 >=、 <、 <=、 = =、!
java面向对象冷门知识
05-19
以下是一些Java面向对象的冷门知识： 1. 内部类：Java中允许在类的内部定义另一个类，这个被定义的类就是内部类。内部类可以访问外部类的私有属性和方法，但外部类不能直接访问内部类的私有属性和方法。 2. 匿名内部类：匿名内部类是一种特殊的内部类，它没有类名，同时可以直接创建对象。通常情况下，匿名内部类用来实现接口或抽象类的方法。 3. 静态内部类：静态内部类是指在一个类中定义的静态类。静态内部类可以直接通过外部类名访问，而不需要创建外部类的实例。 4. 枚举类：枚举类是一种特殊的类，它只有有限个实例。枚举类通常用于表示一组固定的常量。 5. 反射：Java中的反射机制可以在运行时动态地获取类的信息，并且可以使用反射机制来创建对象、调用方法等。 6. 泛型：泛型是一种在编译时确定类型的机制，可以有效地避免类型转换错误和安全问题。 7. 注解：Java中的注解是一种在代码中添加元数据的机制。注解可以用于标记类、方法、变量等，以便在编译时或运行时进行处理。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

瘾力

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值