标签：name 对象 创建 void Person int 使用 我们

@

目录

• 面向对象基础篇
  • 类与对象
    • 类的定义与对象创建
    • 对象的使用
    • 方法创建与使用
    • 方法进阶使用
    • 构造方法

---

源码：
Gitee https://gitee.com/drip123456/java-se
GIthub https://github.com/Drip123456/JavaSE

专栏： JavaSE笔记专栏

面向对象基础篇

我们在前面已经学习了面向过程编程，也可以自行编写出简单的程序了。我们接着就需要认识 面向对象程序设计（Object Oriented Programming）它是我们在Java语言中要学习的重要内容，面向对象也是高级语言的一大重要特性。

面向对象是新手成长的一道分水岭，有的人秒懂，有的人直到最后都无法理解。

这一章开始难度就上来了，所以说请各位小伙伴一定认真。

类与对象

类的概念我们在生活中其实已经听说过很多了。

人类、鸟类、鱼类... 所谓类，就是对一类事物的描述，是抽象的、概念上的定义，比如鸟类，就泛指所有具有鸟类特征的动物。比如人类，不同的人，有着不同的性格、不同的爱好、不同的样貌等等，但是他们根本上都是人，所以说可以将他们抽象描述为人类。

对象是某一类事物实际存在的每个个体，因而也被称为实例（instance）我们每个人都是人类的一个实际存在的个体。

所以说，类就是抽象概念的人，而对象，就是具体的某一个人。

• A：是谁拿走了我的手机？
• B：是个人。（某一个类）
• A：我还知道是个人呢，具体是谁呢？
• B：是XXX。（具体某个对象）

而我们在Java中，也可以像这样进行编程，我们可以定义一个类，然后进一步创建许多这个类的实例对象。像这种编程方式，我们称为面向对象编程。

类的定义与对象创建

前面我们介绍了什么是类，什么是对象，首先我们就来看看如何去定义一个类。

比如现在我们想要定义一个人类，我们可以右键src目录，点击创建新的类：

我们在对类进行命名时，一般使用英文单词，并且首字母大写，跟变量命名一样，不能出现任何的特殊字符。

可以看到，现在我们的目录下有了两个.java源文件，其中一个是默认创建的Main.java，还有一个是我们刚刚创建的类。

我们来看看创建好之后，一个类写了哪些内容：

public class Person {
    
}

可以发现，这不是跟一开始创建的Main中写的格式一模一样吗？没错，Main也是一个类，只不过我们一直都将其当做主类在使用，也就是编写主方法的类，关于方法我们会在后面进行介绍。

现在我们就创建好了一个类，既然是人类，那么肯定有人相关的一些属性，比如名字、性别、年龄等等，那么怎么才能给这个类添加一些属性呢？

我们可以将这些属性直接作为类的成员变量（成员变量相当于是这个类所具有的属性，每个实例创建出来之后，这些属性都可能会各不相同）定义到类中。

public class Person {   //这里定义的人类具有三个属性，名字、年龄、性别
    String name;   //直接在类中定义变量，表示类具有的属性
    int age;
    String sex;
}

可能会有小伙伴疑问，这些变量啥时候被赋值呢？实际上这些变量只有在一个具体的对象中才可以使用。

那么现在人类的属性都规定好了，我们就可以尝试创建一个实例对象了，实例对应的应该是一个具体的人：

new 类名();

public static void main(String[] args) {
    new Person();   //我们可以使用new关键字来创建某个类的对象，注意new后面需要跟上 类名()
  	//这里创建出来的，就是一个具体的人了
}

实际上整个流程为：

只不过这里仅仅是创建出了这样的一个对象，我们目前没有办法去操作这个对象，比如想要修改或是获取这个人的名字等等。

对象的使用

既然现在我们知道如何创建对象，那么我们怎么去访问这个对象呢，比如我现在想要去查看或是修改它的名字。

