初识Java（Java类和对象-对象)

2022-05-26 07:48 141阅读 0赞

### 一、对象 ###

Java 是一门面向对象的程序设计语言，对象时由类抽象出来的，所有的问题都通过对象来处理，对象可以操作类的属性和方法解决相应的问题，所以了解对象的产生、操作和消亡是必要的。

1.1 对象的创建

对象可以认为是在一类事物中出现出来的某一特例，可以通过这个特例来处理这类事物出现的问题。在 Java 语言中通过 new 操作符来创建对象。每实例化一个对象就会自动调用一次构造方法，实质上这个过程就是创建对象的过程，在 Java 语言中使用 new 操作符调用构造方法来创建对象。

语法 ：

Test test = new Test();
    Test test = new Test("a");

<table>  创建对象语法中的参数说明  
 <tbody> 
  <tr> 
   <td>设置值</td> 
   <td>描述</td> 
  </tr> 
  <tr> 
   <td>Test</td> 
   <td>类名</td> 
  </tr> 
  <tr> 
   <td>test</td> 
   <td>创建 Test 类对象</td> 
  </tr> 
  <tr> 
   <td>new</td> 
   <td>创建对象操作符</td> 
  </tr> 
  <tr> 
   <td>" a "</td> 
   <td>构造方法的参数</td> 
  </tr> 
 </tbody> 
</table>

test 对象被创建出来时，就是一个对象的引用，这个引用在内存中为对象分配了存储空间，在构造方法中初始化成员变量，当创建对象时，自动调用构造方法，也就是说在 Java 语言中初始化与创建时被捆绑在一起的。

每个对象都是相互独立的，在内存中占据独立的内存地址，并且每个对象都具有自已的生命周期，当一个对象的生命周期结束时，对象就变成垃圾，由 Java 虚拟机自带的垃圾回收机制处理，不能再被使用。

在 Java 语言中对象和实例事实上可以通用。

eg ： 创建类，在类中创建对象并在主方法中创建对象。

public class CreateObject{
        public CreateObject(){                         //构造方法
            System.out.println("创建对象");
        }
        public static void main(String[] args){        //主方法
            //在主方法中使用 new 操作符创建对象，创建对象的同时，将自动调用构造方法中的代码
            new CreateObject();                        //创建对象
        }
    }

运行结果为 ： 创建对象

1.2 访问对象的属性和行为

用户使用 new 操作符创建一个对象后，可以使用“ 对象 . 类成员 ”来获取对象的属性和行为。对象的属性和行为在类中是通过类成员变量和成员方法的形式来表示的，所以当对象获取类成员时，也相应地获取了对象的属性和行为。

eg ： 创建类，在类中说明对象时如何调用类成员的。

public class TransferProperty{
        int i = 47 ;                                                            //定义成员变量
        public void call(){                                                     //定义成员方法
            System.out.println("调用 call() 方法");
            for(i = 0 ; i < 3 ; i++){
                System.out.print(i + "");
                if(i == 2){
                    System.out.println(" \n");
                }
            }
        }
        public TransferPropety(){                                               //定义构造方法
        }
        public static void main(String[] args){                                 //主方法
            TransferProperty t1 = new TransferProperty();                       //创建一个对象
            TransferProperty t2 = new TransferProperty();                       //创建另一个对象
            t2.i = 60;                                                          //将类成员变量赋值为 60
            //使用第一个对象调用类成员变量
            System.out.println("第一个实例对象调用变量 i 的结果："+t1.i++);
            t1.call();//使用第一个对象调用类成员方法
            //使用第二个对象调用类成员变量
            System.out.println("第二个实例对象调用变量 i 的结果："+t2.i);
            t2.call();                                                          //使用第二个对象调用类成员方法
        }
    }

运行结果为 ：

第一个实例对象调用变量 i 的结果：47
    调用call() 方法
    0 1 2
    第二个实例对象调用变量 i 的结果：60
    调用 call() 方法
    0 1 2

在上述代码的主方法中首先实例化一个对象，然后使用“ . ”操作符调用类的成员变量和成员方法。但是在结果中却是不同的，因为在打印这个成员变量的值之前重新赋值为 60 ，但在赋值时使用的是第二个对象 t2 调用成员变量，所以在第一个对象 t1 调用成员变量打印该值时还是变量的初始值。

如果希望成员变量不被其中任何一个对象改变，可以使用 static 关键字。

eg ： 创建类，该类举例说明对象调用静态成员变量。

public class AccessProperty{
        static int i = 47 ;                                                     //定义成员变量
        public void call(){                                                     //定义成员方法
            System.out.println("调用 call() 方法");
            for(i = 0 ; i < 3 ; i++){
                System.out.print(i + "");
                if(i == 2){
                    System.out.println(" \n");
                }
            }
        }
        public AccessProperty(){                                                //定义构造方法
        }
        public static void main(String[] args){                                 //主方法
            AccessProperty t1 = new AccessProperty();                           //创建一个对象
            AccessProperty t2 = new AccessProperty();                           //创建另一个对象
            t2.i = 60;                                                          //将类成员变量赋值为 60
            //使用第一个对象调用类成员变量
            System.out.println("第一个实例对象调用变量 i 的结果："+t1.i++);
            ta.call();                                                          //使用第一个对象调用类成员方法
            //使用第二个对象调用类成员变量
            System.out.println("第二个实例对象调用变量 i 的结果："+t2.i);
            t2.call();                                                          //使用第二个对象调用类成员方法
        }
    }

运行结果为 ：

第一个实例对象调用变量 i 的结果：60
    调用call() 方法
    0 1 2
    第二个实例对象调用变量 i 的结果：3
    调用 call() 方法
    0 1 2

从上述运行结果中可以看到，由于使用 t2.i = 60 语句改变了静态成员逼你了的值，使用对象 t1 调用成员变量的值也为 60，这正是 i 值被定义为静态成员变量的效果，即使使用两个对象对同一个静态成员变量进行操作，依然可以改变静态成员变量的值，因为在内存中两个兑现同时指向同一块内存区域。t1.i++语句执行完毕后，i 的值变为 3 。当再次调用 call() 方法时又被重新赋值为 0 ，做循环打印操作。