简单学懂面向对象

什么是面向对象？

不不不，不是说你那个薛定谔的对象。你可以把它看成是一种思维方式。

既然提到了面向对象，那就一定要说一下面向过程，代表语言就是我们的c语言。

面向对象与面向过程的区别

如果你要烧一壶水，想一下，这是怎样一个过程：

1. 打开水壶盖子
2. 打开水龙头接水
3. 关闭水壶盖子
4. 打开燃气灶烧水

如果你按照这样一个过程去思考，那么恭喜你，你已经具备面向过程的思想。

但是如何用面向对象的思想去烧这壶水呢：

首先我们要将对象分为水壶、水龙头、燃气灶

然后每个对象要提供与操作有关的方法，我们通过 “ 对象 . 操作方法 ” 来代表这一步的操作。

水壶.打开壶盖
水龙头.开闸放水
水壶.接水
水龙头.关闭闸门
水壶.关闭壶盖
燃气灶.打开

如果你已经看明白了上面的内容，那么恭喜你，你已经学会了面向对象。

如果你还没有Java基础，那么希望你先补充一下相关知识，如果你已经有了，那么就继续跟着我来吧。

类和对象

什么是类？什么是对象

类其实就是对象的抽象。

我们可以将每一个类都放到一个对象里，像上面那样调用类中的属性和方法

class Dog{
    int age;
    int weight;
    int height;

    public void printinfo(){
        System.out.println(age);
        System.out.println(weight);
        System.out.println(height);
    }
}

如同以上代码所示，Dog就是一个类，而printinfo就是Dog类中的方法，其他诸如age、weight等都是Dog的属性

那么我们调用的时候就可以这样调用

 Dog dog = new Dog();
 dog.printinfo();
 

是不是和我们上面提到的“ 水壶 . 打开壶盖” 一样呢？没错，这就是在调用对象的方法。

那上面那个 “ Dog dog = new Dog(); ” 是干什么呢？其实就是将类放到对象里，这个过程叫做实例化。

new的意思就是将类中的东西统统打包放到对象里。方便我们通过对象调用类中的属性和方法。

类的语法结构

类是有着语法结构的

修饰符 类名{

    修饰符 类型 属性；

    修饰符 [返回值类型] 方法([参数列表……]){
        [return 值]
    }
}

public class Dog{
    //public是修饰符;Dog是类名

    //属性
    int age;
    int weight;
    int height;

    //方法
    public void printinfo(){
        System.out.println(age);
        System.out.println(weight);
        System.out.println(height);
    }
}

注意，[ ]中的内容是可选的

写在类中的属性是全局变量,可以在类中使用。

构造方法

构造方法与类的初始化相关，我们在实例化对象的过程中实际上就是在调用类的构造方法

Dog dog = new Dog();
//其中new后面的 Dog() 就是在调用构造方法

构造方法需要注意一下几点：

1. 构造方法名需要与类名一致
2. 构造方法没有返回值
3. 类中会默认为我们提供一个没有参数的构造方法
4. 如果我们自己写了一个构造方法，类将不再为我们提供默认的构造方法

class Dog{

    int age;
    int weight;
    int height;
    
    public Dog(){
        System.out.println("无参构造方法");
    }
    
    public Dog(int age){
        System.out.println("含参构造方法");
    }
}

基于上面第四条，如果我们自己写了一个有参构造方法，再想调用无参构造方法就不行了

因为类已经不再为我们提供默认的无参构造方法，而是需要我们自己写

创建对象和调用类中的内容

刚才已经提到了new可以创建一个新的对象

        Dog dog = new Dog();
        //类名 对象名 = new 构造方法（）；

而创建对象就是通过new一个类的构造方法来构建的

如果你有定义一个含参的构造方法，你还可以通过这种方式向对象赋值，只需要在构造方法中接收一下就好了

public class test101 {
    public static void main(String[] args) {
        Dog dog = new Dog(5);
        dog.printinfo();
    }

}

class Dog{

    int age;
    int weight;
    int height;

    public Dog(){
        System.out.println("无参构造方法");
    }

    public Dog(int age1){
        System.out.println("含参构造方法");
        age = age1;
    }
}

就像上面代码中写的那样，调用一个对象的属性和方法可以通过

对象名.属性
对象名.方法

这种方式来调用，可以直接使用类中的属性和方法

public class test101 {
    public static void main(String[] args) {
        Dog dog = new Dog(5);
        int age = dog.age;
        dog.printinfo();
    }

}

class Dog{

    int age;
    int weight;
    int height;

    public Dog(){
        System.out.println("无参构造方法");
    }

    public Dog(int age1){
        System.out.println("含参构造方法");
        age = age1;
    }


    public void printinfo(){
        System.out.println(age);
        System.out.println(weight);
        System.out.println(height);
    }
}

