Java019——类和对象

曾经终败给现在 2024-05-05 22:17 4阅读 0赞

在Java中`一切皆对象`

## 一、什么是对象？ ##

一个人、一只猫、一条狗…这些就是一个对象；  
每个对象都有属性（名词）和行为（动作）。

## 二、什么是类？ ##

类即同类别，例如：不论男人、女人、黑人、白人…，都是人类，即同一类事务的统称。

## 三、类的组成（类长什么样？） ##

1、Java程序的基本组成单元是类  
2、类中包含`属性`和`方法`两部分  
![在这里插入图片描述][6e920046708e45d5b09ce23b21e48ad4.png]  
实例1：下面定义了一个Human类，  
1、有name属性和heart 属性（其中heart 是静态成员变量）、  
2、getName()方法和setName(String name)方法、静态方法（类方法） hello()

class Human {
        
        String name = "二毛";;			//name属性（实例成员变量） 
        static int heart = 1;			//使用static定义静态成员变量heart
        
        String getName() {
        				//getName()方法
            return name;
        }
    
        void setName(String name) {
        		//setName(String name)方法
            this.name = name;
        }
    	
    	static void hello(){
        			//静态方法（类方法） hello()
    		System.out.println("静态方法（类方法）hello");
    	}
    	
    	Human() {
        
    		System.out.println("构造方法Human");
    	}
    }

## 四、对象的创建和使用（对象长什么样？） ##

### 4.1、对象的创建 ###

其实对象也是变量，只是对象这个变量的数据类型是一个确切的类  
对象的创建叫`实例化类的对象`

class Human {
        
        String name = "二毛";
        static int heart = 1;
        String getName() {
        
            return name;
        }
    
        void setName(String name) {
        
            this.name = name;
        }
    
    	/*main方法*/
        public static void main(String[] args){
        
            // 下面的语句将创建一个Human对象叫human
            Human human = new Human();
        }
    }

从上面可以看出，对象的创建格式为：

> 类名 对象名 = new 类名();//调用无参构造函数创建对象（方式一）

### 4.2、对象的使用（访问实例变量和方法） ###

*通过对象只能访问到实例变量和方法*

对象访问实例变量和方法的格式：

> 对象名.实例变量  
> 或  
> 对象名.方法名(参数)

class Human {
        
        String name = "二毛";		//name属性（实例成员变量）
        static int heart = 1;		//使用static定义静态成员变量heart
        
        String getName() {
        			//getName()方法
            System.out.println(name);
            return name;
        }
    
    	/*mian方法*/
        public static void main(String[] args){
        
            // 下面的语句将创建一个Human对象叫human
            /*对象的创建其实分为两步
    			1、声明：声明一个对象，包括对象名称和对象类型。
    			2、实例化+初始化：使用关键字 new 来创建一个对象。使用 new 创建对象时，会调用构造方法初始化对象。
    		*/
            Human human = new Human();
    
            System.out.println(human.name);//访问实例变量和方法
            human.getName();//访问方法
        }
    }
    
    //运行结果
    二毛
    二毛

## 五、构造方法 ##

### 5.1、创建对象的补充说明 ###

对象的创建其实分为两步：1、声明，2、实例化+初始化

class Human {
        
        String name = "二毛";		
        static int heart = 1;		
        
        String getName() {
        			
            System.out.println(name);
            return name;
        }
    
    	/*mian方法*/
        public static void main(String[] args){
        
            // 下面的语句将创建一个Human对象叫human
            /*对象的创建其实分为两步
    			1、声明：声明一个对象，包括对象名称和对象类型。
    			2、实例化+初始化：使用关键字 new 来创建一个对象。使用 new 创建对象时，会调用构造方法初始化对象。
    		*/
            Human human = new Human();
    
            System.out.println(human.name);
            human.getName();
        }
    }
    
    //运行结果
    二毛
    二毛

### 5.2、什么是构造方法？ ###

上面代码注释中提到了`构造方法`，下面来说明一下什么是构造方法

1、构造方法，顾名思义还是方法，只是构造方法的名称必须与类名称一样，也就是`方法名和类名一样的方法就是构造方法`

//示例
    class Human {
        
    	Human(){
        //无参构造
    
        }
        Human(String name){
        //有参构造
            System.out.println(name );
        }
    }

说明：  
1、构造方法的名称必须与类名称一样。  
2、一个类可以有多个构造方法。  
3、构造方法分为有参构造和无参构造。  
4、对象的创建就是通过构造方法完成的。  
5、构造方法没有返回值，也不能用void修饰

对于第4点说明，有人就有疑惑了，在上面创建对象的例子中，Human类中根本就没有看到构造方法，怎么又说`对象的创建就是通过构造方法完成的`呢？

其实，在你定义一个类的时候Java就自动给你添加了一个隐藏的无参构造方法，也就是这样

//示例
    class Human {
        
    	Human(){
        //无参构造
    
        }
    }

只不过这个无参构造没有向我们这样显式的写出来，它是隐藏起来的，也就是这样

//示例
    class Human {
        
    	/*Human(){//无参构造
    
        }*/
    }

当我们使用new关键字创建对象的时候就会调用相应的构造方法（无参构造或有参构造）

前面Human human = new Human();使用的是默认的无参构造方法创建对象。你也可以定义有参构造来创建对象

class Human {
        
        String name = "二毛";
    
        Human(){
        //无参构造
    
        }
        Human(String name){
        //有参构造
            this.name = name;
            System.out.println(name );
        }
    
