《JavaSE》---10.＜面向对象系列之（类和对象）＞

本篇博客主要讲解Java基础语法中的 面向对象，包括类、实例化对象、构造方法的快捷键、对象的五种初始化方法、对象的打印，快捷的toString方法。 详解： 1.类中一般包含，成员变量（也叫做成员属性、字段）。构造方法，成员方法。 2.new关键字用来实例化一个对象，每个实例化的对象都是独立存在的。 3.对象的初始化有用构造方法初始化（最常用）、默认初始化，本地初始化还有实例化代码块进行初始化、静态代码块进行初始化五种方法 4.对象的打印，快捷的toString方法

大家好，本人是普通一本的在校大学生一枚，目前在学习java。之前也学了一段时间，但是没有发布博客。本人现在已经大二结束了，开学就大三了，时间过的真的很快。我会利用好这个暑假，来复习之前学过的内容，并整理好之前写过的博客进行发布。如果博客中有错误或者没有读懂的地方。热烈欢迎大家在评论区进行讨论！！！ 喜欢我文章的兄弟姐妹们可以点赞，收藏和评论我的文章。喜欢我的兄弟姐妹们以及也想复习一遍java知识的兄弟姐妹们可以关注我呦，我会持续更新滴，并且追求完整。 望支持！！！！！！一起加油呀！！！！

语言只是工具，不能决定你好不好找工作，决定你好不好找工作的是你的能力！！！！！

学历本科及以上就够用了！！！！！！！！！！！！！！！！！！！！！！！！！！！！

一、初识面向对象

1.1什么是面向对象

之前都是在讲基础语法，今天终于到了java重中之重的面向对象系列。

我们都知道Java是一门面向对象的语言，

面向对象是解决问题的一种思想，主要依靠对象之间的交互完成一件事情。

用面向对象的思想来编写程序，不仅符合人们的认知，并且也有利用对程序的设计、扩展、以及维护。

面向对象程序的三大特性：

封装、继承、多态。

1.2 面向过程与面向对象

面向过程：更加注重于用代码解决问题的具体过程。适用于解决那些需要注重过程的问题

面向对象：更加注重于用代码解决问题的结果。适用于解决那些不需要注重问题的过程，只需要 将问题的结果实现就行了。

注意：面向过程与面向对象并不是一门语言，而是解决问题的方法。没有那个好坏之分，都有其专门的应用场景。

二、类的定义与使用

假如大家学过c语言，c语言中的结构体与java中的类和对象有相似之处

2.1认识类

类是用来对一个实体(对象)来进行描述的

主要描述该实体(对象)具有哪些

属性：(外观尺寸等)，哪些 功能：(用来干 啥)，描述完成后计算机就可以识别了

面相对象程序设计关注的是对象，而对象是现实生活中的实体。

对象的产生依赖于类，我们首先要定义一个类，再将类实例化产生对象

class后面的就是类名，我们在设置类名时一般用大驼峰的形式命名：首字母大写

ps： 大驼峰形式命名：所有单词的首字母大写，若是组合单词，每个单词的首字母都需要大写。 （类名） 小驼峰形式命名：第一个单词的首字母小写，其余大写。 （成员方法名）（方法名）

2.2类的定义格式

// 创建类 class ClassName { fifield ; //被称作 字段 ( 属性 ) 或者 成员属性 它是定义在类里面方法的外面 method ; // 行为 或者 成员方法 }

class为Java中定义类的关键字，ClassName为类的名字（自定义），{} 中为类的主体。 类中包含的内容称为 类的成员。 属性主要是用来描述类的，称之为类的成员属性或者类成员变量。 方法主要说明类 具有哪些功能，称为类的成员方法。

大家应该都玩过风车，那么我们把风车具有的属性抽象出来，定义一个WindMill（风车）类。

比如：大风车，在Java 中可以将其看成是一个类。

（成员变量）属性：型号，重量，外观尺寸，颜色 （成员方法）功能：发电。旋转。