我们同样可以使用一个变量来指代某个对象，只不过引用类型的变量，存储的是对象的引用，而不是对象本身：

public static void main(String[] args) {
  	//这里的a存放的是具体的某个值
  	int a = 10;
  	//创建一个变量指代我们刚刚创建好的对象，变量的类型就是对应的类名
  	//这里的p存放的是对象的引用，而不是本体，我们可以通过对象的引用来间接操作对象
    Person p = new Person();
}

至于为什么对象类型的变量存放的是对象的引用，比如：

public static void main(String[] args) {
    Person p1 = new Person();
    Person p2 = p1;
}

这里，我们将变量p2赋值为p1的值，那么实际上只是传递了对象的引用，而不是对象本身的复制，这跟我们前面的基本数据类型有些不同，p2和p1都指向的是同一个对象（如果你学习过C语言，它就类似于指针一样的存在）

我们可以来测试一下：

public static void main(String[] args) {
    Person p1 = new Person();
    Person p2 = p1;
    System.out.println(p1 == p2);    //使用 == 可以判断两个变量引用的是不是同一个对象
}

但是如果我们像这样去编写：

public static void main(String[] args) {
    Person p1 = new Person();   //这两个变量分别引用的是不同的两个对象
    Person p2 = new Person();
    System.out.println(p1 == p2);   //如果两个变量存放的是不同对象的引用，那么肯定就是不一样的了
}

实际上我们之前使用的String类型，也是一个引用类型，我们会在下一章详细讨论。我们在上一章介绍的都是基本类型，而类使用的都是引用类型。

现在我们有了对象的引用之后，我们就可以进行操作了：

我们可以直接访问对象的一些属性，也就是我们在类中定义好的那些，对于不同的对象，这些属性都具体存放值也会不同。

比如我们可以修改对象的名字：

public static void main(String[] args) {
    Person p = new Person();
    p.name = "小明";   //要访问对象的属性，我们需要使用 . 运算符
    System.out.println(p.name);   //直接打印对象的名字，就是我们刚刚修改好的结果了
}

注意，不同对象的属性是分开独立存放的，每个对象都有一个自己的空间，修改一个对象的属性并不会影响到其他对象：

public static void main(String[] args) {
    Person p1 = new Person();
    Person p2 = new Person();
    p1.name = "小明";   //这个修改的是第一个对象的属性
    p2.name = "大明";   //这里修改的是第二个对象的属性
    System.out.println(p1.name);  //这里我们获取的是第一个对象的属性
}

关于对象类型的变量，我们也可以不对任何对象进行引用：

public static void main(String[] args) {
    Person p1 = null;  //null是一个特殊的值，它表示空，也就是不引用任何的对象
}

注意，如果不引用任何的对象，那肯定是不应该去通过这个变量去操作所引用的对象的（都没有引用对象，我操作谁啊我）

虽然这样可以编译通过，但是在运行时会出现问题：

public static void main(String[] args) {
    Person p = null;   //此时变量没有引用任何对象
    p.name = "小红";   //我任性，就是要操作
    System.out.println(p.name);
}

我们来尝试运行一下这段代码：

此时程序在运行的过程中，出现了异常，虽然我们还没有学习到异常，但是各位可以将异常理解为程序在运行过程中出现了问题，此时不得不终止程序退出。

这里出现的是空指针异常，很明显是因为我们去操作一个值为null的变量导致的。在我们以后的学习中，这个异常是出现频率最高的。

我们来看最后一个问题，对象创建成功之后，它的属性没有进行赋值，但是我们前面说了，变量使用之前需要先赋值，那么创建对象之后能否直接访问呢？

public static void main(String[] args) {
    Person p = new Person();
    System.out.println("name = "+p.name);
    System.out.println("age = "+p.age);
    System.out.println("sex = "+p.sex);
}

我们来看看运行结果：

我们可以看到，如果直接创建对象，那么对象的属性都会存在初始值，如果是基本类型，那么默认是统一为0（如果是boolean的话，默认值为false）如果是引用类型，那么默认是null。

