OOP类与对象&构造器

以类的方式组织代码，以对象的形式封装数据

小结：

1、类与对象：
        类是抽象的一个模版，对象是一个具体的实例

2、方法：

        定义、调用

3、对象的引用：
        引用类型：对象是通过引用来操做的，栈--->堆

        对应的是基本类型（8大基本类型int、byte、short、long、double、float、char、boolean）

4、对象的属性：字段filed/成员变量

        默认初始化：

                数字：0、0.0

                char：u0000

                boolean：false

                引用类型：null

属性定义：修饰符 属性类型 属性名 = 属性值

5、对象的创建和使用

        - 必须使用new 关键字来创建对象，必须有构造器  Person jianghanyi = new Person()；

        - 对象的属性：jianghanyi.name()

        - 对象的方法：jianghanyi.sleep()

6、类：只能写👇

        静态的属性；

        动态的行为

---

一、类与对象的关系

类：

是一种抽象的数据类型，它是对某一类食物整体描述、定义，但是不能代表某一个具体的事物。

比如：Person类、Car类等，用来描述这一类事物应该具备的特点和行为

对象：

是抽象概念的具体实例。

比如：张三是Person类的一个具体实例，张三的车是Car类的一个具体实例

能够体现出特点，展现出功能的是具体的实例，而不是一个抽象的概念

类是抽象的，对象时具体的，类是对象的模版

二、创建与初始化对象

一个程序只有一个main方法，执行一个程序首先执行main方法，所以只用在main方法里调用自己写的方法就好了

使用new关键字创建对象：
使用new关键字创建的时候，除了分配内存空间外，如果你没有给创建的对象赋值，他还会自动给创建好的对象进行默认初始化（比如String类型默认null），以及对类中构造器的调用。

先创建一个Student类：

package com.Jiang.oop.demo02;

//学生类
public class Student {

    //属性：字段
    String name;//null
    int age;//0


    //方法
    public void study(){
        System.out.println(this.name+"学生在学习");
        //this代表当前这个类，意思是当前这个学生在学习
    }
    
}

在Application类中创建对象：

package com.Jiang.oop.demo02;

//一个项目应该只存在一个main方法
public class Application {
    public static void main(String[] args) {

        //类：抽象的，需要实例化——new
        //类实例化后会返回一个自己的对象
        //student对象就是Student类的一个具体实例
        Student student = new Student();
        Student xiaoming = new Student();
        Student jianghanyi = new Student();

        xiaoming.name = "小明";
        xiaoming.age = 4;

        System.out.println(xiaoming.name);//小明
        System.out.println(xiaoming.age);//4

        System.out.println(jianghanyi.name);//null
        System.out.println(jianghanyi.age);//0
    }
}

三、构造器

类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的。

构造器有以下两个特点：

        1、必须和类的名字相同

        2、必须没有返回类型，也不能写void

package com.Jiang.oop.demo02;


public class Person {

    //一个类即使什么都不写，他也会存在一个方法
    //显示的定义构造器

    String name;
    int age;

    //实例化初始值
    //构造器作用：
    //1、使用new关键字，本质是在调用构造器
    //2、构造器用来初始化值
    public Person(){//无参构造
        this.name = "jiannghnyi";
    }

    //存在重载方法有参构造器时，重载方法名字的无参构造器必须要写出来！
    public Person(String name){//有参构造
    //this.name是指上面创建的属性，后面的name是指传进来的name，即这个方法里的
        this.name = name;
    }

    public Person(String name, int age) {//有参构造
        this.name = name;
        this.age = age;
    }

    /*
            //new 实例化了一个对象
        //有参数就走有参，无参数就走无参，出来的是定义的值
        Person person1 = new Person();//走无参的那个方法
        Person person = new Person("jianghnayi");
        Person person2 = new Person("jiang",19);//调用相应的构造器
        System.out.println(person1.name);//jianghnayi
        System.out.println(person.name);//jianghnayi
        System.out.println(person2.name);//jiang
        System.out.println(person2.age);//19


        构造器：
        1、因为构造器名字必须和类名相同，所以是重载
        2、没有返回值
        作用：
        1、new 本质是在调用构造方法
        2、初始化对象的值
        注意点：
        1、定义有参构造之后，如果想使用无参构造，无参构造器必须写出来

        command+N
       
     */


}

四、创建对象内存分析

创建一个Pet类：

package com.Jiang.oop.demo03;

public class Pet {
   public String name;
   public int age;

    //无参构造：不写方法的时候无参构造会自动存在，
    //写了有参构造后就会没有，所以要自己先写一个无参构造显示出来
    public void shout(){
        System.out.println("叫了一声");
    }

}

在Application中引用该类并创建对象

package com.Jiang.oop;

import com.Jiang.oop.demo03.Pet;

public class Application {

   public static void main(String[] args) {

       Pet dog = new Pet();
       dog.name="旺财";//赋值
       dog.age = 3;//赋值
       dog.shout();//叫了一声：引用方法

       Pet cat = new Pet();


       System.out.println(dog.name);
       System.out.println(dog.age);
   }


}