JAVA类与对象-CSDN博客

本文链接：https://blog.csdn.net/m0_56281327/article/details/119981698

什么是面向对象

Java是一门纯面相对象的语言(Object Oriented Program，继承OOP)，在面相对象的世界里，一切皆为对象。面相对象是解决问题的一种思想，主要依靠对象之间的交互完成一件事情。用面相对象的思想来涉及程序，更符合人们对事物的认知，对于大型程序的设计、扩展以及维护都非常友好。

面向对象与面向过程的区别

面向过程是一种以事件为中心的编程思想，编程的时候把解决问题的步骤分析出来，然后用函数把这些步骤实现，在一步一步的具体步骤中再按顺序调用函数。
面向对象是一种以“对象”为中心的编程思想，把要解决的问题分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为了描叙某个对象在整个解决问题的步骤中的属性和行为。

类的定义与使用

类是一个模板，它描述一类对象的行为和状态。
类的定义格式：（java中定义类时需要用到class关键字，具体语法如下）

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

class为定义类的关键字，ClassName为类的名字，{}中为类的主体
类中包含的内容称为类的成员。属性主要是用来描述类的，称之为类的成员属性或者类成员变量。方法主要说明类具有哪些功能，称为类的成员方法。
对象：对象是类的一个实例，有状态和行为。软件对象也有状态和行为。软件对象的状态就是属性，行为通过方法体现。例如，一条狗是一个对象，它的状态有：颜色、名字、品种；行为有：摇尾巴、叫等。
例如定义一个狗类：
在这里插入图片描述

class PetDog {
 public String name;//名字
 public String color;//颜色
 // 狗的属性
 public void barks() {
 System.out.println(name + ": 旺旺旺~~~");
 }
 
 // 狗的行为
 public void wag() {
 System.out.println(name + ": 摇尾巴~~~");
 }
}

一个类可以包含以下类型变量：
局部变量：在方法、构造方法或者语句块中定义的变量被称为局部变量。变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁。
成员变量：成员变量是定义在类中，方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中方法、构造方法和特定类的语句块访问。
类变量：类变量也声明在类中，方法体之外，但必须声明为 static 类型。
一个类可以拥有多个方法，在上面的例子中：wag()，barks() 都是 Dog 类的方法。

创建对象

对象是根据类创建的。在Java中，使用关键字 new 来创建一个新的对象。创建对象需要以下三步：
声明：声明一个对象，包括对象名称和对象类型。
实例化：使用关键字 new 来创建一个对象，使用 . 来访问对象中的属性和方法，同一个类可以创建对个实例。
初始化：使用 new 创建对象时，会调用构造方法初始化对象。
例：

public class Puppy{
   public Puppy(String name){
      //这个构造器仅有一个参数：name
      System.out.println("小狗的名字是 : " + name ); 
   }
   public static void main(String[] args){
      // 下面的语句将创建一个Puppy对象
      Puppy myPuppy = new Puppy( "tommy" );
   }
}

编译并运行上面的程序，会打印出下面的结果：
小狗的名字是 : tommy

类和对象的说明

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

源文件声明规则

1.一个源文件中只能有一个 public 类
2.一个源文件可以有多个非 public 类
3. 源文件的名称应该和 public类的类名保持一致。例如：源文件中 public 类的类名是 Employee，那么源文件应该命名为Employee.java。main方法所在的类必须要使用public修饰。
4. 如果一个类定义在某个包中，那么 package 语句应该在源文件的首行。
5.如果源文件包含 import 语句，那么应该放package 语句和类定义之间。如果没有 package 语句，那么 import 语句应该在源文件中最前面。 import 语句和 package语句对源文件中定义的所有类都有效。
6.在同一源文件中，不能给不同的类不同的包声明

this引用

为什么要有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，d2，d3的日期设置
 d1.setDay(2020,9,15);
 d2.setDay(2020,9,16);
 d3.setDay(2020,9,17);
 // 打印日期中的内容
 d1.printDate();
 d2.printDate();
 d3.printDate();
 }
}

以上代码定义了一个日期类，然后main方法中创建了三个对象，并通过Date类中的成员方法对对象进行设置和打
印，代码整体逻辑非常简单，没有任何问题。
但是细思之下有以下两个疑问：