        public static void main(String[] args){
        
            // 下面的语句使用有参构造创建一个Human对象叫human，并初始化humen对象的name等于“三毛”
            Human human = new Human("三毛");
    
            System.out.println(human.name);
        }
    }
    
    //运行结果
    三毛
    三毛

所以，对象的另一种创建格式为：

> 类名 对象名 = new 类名(参数);//调用有参构造函数创建对象（方式二）

## 六 、static关键字&静态变量和静态方法 ##

在类中被static修饰的变量称为`静态变量（类变量）`，被static修饰的方法称为`静态方法`

### 6.1、静态变量 ###

class Human {
        
        String name = "二毛";;			//name属性（实例成员变量）
        static int heart = 1;			//使用static定义静态成员变量heart，也叫类变量
    }

> ### 实例变量和静态成员变量的区别   一、实例变量   1、只能被对象访问   2、不同对象之间不共享数据值 ###
> 
> 二、静态成员变量  
> 1、可以被对象访问（格式：对象名.静态变量名），也可以用类名词访问（格式：类名.静态变量名）  
> 2、不同对象之间共享数据值

### 6.2、静态方法 ###

class Human {
        
        int method1(int num){
        
    		System.out.println("这是一个实例方法");
    		return 1+num;
    	}
    	
    	//静态方法
    	static int method2(int num){
        
    		System.out.println("这是一个静态方法");
    		return 1+num;
    	}
    }

> ### 实例方法与静态方法【类方法】的区别   一、实例变量   1、实例方法只能对象访问，   2、实例方法只在方法调用时分配运行空间， ###
> 
> 二、静态方法【类方法】  
> 1、 静态方法【类方法】 可以通过对象访问（格式：对象名.静态变量名），也可以通过类名访问（格式：类名.静态变量名）  
> 2、静态方法【类方法】在方法调用前已经分配好运行空间。  
> 3、静态方法不可以使用this关键字  
> 4、静态方法不可以直接调用非静态方法，但是可以调用其他静态方法

## 七、this 关键字 ##

在上面的对象的创建和使用中的setName()方法中，使用了一个关键字this，如下：

现在说明一下this代表什么？

this英文意思位`“这”`，在Java中表示当前调用类中属性或方法的对象，例如上面例子中的this就代表对象human。  
实际上this代表当前对象的引用

即哪个对象去操作类，这时的this就代表该对象，或者说是该对象的引用。

## 八、对象的引用 ##

在 Java 语言中，尽管一切都可以看作对象，但真正的操作标识符实质上是一个引用，那么引用在Java 中是如何体现的呢? 语法如下:

> 类名 对象的引用变量

例如，一个 People 类的引用可以使用以下代码:

People tom;

通常一个引用不一定需要有一个对象相关联。引用与对象相关联的语法如下:

People tom = new People();

在上述代码中，各个单词的含义下图 所示：  
![在这里插入图片描述][a651c03bce0a4a52ac437a5815484942.png]

1.  实际上真正的对象是“`new People()`”这段代码。
2.  实际上，`tom 只是一段内存地址`，用于标记“new People()”对象在内存中的位置。因为内存地址又长又乱，很难让人记住，所以 Java 语言利用引用变量帮开发者标记`内存地址`。
3.  “new People0”对象能做的事，tom 也能做。例如下面这行代码:

new People().getClass();
    等价于:
    People tom = new People();
    tom.getClass();

## 九、Java垃圾回收机制 ##

Java中的垃圾回收机制（Garbage Collection）负责自动回收不再使用的内存，使程序员可以专注于业务逻辑而不必手动释放内存。以下是一些Java垃圾回收机制实际使用的示例：

1.  对象的销毁：当一个对象在程序中不再被引用时，垃圾回收机制会自动回收它所占用的内存空间。例如，创建了一个对象后，如果没有任何变量引用它，那么垃圾回收机制将自动回收该对象的内存。
    
        public static void main(String[] args) {
              
            // 创建一个对象
            MyClass obj = new MyClass();
            
            // 将对象置为null，不再有引用指向它
            obj = null;
            
            // 在适当的时间，垃圾回收机制将回收obj对象的内存
        }
2.  手动调用`System.gc()`：在某些情况下，我们可能希望尽快触发垃圾回收机制来回收不再使用的内存。我们可以使用`System.gc()`方法来建议垃圾回收机制运行。请注意，这只是一个建议，具体的回收时间取决于垃圾回收器的工作情况。
    
        public static void main(String[] args) {
              
            // 创建一些对象并使用它们
            // ...
            
            // 调用System.gc()建议垃圾回收机制运行
            System.gc();
            
            // 在适当的时间，垃圾回收机制将回收不再使用的内存
        }

这些示例展示了Java垃圾回收机制的使用。通过自动回收不再使用的内存，垃圾回收机制有效地管理内存，提高应用程序的性能和稳定性。

## 与君共享 ##

👉👉👉👉👉最后，有兴趣的小伙伴可以点击下面链接，这里有我整理的完整Java学习博客内容，谢谢~ 🌹🌹🌹🌹🌹

[《Java基础专栏完整学习》][Java]

[6e920046708e45d5b09ce23b21e48ad4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/05/5d5bf9327cec4f1a8290aa1dbe7083b0.png
[a651c03bce0a4a52ac437a5815484942.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/05/6c3c04d4eb09462db0e47f75bade5bdf.png
[Java]: https://blog.csdn.net/weixin_45084986/category_11588062.html