话不多说，我们直接上代码。

代码如下（示例）：

class WindMill{
    //成员变量
    public String type; // 类型
    public String color; // 颜色

    //成员方法
    public void generateE(){ // 发电
        System.out.println("发电功能");
    }
    public void rotate(){ // 旋转
        System.out.println("旋转功能");
    }
}

这样我们便定义好了大风车类。

根据这个我们再类似的做个练习：

定义一个学生（Student）类和一个狗（PetDog）类

 class Student{
//成员变量
    public String name;    //学生姓名
    public String gender;  //学生性别
    public short age;      //学生年龄
    public double score;   //学生分数
//成员方法
    public void DoClass(){}     //上课
    public void DoHomework(){}  //做作业
    public void Exam(){}        //考试
}

采用Java语言将大风车类、学生类在计算机中定义完成， 经过javac编译之后形成.class文件，在JVM的基础上计算机就可以识别了。

注意事项：

• 1. 一般一个文件当中只定义一个类
• 2. main方法所在的类一般要使用public修饰(注意：Eclipse默认会在public修饰的类中找main方法)（Eclipse也是一种ide（集成开发环境）和idea一样两个都可以进行java项目开发）
• 3. public修饰的类必须要和文件名相同
• 4. 不要轻易去修改public修饰的类的名称，如果要修改，通过开发工具修改。
• 5.成员属性我们暂统一用public修饰。方便我们使用，当然也可以使用别的。我们慢慢了解
• 6.此处的成员方法不加static关键字，后面会单独出一个static关键字的文章会详细讲到。

2.3类的实例化产生对象

2.3.1什么是实例化

定义了一个类，就相当于在计算机中定义了一种新的类型。

与 int ， double 类似，只不过 int 和 double 是 java 语言自带的内置类型，而类是用户自定义了一个新的类型。

比如上述的：PetDog 类和 Student 类。它们都是类 ( 一种新定 义的类型) 有了这些自定义的类型之后，就可以使用这些类来定义实例 ( 或者称为对象 ) 。

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

2.3.2实例化代码示例

废话不多说。

代码如下（示例）：

假设我们定义了一个狗类，那么实例化它的代码如下

        PetDog dog1 = new PetDog(); 

1.实例化类PetDog相当于一种数据类型（引用类型）。后续我们可以根据这个类型来创建变量。 2.定义了一个变量dog1（虚拟机栈中） 3.这个dog1我们称之为一个引用，它指向了PetDog这个对象。存储着PetDog的地址。 4.PetDog便是我们实例化出来的对象（存储在堆中）

下面是完整代码和输出结果

//创建一个狗类
class PetDog {
//成员变量
    public String name;//名字
    public String color;//颜色
    // 狗的属性

//成员方法
    // 狗的行为
    public void barks() {
        System.out.println(name + ": 旺旺旺~~~");
    }
    public void wag() {
        System.out.println(name + ": 摇尾巴~~~");
    }
}

public class Test {
//在主函数中，我们进行实例化这个类。并对实例化出的类进行使用。
    public static void main(String[] args) {
        PetDog dog1 = new PetDog(); 
//实例化类PetDog相当于一种数据类型（引用类型）。定义了一个变量dog1
//这个dog1我们称之为一个引用，它指向了PetDog这个对象。存储着PetDog的地址。
//PetDog便是我们实例化出来的对象


//对PetDog这个类中的成员变量进行初始化
        dog1.name = "阿忠"; 
        dog1.color = "黑色";
        dog1.barks();
        dog1.wag();
        
//对成员方法进行引用。
        PetDog dog2 = new PetDog();
        dog2.name = "阿花";
        dog2.color = "黄色";
        dog2.barks();
        dog2.wag();
    }
}

输出结果：

阿忠: 旺旺旺~~~ 阿忠: 摇尾巴~~~ 阿花: 旺旺旺~~~ 阿花: 摇尾巴~~~