形参名不小心与成员变量名相同：

public void setDay(int year, int month, int day){
 year = year;
 month = month;
 day = day; }

那函数体中到底是谁给谁赋值？
2. 三个对象都在调用setDay和printDate函数，但是这两个函数中没有任何有关对象的说明，setDay和printDate函数如何知道打印的是那个对象的数据呢？
什么是this引用
java编译器给每个“成员方法“增加了一个隐藏的引用类型参数，该引用参数指向当前对象(成员方法运行时调用该成员方法的对象)，在成员方法中中所有成员变量的操作，都是通过该引用去访问。

public class Date {
    private int year;
    private int month;
    private int day;
    public void setYear(int year){
        this.year=year;
    }
    public void setDate(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) {
        Date d1=new Date();
        d1.setDate(2021,8,29);
        d1.printDate();
    }
  }

在这里插入图片描述

只不过所有的操作对用户是透明的，即用户不需要来传递，编译器自动完成。即不需要用户自己添加上述代码中的this引用，有编译器自动完成。

this引用的特性

this的类型：对应类类型引用，即哪个对象调用就是哪个对象的引用类型
this只能在"非静态成员方法"中使用
在"非静态成员方法"中，this只能引用当前对象，不能再引用其他对象，具有final属性
this是“成员方法”第一个隐藏的参数，编译器会自动传递，在成员方法执行时，编译器会负责将调用成员方法对象的引用传递给该成员方法，this负责来接收
5.this引用不能为空。
从字节码角度证明，this引用存在

static成员

概念

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

静态成员变量的特性

不属于某个具体的对象，是类的属性，所有对象共享的，不存储在某个对象的空间中
既可以通过对象访问，也可以通过类名访问，但一般更推荐使用类名访问
JDK7及以前，HotSpot(Java虚拟机)中存储在方法区，JDK8及之后，类变量存储在Java堆中
生命周期伴随类的一生(即：随类的加载而创建，随类的卸载而销毁)

public class Student{
    public String name;
    public String gender;
    public int age;
    public double score;
    public static String classRoom = "Bit306";

    public Student(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(Student.classRoom);
        Student s1 = new Student("LiMing", "男", 18, 3.8);
        Student s2 = new Student("Cara", "女", 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);
    }
}

在这里插入图片描述

static成员方法

Java中，被static修饰的成员方法称为静态成员方法，是类的方法，不是某个对象所特有的。静态成员一般是通过
静态方法来访问的。

public class Student{
 // ...
 
 private static String classRoom = "Bit306";
 
 // ...
 
 public static String getClassRoom(){
 return classRoom;
 }
}
public class TestStudent {
 public static void main(String[] args) {
 System.out.println(Student.getclassRoom);
 }
}
//输出：Bit306

静态成员方法的特性

不属于某个具体的对象，是类方法
可以通过对象调用，也可以通过类名.静态方法名(…)方式调用，更推荐后者
静态方法没有隐藏的this引用参数，因此不能在静态方法中访问任何非静态成员变量
静态方法中不能调用任何非静态方法，因为非静态方法有this参数，在静态方法中调用时候无法传递this引用

对象的初始化

构造方法

每个类都有构造方法。如果没有显式地为类定义构造方法，Java 编译器将会为该类提供一个默认构造方法。
在创建一个对象的时候，至少要调用一个构造方法。构造方法的名称必须与类同名，一个类可以有多个构造方法。在创建对象时，由编译器自动调用，并且在整个对象的生命周期内只调用一次。
例：

public class Puppy{
	private	String name;
	private	int age;
    public Puppy(){
    }
    public Puppy(String name){
        // 这个构造器仅有一个参数：name
    }
    public Puppy(String name,int age){
    	this.name=name;
    	this.age=age;//这个构造器有两个参数
    }//注意：构造方法的作用就是对对象中的成员进行初始化，
    //并不负责给对象开辟空间。
}

构造方法特性：

名字必须与类名相同
没有返回值类型，设置为void也不行
创建对象时由编译器自动调用，并且在对象的生命周期内只调用一次(相当于人的出生，每个人只能出生一次)
构造方法可以重载(用户根据自己的需求提供不同参数的构造方法)
如果用户没有显式定义，编译器会生成一份默认的构造方法，生成的默认构造方法一定是无参的。

