Java基础:类与对象,递归,方法

news2024/11/26 13:39:32

类与对象的区别和联系

1.类是抽象的,概念的他是数据类型

2.对象是具体的实际的,代表一个具体事务

3.类是对象的模板,对象是类的个体

**对象在内存中的存在形式**

基本数据类型在堆,引用类型如String,数组在方法区

对象的属性

属性基本说明

1.成员变量or成员属性

属性的定义语法: public/protected/默认(包级私有/private

2.属性可以定义为任何类型

3.不赋值,就有默认值

如何访问属性

对象名.属性

如何创建对象

1.先声明后创建

Cat cat;

cat = new Cat();

2.直接创建

Cat cat = new Cat();

对象创建过程

1.栈:一般存放基本数据类型

2.堆:存放对象,数组等

3,方法区:常量池(比如字符串),类加载信息(只会加载一次)等

创建流程:

1.先加载Person类信息(属性和方法信息,只会加载一次)

2.在堆中分配空间,进行默认初始化,

3.把地址赋值给p,p就指向对象了

4.进行指定初始化

**类和对象的内存分配机制**

1.创建对象,加载类的信息,没赋值前是默认值

2.进行赋值,改变默认值

3.person p1 = p2;是一个拷贝传递,p1 p2共用同一个堆里的地址

成员方法

例:public void speak(){...}

public表示方法公开,void表示没返回值,speak是方法名,通过.调用方法

方法调用机制

1.当程序执行到int ret...时,会开辟一个独立的空间,然后会跳到方法所在的栈

2.方法运行完后通过返回值提前留存的地址返回到int res...=,

3.方法完成后会销毁方法

成员方法的好处

提高方法的复用性

可以将实现的细节封装起来,以便其他用户来调用

方法的定义

访问修饰符 返回值类型 方法名(参数表){//方法体

语句;

return 返回值;}

方法使用细节

方法修饰符(作用是控制方法使用范围),public,protected,默认,private

  1. 一个方法只能有一个返回值,若想要多个返回值,可以将其封装在数组中返回
public class Object01{
	public static void main(String[] args){
		AA a = new AA();
int[] res = a.getSumAndSub(1,4);
	}
}
class AA{
    public int[] getSumAndSub(int n1,int n2){
    int[] resArr = new int[2];
    resArr[0] = n1 + n2;    
    resArr[1] = n1 - n2;    
    return resArr;
}
  1. 返回类型可以为任何类型(基本/引用)
  2. 有无return 取决于是否是void ,且返回的数据必须一致或兼容(可以自动转换的)无return可以只写return;不能带返回值
  3. 一个方法可以有0个参数或者多个
  4. 参数类型可以为任何类型,调用时传入的参数必须一致或兼容
  5. 个数顺序都需一致,方法定义时的参数是形参,调用时的参数是实参
  6. 同一个类的方法可以直接调用,跨类调用 对象名.方法名
  7. 跨类的方法调用和方法的修饰符有关
  8. 在Java中，方法（包括普通方法和静态方法）不能单独写在类（class）的外面

**Java 方法传参机制**

基本数据类型传参

对于基本数据类型,传递的是值(值拷贝),形参的任何改变不会影响实参

public class Object01{
	public static void main(String[] args){
		int a = 10;
        int b = 20;
        AA obj = new AA();
        obj.swap(a,b);//运行swap方法后,原来的ab值并不会发生了交换,
        //是因为运用到方法时会单独开一个栈,进行运算,无法影响到主栈
        System.out.println("a=" + a + "b=" + b);//10,20
	}
}
class AA{
    public void swap(int a,int b){
        System.out.println("交换前:" + "a=" + a + "b=" + b);//10,20
        int temp = a;
        a = b;
        b = temp;
        System.out.println("交换后:" + "a=" + a + "b=" + b);//20,10
    }
}

引用数据类型传参

引用数据类型传递的是地址(传递也是值,但值是地址),可以通过形参影响实参(包括对象和数组!)

public class Object01{
	public static void main(String[] args){
        AA obj = new AA();
        int[] arr = {1,2,3};
        obj.swap(arr);
        System.out.println("main方法的arr");
        for(int i= 0 ;i < arr.length;i++){
            System.out.print(arr[i] + "\t");// 200 2 3
//数组的值会改变是因为数组是引用数据类型,运行方法开辟新栈的时候传递过去的是数组的地址,
//arr栈和main栈里面的arr数组共用同一个地址相当于有两个变量保存了地址,改变地址所指向的值,也会影响主栈
//把其中一个地址置空不会影响另一个地址(地址是基本数据类型,改变其中一个地址的值不会影响的另一个地址
//故在方法里面改变数组的形参时也会影响到实参
        }
        System.out.println();
	}
}
class AA{
    public void swap(int[] arr){
        System.out.println("方法的arr");
        arr[0] = 200;//修改arr[0]
        for(int i= 0 ;i < arr.length;i++){
            System.out.print(arr[i] + "\t");//200 2 3
        }
        System.out.println();
    }
}

总结:

  • 基本数据类型的传递是值传递，传递的是值的副本。
  • 引用数据类型的传递在表面上看起来像是引用传递（因为它传递的是对象的引用），但实际上仍然是值传递（传递的是引用值的副本）。这个副本和原始引用都指向同一个对象，因此可以通过引用修改对象的状态，但无法通过引用本身改变它指向的对象（即不能改变引用的“地址”）。

克隆对象

public class Object01{
	public static void main(String[] args){
        Person p1 = new Person();
        p1.age = 22;
        p1.name = "小罗";
        MyTools tools = new MyTools();//创建tools对象
        Person p2 =tools.copyPerson(p1);//
        System.out.println("p1的名字" + p1.name + "p1的年龄" + p1.age);
        System.out.println("p2的名字" + p2.name + "p2的年龄" + p2.age);
        //可以通过输出对象的hashCode来看看对象属性是否相同
	}
}
class Person{
    int age;
    String name;
}
class MyTools{
    public Person copyPerson(Person p){
    Person a = new Person();
    a.name = p.name;
    a.age = p.age;
    return a;
}
}

递归

简介:

Java中的递归是一种强大的编程技术，它允许一个方法直接或间接地调用自身。递归在解决可以分解为相似子问题的问题时特别有用，如遍历树或图结构、计算阶乘、求解斐波那契数列等。

简单递归演示


public class Recursion01{
	
	//编写一个main方法
	public static void main(String[] args){

		T t1 = new T();
		t1.text(4);
		int res = t1.factorial(5);
		System.out.println("5的阶乘res=" + res);
	}
}

class T{
	//递归初探
	public void text(int n){
		if(n > 2){
			text(n - 1);
		}
			System.out.println("n=" + n);
	}
	//阶乘
	public int factorial(int n){
		if(n == 1)
			return 1;
		else 
			return factorial(n - 1) * n;
	}
}

递归重要规则

  1. 执行一个方法时,就创建一个新的受保护的空间(栈空间)
  2. 方法中的局部变量是独立的,不会相互影响
  3. 如果方法中使用的是引用类型变量,就会共享该引用类型的数据
  4. 递归必须向退出递归的条件逼近,否则就是无限递归,出现死龟(SrackOverfloeError)
  5. 当一个方法执行完毕或者遇到return,就会返回,遵守谁调用就将结果返回给谁,同时当方法执行完毕或者返回时,该方法也就执行完毕.

递归--斐波那契数列


public class Recursion01{
	
	//编写一个main方法
	public static void main(String[] args){

		//求斐波那契数列1,1,2,3,5,8,13...
		T t1 = new T();
		int res = t1.nub(-1);
		System.out.println("res=" + res);
	}
}

class T{
	//递归--斐波那契数列
		public int nub(int n){
			if(n >= 1){
				if(n == 1 || n == 2)
				return 1;
			else 
				return (nub(n-1)+nub(n-2));
		}else {
			System.out.println("请输入一个大于等于一的整数");
			return 0;
		}
	}
}

递归--猴子吃桃

//
public class Recursion02{

	//编写一个main方法
	public static void main(String[] args){
		A a = new A();
		int peach = a.eattz(-1);
		if(peach != -1)
			System.out.println("第一天桃子数为=" + peach);
	}
}
//day10 = 1;
//day9 = (day10 + 1)*2
//dayn = (day(n+1) + 1)*2
//如果输入的为n,dayn = eattz(n),day(n+1) = eattz(n+1)
//故两者关系应该表述为 eattz(n) = (eattz(n + 1) + 1)*2
class A
{
	public int eattz(int day)
	{
		//返回第n天有几个桃子
		if(day == 10)
			return 1;
		else if(day >=1 && day <= 9)
			return (eattz(day + 1) + 1)*2;
		else 
			return -1;
	}
}

递归--迷宫问题


public class MG{

	//编写一个main方法
	public static void main(String[] args)
	{
		/*思路分析
		1.使用一个二维数组来制定迷宫
		2.观察迷宫,指定规则,由于编译器可以默认初始化为0,
		我们可以把走不通的路设为1,能走的路设为0,这样可以简化初始化步骤
		3.观察可知
		*/
		int[][] map = new int[8][7];//二维数组表示迷宫
		for(int i = 0;i < 7;i++){//将第一行和最后一行置为1
			map[0][i] = 1;
			map[7][i] = 1;
		}
		for(int i = 0;i < 8;i++){//将第一列和最后一列置为1
			map[i][0] = 1;
			map[i][6] = 1;
		}
		//无规律的置1
		map[3][1] = 1;
		map[3][2] = 1;
		System.out.println("===迷宫===");
		for(int i = 0;i < map.length;i++){
			for(int j = 0;j < map[i].length;j++){
				System.out.print(map[i][j]);
			}
			System.out.println();
		}
		T t1 = new T();
		t1.findway(map,1,1);
		System.out.println("===找路情况如下===");
		for(int i = 0;i < map.length;i++){
			for(int j = 0;j < map[i].length;j++){
				System.out.print(map[i][j]);
			}
			System.out.println();
		}
	}
}

class T{
	//使用递归回溯的思想来解决老鼠出迷宫
	//1.findway方法时专门来找出出迷宫的路径
	//2.如果找到返回true,否则返回false
	//3.map是二维数组,即表示迷宫
	//4.i,j就是老鼠的位置,初始化位置为(1,1)
	//5.由于是递归找路,所以规定 map数组的各个值的含义
	//0表示可以走 1表示障碍物 2表示可以走 3表示走过但是走不通
	//6.当map[6][5] = 2就表示找到通路了,可以结束了,否则就继续找
	//7.先确定老鼠找路的策略,下->右->上->左
	//改变走路策略也能走到终点
	public boolean findway(int[][] map,int i,int j){//接受下一个位置的位置
		if(map[6][5] == 2){
			return true;
		}else{
			if(map[i][j] == 0){//表示此处在的位置,为0表示可以进行下一步
				map[i][j] = 2;//假定该位置能走向下一个位置
				//走路策略 下右上左
				if(findway(map,i + 1,j)){
//先假定向下走,如果条件为真则进入下一层递归,
//对下下次路进行判断是否能走,可以再进行下下下次,不能则返回false,向下走的if为false,执行下一个if else重新进行相同判断,
//如果所有路都为false则把该点置为3,表示死路了,否则会一路找到终点,即map[6][5] == 2时,开始一路返回true,直至退出所有递归
					return false;
				}else if(findway(map,i,j + 1)){//向右
					return false;
				}else if(findway(map,i - 1,j)){//向上
					return false;
				}else if(findway(map,i,j - 1)){//向左
					return false;
				}else {
					map[i][j] = 3;
					return false;//都走不通,标记死机
				}
			}else{//为1,2,3走不了返回假
				return false;
			}
		}
	}
}
//回溯现象
//当一个位置置为3时,会返回上一个位置
//这是因为处在3这个位置会返回false,让上一次的向下为false,让他执行另一个else if
//不同路径都能找到终点,那如何求出最短路径呢?
//1.穷举2.图

递归问题--汉诺塔


public class Tower{

	//编写一个main方法
	public static void main(String[] args){
		T t = new T();
		t.move(5,'A','B','C');
	}
}
class T{
	public void move(int num,char a,char b,char c){
		if(num == 1){
			System.out.println(a + "->" + c);
		}else{
			//如果有多个盘,可以看成两个,最下面和最上面所有盘(num - 1)
			//(1)移动上面所有盘到b,借助c
			move(num - 1, a , c , b);
			//(2)把最下面的这个盘移动到c
			System.out.println(a + "->" + c);
			//(3)再把b的所有盘移动到c,借助a
			move(num - 1, b,c,a);
		}
	}
}

递归--八皇后问题

方法重载

Java允许在同一个类中有多种同名方法的存在,但要求形参不一样

注意细节:

1.方法名相同,

2.形参类型或个数或顺序至少有一种不同

3.返回类型无要求

可变参数

Java允许将同一个类中多个同名同功能但参数不同的方法,封装成一个方法,就可以通过可变参数实现

1.int...nums表示的是可变参数,类型是int,即可接受多个参数int(0-多)

2.可变参数实参可以为数组(由数组等效表示多个实参)

3.可变参数本质就是数组,即可以.length,遍历求和等

4.可变参数可以和普通参数放在同一个列表,但可变参数必须放在后面

5.一个形参列表中只能出现一个可变参数


public class VarParameter01{

	//编写一个main方法
	public static void main(String[] args){
		T t = new T();
		int[] arr = {1,2,3};
		System.out.println(t.sum(1,5,7,9));
		System.out.println(t.sum(1,5));
		System.out.println(t.sum(arr));
	}
}
class T{
	//可以计算2,3,4,...多个数的和
	//1.int...nums表示的是可变参数,类型是int,即可接受多个参数int(0-多)
	//2.使用可变参数时可以当做数组来使用,即可以.length,遍历求和等
	public int sum(int... nums){
		//4.可变参数可以和普通参数放在同一个列表,但可变参数必须放在后面
		//(int... nums,double a)x
		//(double a，int... nums)对
		System.out.println("接受的参数个数是=" + nums.length);
		//遍历求和
		int res = 0;
		for(int i = 0;i < nums.length;i++){
			res += nums[i];
		}
		return res;
	}
}
/*
public class VarParameter01{

	//编写一个main方法
	public static void main(String[] args){
		T t = new T();
		System.out.println(t.sum("刘宇", 13.2, 11.8));  
        System.out.println(t.sum("小罗", 12.0, 12.0, 12.0));  
        System.out.println(t.sum("好友位", 2.0, 8.0, 8.0, 8.0, 5.0, 4.0)); 
	}
}
class T{
	public String sum(String name,double... nums){
		double res = 0;
		for(int i = 0; i < nums.length;i++){
			res += nums[i];
		}
		return name + nums.length + "们课的成绩总分为=" + res;
	}
}*/

变量作用域

1.全局变量:也就是属性,作用域为整个类体;可以被本类使用或者其他类使用,通过对象调用

2.局部变量:除了属性之外的局部变量,只能在它定义的地方使用.

3.全局变量可以不赋值直接使用,因为有默认值,但局部变量不能,因为局部变量没有默认值

4.属性和局部变量可以重名,访问时遵循就近原则

5.同一个作用域定义局部变量不能重名

6.属性生命周期长,伴随着对象的创建而创建,伴随对象的销毁而销毁.局部变量生命周期短,伴随代码块的执行而创建,伴随代码块的销毁而销毁.

7.属性前面可以加修饰符但局部变量不行

构造方法/构造器(即构造函数)

构造器细节即注意事项

1.构造器的修饰符可以默认

2.构造器没有返回值

3.方法名和类名一样

4.参数列表和成员方法一样的规则

5.构造器的调用由计算机本身调用,完成对对象的初始化不是创建对象

修饰符 类名(形参){...}

6.构造器可重载,没定义会有默认的构造器,若定义了构造器则默认的会被覆盖


public class VarScope{

	//编写一个main方法
	public static void main(String[] args){
		Person p = new Person();
		System.out.println("p的信息 name="+ p.name + "age=" + p.age);
		Person p1 = new Person("小罗",19);
		System.out.println("p1的信息 name="+ p1.name + "age=" + p1.age);
	}
}
class Person{
	int age;
	String name;
	public Person(){
		age = 18;
	}
	public Person(String pname,int Age){
		name = pname;
		age = Age;
	}
}

对象创建的流程分析

真正的对象在堆里,栈里的对象实际上是一个地址指向堆里(就像名字和人一样)

注意:构造器初始化会覆盖显式初始化

this关键字

什么是this

java虚拟机会给每个对象分配this,代表当前对象

this的理解

this使用细节和注意事项

1.哪个调用this,this就指向谁

2.this可以用来访问本类的属性,方法,构造器

3.访问方法:this.方法名(参数列表)

4.访问构造器:this(参数列表);注意只能在构造器调用另一个构造器,如果要在构造器使用this,必须将this置于第一条语句

5.this不能再类定义的外部使用,只能在类定义的方法中使用


public class This01{

	//编写一个main方法
	public static void main(String[] args){
		//T t1 = new T("小罗",19);
		T t1 = new T();
		//t1.f2();
		t1.f1();
	}
}
class T{
	String name = "刘宇";
	int age = 18;
	public T(){
		//通过this访问另一个构造器
		this("yingran",80);
		System.out.println("T()构造器");
	}
	public T(String name,int age){
		/*this.表示当前对象的属性
		//name = name;
		this.name = name;
		//age = age;
		this.age = age;*/
		System.out.println("public T(String name,int age)构造器被调用");

	}
	//由于构造器的就近原则,默认为形参
	public void f1(){
		String name = "有味";
		int age = 9;
		System.out.println("name= " + name + "age=" + age);//就近原则
		System.out.println("name= " + this.name + "age=" + this.age);//准确访问属性
		//name= 有味age=9
		//name= 刘宇age=18
	}
	/*
	public void f2(){
		System.out.println("f2方法被调用");
		f1();
		this.f1();
	}*/
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1941313.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

双向链表＜数据结构 C版＞

双向链表＜数据结构 C版＞

目录 关于链表的分类 双向链表结构体 初始化 尾插 头插 打印 判断是否为空 尾删 头删 查找 指定位置之后的插入 指定位置的删除 销毁 关于链表的分类 根据链表的三大特性&#xff0c;单向or双向、带头or不带头、循环or不循环&#xff0c;可将链表分为2*2*2&#xf…
阅读更多...
利用ascp下载SRA Explorer中转录组数据

利用ascp下载SRA Explorer中转录组数据

最近在windows系统里下载了MobaXterm可以远程登入服务器&#xff0c;处理RNA的数据&#xff0c;需要从NCBI数据库上下载数据。本文提供用虚拟机ubuntu或者linux系统下载Aspera的方法和问题解决&#xff0c;以及从NCBI上批量下载数据库、最后得到一个项目里的所有fastq文件。 A…
阅读更多...
前端：Vue学习-2

前端：Vue学习-2

前端&#xff1a;Vue学习-2 1. vue的生命周期2. 工程化开发和脚手架Vue CLI2.1 组件化开发2.2 scoped解决样式冲突2.3 data是一个函数2.4 组件通信2.5 非父子通信- event bus事件&#xff0c;provide&inject 3.v-model原理->实现父子组件双向绑定4. sync 修饰符->实现…
阅读更多...
谷粒商城实战笔记-42-前端基础-Vue-生命周期和钩子函数

谷粒商城实战笔记-42-前端基础-Vue-生命周期和钩子函数

下面是Vue官网关于生命周期及不同阶段的钩子函数的图示。 Vue 实例生命周期是指从一个组件被创建到最终被销毁的整个过程。 在这一过程中&#xff0c;Vue 提供了一系列的“钩子”函数&#xff0c;在生命周期的不同阶段执行自定义的代码。 以下是 Vue 对象生命周期的主要阶段…
阅读更多...
C语言实现二叉树以及二叉树的详细介绍

C语言实现二叉树以及二叉树的详细介绍

目录 1.树概念及结构 1.1树的概念 1.2树的相关概念 1.3树的表示 2.二叉树概念及结构 2.1二叉树的概念 2.2特殊的二叉树 2.3二叉树的性质 2.4二叉树的存储结构 3.二叉树顺序结构--特殊的二叉树--堆及其实现 3.1堆的概念及结构 3.2堆的实现 3.2.1堆的结构 3.2.2堆…
阅读更多...
filebeat生产环境配置

filebeat生产环境配置

配置文件属性 生产配置 filebeat.inputs: - type: logenabled: truepaths: - /tmp/logs/*.log- /var/log/system.log- /var/log/wifi.logsymlinks: truejson.keys_under_root: truejson.message_key: xxxjson.add_error_key: true# 如果想卡部分日志&#xff0c;比如用时间作…
阅读更多...
Monaco 使用 HoverProvider

Monaco 使用 HoverProvider

Monaco 中自定义 Hover&#xff0c;Hover 效果是指当鼠标移动文字上展示出提示效果&#xff0c;就像页面上的 Tooltip 效果。最终页面的显示效果如下&#xff1a; 通过 registerHoverProvider 注册 Hover 触发时的处理方法 接口中提供了 4 个参数&#xff0c;前两个参数比较重…
阅读更多...
python学习之闭包与装饰器

python学习之闭包与装饰器

一、闭包 闭包允许一个函数访问并操作函数外部的变量&#xff08;即父级作用域中的变量&#xff09;&#xff0c;即使在该函数外部执行。 特性&#xff1a; (1)外部函数嵌套内部函数。 (2)外部函数可以返回内部函数。 (3)内部函数可以访问外部函数的局部变量。 def out()…
阅读更多...
【jmeter边界值提取器】

【jmeter边界值提取器】

【目的】 从响应头中取token的内容 【方案】 使用后置处理器-边界值提取器 【组件路径】HTTP请求->右键添加->后置处理器->边界提取器 用途&#xff1a;边界提取器(Boundary Extractor)是放在Sample请求之后执行的&#xff0c;用于获取左右边界中间的所有字符&#xf…
阅读更多...
Windows配置Qt+VLC

Windows配置Qt+VLC

文章目录 前言下载库文件提取文件编写qmakeqtvlc测试代码 总结 前言 在Windows平台上配置Qt和VLC是开发多媒体应用程序的一个重要步骤。Qt作为一个强大的跨平台应用开发框架&#xff0c;为开发人员提供了丰富的GUI工具和库&#xff0c;而VLC则是一个开源的多媒体播放器&#x…
阅读更多...
基于STM32的农业大棚温湿度采集控制系统的设计

基于STM32的农业大棚温湿度采集控制系统的设计

目录 1、设计要求 2、系统功能 3、演示视频和实物 4、系统设计框图 5、软件设计流程图 6、原理图 7、主程序 8、总结 &#x1f91e;大家好&#xff0c;这里是5132单片机毕设设计项目分享&#xff0c;今天给大家分享的是智能教室。 设备的详细功能见网盘中的文章《8、基…
阅读更多...
451.根据字符出现频率排序（中等）

451.根据字符出现频率排序（中等）

451.根据字符出现频率排序&#xff08;中等&#xff09; 1. 题目描述2.详细题解3.代码实现3.1 Python3.2 Java 1. 题目描述 题目中转&#xff1a;451.根据字符出现频率排序&#xff08;中等&#xff09; 2.详细题解 题目&#xff1a; 347. 前 K 个高频元素&#xff08;中等&am…
阅读更多...
2月科研——arcgis计算植被差异

2月科研——arcgis计算植被差异

ArcGIS中&#xff0c;设置高于或低于某个值的像元为 -9999&#xff0c;然后将这些地方设为空——目的&#xff1a;去除异常值和黑色背景值 Con(("T_std ano7.tif" > 2) | ("T_std ano7.tif" < - 2), - 9999,"T_std ano7.tif") SetNull(&…
阅读更多...
数学基础【俗说矩阵】：初等矩阵和矩阵的初等行变化关系推导

数学基础【俗说矩阵】：初等矩阵和矩阵的初等行变化关系推导

初等矩阵和矩阵的初等行变换 初等矩阵 矩阵的初等行变换 对单位阵E进行一次初等行变化得到的阵叫做初等阵。 这里只能进行一次初等行变换。 置换阵 给矩阵【左乘】一个【置换阵】&#xff0c;相当与对该矩阵进行了一次【置换阵】对应的【置换】初等行变换&#xff1b; 数…
阅读更多...
爬取百度图片，想爬谁就爬谁

爬取百度图片，想爬谁就爬谁

前言 既然是做爬虫&#xff0c;那么肯定就会有一些小心思&#xff0c;比如去获取一些自己喜欢的资料等。 去百度图片去抓取图片吧 打开百度图片网站&#xff0c;点击搜索xxx&#xff0c;打开后&#xff0c;滚动滚动条&#xff0c;发现滚动条越来越小&#xff0c;说明图片加载…
阅读更多...
Wordpress文章分享到微信朋友圈不带图像问题的解决

Wordpress文章分享到微信朋友圈不带图像问题的解决

目录 一、插件选择 二、插件安装 三、获取微信公众号管理信息 1、登录微信公众平台 2、配置“JS接口安全域名” 3、至安全中心设置“IP白名单” 4、获得“开发者ID(AppID)” 5、获得“开发者密码(AppSecret)” 四、配置插件 五、验证 WordPress装配好后&#xff0c;可…
阅读更多...
10.11和10.8那个大（各种ai的回答）

10.11和10.8那个大（各种ai的回答）

问题&#xff1a;10.11和10.8两个数哪个大 腾讯混元 ✔️ chatGPT ❎ 通义千问 ❎ 文心一言 ✔️ 智谱清言 ❎ 讯飞星火 ✔️ C知道 ❎ 豆包 ✔️
阅读更多...
matlab 声音信号希尔伯特黄变换

matlab 声音信号希尔伯特黄变换

1、内容简介 略 91-可以交流、咨询、答疑 2、内容说明 略 Hilbert-Huang变换&#xff08;HHT&#xff09;是一种基于经验的数据分析方法 方法。它的扩展基础是自适应的&#xff0c;因此它可以从非线性和非平稳过程中产生具有物理意义的数据表示。这个 适应性的优势是有代价…
阅读更多...
代码随想录第二天 | 数组 | 双指针法、滑动窗口、螺旋数组

代码随想录第二天 | 数组 | 双指针法、滑动窗口、螺旋数组

来源 代码随想录数组第二天 有序数组的平方 数组其实是有序的&#xff0c; 只不过负数平方之后可能成为最大数了。 那么数组平方的最大值就在数组的两端&#xff0c;不是最左边就是最右边&#xff0c;不可能是中间。 此时可以考虑双指针法了&#xff0c;i指向起始位置&…
阅读更多...
matlab永磁同步电机反馈试验装置的设计和永磁同步电机仿真

matlab永磁同步电机反馈试验装置的设计和永磁同步电机仿真

1、内容简介 略 85-可以交流、咨询、答疑 2、内容说明 略 摘要&#xff1a;得益于电力电子器件及控制技术的高速发展&#xff0c;使得电机的应用越来越方便及精确&#xff0c;适应了实际应用对电机性能及质量提出的更高要求和标准。同时电机测试技术也因为电力电子技术的发…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023