零基础学Java：对象和类

“二哥，我那天在图书馆复习上一节你讲的内容，刚好碰见一个学长，他问我有没有‘对象’，我说还没有啊。结果你猜他说什么，‘要不要我给你 new 一个啊?’我当时就懵了，new 是啥意思啊，二哥?”三妹满是疑惑的问我。

成都创新互联公司是一家专注于成都网站设计、成都网站制作与策划设计,涵江网站建设哪家好?成都创新互联公司做网站,专注于网站建设10多年,网设计领域的专业建站公司;建站业务涵盖:涵江等地区。涵江做网站价格咨询:028-86922220

“哈哈，三妹，你学长还挺幽默啊。new 是 Java 中的一个关键字，用来把类变成对象。”我笑着对三妹说，“对象和类是 Java 中最基本的两个概念，可以说撑起了面向对象编程(OOP)的一片天。”

01、面向过程和面向对象

三妹是不是要问，什么是 OOP?

OOP 的英文全称是 Object Oriented Programming，要理解它的话，就要先理解面向对象，要想理解面向对象的话，就要先理解面向过程，因为一开始没有面向对象的编程语言，都是面向过程。

举个简单点的例子来区分一下面向过程和面向对象。

有一天，你想吃小碗汤了，怎么办呢?有两个选择：

1)自己买食材，豆腐皮啊、肉啊、蒜苔啊等等，自己动手做。

2)到饭店去，只需要对老板喊一声，“来份小碗汤。”

第一种就是面向过程，第二种就是面向对象。

面向过程有什么劣势呢?假如你买了小碗汤的食材，临了又想吃宫保鸡丁了，你是不是还得重新买食材?

面向对象有什么优势呢?假如你不想吃小碗汤了，你只需要对老板说，“我那个小碗汤如果没做的话，换成宫保鸡丁吧!”

面向过程是流程化的，一步一步，上一步做完了，再做下一步。

面向对象是模块化的，我做我的，你做你的，我需要你做的话，我就告诉你一声。我不需要知道你到底怎么做，只看功劳不看苦劳。

不过，如果追到底的话，面向对象的底层其实还是面向过程，只不过把面向过程进行了抽象化，封装成了类，方便我们的调用。

02、类

对象可以是现实中看得见的任何物体，比如说，一只特立独行的猪;也可以是想象中的任何虚拟物体，比如说能七十二变的孙悟空。

Java 通过类(class)来定义这些物体，这些物体有什么状态，通过字段来定义，比如说比如说猪的颜色是纯色还是花色;这些物体有什么行为，通过方法来定义，比如说猪会吃，会睡觉。

来，定义一个简单的类给你看看。

 
 
 
 
    
  
  
  
  
  1. /**
    2. 
  
  
  
  
  2.  * 微信搜索「沉默王二」，回复 Java
    3. 
  
  
  
  
  3.  *
    4. 
  
  
  
  
  4.  * @author 沉默王二
    5. 
  
  
  
  
  5.  * @date 2020/11/19
    6. 
  
  
  
  
  6.  */
    7. 
  
  
  
  
  7. public class Person {
    8. 
  
  
  
  
  8.     private String name;
    9. 
  
  
  
  
  9.     private int age;
    10. 
  
  
  
  
  10.     private int sex;
    11. 
  
  
  
  
  11. 
  
  
  
  
  12.     private void eat() {
    13. 
  
  
  
  
  13.     }
    14. 
  
  
  
  
  14. 
  
  
  
  
  15.     private void sleep() {
    16. 
  
  
  
  
  16.     }
    17. 
  
  
  
  
  17. 
  
  
  
  
  18.     private void dadoudou() {
    19. 
  
  
  
  
  19.     }
    20. 
  
  
  
  
  20. }
    21.

一个类可以包含：

  • 字段(Filed)
  • 方法(Method)
  • 构造方法(Constructor)

在 Person 类中，字段有 3 个，分别是 name、age 和 sex，它们也称为成员变量——在类内部但在方法外部，方法内部的叫临时变量。

成员变量有时候也叫做实例变量，在编译时不占用内存空间，在运行时获取内存，也就是说，只有在对象实例化(new Person())后，字段才会获取到内存，这也正是它被称作“实例”变量的原因。

方法 3 个，分别是 eat()、sleep() 和 dadoudou()，表示 Person 这个对象可以做什么，也就是吃饭睡觉打豆豆。

那三妹是不是要问，“怎么没有构造方法呢?”

