JavaSE---类和对象

Java中的类和对象总结 Java中的类和对象总结Java中的类和对象总结 立即下载

一、类的定义

1.类的概念

类是用来对一个实体(对象)来进行描述的, 主要描述该实体(对象)具有哪些属性(外观尺寸等),哪些功能(用来干啥),描述完成后计算机就可以识别了。

2.类的定义格式

在java中定义类时需要用到class关键字,具体语法如下:

// 创建类
class ClassName{ 
  field;    // 字段(属性) 或者 成员变量
  method;    // 行为 或者 成员方法
}

3.实例

3.1 定义一个学生类

class Student{
	public String name;
	public int age;
	
	public void doClass(){
		System.out.println(name+"正在上课!");
		}
	}

3.2 定义一个动物类

class Animal{
	public String name;
	public void eat(){
		System.out.println(name+"正在吃饭!");
		}
	}

二、类的实例化

2.1 实例化的定义

定义了一个类,就相当于在计算机中定义了一种新的类型,与int,double类似,只不过int和double是java语言自带的内置类型,而类是用户自定义了一个新的类型,比如上述的:Animal类和Student类。它们都是类(一种新定
义的类型)有了这些自定义的类型之后,就可以使用这些类来定义实例(或者称为对象)。

用类类型创建对象的过程,称为类的实例化,在java中采用new关键字,配合类名来实例化对象。

2.2 实例化对象

public class Main{
public static void main(String[] args) {
    PetDog dogh = new PetDog();   //通过new实例化对象
    dogh.name = "阿黄";
    dogh.color = "黑黄";
    dogh.barks();
    dogh.wag();
   
    PetDog dogs = new PetDog();
    dogs.name = "阿黄";
    dogs.color = "黑黄";
    dogs.barks();
    dogs.wag();
	}
}

实例化在内存中就是,通过关键字new在堆上开辟一段空间给成员变量(或称为类变量),而类中的成员方法都只在方法区。

注意事项:

  • new关键字用于创建一个对象的实例。
  • 使用(.)来访问对象中的属性和方法。
  • 同一个类可以创建多个实例

2.3 关于类和对象的说明

1.类只是一个模型一样的东西,用来对一个实体进行描述,限定了类有哪些成员.
2.类是一种自定义的类型,可以用来定义变量.
3.一个类可以实例化出多个对象,实例化出的对象 占用实际的物理空间,存储类成员变量
4.做个比方。类实例化出对象就像现实中使用建筑设计图建造出房子,类就像是设计图,只设计出需要什么东西,但是并没有实体的建筑存在,同样类也只是一个设计,实例化出的对象才能实际存储数据,占用物理空间


三、this引用

3.1 为什么要用this引用?

我们先来看一个例子:

public class Date {
  public int year;
  public int month;
  public int day;
  public void setDay(int y, int m, int d){
    year = y;
    month = m;
    day = d;
 }
  public void printDate(){
    System.out.println(year + "/" + month + "/" + day);
 }
  public static void main(String[] args) {
    // 构造三个日期类型的对象 d1 d2 d3
    Date d1 = new Date();
    Date d2 = new Date();
    Date d3 = new Date();
    
    d1.setDay(2020,9,15);
    d2.setDay(2020,9,16);
    d3.setDay(2020,9,17);
    // 打印日期中的内容
    d1.printDate();
    d2.printDate();
    d3.printDate();
    }
}

那么我们会不会产生两个疑问:

  • 1. 形参名不小心和成员变量名相同。
public void setDay(int year, int month, int day){
  year = year;
  month = month;
  day = day;
  }

那么此时疑问来了,如果形参和成员变量一样,那么函数体中到底是谁给谁赋值?成员变量给成员变量?参数给参数?参数给成员变量?成员变量参数?

  • 2. 三个对象都在调用setDate和printDate函数,但是这两个函数中没有任何有关对象的说明,setDate和printDate函数如何知道打印的是那个对象的数据呢?
    在这里插入图片描述

3.2 什么是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);
 }
}