方法重载

记得刚刚我提到的构造方法吗？除了类中默认为我们提供的构造方法之外，我们还自己写了含参数的构造方法。

这个自己重新写的过程就叫做重载。

记得是怎么写的了吗？我们使用了相同的方法名，但是重写了参数列表，修饰符和返回值之类的并没有改动。由此我们得出方法重载的特点：

1. 方法名相同
2. 参数列表不同
3. 与返回值、修饰符等无关
4. 除了类中的成员方法，还可以重载构造方法

public Girl(String _name, int _age) {
    name = _name;
    age = _age;
}

public Girl(int _age, String _name) {
    name = _name;
    age = _age;
}

public Girl(String _name, int _age, int _height) {
    name = _name;
    age = _age;
    height = _height;
    
}

public void sleep() {
    System.out.println("每天睡到自然醒");
}

public void sleep(int hour) {
    System.out.println("每天睡" + hour + "个小时");
}

// 返回值不一样,不代表重载，编译会报错
public int sleep(int hour) {
    return hour + 10;
}

但是这里还有一个问题，就是形式参数需要和成员属性的名字区分开。

this关键字

如果形式参数和成员属性的名字一致，就容易傻傻分不清，还会导致冲突。

这时候this关键字就显得非常重要了

this关键字的使用如下

this.成员属性
//通过这种方法可以区分开形参和成员变量

//例如
class Dog{
    String name

    Dog(String name){
        this.name = name
    }
//其中 this.name 指的是成员变量，name指的是形参
}

同时，调用方法也可以通过这种方式调用

this("Dog");

上面代码调用的是构造方法，也可以用来调用成员方法

this关键字的使用规则如下：

1. 通过 this.变量名 来调用成员变量，如果没有变量名冲突可以不写
2. 通过 this.方法名 来调用构造方法或者成员方法
3. 调用成员方法时可不写
4. 调用构造方法时必须放在第一行

//调用成员方法
public void eat() {
    System.out.println("饱餐一顿");
    // 调用其他的方法
    this.sleep();
}

//调用构造方法
public Girl(String _name, int _age) {
    // 必须放在第1行
    this();
    age = _age;
}

static关键字

在我们初学方法时，都会在public后面加一个static，然后就可以不通过对象名直接调用该方法

如果有印象，那么static的精髓已经被你掌控了，咱们只需要稍微补充一些即可

static可以放在成员变量和成员方法上，让它们都变成静态的，即静态变量、静态方法。

也可以称为类变量、类方法。

在权限允许的情况下，可以通过 类名.变量名 / 类名.方法名 来调用对应的属性和方法

相当于不需要new对象，直接就可以访问

静态变量

静态变量由整个类共享，不管类是否产生对象，产生了多少对象。

public class Girl {
    public static int LIKE_DIAMOND = 1;
    
    public void makeup() {
        // 同一个类中，可以直接调用，也可以通过类名调用
        System.out.println(LIKE_DIAMOND);
		System.out.println(Girl.LIKE_DIAMOND);
    }
}

// 在类外，一般都是通过类名进行调用
System.out.println(Girl.LIKE_DIAMOND);

注意：static不能用于修饰局部变量

静态方法

public class Girl {
    public static void shopping() {
        System.out.println("大多数女孩都喜欢逛街");
    }
    
    public void sleep() {
        // 和静态变量类似，在同一个类中，可以直接调用，也可通过类名调用
        shopping();
		Girl.shopping();
    }
}

// 类外，一般通过类名直接调用
Girl.shopping();

注意：静态方法可以通过类名访问（常规做法），也可以通过对象名访问

静态代码块

什么是代码块呢？

{
    使用大括号包裹住的内容就叫做代码块
}

代码块位于类的内部，方法的外部。

Java中的代码块分为：静态代码块，实例代码块。

public class Girl {
    static {
        System.out.println("这是静态代码块");
    }

    {
        System.out.println("这是实例代码块");
    }
    
    public Girl() {
		System.out.println("这是构造方法");
	}
    
}

public static void main(String[] args) {
    Girl girl = new Girl();
	Girl girl1 = new Girl();
}

如上面代码所示，我们写了两个代码块，分别代表静态代码块、实例代码块。

实例代码块没有static修饰

它们现在和构造方法比较一下运行顺序。

静态代码块会在类加载的时候执行一次，而实例代码块会在每次创建对象的时候执行

但是它们都优先于构造方法

由此可以得出：

静态代码块 > 实例代码块 > 构造方法

可以得出static修饰的内容属于类，并不属于某个对象，由所有对象共享。

静态变量和静态方法可以通过类名调用，在类中也可以直接调用，在类外可以通过对象名调用。但是推荐使用类名调用。

静态方法块会在加载类时执行一次，创建对象时不执行，与对象无关。