的确在 Person 类的源码文件(.java)中没看到，但在反编译后的字节码文件(.class)中是可以看得到的。

 
 
 
 
    
  
  
  
  
  1. //
    2. 
  
  
  
  
  2. // Source code recreated from a .class file by IntelliJ IDEA
    3. 
  
  
  
  
  3. // (powered by Fernflower decompiler)
    4. 
  
  
  
  
  4. //
    5. 
  
  
  
  
  5. 
  
  
  
  
  6. package com.itwanger.twentythree;
    7. 
  
  
  
  
  7. 
  
  
  
  
  8. public class Person {
    9. 
  
  
  
  
  9.     private String name;
    10. 
  
  
  
  
  10.     private int age;
    11. 
  
  
  
  
  11.     private int sex;
    12. 
  
  
  
  
  12. 
  
  
  
  
  13.     public Person() {
    14. 
  
  
  
  
  14.     }
    15. 
  
  
  
  
  15. 
  
  
  
  
  16.     private void eat() {
    17. 
  
  
  
  
  17.     }
    18. 
  
  
  
  
  18. 
  
  
  
  
  19.     private void sleep() {
    20. 
  
  
  
  
  20.     }
    21. 
  
  
  
  
  21. 
  
  
  
  
  22.     private void dadoudou() {
    23. 
  
  
  
  
  23.     }
    24. 
  
  
  
  
  24. }
    25.

public Person(){} 就是默认的构造方法，因为是空的构造方法(方法体中没有内容)，所以可以缺省。Java 聪明就聪明在这，有些很死板的代码不需要开发人员添加，它会偷偷地做了。

03、new 一个对象

创建 Java 对象时，需要用到 new 关键字。

Person person = new Person();

这行代码就通过 Person 类创建了一个 Person 对象。所有对象在创建的时候都会在堆内存中分配空间。

创建对象的时候，需要一个 main() 方法作为入口， main() 方法可以在当前类中，也可以在另外一个类中。

第一种：main() 方法直接放在 Person 类中。

 
 
 
 
    
  
  
  
  
  1. public class Person {
    2. 
  
  
  
  
  2.     private String name;
    3. 
  
  
  
  
  3.     private int age;
    4. 
  
  
  
  
  4.     private int sex;
    5. 
  
  
  
  
  5. 
  
  
  
  
  6.     private void eat() {}
    7. 
  
  
  
  
  7.     private void sleep() {}
    8. 
  
  
  
  
  8.     private void dadoudou() {}
    9. 
  
  
  
  
  9. 
  
  
  
  
  10.     public static void main(String[] args) {
    11. 
  
  
  
  
  11.         Person person = new Person();
    12. 
  
  
  
  
  12.         System.out.println(person.name);
    13. 
  
  
  
  
  13.         System.out.println(person.age);
    14. 
  
  
  
  
  14.         System.out.println(person.sex);
    15. 
  
  
  
  
  15.     }
    16. 
  
  
  
  
  16. }
    17.

输出结果如下所示：

 
 
 
 
    
  
  
  
  
  1. null
    2. 
  
  
  
  
  2. 0
    3. 
  
  
  
  
  3. 0
    4.

第二种：main() 方法不在 Person 类中，而在另外一个类中。

实际开发中，我们通常不在当前类中直接创建对象并使用它，而是放在使用对象的类中，比如说上图中的 PersonTest 类。

可以把 PersonTest 类和 Person 类放在两个文件中，也可以放在一个文件(命名为 PersonTest.java)中，就像下面这样。

 
 
 
 
    
  
  
  
  
  1. /**
    2. 
  
  
  
  
  2.  * @author 微信搜「沉默王二」，回复关键字 PDF
    3. 
  
  
  
  
  3.  */
    4. 
  
  
  
  
  4. public class PersonTest {
    5. 
  
  
  
  
  5.     public static void main(String[] args) {
    6. 
  
  
  
  
  6.         Person person = new Person();
    7. 
  
  
  
  
  7.     }
    8. 
  
  
  
  
  8. }
    9. 
  
  
  
  
  9. 
  
  
  
  
  10. class Person {
    11. 
  
  
  
  
  11.     private String name;
    12. 
  
  
  
  
  12.     private int age;
    13. 
  
  
  
  
  13.     private int sex;
    14. 
  
  
  
  
  14. 
  
  
  
  
  15.     private void eat() {}
    16. 
  
  
  
  
  16.     private void sleep() {}
    17. 
  
  
  
  
  17.     private void dadoudou() {}
    18. 
  
  
  
  
  18. }
    19.

04、初始化对象

在之前的例子中，程序输出结果为：

 
 
 
 
    
  
  
  
  
  1. null
    2. 
  
  
  
  
  2. 0
    3. 
  
  
  
  
  3. 0
    4.

为什么会有这样的输出结果呢?因为 Person 对象没有初始化，因此输出了 String 的默认值 null，int 的默认值 0。

那怎么初始化 Person 对象(对字段赋值)呢?

第一种：通过对象的引用变量。

 
 
 
 
    
  
  
  
  
  1. public class Person {
    2. 
  
  
  
  
  2.     private String name;
    3. 
  
  
  
  
  3.     private int age;
    4. 
  
  
  
  
  4.     private int sex;
    5. 
  
  
  
  
  5. 
  
  
  
  
  6.     public static void main(String[] args) {
    7. 
  
  
  
  
  7.         Person person = new Person();
    8. 
  
  
  
  
  8.         person.name = "沉默王二";
    9. 
  
  
  
  
  9.         person.age = 18;
    10. 
  
  
  
  
  10.         person.sex = 1;
    11. 
  
  
  
  
  11.         
    12. 
  
  
  
  
  12.         System.out.println(person.name);
    13. 
  
  
  
  
  13.         System.out.println(person.age);
    14. 
  
  
  
  
  14.         System.out.println(person.sex);
    15. 
  
  
  
  
  15.     }
    16. 
  
  
  
  
  16. }
    17.