注意:this引用的是调用成员方法的对象。
在这里插入图片描述

3.3 this引用的特性

  • 1. this的类型:对应类类型引用,即哪个对象调用就是哪个对象的引用类型
  • 2. this只能在"成员方法"中使用
  • 3. 在"成员方法"中,this只能引用当前对象,不能再引用其他对象
  • this是“成员方法”第一个隐藏的参数,编译器会自动传递,在成员方法执行时,编译器会负责将调用成员方法对象的引用传递给该成员方法,this负责来接收

在代码层面来简单演示—>注意:下图右侧中的Date类也是可以通过编译的
在这里插入图片描述而恰好是这个this的存在,才让我们解决了以上两个疑问。也就是说有这个this的存在,当调用成员方法的时候,可以确定是哪个对象在调用成员方法。


四、对象的构造及初始化

4.1 如何初始化对象

在java中,在java方法内部定义的局部变量,必须先进行初始化,否则会编译失败。

public static void main(String[] args) {
  int a;
  System.out.println(a);
}
//java编译器会报错:可能尚未初始化变量a

要让上述代码通过编译,非常简单,只需在正式使用a之前,给a设置一个初始值即可。如果是对象:

public static void main(String[] args) {
  Date d = new Date();
  d.printDate();
  d.setDate(2021,6,9);
  d.printDate();
}
//代码即可正常编译通过

而通过以上代码,我们可以想到几个疑问:

  • 1.每次对象创建好后调用SetDate方法设置具体日期,比较麻烦,那对象该如何初始化?
  • 2.局部变量必须要初始化才能使用,为什么字段声明之后没有给值依然可以使用?

从而引出我们下一个知识:构造方法和初始化

4.2 构造方法

4.2.1 什么是构造方法?

构造方法(也称为构造器)是一个特殊的成员方法,名字必须与类名相同,在创建对象时,由编译器自动调用,并且在整个对象的生命周期内只调用一次。

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()中输入相对应的参数而调用了相对应的构造方法
    Date d = new Date(2021,6,9);  // 输出Date(int,int,int)方法被调用了
    d.printDate();   // 2021-6-9
 }
}

注意:构造方法的作用就是对对象中的成员进行初始化,并不负责给对象开辟空间。

4.2.2 构造方法的特性

  • 1. 名字必须与类名相同
  • 2. 没有返回值类型,设置为void也不行
  • 3. 创建对象时由编译器自动调用,并且在对象的生命周期内只调用一次(相当于人的出生,每个人只能出生一次)
  • 4. 构造方法可以重载(用户根据自己的需求提供不同参数的构造方法)
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();//输出的是1900-1-1
 }
}

上述两个构造方法:名字相同,参数列表不同,因此构成了方法重载。

  • 5. 如果用户没有自己定义一个构造方法,编译器会生成一份默认的构造方法,生成的默认构造方法一定是无参的。
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类中,没有定义任何构造方法,编译器会默认生成一个不带参数的构造方法。
注意:一旦用户定义,编译器则不再生成。

public class Date {
  public int year;
  public int month;
  public int day;
  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();
 }
}
/*
Error: java: 无法将类 extend01.Date中的构造器 Date应用到给定类型;
 需要: int,int,int
 找到: 没有参数
 原因: 实际参数列表和形式参数列表长度不同
 */
  • 6. 构造方法中,可以通过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: java: 递归构造器调用
*/
  • 7. 绝大多数情况下使用public来修饰,特殊场景下会被private修饰

4.3 初始化

在上文中提出的第二个问题:为什么局部变量在使用时必须要初始化,而成员变量可以不用呢?

4.3.1 默认初始化

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(2021,6,9);

在程序层面只是简单的一条语句,在JVM层面需要做好多事情,下面简单介绍下:

  • 1. 检测对象对应的类是否加载了,如果没有加载则加载
  • 2. 为对象分配内存空间
  • 3. 处理并发安全问题

比如:多个线程同时申请对象,JVM要保证给对象分配的空间不冲突

  • 4. 初始化所分配的空间
    即:对象空间被申请好之后,对象中包含的成员已经设置好了初始值,比如

