Java零基础(第九章)---》对象的创建和使用

知识框架

🏀对象的创建和使用

🥅创建对象对应的JVM内存结构

❤️Student类

学生类
    学号：int
    姓名：String
    年龄：int
    性别：boolean
    住址：String

public class Student{
    // 属性（描述状态），在java程序中以“成员变量”的形式存在。
    int no; // 这种“成员变量”又被称为“实例变量”。
    // 姓名
    String name;
    // 年龄
    int age;
    // 性别
    boolean sex;
    // 住址
    String addr;
}

⭐️对于变量必须先声明，再赋值才能访问。
⭐️对于成员变量来说，没有手动赋值时，系统默认赋值；默认值是什么？

类型                默认值
---------------------
byte                 0
short                0
int                  0
long                 0L
float                0.0F
double               0.0
boolean              false
char                 \u0000
引用数据类型           null

⭐️null是一个java关键字，全部小写，表示空。是引用类型的默认值。

❤️StudentTest类

public class StudentTest{
    public static void main(String[] args){
1.//局部变量不初始化，不能直接访问，例如：
        int k;
        System.out.println(k); //错误: 可能尚未初始化变量k

//2.访问学生姓名no可以直接通过类名吗？
    //学生姓名是一个实例变量。实例变量是对象级别的变量；不能通过“类名”来直接访问“实例变量”。
        System.out.println(Student.name);//err,应该先new一个对象
        
//3.i属于局部变量吗？当然是；局部变量存储在栈内存当中。（栈主要存储局部变量。）
        int i = 100;

//4.创建学生对象1       
        Student s1 = new Student();// s1属于局部变量；s1这个局部变量叫做引用
        //怎么访问实例变量？语法：引用.实例变量名
        System.out.println(s1.no);
        System.out.println(s1.name);
        System.out.println(s1.age);
        System.out.println(s1.sex);
        System.out.println(s1.addr);

        System.out.println("-----------------------------");

//5. 程序执行到此处我可以修改s1这个学生的学号吗？
        // 通过“=”赋值的方式将内存中实例变量的值修改一下。
        s1.no = 110;
        s1.name = "张三";
        s1.age = 20;
        s1.sex = true;
        s1.addr = "深圳宝安区";

        System.out.println("学号=" + s1.no);
        System.out.println("姓名=" + s1.name);
        System.out.println("年龄=" + s1.age);
        System.out.println("性别=" + s1.sex);
        System.out.println("住址=" + s1.addr);
    }
}

  

❤️****内存图

❤️在语法级别上是完成对象创建：类名 变量名 = new 类名();

❤️什么是实例变量？
⭐️对象又被称为实例；实例变量实际上就是：对象级别的变量。

  public class 明星类{
        double height;//实例变量
    }

⭐️身高这个属性所有的明星对象都有，但是每一个对象都有“自己的身高值”。
假设创建10个明星对象，height变量应该有10份；所以这种变量被称为对象级别的变量；属于实例变量；实例变量在访问的时候，是不是必须先创建对象？

❤️对象和引用的区别？
对象是：通过new出来的，在堆内存中存储。
引用是：但凡是变量，并且该变量中保存了内存地址指向了堆内存当中的对象的。

❤️例1

⭐️User类

public class User{
    int id; 
    String username; 
    String password;
}

⭐️UserTest类

public class UserTest{
    public static void main(String[] args){
//1.创建一个用户
        User u1 = new User();
        //默认值
        System.out.println(u1.id); //0
        System.out.println(u1.username); //null
        System.out.println(u1.password); //null
        //重新赋值打印
        u1.id = 11111;
        u1.username = "zhangsan";
        u1.password = "123";
        System.out.println(u1.id);
        System.out.println(u1.username);
        System.out.println(u1.password);
//2.创建另一个用户        
        User u2 = new User();
        u2.id = 22222;
        u2.username = "lisi";
        u2.password = "456";
        System.out.println(u2.id);
        System.out.println(u2.username);
        System.out.println(u2.password);
    }
}

⭐️内存图

❤️例2

⭐️Address

public class Address{
    String city; 
    String street;
    String zipcode;
}

⭐️User

public class User{
    int id; // 实例变量
    String username; // 实例变量
    Address addr; // Address是一种引用数据类型；addr是一个引用。
}

⭐️Test

public class Test{
    public static void main(String[] args){

        // 家庭住址对象
        Address a = new Address();
        a.city = "北京";
        a.street = "大兴区";
        a.zipcode = "121221";
        
        // 用户对象
        User u = new User();
        System.out.println(u.id); // 0
        System.out.println(u.username); // null
        System.out.println(u.addr); // null

        u.id = 11111;
        u.username = "zhangsan";
        u.addr = a; //这相当于是建立了连接

        System.out.println(u.username + "是"+u.addr.city+"城市的！");

    }
}