方法创建与使用

前面我们介绍了类的定义以及对象的创建和使用。

现在我们的类有了属性，我们可以为创建的这些对象设定不同的属性值，比如每个人的名字都不一样，性别不一样，年龄不一样等等。只不过光有属性还不行，对象还需要具有一定的行为，就像我们人可以行走，可以跳跃，可以思考一样。

而对象也可以做出一些行为，我们可以通过定义方法来实现（在C语言中叫做函数）

方法是语句的集合，是为了完成某件事情而存在的。完成某件事情，可以有结果，也可以做了就做了，不返回结果。比如计算两个数字的和，我们需要得到计算后的结果，所以说方法需要有返回值；又比如，我们只想吧数字打印在控制台，只需要打印就行，不用给我结果，所以说方法不需要有返回值。

方法的定义如下：

返回值类型 方法名称() {
		方法体...
}

首先是返回值类型，也就是说这个方法完成任务之后，得到的结果的数据类型（可以是基本类型，也可以是引用类型）当然，如果没有返回值，只是完成任务，那么可以使用void表示没有返回值，比如我们现在给人类编写一个自我介绍的行为：

public class Person {
    String name;
    int age;
    String sex;

  	//自我介绍只需要完成就行，没有返回值，所以说使用void
    void hello(){
      	//完成自我介绍需要执行的所有代码就在这个花括号中编写
      	//这里编写代码跟我们之前在main中是一样的（实际上main就是一个函数）
      	//自我介绍需要用到当前对象的名字和年龄，我们直接使用成员变量即可，变量的值就是当前对象的存放值
        System.out.println("我叫 "+name+" 今年 "+age+" 岁了！");
    }
}

注意，方法名称同样可以随便起，但是规则跟变量的命名差不多，也是尽量使用小写字母开头的单词，如果是多个单词，一般使用驼峰命名法最规范。

现在我们给人类定义好了一个方法（行为）那么怎么才能让对象执行这个行为呢？

public static void main(String[] args) {
    Person p = new Person();
    p.name = "小明";
    p.age = 18;
    p.hello();    //我们只需要使用 . 运算符，就可以执行定义好的方法了，只需要 .方法名称() 即可
}

像这样执行定义好的方法，我们一般称为方法的调用，我们来看看效果：

比如现在我们要让人类学会加法运算，我们也可以通过定义一个方法的形式来完成，只不过，要完成加法运算，我们需要别人给人类提供两个参与加法运算的值才可以，所以我们这里就要用到参数了：

//我们的方法需要别人提供参与运算的值才可以
//我们可以为方法设定参数，在调用方法时，需要外部传入参数才可以
//参数的定义需要在小括号内部编写，类似于变量定义，需要填写 类型和参数名称，多个参数用逗号隔开
int sum(int a, int b){   //这里需要两个int类型的参数进行计算

}

那么现在参数从外部传入之后，我们怎么使用呢？

int sum(int a, int b){   //这里的参数，相当于我们在函数中定义了两个局部变量，我们可以直接在方法中使用
    int c = a + b;   //直接c = a + b
}

那么现在计算完成了，我们该怎么将结果传递到外面呢？首先函数的返回值是int类型，我们只需要使用return关键字来返回一个int类型的结果就可以了：

int sum(int a, int b){
    int c = a + b;
    return c;   //return后面紧跟需要返回的结果，这样就可以将计算结果丢出去了
  	//带返回值的方法，是一定要有一个返回结果的！否则无法通过编译！
}

我们来测试一下吧：

public static void main(String[] args) {
    Person p = new Person();
    p.name = "小明";
    p.age = 18;
    int result = p.sum(10, 20);    //现在我们要让这个对象帮我们计算10 + 20的结果
    System.out.println(result);    //成功得到30，实际上这里的println也是在调用方法进行打印操作
}