数据类型 默认值
byte -> 0
char -> ‘\u0000’
short -> 0
int -> 0
long -> 0L
boolean -> false
float ->0.0f
double -> 0.0
reference -> null

  • 5. 设置对象头信息
  • 6. 调用构造方法,给对象中各个成员赋值

4.3.2 就地初始化

在声明成员变量时,就直接给出了初始值。

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();
 }
}

注意:代码编译完成后,编译器会将所有给成员初始化的这些语句添加到各个构造函数中


五、封装

5.1 封装的概念

面向对象程序三大特性:封装、继承、多态。 而类和对象阶段,主要研究的就是封装特性。何为封装呢?简单来说就是套壳屏蔽细节
对于计算机使用者而言,不用关心内部核心部件,比如主板上线路是如何布局的,CPU内部是如何设计的等,用户只需要知道,怎么开机、怎么通过键盘和鼠标与计算机进行交互即可。因此计算机厂商在出厂时,在外部套上壳子,将内部实现细节隐藏起来,仅仅对外提供开关机、鼠标以及键盘插孔等,让用户可以与计算机进行交互即可。
封装:将数据和操作数据的方法进行有机结合,隐藏对象的属性和实现细节,仅对外公开接口来和对象进行 交互

5.2 访问限定符

Java中主要通过类和访问权限来实现封装:类可以将数据以及封装数据的方法结合在一起, 更符合人类对事物的认知,而访问权限用来控制方法或者字段能否直接在类外使用。 Java中提供了四种访问限定符:
在这里插入图片描述比如:

  • public:可以理解为一个人的外貌特征,谁都可以看得到
  • default: 对于自己家族中(同一个包中)不是什么秘密,对于其他人来说就是隐私了
  • private:只有自己知道,其他人都不知道
    【说明】
  • protected主要是用在继承中
  • default权限指:什么都不写时的默认权限
  • 访问权限除了可以限定类中成员的可见性,也可以控制类的可见性
