面向对象 - 方法、值传递、构造器

什么是面向对象

狂神说Java BV12J41137hu

面向过程思想：
- 步骤清晰简单--第一步做什么，第二步做什么...
- 面对过程适合处理一些较为简单的问题
面向对象思想：

（属性 + 方法）
- 分析的思维模式，首先将问题归类，然后解决分类下的问题
- 适合处理复杂问题，适合处理需要多人协作的问题

对于描述复杂的事物，为了从宏观上把握、从整体上合理分析，我们需要使用面向对象的思路来分析整个系统。但是，具体到微观操作，仍然需要面向过程的思路去处理。

面向对象编程（Object-Oriented Programming, OOP）

面向对象编程的本质就是：以类的方式组织代码，以对象的形式组织（封装）数据。

抽象

三大特性：

封装
继承
多态

方法的调用

静态方法

当在类MyClass中声明方法使用了静态方法

public static 返回值类型 func (参数) {}

则在调用这个func时，可以使用 MyClass.func(参数); 调用这个方法

这个过程在同一个包（package）中不需要任何引用语句，直接调用即可

非静态方法

而使用非静态方法声明func时，引用这一方法的前提是实例化方法所在对象MyClass

public 返回值类型 func (参数) {}

引用func这一方法

法一

new MyClass.func(参数);

法二


MyClass 对象名字 = new MyClass();

对象名字.func(参数);

特殊情况

当方法 funcA 和 funcB 都是非静态方法时，互相之间是可以调用的

public void funcA(){
    funcB();
}
public void funcB(){
    
}

有static修饰符，表示这个方法是和类一起加载的，

没有则表示，这个方法是类实例化之后才存在的

因而方法之间互相调用要注意是否静态。

值传递和引用传递

值传递（Pass By Value）

本人在认识方法中简单讨论过

package oop.exercise;

public class PassByValue {
    public static void main(String[] args) {
        int a = 1;
        System.out.println("原始值：\t" + a);
        PassByValue.changeNumber(a);
        System.out.println("经过值传递后的值：\t" + a);

    }
    public static void changeNumber(int inputNumber) {
        inputNumber = 10;
    }
}
//原始值：	1
//经过值传递后的值：	1

引用传递（Pass By Reference）

package oop.exercise;

public class PassByReference {
    public static void main(String[] args) {
        Person person = new Person();
        System.out.println("初始person.name");
        System.out.println(person.name);
        PassByReference.changeName(person);
        System.out.println("引用传递后的person.name");
        System.out.println(person.name);
    }
    public static void changeName(Person person) {
        person.name = "ChenRui_Sigma";
    }
}

class Person{
    String name; // 默认值 null
}
//初始person.name
//null
//引用传递后的person.name
//ChenRui_Sigma
//
//Process finished with exit code 0

小结

当传递的是基本数据类型时，值传递不修改原变量的数值（Java木得全局变量的概念）

当传递的是对象的时候，引用传递会直接修改原对象的属性（直接操作传入对象的情况下）

类与对象的

二者的关系

类是一种抽象的数据类型，它是对某一类事物整体描述/定义，但是并不能代表某一个具体的事物（类是对象的模板）；
对象是抽象概念的具体实例。

创建与初始化对象

使用new关键字创建对象

创建的时候除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及对类中构造器的调用

MyStudentClass.java

package oop.app;

public class MyStudentClass {
    String name;
    int age;
    public void study() {
        System.out.println(this.name + "正在学习");
    }
}

Application.java

package oop.app;

// 一个项目应该只存在一个 main() 方法
public class Application {
    public static void main(String[] args) {
        MyStudentClass juniorMing = new MyStudentClass();
        System.out.println("名\t" + juniorMing.name
                + ",\t年龄\t" + juniorMing.age);
        juniorMing.name = "小明";
        juniorMing.age = 13;
        System.out.println("名\t" + juniorMing.name
                + ",\t年龄\t" + juniorMing.age);
        MyStudentClass juniorHong = new MyStudentClass();
        System.out.println("名\t" + juniorHong.name
                + ",\t年龄\t" + juniorHong.age);
        juniorHong.name = "小红";
        juniorHong.age = 12;
        System.out.println("名\t" + juniorHong.name
                + ",\t年龄\t" + juniorHong.age);
    }
}
//名	null,	年龄	0
//名	小明,	年龄	13
//名	null,	年龄	0
//名	小红,	年龄	12
//
//Process finished with exit code 0

构造器

构造器必须要掌握

一个空的 MyPersonClass 和其源码

MyPersonClass.java

package oop.app;

public class MyPersonClass {

}

MyPersonClass.class

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//

package oop.app;

public class MyPersonClass {
    public MyPersonClass() { // 构造器， 有参无参均可
    }
}

一个类即使什么都不写，也会存在一个构造方法，特点：

必须和类的名字相同；
必须没有返回类型，也不能写void；
有无传递参数均可

使用 new 关键字创建对象，本质是在调用构造器

构造器用来初始化值

当希望new 对象的时候即可以不传递参数，也可以选择传递参数时，无参构造器必须要声明出来，也就是代码里有两个构造器，一个无参，一个有参