注意：方法定义时编写的参数，我们一般称为形式参数，而调用方法实际传入的参数，我们成为实际参数。

是不是越来越感觉我们真的在跟一个对象进行交互？只要各位有了这样的体验，基本上就已经摸到面向对象的门路了。

关于return关键字，我们还需要进行进一步的介绍。

在我们使用return关键字之后，方法就会直接结束并返回结果，所以说在这之后编写的任何代码，都是不可到达的：

在return后编写代码，会导致编译不通过，因为存在不可达语句。

如果我们的程序中出现了分支语句，那么必须保证每一个分支都有返回值才可以：

只要有任何一个分支缺少了return语句，都无法正常通过编译，总之就是必须考虑到所有的情况，任何情况下都必须要有返回值。

当然，如果方法没有返回值，我们也可以使用return语句，不需要跟上任何内容，只不过这种情况下使用，仅仅是为了快速结束方法的执行：

void test(int a){
    if(a == 10) return;    //当a等于10时直接结束方法，后面无论有没有代码都不会执行了
    System.out.println("Hello World!");   //不是的情况就正常执行
}

最后我们来讨论一下参数的传递问题：

void test(int a){   //我们可以设置参数来让外部的数据传入到函数内部
    System.out.println(a);
}

实际上参数的传递，会在调用方法的时候，对参数的值进行复制，方法中的参数变量，不是我们传入的变量本身，我们来下面的这个例子：

void swap(int a, int b){   //这个函数的目的很明显，就是为了交换a和b的值
    int tmp = a;
    a = b;
    b = a;
}

那么我们来测试一下：

public static void main(String[] args) {
    Person p = new Person();
    int a = 5, b = 9;   //外面也叫a和b
    p.swap(a, b);
    System.out.println("a = "+a+", b = "+b);   //最后的结果会变成什么样子呢？
}

我们来看看结果是什么：

我们发现a和b的值并没有发生交换，但是按照我们的方法逻辑来说，应该是会交换才对，这是为什么呢？实际上这里仅仅是将值复制给了函数里面的变量而已（相当于是变量的赋值）

所以说我们交换的仅仅是方法中的a和b，参数传递仅仅是值传递，我们是没有办法直接操作到外面的a和b的。

那么各位小伙伴看看下面的例子：

void modify(Person person){
    person.name = "lbwnb";   //修改对象的名称
}

public static void main(String[] args) {
    Person p = new Person();
    p.name = "小明";     //先在外面修改一次
    p.modify(p);        //调用方法再修改一次
    System.out.println(p.name);    //请问最后name会是什么？
}

我们来看看结果：

不对啊，前面不是说只是值传递吗，怎么这里又可以修改成功呢？

确实，这里同样是进行的值传递，只不过各位小伙伴别忘了，我们前面可是说的清清楚楚，引用类型的变量，仅仅存放的是对象的引用，而不是对象本身。那么这里进行了值传递，相当于将对象的引用复制到了方法内部的变量中，而这个内部的变量，依然是引用的同一个对象，所以说这里在方法内操作，相当于直接操作外面的定义对象。

方法进阶使用

有时候我们的方法中可能会出现一些与成员变量重名的变量：

//我们希望使用这个方法，来为当前对象设定名字
void setName(String name) {
   
}

此时类中定义的变量名称也是name，那么我们是否可以这样编写呢：

void setName(String name) {
    name = name;    //出现重名时，优先使用作用域最接近的，这里实际上是将方法参数的局部变量name赋值为本身
}

我们来测试一下：

public static void main(String[] args) {
    Person p = new Person();
    p.setName("小明");
    System.out.println(p.name);
}

我们发现，似乎这样做并没有任何的效果，name依然是没有修改的状态。那么当出现重名的时候，因为默认情况下会优先使用作用域最近的变量，我们怎么才能表示要使用的变量是类的成员变量呢？

Person p = new Person();
p.name = "小明";    //我们之前在外面使用时，可以直接通过对象.属性的形式访问到