这样我们就完成了简单的类的创建和类的实例化。

补充：

我们新建的PetDog类型的引用变量dog1和dog2是在栈上开辟的空间存储的，而我们new的对象PetDog是在堆上存储的，而dog1存储了这个对象的地址

如图，左边小矩形我们看作是栈区上的空间，右边大矩形我们看作是堆区的空间

• 每一次new一个对象PetDog都会开辟一块内存，因此每一个对象都是独立存在的。
• 通过new这个关键字可以创建多个对象。有了类才有了对象。
• 通过.点号来访问对象中的属性和方法
• 而方法在方法区放着，方法通过编译之后变成一些指令在方法区放着。

简单总结：

1. 类只是一个模型一样的东西，用来对一个实体进行描述，限定了类有哪些成员.

2. 类是一种自定义的类型，可以用来定义变量.

3. 一个类可以实例化出多个对象，实例化出的对象 占用实际的物理空间，存储类成员变量

4.类就像是房子的设计图， 类实例化出对象就像现实中使用类这个设计图建造出房子，类只设计出需要什么东西，但是并没有实体的建筑存在，实例化出的对象才能实际存储数据，占用物理空间。

三、对象的构造及初始化

其实在上述类的实例化中我们就已经体现了对象的构造与初始化，但是那样的初始化很不方便，因此Java中创建了构造方法来对类中的成员变量进行初始化。

3.1.用构造方法进行初始化（方式一（最常用））

构造方法其实就是一个快捷的方法（函数）。我们将这个快捷的方法（函数）放在类中，方便在main方法中进行使用。

3.1.1构造方法的概念

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

3.1.2构造方法代码示例

构造方法有快捷的创建方式

（只能创建有参数的构造方法，无参数的需要我们自己敲）

快捷1：在这个类当中鼠标右键，点击generate...再点击Construct，之后我们可以选择参数，再点击ok就行了，如果需要选择多个参数，只需要按住Ctrl点击就可以选择多个参数了

快捷2：光标点在这个类当中，按键盘Alt+Insert，再点击Construct，之后与快捷1同理。

而我们创建出来的有参数的构造方法当中为什么是 this.name = name; this.color = color; 我单独会写一个文章来详细谈论这个。现在只需要理解是传入参数后给我们的成员属性赋值就可以了。

代码示例：

//创建一个狗类
class PetDog {
    //成员变量
    public String name;//名字
    public String color;//颜色
    // 狗的属性

    //构造方法，//我们在这里创建了多个构造方法，方便后面的使用。
    public PetDog(){
        System.out.println("构造方法1");
    }
    public PetDog(String name) {
        this.name = name;
        System.out.println("构造方法2");
    }
    public PetDog(String name, String color) {
        this.name = name;
        this.color = color;
        System.out.println("构造方法3");
    }


    //成员方法
    // 狗的行为
    public void barks() {
        System.out.println(name + ": 旺旺旺~~~");
    }
    public void wag() {
        System.out.println(name + ": 摇尾巴~~~");
    }
}

public class Test {
    //在主函数中，我们进行实例化这个类。并对实例化出的类进行使用。
    public static void main(String[] args) {
        PetDog dog1 = new PetDog();//其实在这里我们就可以说是调用了构造方法
        dog1.barks();//之前我们并没有创建构造方法，但是依然这样写并没有报错，是因为如果没有，编译器会给你创建一个没有参数也不做任何行为的构造方法，是隐藏的，你看不到，因此可以顺利通过编译。
        dog1.wag();

        PetDog dog2 = new PetDog("阿忠");
        dog2.barks();
        dog2.wag();

        PetDog dog3 = new PetDog("阿花","黄色"); 
  //有了构造方法之后，我们在对象的创建之时就可以对成员变量进行初始化
  //dog3便是我们创建的对象，并顺便进行了初始化
        System.out.println("颜色："+dog3.color);
        dog3.barks();
        dog3.wag();
    }
}

