💬 💬 💬java是一门纯面向对象的语言，它不同于面向过程的C语言，在面向过程中,注重的是过程，在面向对象的世界里，一切皆为对象.面向对象是解决问题的一种思想，主要依靠对象之间的交互来完成一件事情.

一、类

java作为一种面向对象的语言。支持：多态 继承 封装 抽象 类 对象 实例 方法 重载
我们这节重点研究对象和类

类可以看作创建对象的模板.

我们简单创造一个类来理解一下：

class Dog {
    public String name;
    public int age;

    public void bark() {
        System.out.println("汪汪叫！");
    }
    
    public void eat() {
        System.out.println(name+"正在吃东西");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

类中包含的内容称为类的成员。属性主要是用来描述类的，称之为类的成员属性或者类成员变量。方法主要说明类
具有哪些功能，称为类的成员方法。

二、对象

对象：对象是类的一个实例（对象不是找个女朋友），有状态和行为。例如，一条狗是一个对象，它的状态有：颜色、名字、品种；行为有：摇尾巴、叫、吃等。

1.类的实例化

定义了一个类，就相当于在计算机中定义了一种新的类型，它是对对象的抽象。
用类类型创建对象的过程，成为类的实例化，在java中采用new关键字，实例化对象.

public class Test {
    public static void main(String[] args) {
        Dog dog = new Dog();//通过new实例化对象
        dog.name = "旺财";
        dog.age = 18;
        dog.bark();
        dog.eat();
    }
}
1
2
3
4
5
6
7
8
9

2.类和对象的关系

1.类是一个模型,用来对一个实体进行描述，限制。
2.类是一种自定义类型，可以用来定义变量。
3.一个类可以实例化多个对象，类不占空间，只有实例化的对象才占真正的空间。

三、this

1.this存在的意义

class Circle {
    public int x;
    public int y;
    public int r;
    public void setCircle(int a1,int a2,int a3) {
        x = a1;
        y = a2;
        r = a3;
    }
    public void printCircle() {
        System.out.println(x+" "+y+" "+r);
    }
}
public static void main(String[] args) {
        Circle circle = new Circle();
        circle.setCircle(1,2,3);
        circle.printCircle();
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

这样实例化一个对象，赋值，打印都没什么问题.

但是我们在类中的set方法形参给的太抽象了，我们给的具体一点看一下

public void setCircle(int x,int y,int r) {
        x = x;
        y = y;
        r = r;
    }
1
2
3
4
5

为啥？不是已经进行赋值了吗，怎么会打印出来0

2.this的引入

this指向当前对象，在成员方法中调用成员变量都是运用的this去访问。

public void setCircle(int x,int y,int r) {
        this.x = x;
        this.y = y;
        this.r = r;
    }
    public void printCircle() {
        System.out.println(this.x+" "+this.y+" "+this.r);
    }
1
2
3
4
5
6
7
8

this引用的是调用成员方法的对象.

public static void main(String[] args) {
        Circle circle = new Circle();
        circle.setCircle(1,2,3);
        circle.printCircle();
    }
1
2
3
4
5

1.this的类型,那个对象调用就是那个对象的引用类型
2.this只能在成员方法中使用
3.this只能引用当前对象，不能在引用其他对象
4.this是成员方法第一个参数，编译器会自动传递，编译器会将对象的引用传递给该成员方法，this负责接收.

四、构造方法

1.初始化对象

public static void main(String[] args) {
        int count;
        System.out.println(count);
    }
1
2
3
4

public static void main(String[] args) {
        Dog dog = new Dog();
        dog.eat();
    }
1
2
3
4

下面两段代码能否通过编译？

1.为什么局部变量必须初始化才能使用，而对象可以不初始化？
2.对象赋值有没有简单的方法？

2.构造方法

每个类都有构造方法。如果没有显式地为类定义构造方法，Java 编译器将会为该类提供一个默认构造方法。
在创建一个对象的时候，至少要调用一个构造方法。构造方法的名称必须与类同名，一个类可以有多个构造方法。

class Dog {
    public String name;
    public int age;

    //无参的构造方法
    public Dog(){
        
    }
    //带有两个参数的构造方法
    public Dog(String name,int age) {
        this.name = name;
        this.age = age;
    }
 }
1
2
3
4
5
6
7
8
9
10
11
12
13
14

这里证明：构造方法也可以重载.

class Circle {
    public int x;
    public int y;
    public int r;

    public Circle(int x,int y,int r) {
        this.x = x;
        this.y = y;
        this.r = r;
    }
}
public static void main(String[] args) {
        Circle circle = new Circle();
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14

这里报错了，因为我们自己写了一个带参数的构造方法，所以系统不在自己生成构造方法.

this的自我调用

class Circle {
    public int x;
    public int y;
    public int r;
    
    public Circle() {
        this(3,2,1);
    }

    public Circle(int x,int y,int r) {
        this.x = x;
        this.y = y;
        this.r = r;
    }
    public void printCircle(Circle this) {
        System.out.println(this.x+" "+this.y+" "+this.r);
    }
 }
 public static void main(String[] args) {
        Circle circle = new Circle();
        circle.printCircle();
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

在构造方法中可以使用this()去调用其他的构造方法，但this()必须在构造方法的首行，而且不能成环.

3.对象初始化

为什么局部变量没有初始化无法编译，而成员变量可以.

    Dog dog = new Dog();
1

在这样的一个实例化过程中，虽然没有显式的初始化，但是JVM会替我们做很多.后面我们会学到很多，只简单介绍两点：
1.检测对象对应的类是否加载，如果没有加载进行加载
2.初始化空间：空间申请好之后，将成员变量设置为默认值.

五、打印对象

如果我们想打印对象该怎么打印？

class Dog {
    public String name;
    public int age;

    //无参的构造方法
    public Dog(){

    }
    public Dog(String name,int age) {
        this.name = name;
        this.age = age;
    }
}
public static void main(String[] args) {
        Dog dog = new Dog();
        System.out.println(dog);
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

我们可以看到打印对象打印出来的是一个像地址的东西.



我们可以层层剥皮发现,我们打印的是toString这个方法，那我们是不是可以自己写一下这个toString方法。

@Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
1
2
3
4
5
6
7

我们自动生成了一个toString（）方法，打印如上,当然我们也可以自己写一个toString()方法

@Override
    public String toString() {
        return "name='" + name  + ", age=" + age;
    }
1
2
3
4

总结

今天初始面向对象上就到这里了，随后我会更新初始对象下，一起卷起来.