同样的，我们如果想要在方法中访问到当前对象的属性，那么可以使用this关键字，来明确表示当前类的示例对象本身：

void setName(String name) {
    this.name = name;   //让当前对象的name变量值等于参数传入的值
}

这样就可以修改成功了，当然，如果方法内没有变量出现重名的情况，那么默认情况下可以不使用this关键字来明确表示当前对象：

String getName() {
    return name;    //这里没有使用this，但是当前作用域下只有对象属性的name变量，所以说直接就使用了
}

我们接着来看方法的重载。

有些时候，参数类型可能会多种多样，我们的方法需要能够同时应对多种情况：

int sum(int a, int b){
    return a + b;
}

public static void main(String[] args) {
    Person p = new Person();
    System.out.println(p.sum(10, 20));    //这里可以正常计算两个整数的和
}

但是要是我们现在不仅要让人类会计算整数，还要会计算小数呢？

当我们使用小数时，可以看到，参数要求的是int类型，那么肯定会出现错误，这个方法只能用于计算整数。此时，为了让这个方法支持使用小数进行计算，我们可以将这个方法进行重载。

一个类中可以包含多个同名的方法，但是需要的形式参数不一样，方法的返回类型，可以相同，也可以不同，但是仅返回类型不同，是不允许的！

int sum(int a, int b){
    return a + b;
}

double sum(double a, double b){    //为了支持小数加法，我们可以进行一次重载
    return a + b;
}

这样就可以正常使用了：

public static void main(String[] args) {
    Person p = new Person();
  	//当方法出现多个重载的情况，在调用时会自动进行匹配，选择合适的方法进行调用
    System.out.println(p.sum(1.5, 2.2));
}

包括我们之前一直在使用的println方法，其实也是重载了很多次的，因为要支持各种值的打印。

注意，如果仅仅是返回值的不同，是不支持重载的：

当然，方法之间是可以相互调用的：

void test(){
    System.out.println("我是test");   //实际上这里也是调用另一个方法
}

void say(){
    test();   //在一个方法内调用另一个方法
}

如果我们这样写的话：

void test(){
    say();
}

void say(){
    test();
}

各位猜猜看会出现什么情况？
会导致栈溢出异常，这里大家不用细想，之后我们会在异常一章列讲解

此时又出现了一个我们不认识的异常，实际上什么原因导致的我们自己都很清楚，方法之间一直在相互调用，没有一个出口。

方法自己也可以调用自己：

void test(){
    test();
}

像这样自己调用自己的行为，我们称为递归调用，如果直接这样编写，会跟上面一样，出现栈溢出错误。但是如果我们给其合理地设置出口，就不会出现这种问题，比如我们想要计算从1加到n的和：

int test(int n){
    if(n == 0) return 0;
    return test(n - 1) + n;    //返回的结果是下一层返回的结果+当前这一层的n
}

是不是感觉很巧妙？实际上递归调用在很多情况下能够快速解决一些很麻烦的问题，我们会在后面继续了解。

构造方法

我们接着来看一种比较特殊的方法，构造方法。

我们前面创建对象，都是直接使用new关键字就能直接搞定了，但是我们发现，对象在创建之后，各种属性都是默认值，那么能否实现在对象创建时就为其指定名字、年龄、性别呢？要在对象创建时进行处理，我们可以使用构造方法（构造器）来完成。

实际上每个类都有一个默认的构造方法，我们可以来看看反编译的结果：

public class Person {
    String name;
    int age;
    String sex;

    public Person() {    //反编译中，多出来了这样一个方法，这其实就是构造方法
    }
}

构造方法不需要填写返回值，并且方法名称与类名相同，默认情况下每个类都会自带一个没有任何参数的无参构造方法（只是不用我们去写，编译出来就自带）当然，我们也可以手动声明，对其进行修改：

标签：name,对象,创建,void,Person,int,使用,我们
From： https://www.cnblogs.com/drip3775/p/18042142