输出结果：

构造方法1 null: 旺旺旺~~~ null: 摇尾巴~~~ 构造方法2 阿忠: 旺旺旺~~~ 阿忠: 摇尾巴~~~ 构造方法3

颜色：黄色 阿花: 旺旺旺~~~ 阿花: 摇尾巴~~~

阐释：

(1)、构造方法1：我们看到第一个没有参数的构造方法，我只让它输出了构造方法1这句话。接下来我们调用了成员方法，但是由于我们并没有对名字进行初始化，在没有初始化的成员变量中，Java默认这个字符串类型的变量的值是null，因此name打印出来的结果就是null (2)、构造方法2：我们传入了阿忠这个名字，因此编译器自动匹配到构造方法2，对name进行赋值为阿忠，并打印出了构造方法2，也成功的调用了成员方法。打印出阿忠: 旺旺旺~~~ 阿忠: 摇尾巴~~~ (3)、构造方法3：我们传入了阿花和黄色这个两个参数，因此编译器自动匹配到构造方法3，对name进行赋值为阿花，对color赋值为黄色，并打印出了构造方法3，和颜色：黄色。也成功的调用了成员方法，打印出阿花: 旺旺旺~~~阿花: 摇尾巴~~~

方法的重载

我们看到我们创建的三个构造方法在同一个类中

方法名相同，参数列表不同，这就构成了方法的重载。

方法的重载的条件

1. 方法名必须相同

2. 参数列表必须不同 ( 参数的个数不同、参数的类型不同、类型的次序必须不同 )

3. 与返回值类型是否相同无关

4.根据你传入的参数，编译器会自动匹配到某一个方法。

上述三个构造方法：名字相同，参数列表不同，因此构成了方法重载

3.1.3构造方法的特点

1. 方法 名字必须与类名相同

2. 没有返回值类型，设置为 void 也不行

3. 创建对象时由编译器自动调用，并且在对象的生命周期内只调用一次

4. 构造方法可以重载 ( 用户根据自己的需求提供不同参数的构造方法 )

5. 如果用户没有自己构造方法定义，编译器会生成一份默认的构造方法，生成的默认构造方法是无参的。

注意：一旦用户定义其他构造方法，编译器则不再生成这个无参的构造方法。

6. 构造方法中，可以通过 this 调用其他构造方法来简化代码（在后面this和super文章中讲到）

7.绝大多数情况用public修饰，特殊场景用private修饰，如封装情况下。

3.2.对象的默认初始化（方式二（用的很少））

我们知道在 Java 方法内部定义一个局部变量时，必须要初始化，否则会编译失败。而全局变量可以不用初始化也可以通过编译。

对象的成员属性，在没有赋值的时候，会进行默认初始化。（用的很少）

引用类型：默认值为null 基本数据类型：默认值是对应的0值

数据类型 默认值

byte 0

char '\u0000'

short 0

int 0

long 0L

boolean false

flfloat 0.0f

double 0.0

(引用类型) null

3.3对象的就地初始化（方式三）

就是在创建类的时候，在定义成员属性（成员变量）的时候直接进行赋值。

注意：编译完代码成后，编译器会将所有给成员初始化的这些语句添加到各个构造方法中。（这个大家理解不理解问题不大就是字面意思。）

class PetDog {//在类中成员变量定义时，就直接给予初始值。
    //成员变量
    public String name = "阿七";//名字
    public String color = "黄色";//颜色
    public int age = 20;   //年龄
    // 狗的属性

    //构造方法，//我们在这里创建了多个构造方法，方便后面的使用。
    public PetDog(){
        this("阿花","花色",25);
        System.out.println("构造方法1");

    }


    public PetDog(String name, String color, int age) {
        this.name = name;
        this.color = color;
        this.age = age;
        System.out.println("构造方法2");
    }