⭐️引用和对象怎么区分？
“引用”是啥？是存储对象内存地址的一个变量。
“对象”是啥？堆里new出来的。
⭐️通俗一点：
** 只要这个变量中保存的是一个对象的内存地址，那么这个变量就叫做“引用”。 **
⭐️思考：引用一定是局部变量吗？
不一定。引用一般情况下都是局部变量，在栈区；但a也有可能是实例变量（成员变量）；例如：下面的0x1478

⭐️内存图

❤️例3

public class T{
    A o1;
    public static void main(String[] args){    
        A a = new A();
        B b = new B();
        C c = new C();
        D d = new D();
        T t = new T();

        //这里不写代码会出现NullPointerException异常。（空指针异常。）
        c.o4 = d; //这里全是相当于建立连接关系
        b.o3 = c;
        a.o2 = b;
        t.o1 = a;

        // 编写代码通过t来访问d中的i
        //System.out.println(T.a); //错误的。
        System.out.println(t.o1.o2.o3.o4.i);
    }
}
class A{
    B o2;
}
class B{
    C o3;
}
class C{
    D o4;
}
class D{
    int i;
}

🥅空指针异常

❤️空指针异常。（NullPointerException）
❤️关于垃圾回收器：GC（主要针对的是堆内存）
⭐️在java语言中，垃圾回收器主要针对的是堆内存。
⭐️当一个java对象没有任何引用指向该对象的时候，
⭐️GC会考虑将该垃圾数据释放回收掉。
❤️出现空指针异常的前提条件是？
"空引用"访问实例【对象相关】相关的数据时，都会出现空指针异常。

❤️对于空指针，我们只要不调用，就算把引用置为空，编译也是没问题的；因为编译器是只检查语法错误！

public class NullPointerTest{
    public static void main(String[] args){
//1. 创建客户对象
        Customer c = new Customer();//c指向内存地址
//2. 访问这个客户的id
        System.out.println(c.id); // 0

//3. 重新给id赋值
        c.id = 9521; // 终身代号
        System.out.println("客户的id是=" + c.id);
//4.c赋值为空指针
        c = null;
        // NullPointerException
        // 编译器没问题，因为编译器只检查语法，编译器发现c是Customer类型，
        // Customer类型中有id属性，所以可以：c.id。语法过了。
        // 但是运行的时候需要对象的存在，但是对象没了，尴尬了，就只能出现一个异常。
        System.out.println(c.id);//err
//5.可以重新给c赋值，继续使用
         c = new Customer();
    }
}

class Customer{
    // 客户id
    int id; // 成员变量中的实例变量，应该先创建对象，然后通过“引用.”的方式访问。
}

⭐️内存图1

⭐️内存图2

🥅方法调用时参数的传递问题

❤️例1

⭐️java中规定：参数传递的时候，和类型无关，不管是基本数据类型还是引用数据类型；统一都是将盒子中保存的那个“值”复制一份，传递下去。
⭐️java中只有一个规定：参数传递的时候，一定是将“盒子”中的东西复制一份传递过去。

⭐️类似于C语言中的传值调用

// x赋值给y，是怎么传递的？将x变量中保存的100这个值复制一份传给y；y的改变不贵改变x的值
  //很类似于C语言中的传值调用
    int x = 100;
    int y = x; //将x的值复制一份传给y，所以y的改变不会影响x

public class Test1{
    public static void main(String[] args){

        // 局部变量，域是main
        int i = 10;
        // 将i变量中保存的10复制一份，传给add方法；下面的i改变不会影响上面的i
        add(i); 
        System.out.println("main ---> " + i); //10
    }

    public static void add(int i){ // i是局部变量，域是add
        i++;
        System.out.println("add ----> " + i); //11
    }

}

⭐️内存图

❤️例2

⭐️java中关于方法调用时参数传递实际上只有一个规则：
不管你是基本数据类型，还是引用数据类型，实际上在传递的时候都是将变量中保存的那个“值”复制一份，传过去。
⭐️例如： int x = 1;int y = x; 把x中保存1复制一份传给y，x和y都是两个局部变量。
Person p1 = 0x1234;Person p2 = p1; 把p1中保存的0x1234复制一份传给p2，p1和p2都是两个局部变量。
⭐️例如：你和你媳妇，都有你家大门上的钥匙，钥匙是两把。但是都可以打开你家的大门。