public class Puppy{
    private	String name;
    private	int age;
    public static void main(String[] args) {
        Puppy puppy=new Puppy();
    }
}

在这里插入图片描述
从字节码的角度看出，用户没有定义构造函数，编译器给Puppy类生成了一份无参的构造方法，构造函数的名字为"< init >"
6.一旦用户定义了构造方法，编译器不再生成

public class Puppy{
    private	String name;
    private	int age;
    public Puppy(String name){
        // 这个构造器仅有一个参数：name
    }
    public static void main(String[] args) {
        Puppy puppy=new Puppy();
    }
}

编译报错，证明编译器没有再提供无参的构造函数。

构造方法中，可以通过this调用其他构造方法来简化代码

public class Puppy{
    private	String name;
    private	int age;
    public Puppy(String name){
        this.name=name;
    }
    public Puppy(String name,int age){
        this(name);//此处给name赋值，
        //与上面的构造方法语句重复，
        //可使用this调用上述构造方法，
        //但必须作为第一条语句。
        this.age=age;
    }
    public static void main(String[] args) {
        Puppy puppy=new Puppy("tidy",10);
    }
}

this(...)必须是构造方法中第一条语句
不能形成环

public class Puppy{
    private	String name;
    private	int age;
    public Puppy(String name){
        this(name,10);
    }
    public Puppy(String name,int age){
        this(name);
        this.age=age;
    }
    public static void main(String[] args) {
        Puppy puppy=new Puppy("tidy",10);
    }
}

this成环，构造器递归调用，编译出错。

默认初始化

public class Puppy{
    private	String name;
    private	int age;
    public Puppy(){

    }
    public static void main(String[] args) {
        Puppy puppy=new Puppy();
        System.out.println(puppy.name);
        System.out.println(puppy.age);
    }
}

输出结果为 null,0

创建对象时，在JVM层面做的事

检测对象对应的类是否加载了，如果没有加载则加载
为对象分配内存空间
处理并发安全问题
初始化所分配的空间
对象空间申请好后，对象的成员已经被初始化

常见的数据默认值：

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

设置对象头信息

一个Java对象可以分为三部分存储在内存中，分别是：对象头(Header)、实例数据(Instance> Data)和对齐填充(Padding)。
对象头（包含锁状态标志，线程持有的锁等标志）
实例数据
对齐填充

调用构造方法<>，给对象中各个成员赋值

就地初始化

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

public class Puppy{
    private	String name="tidy";
    private	int age=10;
    public Puppy(String name,int age){
        this.name=name;
        this.age=age;
    }
    public static void main(String[] args) {
        Puppy puppy=new Puppy("haha",1);
        System.out.println(puppy.name);
        System.out.println(puppy.age);
    }
}

在这里插入图片描述

代码块初始化

使用 {} 定义的一段代码称为代码块。根据代码块定义的位置以及关键字，又可分为以下四种：
普通代码块
构造块
静态块
同步代码块（后续讲解多线程部分再谈）

普通代码块

定义在方法中的代码块.

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

构造代码块

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

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 = "bit";
 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) {
 Person p1 = new Person();
 p1.show();
 }
}
// 运行结果
I am instance init()! I am Person init()!
name: bit age: 12 sex: man

注意
实例代码块优先于构造方法执行，因为编译完成后，编译器会将实例代码块中的代码拷贝到每个构造方法第一条语
句前。
在这里插入图片描述

静态代码块

使用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加载类时开辟空间并初始化的
Java代码在经过编译器编译之后，如果要运行必须先要经过类加载子系统加载到JVM中才能运行。在加载阶段：

在链接阶段第二步准备中会给静态成员变量开辟空间，并设置为默认值，在初始化阶段，会执行静态代码块中的代码。
如果一个类中包含多个静态代码块，在编译代码时，编译器会按照定义的先后次序依次合并，最终放在生成的< clinit >方法中，该方法在类加载时调用，并且只调用一次。
实例代码块只有在创建对象时才会执行。
实例代码块只有在创建对象时才会执行。