person 被称为对象 Person 的引用变量，见下图：

通过对象的引用变量，可以直接对字段进行初始化(person.name = "沉默王二")，所以以上代码输出结果如下所示：

 
 
 
 
    
  
  
  
  
  1. 沉默王二
    2. 
  
  
  
  
  2. 18
    3. 
  
  
  
  
  3. 1
    4.

第二种：通过方法初始化。

 
 
 
 
    
  
  
  
  
  1. /**
    2. 
  
  
  
  
  2.  * @author 沉默王二，一枚有趣的程序员
    3. 
  
  
  
  
  3.  */
    4. 
  
  
  
  
  4. public class Person {
    5. 
  
  
  
  
  5.     private String name;
    6. 
  
  
  
  
  6.     private int age;
    7. 
  
  
  
  
  7.     private int sex;
    8. 
  
  
  
  
  8. 
  
  
  
  
  9.     public void initialize(String n, int a, int s) {
    10. 
  
  
  
  
  10.         name = n;
    11. 
  
  
  
  
  11.         age = a;
    12. 
  
  
  
  
  12.         sex = s;
    13. 
  
  
  
  
  13.     }
    14. 
  
  
  
  
  14. 
  
  
  
  
  15.     public static void main(String[] args) {
    16. 
  
  
  
  
  16.         Person person = new Person();
    17. 
  
  
  
  
  17.         person.initialize("沉默王二",18,1);
    18. 
  
  
  
  
  18. 
  
  
  
  
  19.         System.out.println(person.name);
    20. 
  
  
  
  
  20.         System.out.println(person.age);
    21. 
  
  
  
  
  21.         System.out.println(person.sex);
    22. 
  
  
  
  
  22.     }
    23. 
  
  
  
  
  23. }
    24.

在 Person 类中新增方法 initialize()，然后在新建对象后传参进行初始化(person.initialize("沉默王二", 18, 1))。

第三种：通过构造方法初始化。

 
 
 
 
    
  
  
  
  
  1. /**
    2. 
  
  
  
  
  2.  * @author 沉默王二，一枚有趣的程序员
    3. 
  
  
  
  
  3.  */
    4. 
  
  
  
  
  4. public class Person {
    5. 
  
  
  
  
  5.     private String name;
    6. 
  
  
  
  
  6.     private int age;
    7. 
  
  
  
  
  7.     private int sex;
    8. 
  
  
  
  
  8. 
  
  
  
  
  9.     public Person(String name, int age, int sex) {
    10. 
  
  
  
  
  10.         this.name = name;
    11. 
  
  
  
  
  11.         this.age = age;
    12. 
  
  
  
  
  12.         this.sex = sex;
    13. 
  
  
  
  
  13.     }
    14. 
  
  
  
  
  14. 
  
  
  
  
  15.     public static void main(String[] args) {
    16. 
  
  
  
  
  16.         Person person = new Person("沉默王二", 18, 1);
    17. 
  
  
  
  
  17. 
  
  
  
  
  18.         System.out.println(person.name);
    19. 
  
  
  
  
  19.         System.out.println(person.age);
    20. 
  
  
  
  
  20.         System.out.println(person.sex);
    21. 
  
  
  
  
  21.     }
    22. 
  
  
  
  
  22. }
    23.

这也是最标准的一种做法，直接在 new 的时候把参数传递过去。

补充一点知识，匿名对象。匿名对象意味着没有引用变量，它只能在创建的时候被使用一次。

 
 
 
 
    
  
  
  
  
  1. new Person();
    2.

可以直接通过匿名对象调用方法：

 
 
 
 
    
  
  
  
  
  1. new Person().initialize("沉默王二", 18, 1);
    2.

“好了，三妹，关于 Java 中的对象和类就先说这么多吧。”转动了一下僵硬的脖子后，我对三妹说。

“好的，二哥，你辛苦了，我来给你按摩下。”

本文转载自微信公众号「沉默王二」，可以通过以下二维码关注。转载本文请联系沉默王二公众号。

文章名称：零基础学Java：对象和类
网站URL：http://www.shufengxianlan.com/qtweb/news19/6919.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

软件开发知识

分类信息网站

成都电信服务器托管　　 　德阳定制网站建设　　 　成都画册设计公司　　 　眉山主机托管　　 　邛崃做网站　　 　成都装饰装修　　 　成都网站建设　　 　梦港之夜　　 　内江做网站　　 　成都网站设计　　 　简阳电信机房　　 　营销网站建设　　 　成都添翼二手车　　 　成都app开发公司　　 　成都木托盘　　 　腾讯云香港空间　　 　教育建设方案　　 　成都ssl证书申请　　 　成都恒翔机电维修　　 　温江网站设计