零基础Java第十一期：类和对象（二）

一、对象的构造及初始化

[1.1. 就地初始化](#1.1. 就地初始化)

[1.2. 默认初始化](#1.2. 默认初始化)

[1.3. 构造方法](#1.3. 构造方法)

二、封装

[2.1. 封装的概念](#2.1. 封装的概念)

[2.2. 访问限定符](#2.2. 访问限定符)

[2.3. 封装扩展之包](#2.3. 封装扩展之包)

三、static成员

[3.1. 再谈学生类](#3.1. 再谈学生类)

[3.2. static修饰成员变量](#3.2. static修饰成员变量)

一、对象的构造及初始化

1.1. 就地初始化

在声明成员变量时，就直接给出了初始值，如下面的代码：

java 复制代码

public int year=2005;
public int month=3;
public int day=13;

1.2. 默认初始化

当我们定义成员变量时，不会给成员变量初始化，那么成员变量就会有一个默认初始化的值，如year=0，month=0，day=0。

1.3. 构造方法

接上一期，什么是构造方法？方法名和类名一样，没有返回值（如下面的代码）。构造方法怎么被调用呢？在Date date=new Date()时被调用。在创建对象时，由编译器自动调用一个不带参数的构造方法，只不过构造方法什么都不做，并且在整个对象的生命周期内只调用一次。一旦用户定义，编译器则不再生成。此外，还可以提供带多个参数的构造方法（需要结合上一期的代码才能看懂）。

java 复制代码

public Date(){

}

java 复制代码

public Date(){
    this.year=year;
    this.month=month;
    this.day=day;
}

public static void main(String[] args){
        Date date=new Date(2024,10,26);
        date.PrintDate();

通过上面的代码，我们可以看到，构造方法可以初始化我们的成员变量。

二、封装

2.1. 封装的概念

不封装可能会很难堪。数据时公开的，会被全世界的人看到，甚至可以被改动。我们如何将程序的从不良数据改成可以保护数据且让你还能修改数据的方式很简单呢？就得将数据隐藏。

封装：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行交互。

我们可以使用一些访问限定符来进行封装，比如private。

java 复制代码

private String title;
private String genre;
private int rating;

那既然我们进行了限定访问，还有方法对title、genre、rating进行访问呢？代码如下：

java 复制代码

public void setTitle(String title){
      this.tiltle=title;
}

public void setGenre(String genre){
      this.genre=genre;
}

java 复制代码

one.Settitle();
one.setGenre();

现在成员变更少，那如果成员变量多呢？我们可以用编译器自己生成，如下图所示：右键点击generate，在点击Getter and Setter，就会生成如下代码

java 复制代码

private String title;

    public String getGenre() {
        return genre;
    }

    public void setGenre(String genre) {
        this.genre = genre;
    }

    private String genre;

    public Movie(String title) {
        this.title = title;
    }

    public int getRating() {
        return rating;
    }


    private int rating;

我们可以选择getter或setter或getter and setter

2.2. 访问限定符

Java中主要通过类和访问权限来实现封装：类可以将数据以及封装数据的方法结合在一起，更符合人类对事物的认知，而访问权限用来控制方法或者字段能否直接在类外使用。Java中提供了四种访问限定符： private、default、protected、public。

2.3. 封装扩展之包

（1）包的概念

在面向对象体系中，提出了一个软件包的概念，即：为了更好的管理类，把多个类收集在一起成为一组，称为软件包。有点类似于目录。比如：为了更好的管理电脑中的歌曲，一种好的方式就是将相同属性的歌曲放在相同文件下，也可以对某个文件夹下的音乐进行更详细的分类。所以包的出现就是为了更好地管理java文件。

比如我们要进行输入操作时，使用Scanner，就需要导入java.util.Scanner包，点号前面是名，后面是类名。我们可以在左侧去寻找这个包，因为博主的电脑里面装了JDK17，所以就会显示出：

在我们的C盘里面这个路径下，可以找到所有java的包，与IDEA上面的一致。

（2）导入包中的类

java 复制代码

import java.sql.*;//并不会把所有类进行加载，用谁取谁，但不是一劳永逸
package java.util;//声明一个包。当前类的第一行，声明一下该类在那个包

这段代码会报错，为什么呢？第一个包有星号，第二个包有Date，下面的date会懵了，不知道该指向哪个了。此时就和定义顺序有关

java 复制代码

import java.util.*;
import java.sql.Date;



Date date = new Date;

这样就不会因为包的顺序而出错了：

java 复制代码

java.util.Date date = new java.util.Date();

java.sql.Date date1 = new java.sql.Date(2015,5,10);

（3）自定义的包

基本规则：在文件的最上方加上一个 package 语句指定该代码在哪个包中；包名要和代码路径相匹配；如果一个类没有 package 语句, 则该类被放到一个默认包中。

操作步骤：右击scr，点击new，再点package，

（4）包的访问控制权限

java 复制代码

package com.HeBei.www;

public class Dog {
    int age;
    String breed;
    String name;

    public void Bark(){
        System.out.println(name+"汪汪叫");
    }
}

java 复制代码

package com.HeBei.www;

public class Test {
    public static void main(String[] args) {
        Dog dog=new Dog();
        System.out.println(dog.name);
    }
}

java 复制代码

package com.university.www;

import com.HeBei.www.Dog;

public class Main {
    public static void main(String[] args) {
        Dog dog =new Dog();
        dog.name
    }
}

我们来看第一段代码，在com.HeBei.www这个包里面，第二段代码与第一段代码同包不同类，可以正常访问Dog的成员变量；但第三段代码与第一段代码不同包，就不能访问。

（5）常见的包

下面给大家看一下比较常见的包：

java.lang:系统常用基础类(String、Object),此包从JDK1.1后自动导入。 2. java.lang.reflect:java 反射编程包; 3. java.net:进行网络编程开发包。 4. java.sql:进行数据库开发的支持包。 5. java.util:是java提供的工具程序包。(集合类等) 非常重要 6. java.io:I/O编程开发包。

三、static成员

3.1. 再谈学生类

java 复制代码

public class Student {
    int age;
    String name;
    String Class;
    public Student(int age,String name,String Class){
        this.age =age;
        this.name =name;
        this.Class=Class;
    }
    public static void doClass(){
        System.out.println();
    }
}
public class Test {
    public static void main(String[] args) {
        Student stu1=new Student(17,"Alan","101");
        Student stu2=new Student(18,"Henry","101");
        Student stu3=new Student(16,"Paul","101");
    }
}

三个stu都隶属于同一个Class，且都放在同一对象里，此时就需要在栈上开辟三块内存空间。那如果我们把Class也包含一份，就需要定义一个static，就不会看到属性里有Class，同时这个成员变量也不再属于对象了，而这个Class存储在了方法区。

java 复制代码

System.out.println(stu1.Class);
System.out.println(stu2.Class);
System.out.println(stu3.Class);

这样我们就把Class放在同一个静态成员变量或者类变量里面，但这种访问不合理。

3.2. static修饰成员变量

static修饰的成员变量，称为静态成员变量，静态成员变量最大的特性：不属于某个具体的对象，是所有对象所共享的。

静态成员变量属性： 1. 不属于某个具体的对象，是类的属性，所有对象共享的，不存储在某个对象的空间中 2. 既可以通过对象访问，也可以通过类名访问，但一般更推荐使用类名访问 3. 类变量存储在方法区当中 4. 生命周期伴随类的一生(即：随类的加载而创建，随类的卸载而销毁)