【JAVA】类和对象
作者主页:paper jie的博客
本文作者:大家好,我是paper jie,感谢你阅读本文,欢迎一建三连哦。
本文录入于《JAVASE语法系列》专栏,本专栏是针对于大学生,编程小白精心打造的。笔者用重金(时间和精力)打造,将javaSE基础知识一网打尽,希望可以帮到读者们哦。
其他专栏:《算法详解》《C语言》等
内容分享:本期将会对JAVA中的类和对象用大量的篇幅来讲解!
目录
类和对象的概念
什么是类和对象
面向对象与面向过程
类的定义和使用
认识类
类的定义格式
练习定义一个 “人” 类
类的实例化
什么是实例化
类和对象的说明
this的引用
什么是this引用
this引用的特点
对象的构造及初始化
构造方法
什么是构造方法
特点
默认初始化
new关键字后面发生了什么?
就地初始化
封装
什么是封装
访问限定符
封装 — 包
什么是包
导包的类
自定义包
包的访问权限控制举例
常见的包
static成员
static修饰的成员变量
static修饰成员方法
static成员变量初始化
代码块
代码块的分类
普通代码块
构造代码块
静态代码块
对象的打印
类和对象的概念
什么是类和对象
Java是一门纯面向对象的语言(Object Oriented Program,简称OOP),在面向对象的世界里,一切皆为对象,面向对象是解决问题的一种思想,主要依靠对象之间的交互完成一件事情。对象:对象是类的一个实例(对象不是找个女朋友),有状态和行为。例如,一条狗是一个对象,它的状态有:颜色、名字、品种;行为有:摇尾巴、叫、吃等。类:类是一个模板,它描述一类对象的行为和状态
面向对象与面向过程
面向对象就是你只需要知道其中的对象,要执行的过程不用关心。
面向过程就是你要知道实现你要做的事件的每一步过程,你都要参与进去。
举个栗子:
以前找地方:你需要通过自己到一段路问一个人怎么走,到一段路怎么走,需要自己亲历亲为。(面向过程)
现在到地方:你只需要知道几个对象:起点,终点,高德地图。其他的跟着导航走就行(面向对象)
注意:其实面向对象和面向过程它并不是针对一门语言来说,而是解决问题的方法。没有好坏区分,各有各的应用场景。
类的定义和使用
认识类
类是用来对一个实体(对象)来进行描述的,主要描述该实体(对象)具有哪些属性,有哪些功能。
栗子:
电脑:java认为它就是类
属性:产品品牌,型号,产品重量,外观尺寸,颜色
功能:显示,查询,播放视频,办公……
类的定义格式
在java中定义类时需要用到class关键字 :
// 创建类
class ClassName{
field; // 字段(属性) 或者 成员变量
method; // 行为 或者 成员方法
}
class为定义类的关键字,ClassName为类的名字,{}中为类的主体。类中包含的内容称为类的成员。属性主要是用来描述类的,称之为类的成员属性或者类成员变量。方法主要说明类具有哪些功能,称为类的成员方法。
class Computer {String brand;//型号String cpu;//cpuint age;//生产日期String color;//颜色int height; //高int length;//长int width;//宽public void show() {System.out.println("显示");}public void sreach() {System.out.println("搜索");}}
Java语言将电脑类在计算机中定义完成,经过javac编译之后形成.class文件,在JVM的基础上计算机就可以识别
注意:
类名注意采用大驼峰
这里的写法没有带static关键字,下面会讲到
练习定义一个 “人” 类
class person {String nume;String sex;String nationality;int age;int id;public void speak() {System.out.println("说话");}public void study() {System.out.println("学习");}public void sleep() {System.out.println("睡觉");}public void motion() {System.out.println("运动");}
}
注意:
一般一个文件里只定义一个类
main方法所在的类一般要使用public修饰(注意:Eclipse默认会在public修饰的类中找main方法)
public修饰的类必须要和文件名相同
不要轻易去修改public修饰的类的名称,如果要修改,通过开发工具修改。
类的实例化
什么是实例化
定义了一个类,就相当于在计算机中定义了一种新的类型,与int,double类似,只不过int和double是java语言自带的内置类型,而类是用户自定义了一个新的类型,比如上述的:PetDog类和Student类。它们都是类(一种新定义的类型)有了这些自定义的类型之后,就可以使用这些类来定义实例(或者称为对象)。
用类类型创建对象的过程,称为类的实例化,在java中采用new关键字,配合类名来实例化对象。
举个栗子:
class Person {String name;String sex;String nationality;int age;int id;public void speak() {System.out.println("说话");}public void study() {System.out.println("学习");}public void sleep() {System.out.println("睡觉");}public void motion() {System.out.println("运动");}
}public class Test {public static void main(String[] args) {Person people1 = new Person();people1.name = "张三";people1.sex = "男";people1.id = 1234;people1.age = 20;people1.sleep();people1.study();Person people2 = new Person();people2.name = "李四";people2.sex = "男";people2.id = 12334;people2.age = 25;people2.sleep();people2.study();}
注意:
new 关键字用于创建一个对象的实例.
使用 . 来访问对象中的属性和方法.
同一个类可以创建多个实例.
类和对象的说明
类只是一个模型一样的东西,用来对一个实体进行描述,限定了类有哪些成员.
类是一种自定义的类型,可以用来定义变量.
一个类可以实例化出多个对象,实例化出的对象 占用实际的物理空间,存储类成员变量
类实例化出对象就像现实中使用建筑设计图建造出房子,类就像是设计图,只设计出需要什么东 西,但是并没有实体的建筑存在,同样类也只是一个设计,实例化出的对象才能实际存储数据,占用物理空间
this的引用
什么是this引用
this引用指向当前对象,即成员方法运行时调用该成员方法的对象,在成员方法中所有成员变量的操作,都是通过该引用去访问。只不过所有的操作对用户是透明的,即用户不需要来传递,编译器自动完成。
public class Date {public int year;public int month;public int day;public void setDay(int year, int month, int day){this.year = year;this.month = month;this.day = day;}public void printDate(){System.out.println(this.year + "/" + this.month + "/" + this.day);}
}
注:shis引用的是调用成员方法的对象
public static void main(String[] args) {
Date d = new Date();
d.setDay(2020,9,15);
d.printDate();
}
this引用的特点
this的类型:对应类类型引用,即哪个对象调用就是哪个对象的引用类型
this只能在成员方法中使用
在成员方法中,this只能引用当前对象,不能引用其他的对象
this是成员方法的第一个,且隐藏的参数,编译器会自动传递,在成员方法执行的时候,编译器会负责将调用成员方法对象的引用传递给该成员的方法,this来接受
对象的构造及初始化
初始化对象我们知道,在方法内部定义一个局部变量的时候,需要初始化,不然会报错,编译失败,但是我们发现下面的代码:
public static void main(String[] args) {Date d = new Date();d.printDate();d.setDate(2021,6,9);d.printDate();
}
它需要调用之前的SetDate方法才可以将具体的日期设置到对象中。这里就有连个问题了:
1. 每次对象创建好后调用SetDate方法设置具体日期,比较麻烦,那对象该如何初始化?
2. 局部变量必须要初始化才能使用,为什么字段声明之后没有给值依然可以使用?
构造方法
什么是构造方法
构造方法是一个特殊的成员方法,名字必须与类名相同,在创建对象时,由编译器自动调用,并且在整个对象的生命周期内只调用一次。
注意:构造方法的作用就是对对象的成员进行初始化,并不负责给对象开辟空间
public class Date {
public int year;
public int month;
public int day;
// 构造方法:
// 名字与类名相同,没有返回值类型,设置为void也不行
// 一般情况下使用public修饰
// 在创建对象时由编译器自动调用,并且在对象的生命周期内只调用一次
public Date(int year, int month, int day){
this.year = year;
this.month = month;
this.day = day;
System.out.println("Date(int,int,int)方法被调用了");
}
public void printDate(){
System.out.println(year + "-" + month + "-" + day);
}
public static void main(String[] args) {
// 此处创建了一个Date类型的对象,并没有显式调用构造方法
Date d = new Date(2021,6,9); // 输出Date(int,int,int)方法被调用了
d.printDate(); // 2021-6-9
}
}
特点
名字得和类型相同
没有返回值类型,void也不行
创建对象时,由编译器自动调用,并且在对象的生命周期内只会调用一次
构造方法可以重载(根据不同的需求提供不同的构造方法)
public class Date {
public int year;
public int month;
public int day;
// 无参构造方法
public Date(){
this.year = 1900;
this.month = 1;
this.day = 1;
}
// 带有三个参数的构造方法
public Date(int year, int month, int day) {
this.year = year;
this.month = month;
this.day = day;
}
public void printDate(){
System.out.println(year + "-" + month + "-" + day);
}
public static void main(String[] args) {
Date d = new Date();
d.printDate();
}
}
代码中的两个构造方法名字相同,参数列表不同,因此构成了方法重载
如果用户自己没有定义,那编译器会自己生成一份默认的构造方法,生成的默认构造方法是无参的
public class Date {
public int year;
public int month;
public int day;
public void printDate(){
System.out.println(year + "-" + month + "-" + day);
}
public static void main(String[] args) {
Date d = new Date();
d.printDate();
}
}
上述Date类中,没有定义任何构造方法,编译器就 会默认生成一个不带参数的构造方法。
构造方法中,可以通过this调用方法来简化代码
public class Date {
public int year;
public int month;
public int day;
// 无参构造方法--内部给各个成员赋值初始值,该部分功能与三个参数的构造方法重复
// 此处可以在无参构造方法中通过this调用带有三个参数的构造方法
// 但是this(1900,1,1);必须是构造方法中第一条语句
public Date(){
//System.out.println(year); 注释取消掉,编译会失败
this(1900, 1, 1);
//this.year = 1900;
//this.month = 1;
//this.day = 1;
} /
/ 带有三个参数的构造方法
public Date(int year, int month, int day) {
this.year = year;
this.month = month;
this.day = day;
}
}
这里要注意:
this()必须是构造方法的第一个语句
public Date(){
this(1900,1,1);
}
public Date(int year, int month, int day) {
this();
} /
* 无
参构造器调用三个参数的构造器,而三个参数构造器有调用无参的构造器,形成构造器的递归调用
编译报错:Error:(19, 12) java: 递归构造器调用
*/
不可以形成环,不然就无限套娃了
绝大多数情况下使用public来修饰,特殊场景下会被private修饰
默认初始化
我们发现一个现象,局部变量在使用的时候需要初始化,而成员变量却可以不用,这是为什么呢?
public class Date {
public int year;
public int month;
public int day;
public Date(int year, int month, int day) {
// 成员变量在定义时,并没有给初始值, 为什么就可以使用呢?
System.out.println(this.year);
System.out.println(this.month);
System.out.println(this.day);
}
public static void main(String[] args) {
// 此处a没有初始化,编译时报错:
// Error:(24, 28) java: 可能尚未初始化变量a
// int a;
// System.out.println(a);
Date d = new Date(2021,6,9);
}
}
new关键字后面发生了什么?
Date d = new Date(2023,8,1);
在JVM层面这句话需要做好多事情:
检查对象对应的类有没有加载,没有加载就要加载
为对象分配内存空间
处理并发安全问题,例如多线程同时申请对象,jvm要保证对象分配的空间不冲突
初始化所分配的空间(对象空间申请好后,对象中的成员已经设置好了默认初始值)
数据类型的默认值:
设置对象头信息
调用构造方法,给对象的各个成员赋值
就地初始化
public class Date {
public int year = 1900;
public int month = 1;
public int day = 1;
public Date(){
}
public Date(int year, int month, int day) {
}
public static void main(String[] args) {
Date d1 = new Date(2021,6,9);
Date d2 = new Date();
}
}
代码编译完成后,编译器会将所有给成员初始化的这些语句添加到各个构造函数中
封装
什么是封装
面向对象程序三大特性:封装、继承、多态。而类和对象阶段,主要研究的就是封装特性。何为封装呢?简单来说就是套壳屏蔽细节,只需要知道使用方法就可以。
封装:将数据和操作数据的方法进行有机结合,隐藏对象的属性和实现细节,仅对外公开接口来和对象进行 交互
访问限定符
Java中主要通过类和访问权限来实现封装:类可以将数据以及封装数据的方法结合在一起,更符合人类对事物的认知,而访问权限用来控制方法或者字段能否直接在类外使用。Java中提供了四种访问限定符:
默认就是default权限
权限除了可以限定类中的成员的可见性,也可以控制类的可见性
class Computer {private String cpu; // cpuprivate String memory; // 内存public String screen; // 屏幕String brand; // 品牌---->default属性public Computer(String brand, String cpu, String memory, String screen) {this.brand = brand;this.cpu = cpu;this.memory = memory;this.screen = screen;}public void Boot(){System.out.println("开机~~~");}public void PowerOff(){System.out.println("关机~~~");}public void SurfInternet(){System.out.println("上网~~~");}
}
public class Test {public static void main(String[] args) {Computer p = new Computer("HW", "i7", "8G", "13*14");System.out.println(p.brand); // default属性:只能被本包中类访问System.out.println(p.screen); // public属性: 可以任何其他类访问//System.out.println(p.cpu); // private属性:只能在Computer类中访问,不能被其他类访问}
}
一般情况下,成员变量设置为private,成员方法设置为public
封装 — 包
什么是包
在面向对象体系中,提出了一个软件包的概念,即:为了更好的管理类,把多个类收集在一起成为一组,称为软件包,有点类似于目录。在Java中也引入了包,包是对类、接口等的封装机制的体现,是一种对类或者接口等的很好的组织方式,比如:一个包中的类不想被其他包中的类使用。包还有一个重要的作用:在同一个工程中允许存在相同名称的类,只要处在不同的包中即可。
导包的类
Java 中已经提供了很多现成的类供我们使用. 例如Date类:可以使用 java.util.Date 导入 java.util 这个包中的 Date类.
Java中我们有几种导包的方式:
直接写:
public class Test {public static void main(String[] args) {java.util.Date date = new java.util.Date();//这里得到一个时间戳System.out.println(date.getTime());}
}
使用import语句导入包:
import java.util.Date;
public class Test {public static void main(String[] args) {Date date = new Date();System.out.println(date.getTime());}
}
如果想使用util全部的类,可以使用import java.util.*
import java.util.*;
public class Test {public static void main(String[] args) {Date date = new Date();System.out.println(date.getTime());}
}
这里更建议使用指定的要导入的类名,不然容易冲突
注意:mport 和 C++ 的 #include 差别很大. C++ 必须 #include 来引入其他文件内容, 但是 Java 不需要.import 只是为了写代码的时候更方便. import 更类似于 C++ 的 namespace 和 using
自定义包
规则:
在文件的最上方加一个package语句 指定该代码在哪个包里
包名需要尽量指定成唯一的名字,通常会用公司的域名的颠倒形式
包名要和代码路径相匹配. 例如创建 com.demo1 的包, 那么会存在一个对应的路径 com/demo1 来存储代码.
如果一个类没有 package 语句, 则该类被放到一个默认包中.
操作步骤:
先在IDEA上新建一个包:src - 新建 - 包
在弹出的对话框中输入包名:com.demo
在包中新建类,包名 - 类,输入类名
这时我们就可以在本地文件中的目录上看到它被创建出来了
我们也可以看到新建的Test.java文件上有一个package
包的访问权限控制举例
package com.bit.demo1;
public class Computer {
private String cpu; // cpu
private String memory; // 内存
public String screen; // 屏幕
String brand; // 品牌
public Computer(String brand, String cpu, String memory, String screen) {
this.brand = brand;
this.cpu = cpu;
this.memory = memory;
this.screen = screen;
}
public void Boot(){
System.out.println("开机~~~");
}
public void PowerOff(){
System.out.println("关机~~~");
}
public void SurfInternet(){
System.out.println("上网~~~");
}
} /
//
package com.bite.demo2;
import com.bite.demo1.Computer;
public class TestComputer {
public static void main(String[] args) {
Computer p = new Computer("HW", "i7", "8G", "13*14");
System.out.println(p.screen);
// System.out.println(p.cpu); // 报错:cup是私有的,不允许被其他类访问
// System.out.println(p.brand); // 报错:brand是default,不允许被其他包中的类访问
}
} /
/ 注意:如果去掉Computer类之前的public修饰符,代码也会编译失败
常见的包
1. java.lang:系统常用基础类(String、Object),此包从JDK1.1后自动导入。
2. java.lang.reflect:java 反射编程包;
3. java.net:进行网络编程开发包。
4. java.sql:进行数据库开发的支持包。
5. java.util:是java提供的工具程序包。(集合类等) 非常重要
6. java.io:I/O编程开发包。
static成员
在Java中,被static修饰的成员,称之为静态成员,也可以称为类成员,其不属于某个具体的对
象,是所有对象所共享的
static修饰的成员变量
static修饰的成员变量,称为静态成员变量,静态成员变量最大的特点:不属于个具体的对
象,是所有对象所共享的
静态成员变量特性:
不属于某个具体的对象,是类的属性,所有对象共享的,不存储在某个对象的空间中
既可以通过对象访问,也可以通过类名访问,推荐使用类名访问
类变量存储在方法区当中
生命周期一直到类的结束,随着类的加载而创建,类的卸载而销毁
public class Test {public String name;public String gender;public int age;public double score;public static String classRoom = "Bit306";public Test(String name,String gender, int age, double score) {this.name = name;this.gender = gender;this.age = age;this.score = score;}// ...public static void main(String[] args) {
// 静态成员变量可以直接通过类名访问System.out.println(Test.classRoom);Test s1 = new Test("Li leilei", "男", 18, 3.8);Test s2 = new Test("Han MeiMei", "女", 19, 4.0);Test s3 = new Test("Jim", "男", 18, 2.6);
// 也可以通过对象访问:但是classRoom是三个对象共享的System.out.println(Test.classRoom);System.out.println(s2.classRoom);System.out.println(s3.classRoom);}
}
通过调试,我们可以发现,静态变量并没有存储到某个具体的对象中
static修饰成员方法
一般类中的数据成员都设置为private,而成员方法设置为public,那设置之后,Student类中classRoom属性如何在类外访问呢?
public class Student{
private String name;
private String gender;
private int age;
private double score;
private static String classRoom = "Bit306";
// ...
}
public class TestStudent {
public static void main(String[] args) {
System.out.println(Student.classRoom);
}
} 编
译失败:
Error:(10, 35) java: classRoom 在 extend01.Student 中是 private 访问控制
我们会发现代码会编译失败,访问不到classRoom。
这里,我们有一种被static修饰的成员方法称为静态成员方法,是类的方法,不是某个对象所特有的。静态成员一般都是通过静态方法来访问的。
public class Test{private String name;private String gender;private int age;private double score;private static String classRoom = "Bit306";public static String classRoom() {return classRoom;}
// ...
}
class TestStudent {public static void main(String[] args) {System.out.println(Test.classRoom());}
}
静态方法特性:
不属于某个具体的对象,是类方法
可以通过对象调用,也可以通过类名.静态方法名()调用
不可以在静态方法中访问非静态成员变量
public static String getClassRoom(){
System.out.println(this);
return classRoom;
} // 编译失败:Error:(35, 28) java: 无法从静态上下文中引用非静态 变量 this
public static String getClassRoom(){
age += 1;
return classRoom;
} // 编译失败:Error:(35, 9) java: 无法从静态上下文中引用非静态 变量 age
静态方法中不可以调用任何非静态方法,因为非静态方法有this参数,在静态方法中调用时候无法传递this引用
public static String getClassRoom(){
doClass();
return classRoom;
} // 编译报错:Error:(35, 9) java: 无法从静态上下文中引用非静态 方法 doClass()
static成员变量初始化
静态变量一般不会放在构造方法中来初始化,构造方法中初始化的是与对象相关的实例属性。
静态成员变量初始化分为两种:就地初始化,静态代码块初始化
就地初始化:
定义时给出初始化
private String name;private String gender;private int age;private double score;private static String classRoom = "Bjjjjjj";
静态初始化:
嘿嘿,往下看!
代码块
代码块的分类
使用{}定义的一段代码就是代码块。代码块可以分为4种:
普通代码块
构造代码块
静态代码块
同步代码块
普通代码块
定义在方法种的代码块:
class TestStudent {public static void main(String[] args) {System.out.println(Test.classRoom());}
}public class Main{public static void main(String[] args) {{ //直接使用{}定义,普通方法块int x = 10 ;System.out.println("x1 = " +x);} int x = 100 ;System.out.println("x2 = " +x);}
} // 执行结果x1 = 10x2 = 100
构造代码块
构造块:定义在类中的代码块(不加修饰符)。也叫:实例代码块。构造代码块一般用于初始化实例成员变量
class Student{//实例成员变量private String name;private String gender;private int age;private double score;public Student() {System.out.println("I am Student init()!");}//实例代码块{this.name = "bit";this.age = 12;this.gender = "man";System.out.println("I am instance init()!");}public void show(){System.out.println("name: "+name+" age: "+age+" sex: "+gender);}
}
public class Test {public static void main(String[] args) {Student stu = new Student();stu.show();}
}
静态代码块
使用static的代码块称为静态代码块。一般用于初始化静态成员变量
public class Student{
private String name;
private String gender;
private int age;
private double score;
private static String classRoom;
//实例代码块
{
this.name = "bit";
this.age = 12;
this.gender = "man";
System.out.println("I am instance init()!");
} // 静态代码块
static {
classRoom = "bit306";
System.out.println("I am static init()!");
}
public Student(){
System.out.println("I am Student init()!");
}
public static void main(String[] args) {
Student s1 = new Student();
Student s2 = new Student();
}
}
注意:
静态代码块不管生成多少个对像,它只会执行一次
静态成员变量是类的属性,因此是在JVM加载类的时候开辟空间并初始化的
如果一个类中包含多个静态代码块,在编译代码时,编译器会按照定义的先后次序依次执行(合并)
实例代码块只有在创建对象时才会执行
对象的打印
重写toString方法:
public class Test {int a;int b;int c;public Test(int a, int b, int c) {this.a = a;this.b = b;this.c = c;}public String toString() {return a + "," + b + "," + c;}public static void main(String[] args) {Test test = new Test(1,2,4);System.out.println(test);}
}
相关文章:

【JAVA】类和对象
作者主页:paper jie的博客 本文作者:大家好,我是paper jie,感谢你阅读本文,欢迎一建三连哦。 本文录入于《JAVASE语法系列》专栏,本专栏是针对于大学生,编程小白精心打造的。笔者用重金(时间和精…...

jenkins准备
回到目录 jenkins是一个开源的、提供友好操作界面的持续集成(CI)工具,主要用于持续、自动的构建/测试软件项目、监控外部任务的运行。Jenkins用Java语言编写,可在Tomcat等流行的servlet容器中运行,也可独立运行。通常与版本管理工具(SCM)、构…...

【Rust】Rust学习
文档:Rust 程序设计语言 - Rust 程序设计语言 简体中文版 (bootcss.com) 墙裂推荐这个文档 第一章入门 入门指南 - Rust 程序设计语言 简体中文版 第二章猜猜看游戏 猜猜看游戏教程 - Rust 程序设计语言 简体中文版 (bootcss.com) // 导入库 use std::io; use s…...
Linux 常用命令之配置环境变量 PATH
PATH是系统环境变量中的一种,同时将一些二进制文件的绝对路径追加进去,则在系统终端中可以发现这些路径下的文件。 一. 环境变量设置 export PATH<二进制文件的绝对路径>:$PATH 以下为结合实际例子的操作 1、临时设置 打开一个终端执行如下命令 e…...

flask-----蓝图
1.引入蓝图 flask都写在一个文件中,项目这样肯定不行,会导致循环导入的问题,分目录,分包,使用蓝图划分目录。 2.使用蓝图 步骤如下: -1 实例化得到一个蓝图对象-order_blueBlueprint(order,__name__,tem…...

学习左耳听风栏目90天——第一天 1-90(学习左耳朵耗子的工匠精神,对技术的热爱)【洞悉技术的本质,享受科技的乐趣】
洞悉技术的本质,享受科技的乐趣 第一篇,我的感受就是 耗叔是一个热爱技术,可以通过代码找到快乐的技术人。 作为it从业者,我们如何可以通过代码找到快乐呢?这是一个问题? 至少目前,我还没有这种…...
后端登录安全的一种思路
PS:作者是小白能接触到的就只会这样写。勿喷。 前提 思路: 结合io流将登录token存储到配置文件中,不将token存储到浏览器端,从而避免盗取。 下面jwt的学习可以参考下这个: JWT --- 入门学习_本郡主是喵的博客-CSDN博客 JWT工具类 Component public class JWTtU…...

【深度学习_TensorFlow】激活函数
写在前面 上篇文章我们了解到感知机使用的阶跃函数和符号函数,它们都是非连续,导数为0的函数: 建议回顾上篇文章,本篇文章将介绍神经网络中的常见激活函数,这些函数都是平滑可导的,适合于梯度下降算法。 写…...

机器学习笔记之优化算法(七)线搜索方法(步长角度;非精确搜索;Wolfe Condition)
机器学习笔记之优化算法——线搜索方法[步长角度,非精确搜索,Wolfe Condition] 引言回顾: Armijo \text{Armijo} Armijo准则及其弊端 Glodstein \text{Glodstein} Glodstein准则及其弊端 Wolfe Condition \text{Wolfe Condition} Wolfe Condi…...

十四.redis哨兵模式
redis哨兵模式 1.概述2.测试3.哨兵模式优缺点 redis哨兵模式基础是主从复制 1.概述 主从切换的技术方法:当主节点服务器宕机后,需要手动把一台从服务器切换为主服务器,这就需要人工干预,费时费力,还会造成一段时间内服…...

采用UWB技术开发的智慧工厂人员定位系统源码【UWB定位基站、卡牌】
UWB (ULTRA WIDE BAND, UWB) 技术是一种无线载波通讯技术,它不采用正弦载波,而是利用纳秒级的非正弦波窄脉冲传输数据,因此其所占的频谱范围很宽。UWB定位系统依托在移动通信,雷达,微波电路,云计算与大数据…...

当你软件测试遇上加密接口,是不是就不能测了?
相信大家在工作中做接口测试的时候,肯定会遇到一个场景,那就是你们的软件,密码是加密存储的。 那么这样的话,我们在执行接口的时候,对于密码的处理就开始头疼了。 所以,本文将使用jmeter这款java开源的接…...
Flink
Flink(Apache Flink)是一个开源的分布式流处理引擎和批处理框架。它是由 Apache 软件基金会维护的项目,旨在处理大规模数据的实时流式处理和批处理任务。Flink 提供了强大的流处理和批处理功能,具有低延迟、高吞吐量和高容错性&am…...
python入门常用操作
python常用操作 1、ndarry数组的切片2、print用法2.1格式化输出format2.2字符串格式化输出 3、均值滤波函数 1、ndarry数组的切片 例如一个5列的ndarry数组,想要获取第2列和第3列数据,可以用 #(1)用法1 data[:,1:3],…...
SpringBoot复习:(21)自定义ImportBeanDefinitionRegistrar
要达到的目的:将某个包下使用了某个自定义注解(比如MyClassMapper)的类注册到Spring 容器。 一、自定义注解: package com.example.demo.service;import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy;Rete…...

小黑子—JavaWeb:第五章 - JSP与会话跟踪技术
JavaWeb入门5.0 1. JSP1.1 JSP快速入门1.2 JSP原理1.3 JSP脚本1.3.1 JSP缺点 1.4 EL 表达式1.5 JSTL 标签1.5.1 JSTL 快速入门1.5.1 - I JSTL标签if1.5.1 - II JSTL标签forEach 1.6 MVC模式1.7 三层架构1.8 实现案例1.8.1 环境准备1.8.2 查询所有1.8.3 添加数据1.8.4 修改1.8.4…...

Python - 【socket】 客户端client重连处理简单示例Demo(一)
一. 前言 在Python中,使用socket进行网络通信时,如果连接断开,可以通过以下步骤实现重连处理 二. 示例代码 1. 定义一个函数,用于建立socket连接 import socketdef connect_socket(host, port):while True:try:# 建立socket连…...

Redis 基础
1.定义 Redis 是一个高性能的key-value数据库,key是字符串类型。 2.核心特点: 单进程: Redis的服务器程序采用的是单进程模型来处理客户端的请求。对读写时间的响 应是通过对epoll函数的包装来做到的。 3.数据类型: 键的类型…...

【0805作业】Linux中 AB终端通过两根有名管道进行通信聊天(半双工)
作业一:打开两个终端,要求实现AB进程对话【两根管道】 打开两个终端,要求实现AB进程对话 A进程先发送一句话给B进程,B进程接收后打印B进程再回复一句话给A进程,A进程接收后打印重复1.2步骤,当收到quit后&am…...
ruby - ckeditor 设置编辑器高度
参考:Blogs <% f.cktext_area :zh_content, ckeditor: { height: 1000} %>...

地震勘探——干扰波识别、井中地震时距曲线特点
目录 干扰波识别反射波地震勘探的干扰波 井中地震时距曲线特点 干扰波识别 有效波:可以用来解决所提出的地质任务的波;干扰波:所有妨碍辨认、追踪有效波的其他波。 地震勘探中,有效波和干扰波是相对的。例如,在反射波…...

TDengine 快速体验(Docker 镜像方式)
简介 TDengine 可以通过安装包、Docker 镜像 及云服务快速体验 TDengine 的功能,本节首先介绍如何通过 Docker 快速体验 TDengine,然后介绍如何在 Docker 环境下体验 TDengine 的写入和查询功能。如果你不熟悉 Docker,请使用 安装包的方式快…...
可靠性+灵活性:电力载波技术在楼宇自控中的核心价值
可靠性灵活性:电力载波技术在楼宇自控中的核心价值 在智能楼宇的自动化控制中,电力载波技术(PLC)凭借其独特的优势,正成为构建高效、稳定、灵活系统的核心解决方案。它利用现有电力线路传输数据,无需额外布…...

NFT模式:数字资产确权与链游经济系统构建
NFT模式:数字资产确权与链游经济系统构建 ——从技术架构到可持续生态的范式革命 一、确权技术革新:构建可信数字资产基石 1. 区块链底层架构的进化 跨链互操作协议:基于LayerZero协议实现以太坊、Solana等公链资产互通,通过零知…...
JDK 17 新特性
#JDK 17 新特性 /**************** 文本块 *****************/ python/scala中早就支持,不稀奇 String json “”" { “name”: “Java”, “version”: 17 } “”"; /**************** Switch 语句 -> 表达式 *****************/ 挺好的ÿ…...
MySQL中【正则表达式】用法
MySQL 中正则表达式通过 REGEXP 或 RLIKE 操作符实现(两者等价),用于在 WHERE 子句中进行复杂的字符串模式匹配。以下是核心用法和示例: 一、基础语法 SELECT column_name FROM table_name WHERE column_name REGEXP pattern; …...

云原生安全实战:API网关Kong的鉴权与限流详解
🔥「炎码工坊」技术弹药已装填! 点击关注 → 解锁工业级干货【工具实测|项目避坑|源码燃烧指南】 一、基础概念 1. API网关(API Gateway) API网关是微服务架构中的核心组件,负责统一管理所有API的流量入口。它像一座…...

基于IDIG-GAN的小样本电机轴承故障诊断
目录 🔍 核心问题 一、IDIG-GAN模型原理 1. 整体架构 2. 核心创新点 (1) 梯度归一化(Gradient Normalization) (2) 判别器梯度间隙正则化(Discriminator Gradient Gap Regularization) (3) 自注意力机制(Self-Attention) 3. 完整损失函数 二…...
【Android】Android 开发 ADB 常用指令
查看当前连接的设备 adb devices 连接设备 adb connect 设备IP 断开已连接的设备 adb disconnect 设备IP 安装应用 adb install 安装包的路径 卸载应用 adb uninstall 应用包名 查看已安装的应用包名 adb shell pm list packages 查看已安装的第三方应用包名 adb shell pm list…...

Scrapy-Redis分布式爬虫架构的可扩展性与容错性增强:基于微服务与容器化的解决方案
在大数据时代,海量数据的采集与处理成为企业和研究机构获取信息的关键环节。Scrapy-Redis作为一种经典的分布式爬虫架构,在处理大规模数据抓取任务时展现出强大的能力。然而,随着业务规模的不断扩大和数据抓取需求的日益复杂,传统…...