⭐️内存地址也是值，也是盒子中保存的一个东西。

public class Test2{
    public static void main(String[] args){
        Person p = new Person();
        p.age = 10;
        add(p);
        System.out.println("main--->" + p.age); //11
    }
    // 方法的参数可以是基本数据类型，也可以是引用数据类型，只要是合法的数据类型就行。
    public static void add(Person p){ // p是add方法的局部变量。
        p.age++;
        System.out.println("add--->" + p.age); //11
    }
}

class Person{
    // 年龄属性，成员变量中的实例变量。
    int age;
}

⭐️内存图

❤️总结：

⭐️程序在什么情况下会出现空指针异常呢？
空引用 访问 "对象相关"的数据时，会出现空指针异常。垃圾回收器主要针对堆内存。

** ⭐️**方法在调用的时候参数是如何传递的？
实际上，在java语言中，方法调用时参数传递，和类型无关，都是将变量中保存的那个“值”传过去，这个“值”可能是一个数字100，也可能是一个java对象的内存地址：0x1234
⭐️记住这句话：不管是哪一种数据类型的传递，都是将“变量中保存的那个值复制一份传递过去

🥅构造方法

❤️构造方法
⭐️什么是构造方法，有什么用？
构造方法是一个比较特殊的方法，通过构造方法可以完成对象的创建，以及实例变量的初始化。换句话说：构造方法是用来创建对象，并且同时给对象的属性赋值。（注意：实例变量没有手动赋值的时候，系统会赋默认值。）

 **⭐️**重点（需要记忆）：**当一个类没有提供任何构造方法，系统会默认提供一个无参数的构造方法。**（而这个构造方法被称为缺省构造器。）

 **⭐️**调用构造方法怎么调用呢？使用哪个运算符呢？
         **使用new运算符来调用构造方法。**
         语法格式：new 构造方法名(实际参数列表);        

** ⭐️构造方法的语法结构是？**

        [修饰符列表] 构造方法名(形式参数列表){ //修饰符列表是public
             构造方法体;
             通常在构造方法体当中给属性赋值，完成属性的初始化。
         }         

        **普通方法的语法结构是？**
             [修饰符列表] 返回值类型 方法名(形式参数列表){//修饰符列表是public static
                 方法体;
             }

 **⭐️对于构造方法**：
             第一：修饰符列表目前统一写：public。千万不要写public static。

            第二：构造方法名和类名必须一致。

            第三：构造方法不需要指定返回值类型，也不能写void，写上void表示普通方法，就不是构造方法了。

❤️构造方法（支持重载）
⭐️当一个类中没有提供任何构造方法，系统默认提供一个无参数的构造方法； 这个无参数的构造方法叫做缺省构造器。

⭐️当一个类中手动的提供了构造方法，那么系统将不再默认提供无参数构造方法；建议将无参数构造方法手动的写出来，这样一定不会出问题。

** ⭐️**无参数构造方法和有参数构造方法都可以调用。
Student x = new Student(); //调用无参数构造方法，去new对象
Student y = new Student(123); //调用有参数构造方法，去new对象
⭐️构造方法支持方法重载吗？
构造方法是支持方法重载的；在一个类当中构造方法可以有多个；并且所有的构造方法名字都是一样的。
方法重载特点：在同一个类中，方法名相同，参数列表不同。

** ⭐️**对于实例变量来说，只要你在构造方法中没有手动给它赋值，统一都会默认赋值。默认赋系统值。

** ⭐️构造方法有什么作用？**
** 创建对象和给属性(成员变量或者实列变量)赋值**

**❤️例1 **

⭐️Student类

public class Student{
    // 学号
    int no;
    // 姓名
    String name
    // 年龄
    int age;
//1.当前的Student这个类当中并没有定义任何构造方法。
  //但是系统实际上会自动给Student类提供一个无参数的构造方法。
  //建议将无参数的构造方法（缺省构造器）写出来    
    public Student(){// 默认初始化为0 null 0
        
    }

//2. 定义一个有参数的构造方法
    public Student(int i){// 默认初始化为0 null 0
    
    }

//3.编译器检测到该方法名“Studen”，发现这个名字和类名不一致，
 //编译器会认为该方法是一个普通方法，普通方法应该有返回值，但是没有写返回值类型，所以报错了。
 //错误: 方法声明无效; 需要返回类型    
    public Studen(String name){
    
    }
    // 第一种修改方式
    //public void Studen(String name){//修改为普通方法
    }

    // 第二种修改方式
    public Student(String name){//修改为构造方法
    
    }
}

⭐️ConstructorTest01类