    //成员方法
    // 狗的行为
    public void barks() {
        System.out.println(this.name + ": 旺旺旺~~~");
    }
    public void wag() {
        this.barks();
        System.out.println(this.name + ": 摇尾巴~~~");
    }
}

public class Test {
    //在主函数中，我们进行实例化这个类。并对实例化出的类进行使用。
    public static void main(String[] args) {
        PetDog dog1 = new PetDog();
        System.out.println("姓名：" + dog1.name);
        System.out.println("颜色：" + dog1.color);
        System.out.println("年龄：" + dog1.age);
        dog1.wag();
    }
}

输出结果：

构造方法2 构造方法1 姓名：阿花 颜色：花色 年龄：25 阿花: 旺旺旺~~~ 阿花: 摇尾巴~~~

我们发现输出的并不是初始值，这是因为我们又用构造方法重新赋值了。若进行就地初始化之后我们没有再通过构造方法进行初始化，那么输出的值就是本地初始化的值。

3.4对象的其他初始化方式（方式四和方式五）

3.4.1用实例化代码块进行初始化

3.4.2用静态代码块进行初始化

这两种初始化方式我们放在

《JavaSE》------面向对象系列之（static关键字）之中进行讲解。到时候我们也会更加深入的去了解类和对象。

不久就会更新的。

四、对象的打印（toString方法）

之前我们写代码总是会写类似

这样的代码来输出我们的成员变量。

为了方便我们打印对象中的成员变量。Java中提供了toString快捷方法，当我们定义好成员变量之后就可以快捷的创建出这个函数来供我们打印使用。

4.1在类中快捷生成toString方法

对象打印toString方法的快捷键：

快捷1：在这个类当中鼠标右键，点击generate...再点toString()之后我们可以选择成员变量，再点击ok就行了，如果需要打印多个成员变量，只需要按住Ctrl点击就可以选择多个成员变量就可以了

快捷2：光标点在这个类当中，按键盘Alt+Insert，再点击toString()，之后与快捷1同理。

4.2在main方法中输出成员变量

由于这个打印对象的方法也是依赖于对象的。需要我们new一个对象 再用printfln打印出对象的引用变量，我们就可以输出toString方法中的return的东西了。 为什么会这样这涉及到了继承，多态，方法的重写。会了这些大家就明白原理了

我们下面的代码不只是单纯有快捷toString的使用，还有涉及到了封装的知识，就当是预习了，不会封装的小伙伴也不用慌。不看封装。只看toString的知识也是可以看懂的

代码示例：

class PetDog {
    //成员变量
    private String name;//名字
    private String color;//颜色
    private int age;   //年龄
    // 狗的属性

//为封装的成员变量提供初始化
    public void setName(String name) {
        this.name = name;
    }
    public void setColor(String color) {
        this.color = color;
    }
    public void setAge(int age) {
        this.age = age;
    }

//这是我们快捷生成的toString方法
    @Override
    public String toString() {
        return "PetDog{" +
                "name='" + name + '\'' +
                ", color='" + color + '\'' +
                ", age=" + age +
                '}';
    }
}

public class Test {
    //在主函数中，我们进行实例化这个类。并对实例化出的类进行使用。
    public static void main(String[] args) {
        PetDog dog1 = new PetDog();//实例化出一个对象
        dog1.setName("阿绿");
        dog1.setColor("绿色");//为封装的成员变量赋值
        dog1.setAge(15);
        System.out.println(dog1);//由这个我们可以转字符串来输出成员变量
    }
}

输出结果：

PetDog{name='阿绿', color='绿色', age=15}

总结

1.类中一般包含，成员变量（也叫做成员属性、字段）。构造方法，成员方法。

2.new关键字用来实例化一个对象，每个实例化的对象都是独立存在的。

3.对象的初始化有用构造方法初始化（最常用）、默认初始化，本地初始化还有实例化代码块进行初始化、静态代码块进行初始化五种方法

4.对象的打印，快捷的toString方法