public class Computer {
  private String cpu;      // cpu
  private 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 TestComputer {
  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。


六、static成员

每个对象都有自己特有的名字、性别,年龄,学分绩点等成员信息,这些信息就是对不同学生来进行描述的,这里我们创建三个学生类对象,如下所示:

public class Student{
  // ...
  public static void main(String[] args) {
    Student s1 = new Student("Li leilei", "男", 18, 3.8);
    Student s2 = new Student("Han MeiMei", "女", 19, 4.0);
    Student s3 = new Student("Jim", "男", 18, 2.6);
 }
}

在这里插入图片描述假设三个同学是同一个班的,那么他们上课肯定是在同一个教室,那既然在同一个教室,那能否给类中再加一个成员变量,来保存同学上课时的教室呢?答案是不行的。

之前在Student类中定义的成员变量,每个对象中都会包含一份(称之为实例变量), 因为需要使用这些信息来描述具体的学生。而现在要表示学生上课的教室,这个教室的属性并不需要每个学生对象中都存储一份,而是需要让所有的学生来共享。在Java中,被static修饰的成员,称之为静态成员,也可以称为类成员,其不属于某个具体的对象,是所有对象所共享的。

6.1 static修饰成员变量

static修饰的成员变量,称为静态成员变量, 静态成员变量最大的特性:不属于某个具体的对象,是所有对象所共享的

【静态成员变量特性】

  • 1. 不属于某个具体的对象,是类的属性,所有对象共享的,不存储在某个对象的空间中
  • 2. 既可以通过对象访问,也可以通过类名访问,但一般更推荐使用类名访问
  • 3. 类变量存储在方法区当中
  • 4. 生命周期伴随类的一生(即:随类的加载而创建,随类的卸载而销毁)
public class Student{
  public String name;
  public String gender;
  public int  age;
  public double score;
  public static String classRoom = "JSU60121";
 
  // ...
 
  public static void main(String[] args) {
    // 静态成员变量可以直接通过类名访问
    System.out.println(Student.classRoom);
    Student s1 = new Student("Li leilei", "男", 18, 3.8);
    Student s2 = new Student("Han MeiMei", "女", 19, 4.0);
    Student s3 = new Student("Jim", "男", 18, 2.6);
    // 也可以通过对象访问:但是classRoom是三个对象共享的
    System.out.println(s1.classRoom);
    System.out.println(s2.classRoom);
    System.out.println(s3.classRoom);
     }
}

可以调试方式运行上述代码,然后在监视窗口中可以看到,静态成员变量并没有存储到某个具体的对象中。

6.2 static修饰成员方法

一般类中的数据成员都设置为private,而成员方法设置为public,那设置之后,Student类中classRoom属性如何在类外访问呢?

public class Student{
  private String name;
  private String gender;
  private int  age;
  private double score;
  private static String classRoom = "JSU60121";
 
  // ...
}
public class TestStudent {
  public static void main(String[] args) {
    System.out.println(Student.classRoom);
 }
}
//编译失败:
//Error: java: classRoom 在 extend01.Student 中是 private 访问控制

那static属性应该如何访问呢?
Java中,被static修饰的成员方法称为静态成员方法,是类的方法,不是某个对象所特有的。 静态成员一般是通过静态方法来访问的。

public class Student{
  // ...
 
  private static String classRoom = "JSU60121";
 
  // ...
 
  public static String getClassRoom(){
    return classRoom;
 }
}
public class TestStudent {
  public static void main(String[] args) {
    System.out.println(Student.getClassRoom());//通过调用成员方法来访问成员变量
 }
}
输出:JSU60121

【静态方法特性】

  • 1. 不属于某个具体的对象,是类方法
  • 2. 可以通过对象调用,也可以通过类名.静态方法名(…)方式调用,更推荐使用后者
  • 3. 不能在静态方法中访问任何非静态成员变量
public static String getClassRoom(){
  System.out.println(this);
  return classRoom;
}
// 编译失败:Error: java: 无法从静态上下文中引用非静态 变量 this
public static String getClassRoom(){
  age += 1;
  return classRoom;
}
// 编译失败:Error: java: 无法从静态上下文中引用非静态变量age
  • 4. 静态方法中不能调用任何非静态方法,因为非静态方法有this参数,在静态方法中调用时候无法传递this引用
public static String getClassRoom(){
  doClass();
  return classRoom;
}
// 编译报错:Error: java: 无法从静态上下文中引用非静态 方法 doClass()
  • 5. 静态方法无法重写,不能用来实现多态

6.3 static成员变量初始化

注意:静态成员变量一般不会放在构造方法中来初始化,构造方法中初始化的是与对象相关的实例属性

静态成员变量的初始化分为两种:就地初始化 和 静态代码块初始化。

6.3.1 就地初始化

就地初始化指的是:在定义时直接给出初始值

public class Student{
  private String name;
  private String gender;
  private int  age;
  private double score;
  private static String classRoom = "JSU60121"; 
 
  // ...
}

6.3.2 静态代码块初始化

后续在代码块部分会有讲解


七、代码块

7.1 什么是代码块?

使用 {} 定义的一段代码称为代码块。 根据代码块定义的位置以及关键字,又可分为以下四种:

  • 普通代码块
  • 构造块
  • 静态块
  • 同步代码块

7.2 普通代码块

普通代码块:定义在方法中的代码块.

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 = 10
x2 = 100

这种用法较少见

7.3 构造代码块

构造块:定义在类中的代码块(不加修饰符)。也叫:实例代码块。构造代码块一般用于初始化实例成员变量。

public 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 = "zhangsan";
this.age = 12;
this.sex = "man";
    System.out.println("I am instance init()!");
}
public void show(){
System.out.println("name: "+name+" age: "+age+" sex: "+sex);
}
}
public class Main {
public static void main(String[] args) {
Student stu = new Student();
stu.show();
}
}
// 运行结果
I am instance init()!
I am Student init()!
name: bit age: 12 sex: man
public class Student{
  private String name;
  private String gender;
  private int  age;
  private double score;
  private static String classRoom;
  //实例代码块
 {
    this.name = "zhangsan";
    this.age = 12;

7.4 静态代码块

使用static定义的代码块称为静态代码块。一般用于初始化静态成员变量。

public class Student{
  private String name;
  private String gender;
  private int  age;
  private double score;
  private static String classRoom;
  //实例代码块
 {
    this.name = "zhangsan";
    this.age = 12;
       this.gender = "man";
    System.out.println("I am instance init()!");
 }
  // 静态代码块
  static {
    classRoom = "JSU60121";
    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加载类时开辟空间并初始化的
  • 如果一个类中包含多个静态代码块,在编译代码时,编译器会按照定义的先后次序依次执行(合并)
  • 实例代码块只有在创建对象时才会执行

7.5 同步代码块(这里不予介绍,多线程部分会有解答)

总结一——浅谈Java的类与对象 NULL 博文链接:https://xiangpin.iteye.com/blog/1668307 立即下载

相关推荐

双目视觉三维重构(一)————简介

优快云中关于立三维重构的介绍层出不穷,CNKI中也有各类综述对三维重构进行总结,撰写这篇博客仅作为本人对该类博客、论文的总结学习,加深自身学习的印象、作为学习的笔记。如有错误的地方,欢迎指正。   1、三维重构 1.1、三维重构到底是什么?   首先要了解立体匹配算法,首先要知道立体匹配算法主要具体应用于什么方向。 三维重构又被称为三维重建,百度百科中对它的定义为:指对三维物体建立适合...

qq_39634612的博客 1万+

Java类和对象学习总结

Java类和对象学习总结

Syllll_的博客 705

NC65增加自定义参照并且参照数据要根据选择的财务组织过滤

1、首先定义一个参照类 package nc.pub.jzcm.ref; import nc.ui.bd.ref.AbstractRefModel; import nc.ui.bd.ref.IRefDocEdit; import nc.ui.bd.ref.IRefMaintenanceHandler; public class PMPrPayDefaultRefModel extends AbstractRefModel { public PMPrPayDefaultRefModel(){ ...

xyl的博客 3496

Java类和对象知识点总结

一、类和对象 1、面向对象 (1)面向对象与 面向过程 (理解) ● 面向过程的操作是以程序的基本功能实现为主,实现之后就完成了,也不考虑修改的可能性,面向对象,更多的是要进行子模块化的设计,每一个模块都需要单独存在,并且可以被重复利用,所以,面向对象的开发更像是一个具备标准的开发模式。 面向过程:强调的是功能行为,以函数为最小单位,考虑怎么做。 面向对象:强调具备了功能的对象,以类/对象为最小单位,考虑谁来做。 (2)面向对象的特征 ● 面向对象可以将复杂的工程逻辑简单化,增强代码的复用性。 ● 面

qq_45676489的博客 1476

AI量化投资开源平台——Qlib(微矿)的学习使用笔记(随缘更新)

Qlib 涵盖了量化投资的全过程,为用户的 AI 算法提供了高性能的底层基础架构,从框架设计上让用户可以更容易地应用 AI 算法来辅助解决量化投资的各个关键问题(例如 Alpha 预测,风险预测,市场动态性建模)。本文旨在记录一些面向初学者的基础内容。

in_void的博客 3134

使用python获取同花顺免费版和同花顺远航版自选股数据用于量化交易

在做量化交易时,有时需要在盘中实时监控同花顺自选股的数量,以便灵活地自定义提醒、捕捉买卖时点等。那么,如何使用python获取同花顺自选股数据呢?

tzzqn2008的专栏 3689

Java之旅(第六章类和对象总结)

Java第六章总结

2201_75496254的博客 323

在 Windows 11 下运行 OminiParse V2,详细教程【含问题解决细节】

OmniParser V2 是微软推出的 GUI 智能体解析工具,可将屏幕截图转换为结构化元素,帮助 LLM 理解和操作界面。它在检测小图标和推理速度上显著提升,延迟降低 60%,并支持多种 LLM。

简简单单Onlinezuozuo 1094

【Java】类和对象详解

面向对象(Object-oriented)是一种程序设计的方法和编程范式,它以对象作为程序的基本单位,通过封装、继承、多态等概念来组织和实现程序逻辑。面向对象的编程思想强调将问题分解为对象的集合,每个对象具有自己的状态(属性)和行为(方法),并通过相互之间的消息传递来实现协助和交互。类(Class)是用来对一个实体(对象)进行描述的,主要包括实体(对象)的属性和行为的描述。在Java语言中,类是面向对象编程的基本组织单位,它是对象的模版或者蓝图,描述了对象的属性和行为。

qq_61635026的博客 8534

WordPress插件depicter存在SQL注入漏洞(CVE-2025-2011)

Depicter 是一款功能强大的 WordPress 幻灯片插件,允许用户通过直观的拖放编辑器轻松创建响应式滑块、轮播和动态内容展示。该插件提供丰富的模板库、动画效果和图层控制,支持多媒体内容嵌入(如图片、视频、HTML),并优化了移动端显示和SEO性能。其无代码操作界面适合非技术用户,同时提供高级自定义选项,适用于产品展示、营销推广和视觉叙事等多种场景,是提升网站视觉吸引力的高效工具。

m0_50125527的博客 556

动网格-网格重构之铺层(三)

运动区域可以是边界区域 (Boundary Zone),也可以是单元区域 ( Cell Zone)。指定了体网格再生方法后,FLUENT自动地根据运动区域(dynamic zones)的运动来调整内部节点以再生体网格。必须保留至少一层网格。(4)如果边面的法向和运动方向偏角较大,生成的网格扭斜度会比较大铺层算法不适用于边界形状变化较大的情况。(1)体网格再生方法的选择(Smoothing,Layering,Remeshing);(2)适用网格种类:四边形、六面体、三棱柱(网格的分布要服从一定的规则)。

weixin_44386973的博客 2096

Java类和对象【超详细】干货满满

Java是一门纯面向对象的语言(Object Oriented Program,简称OOP),在面向对象的世界里,一切皆为对象。面向对象是解决问题的一种思想,主要依靠对象之间的交互完成一件事情。用面向对象的思想来涉及程序,更符合人们对事物的认知,对于大型程序的设计、扩展以及维护都非常友好。面相对象程序设计关注的是对象,而对象是现实生活中的实体,比如:洗衣机。但是洗衣机计算机并不认识,需要开发人员告诉给计算机什么是洗衣机。

weixin_65476629的博客 9664

ROS机器人未知环境自主探索功能包explore_lite最全源码详细解析(一)

本系列文章主要针对ROS机器人常使用的未知环境自主探索功能包explore_lite展开全源码的详细解析,并进行概括总结。 本系列文章共包含六篇文章,前五篇文章主要介绍explore_lite功能包中 explore.cpp、costmap_tools.h、frontier_search.cpp、costmap_client.cpp等源码实现文件中全部函数的详细介绍,第六篇文章进行概括总结,包含自主探索功能包explore_lite的简介,实现未知环境自主探索功能的原理及流程总结,效果演示,使用功能包

慕羽★的博客 3939

【JavaSE】(4)类和对象

构造方法,名字与类名相同没有返回值,作用就是初始化成员变量。创建对象后,编译器会自动调用构造方法,并只调用一次。在没有定义构造方法时,编译器会默认定义一个什么也不做的构造方法。但是定义了构造方法后编译器就不会定义默认的构造方法了。可以重载。静态代码块、静态成员变量(类加载时就分配内存初始化)->实例代码块、示例成员变量(创建对象时)->构造方法。执行顺序(相同):依次。不管 new 了多少个对象,静态代码块只执行一次。多个静态代码块,会合并执行。

2401_86272648的博客 1053

RU DOS版、EFI版32bit/64bit BIOS常用工具

DOS版、EFI版的RU工具,可用来查看IO、MEM、PCI、SMBIOS等资源。亲测在EFI SHELL下可用。

Camera2Demo

在Camera2 的基础上进行封装,使得Camera2一堆初始化逻辑与Activity分离,降低耦合度,完成预览拍照并保存的操作

JavaSE-part6【类和对象】

什么是类、什么是对象,类的实例化、this引用、构造方法、封装、static{静态成员变量和静态成员方法)、代码块。

m0_75082861的博客 1200

LinePhone3.2.7(android端最新版本) sip客户端

SIP客户端For android:LinePhone3.2.7(最新版本),官网地址:http://www.linphone.org/

[JavaSE]类和对象(一)

JavaSE类和对象知识点详细介绍(第一部分),包括类的定义、实例化,对象的构造和初始化等,适合新手,建议收藏!!

2401_88599502的博客 1768

C# WinForm 基于DirectShow.dll编写的程序,可边预览边保存视频,音频和图片

基于微软的DirectShow.dll的二次开发1.自动识别连接的摄像头跟麦克风且可以对其进行选择(默认选中第一个)2.可录制wmv和avi两种格式的视频并且都带有音频,avi可以录制的分辨率和帧数进行选择,wmv默认进行了淸晰度优化如不喜欢可去除代码中有相关提示3.可在预览点开之后进行拍照,也可边录制视频边拍照4.添加了视频和音频的压缩功能(酌情使用)这次二次开发发现C#对DirectShow的相关信息太少,这次做完也不敢藏私共享出来,还望大家指正

JavaSE-类和对象详解

1.在IDEA中先新建一个包右键src ->新建->包2.在弹出的对话框中输入包名3.在包中创建类右键包名->新建->类然后输入类名即可如图:此时可以看到我们的磁盘上的目录结构已经被IDEA自动创建出来了在文件的最上方加上一个package语句指定该代码在哪个包中如果一个类没有package语句则该类被放到一个默认包中。

2301_80873677的博客 847

JavaSE——类和对象

例如:上网查手机参数,打开电商平台,找到这个手机,下单,写地址,取快递,打开包装验货类对象抽象的模版具体的实例不占用内存占用内存定义属性和方法的结构拥有具体的的属性值,可执行方法一个类可以创建对个对象每个对象单独存在。

2302_77280725的博客 984

JavaSE 01 类和对象|继承多态

java基础。

Rancemy的博客 818

JavaSE-5 类和对象

和数组一样,对象在栈上也是存放引用在堆上开辟的“地址”四、如何访问对象的成员。

2401_83117850的博客 775

【JAVASE】第八弹——类和对象(下)

类和对象(下) 封装 static成员 四种代码块详解

2503_90322569的博客 922

JavaSE:类和对象1

重点:类的定义,类的实例化(创建对象),this引用,构造方法(默认、就地初始化和构造方法关系)

Zzzzmo_的博客 774

[JavaSE]类和对象(二)

接上一篇,继续介绍Java类和对象部分核心知识:封装、包、静态成员,讲解详细,建议收藏!!

2401_88599502的博客 656

JavaSE 类和对象

JavaSE 类和对象应用介绍(超详细)

Mwt258的博客 171

JavaSE知识分享——类和对象(下)

基本规则包名要和代码路径相匹配. 例如创建com.bit.demo1 的包, 那么会存在一个对应的路径 com/bit/demo1 来存储代码.如果一个类没有 package 语句, 则该类被放到一个默认包中.com.example 是一个完整的包名。但从目录层次看,它依赖于父目录 com 的存在。在逻辑上, com 和 com.example 是两个不同的包。com.example包中需要时是否需要导入父包中的类?需要。

2502_91380778的博客 715

JavaSE面对对象—类和对象

这篇文章主要介绍了JavaSE面向对象—类和对象

m0_74960218的博客 551
上一篇: 数据的存储(2)
下一篇: [Java]数据结构---顺序表
Crystal_learner
博客等级 码龄5年 117粉丝 8原创
评论 10
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值