public class ConstructorTest01{
    public static void main(String[] args){
//1. 调用Student类的无参数构造方法
        new Student();//没有用变量接收，调用完GC回收

//2. 调用下面的普通方法，在同一个类中，两种方法
        ConstructorTest01.doSome();
        doSome();

//3. 创建Student类型的对象
        Student s1 = new Student();

//4. 输出“引用”；只要输出结果不是null，说明这个对象一定是创建完成了。
    //输出结果大家目前是看不懂的，后期会讲。其实默认调用的是toString()方法
        System.out.println(s1); //Student@54bedef2

//5. 这是调用另一个有参数的构造方法。
        Student s3 = new Student(100);
        System.out.println(s3); //Student@5caf905d
    }

    public static void doSome(){
        System.out.println("do some!!!!");
    }
}

❤️例2：对于实例变量初始化，是在构造方法执行的过程中（创建对象）完成初始化的

⭐️User类

/*
    1、id,name,age都有默认值
        id的默认值是：0 
        name的默认值是：null
        age的默认值是：0
    
    2、思考：实例变量没有手动赋值的时候，实际上系统会默认赋值，那么这个默认赋值操作是在
       什么时间进行的？是在类加载的时候给这些实例变量赋值吗？
       答：不是，实例变量是在构造方法执行的过程中(创建对象时)完成初始化的，完成赋值的。
*/
public class User{
    int id; 
    String name;
    int age;

//3. 手动定义有参数的构造方法，无参数构造方法将消失；要想有必须手动写出来
    public User(int a){ 

    }
//4. 进行初始化
    public User(){    //无参
        // 这就表示不再采用系统默认值，手动赋值了。
        id = 111;
        name = "lisi";
        age = 30;

    }
}

⭐️ConstructorTest02类

/*
    1、构造方法对应的英语单词：Constructor【构造器】
    2、构造方法作用：
        创建对象，并且创建对象的过程中给属性赋值（初始化。）
*/
public class ConstructorTest02{
    public static void main(String[] args){
//1. 调用无参的，进行手动初始化的
        User u = new User();// 创建对象

        System.out.println(u.id); //111
        System.out.println(u.name); //lisi
        System.out.println(u.age); //30
//2. 调用有参的，进行默认初始化的
        User u2 = new User(1111111);// 创建对象

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

❤️例3：最终无参、有参构造方法的使用

⭐️Vip类

public class Vip{
    long no;// 会员号
    String name;    // 会员姓名
    String birth;    // 生日
    boolean sex;    // 性别

//1. 无参数构造方法
    public Vip(){

    }
//---------------下面的代码我们学到this关键字还可以继续优化！
//2.有参数构造方法
    public Vip(long huiYuanHao, String xingMing){
        // 给实例变量赋值【初始化实例变量，初始化属性】
        no = huiYuanHao;
        name = xingMing;
        // 实际上这里还有两行代码（没有手动赋值，系统都会默认赋值。）
        //birth = null;
        //sex = false;
    }

//3. 有参数构造方法
    public Vip(long huiYuanHao,String xingMing, String shengRi){
        no = huiYuanHao;
        name = xingMing;
        birth = shengRi;
        // 实际上这里有一行默认的代码
        //sex = false;
    }

//4. 有参数的构造方法
    public Vip(long huiYuanHao,String xingMing,String shengRi,boolean xingBie){
        no = huiYuanHao;
        name = xingMing;
        birth = shengRi;
        sex = xingBie;
    }
}

⭐️ConstructorTest03类

public class ConstructorTest03{
    public static void main(String[] args){
        //调用不同的构造方法创建对象
        Vip v1 = new Vip();
        System.out.println(v1.no); //0
        System.out.println(v1.name); // null
        System.out.println(v1.birth); // null
        System.out.println(v1.sex); // false

        Vip v2 = new Vip(11111L, "大灰狼");
        System.out.println(v2.no); // 11111L
        System.out.println(v2.name); // "大灰狼"
        System.out.println(v2.birth); // null
        System.out.println(v2.sex); // false

        Vip v3 = new Vip(22222L, "小绵羊", "2000-10-10");
        System.out.println(v3.no); // 22222L
        System.out.println(v3.name); //"小绵羊"
        System.out.println(v3.birth); // "2000-10-10"
        System.out.println(v3.sex); // false

        Vip v4 = new Vip(33333L, "钢铁侠", "1980-10-11", true);
        System.out.println(v4.no); // 33333L
        System.out.println(v4.name); //"钢铁侠"
        System.out.println(v4.birth); //"1980-10-11"
        System.out.println(v4.sex); //true
    }

}