Java学习总结-类和对象【JavaSE】

---

前言

在这里对最近学习的JavaSE中的类和对象的知识总结回忆一下。

---

一、类

1、类定义的注意事项

（1）一般一个文件当中只定义一个类。
（2） main方法所在的类一般要使用public修饰(注意：Eclipse默认会在public修饰的类中找main方法)。
（3） public修饰的类必须要和文件名相同。
（4） 不要轻易去修改public修饰的类的名称，如果要修改，通过开发工具修改。

2、类的实例化

在java中采用new关键字，配合类名来实例化对象。

（1）new 关键字用于创建一个对象的实例。
（2）使用 . 来访问对象中的属性和方法。
（3）同一个类可以创建多个实例。

代码如下（示例）：

public class Main {
    public static void main(String[] args) {
        PetDog dogh = new PetDog(); //通过new实例化对象
        dogh.name = "阿黄";
        dogh.color = "黑黄";
        dogh.barks();
        dogh.wag();
        PetDog dogs = new PetDog();
        dogs.name = "阿黄";
        dogs.color = "黑黄";
        dogs.barks();
        dogs.wag();
    }
}

3、类和对象的说明

（1）类只是一个模型一样的东西，用来对一个实体进行描述，限定了类有哪些成员。
（2）类是一种自定义的类型，可以用来定义变量。
（3）一个类可以实例化出多个对象，实例化出的对象占用实际的物理空间，存储类成员变量。
（4）做个比方。类实例化出对象就像现实中使用建筑设计图建造出房子，类就像是设计图，只设计出需要什么东西，但是并没有实体的建筑存在，同样类也只是一个设计，实例化出的对象才能实际存储数据，占用物理空间。

二、this对象

1、为什么要有this对象

代码如下（示例）：

public class Date {
    public int year;
    public int month;
    public int day;

    public void setDay(int year, int month, int day) {
        this.year = year;
        this.month = month;
        this.day = day;
    }

    public void printDate() {
        System.out.println(year + "/" + month + "/" + day);
    }

    public static void main(String[] args) {
// 构造三个日期类型的对象 d1 d2 d3
        Date d1 = new Date();
        Date d2 = new Date();
        Date d3 = new Date();
// 对d1，d2，d3的日期设置
        d1.setDay(2020, 9, 15);
        d2.setDay(2020, 9, 16);
        d3.setDay(2020, 9, 17);
// 打印日期中的内容
        d1.printDate();
        d2.printDate();
        d3.printDate();
    }
}

以上代码中setDay函数中的形参名与数据成员名相同，需要this来帮忙分清楚。创建的d1,d2,d3对象都调用setDay函数设置数据以及printDate函数来打印，这些也需要this来分清楚对象。

2、什么是this引用

this引用指向当前对象(成员方法运行时调用该成员方法的对象)，在成员方法中所有成员变量的操作，都是通过该引用去访问。

代码如下（示例）:

public class Date {
    public int year;
    public int month;
    public int day;

    public void setDay(int year, int month, int day) {
        this.year = year;
        this.month = month;
        this.day = day;
    }

    public void printDate() {
        System.out.println(this.year + "/" + this.month + "/" + this.day);
    }
}

注意：this引用的是调用成员方法的对象。

3、this引用的特性

（1）this的类型：对应类类型引用，即哪个对象调用就是哪个对象的引用类型。
（2） this只能在"成员方法"中使用。
（3）在"成员方法"中，this只能引用当前对象，不能再引用其他对象。
（4）this是“成员方法”第一个隐藏的参数，编译器会自动传递，在成员方法执行时，编译器会负责将调用成员方法的对象的引用传递给该成员方法，this负责来接收。

三、对象的构造及初始化

1、构造方法

（1）构造方法(也称为构造器)是一个特殊的成员方法，名字必须与类名相同，在创建对象时，由编译器自动调用，并且在整个对象的生命周期内只调用一次。

注意：构造方法的作用就是对对象中的成员进行初始化，并不负责给对象开辟空间。

（2）特性：
    名字必须与类名相同。
    没有返回值类型，设置为void也不行。
    创建对象时由编译器自动调用，并且在对象的生命周期内只调用一次(相当于人的出生，每个人只能出生一次)。
    构造方法可以重载(用户根据自己的需求提供不同参数的构造方法)。
    如果用户没有显式定义，编译器会生成一份默认的构造方法，生成的默认构造方法一定是无参的。（注意：如果用户自定义了构造函数则不会提供默认构造函数）
   构造方法中，可以通过this()调用其他构造方法来简化代码。（注意：this()必须放第一行，并且不能形成环）
   绝大多数情况下使用public来修饰，特殊场景下会被private修饰。(涉及单例模式时会遇到)

2、默认初始化

Date d = new Date(2021,6,9);

在程序层面只是简单的一条语句，在JVM层面需要做好多事情，下面简单介绍下：
   检测对象对应的类是否加载了，如果没有加载则加载。
   为对象分配内存空间。
   处理并发安全问题。比如：多个线程同时申请对象，JVM要保证给对象分配的空间不冲突。
   初始化所分配的空间，即：对象空间被申请好之后，对象中包含的成员已经设置好了初始值。
   设置对象头信息。
   调用构造方法，给对象中各个成员赋值。

数据成员按类型设置初始值，引用类型设为null：

3、就地初始化

在声明成员变量时，就直接给出了初始值。
代码如下（示例）:

public class Date {
    public int year = 1900;
    public int month = 1;
    public int day = 1;

    public Date() {
    }

    public Date(int year, int month, int day) {
    }

    public static void main(String[] args) {
        Date d1 = new Date(2021, 6, 9);
        Date d2 = new Date();
    }
}

注意：代码编译完成后，编译器会将所有给成员初始化的这些语句添加到各个构造函数中。

四、封装

1、封装的概念

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

2、包

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

Java 中已经提供了很多现成的类供我们使用。 例如Date类：可以使用 java.util.Date 导入 java.util 这个包中的 Date类。
可以使用 import语句导入包。

import java.util.Date;

public class Test {
    public static void main(String[] args) {
        Date date = new Date();
// 得到一个毫秒级别的时间戳
        System.out.println(date.getTime());
    }
}

如果出现冲突的情况，需要显示指定要导入的类名。

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

public class Test {
    public static void main(String[] args) {
    //util和sql中都存在一个Date这样的类 此时就会出现歧义 需要显式指定。
        java.util.Date date = new java.util.Date();
        System.out.println(date.getTime());
    }
}

还可以使用import static导入包中静态的方法和字段。

import static java.lang.Math.*;

public class Test {
    public static void main(String[] args) {
        double x = 30;
        double y = 40;
	// 静态导入的方式写起来更方便一些.
	// double result = Math.sqrt(Math.pow(x, 2) + Math.pow(y, 2));
        double result = sqrt(pow(x, 2) + pow(y, 2));
        System.out.println(result);
    }
}

常见的包：

（1）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编程开发包。

3、访问限定符

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

default权限指什么都不写时的默认权限。

五、static成员

在Java中，被static修饰的成员，称之为静态成员，也可以称为类成员，其不属于某个具体的对象，是所有对象所共享的。

1、static修饰成员变量

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

2、static修饰成员方法

Java中，被static修饰的成员方法称为静态成员方法，是类的方法，不是某个对象所特有的。静态成员一般是通过静态方法来访问的。
特性：
（1）不属于某个具体的对象，是类方法。
（2）可以通过对象调用，也可以通过类名.静态方法名(…)方式调用，更推荐使用后者。
（3）不能在静态方法中访问任何非静态成员变量。
（4）静态方法中不能调用任何非静态方法，因为非静态方法有this参数，在静态方法中调用时候无法传递this引用。
（5）静态方法无法重写，不能用来实现多态。

3、static成员变量初始化

注意：静态成员变量一般不会放在构造方法中来初始化，构造方法中初始化的是与对象相关的实例属性。

静态成员变量的初始化分为两种：就地初始化和静态代码块初始化。
（1） 就地初始化
 就地初始化指的是在定义时直接给出初始值。

代码如下（示例）：

public class Student {
    private String name;
    private String gender;
    private int age;
    private double score;
    private static String classRoom = "Bit306";
// ...
}

（2）静态代码块初始化
 代码块总结在后面。

六、代码块

使用 {} 定义的一段代码称为代码块。根据代码块定义的位置以及关键字，又可分为以下四种：普通代码块、构造块、静态块、同步代码块（与多线程有关）。

1、普通代码块

代码如下（示例）：

public class Main {
    public static void main(String[] args) {
        { //直接使用{}定义，普通方法块
            int x = 10;
            System.out.println("x1 = " + x);
        }
        int x = 100;
        System.out.println("x2 = " + x);
    }
}
// 执行结果
x1=10
x2=100

这种用法较少见。

2、构造代码块

构造块：定义在类中的代码块(不加修饰符)。也叫：实例代码块。构造代码块一般用于初始化实例成员变量。
代码如下（示例）：

public class Student {
    //实例成员变量
    private String name;
    private String gender;
    private int age;
    private double score;

    public Student() {
        System.out.println("I am Student init()!");
    }

    //实例代码块
    {
        this.name = "bit";
        this.age = 12;
        this.sex = "man";
        System.out.println("I am instance init()!");
    }

    public void show() {
        System.out.println("name: " + name + " age: " + age + " sex: " + sex);
    }
}

public class Main {
    public static void main(String[] args) {
        Student stu = new Student();
        stu.show();
    }
}
    // 运行结果
    I am instance init()!
    I am Student init()!
    name:bit age:12 sex:man

3、静态代码块

使用static定义的代码块称为静态代码块。一般用于初始化静态成员变量。
代码如下（示例）：

public class Student {
    private String name;
    private String gender;
    private int age;
    private double score;
    private static String classRoom;

    //实例代码块
    {
        this.name = "bit";
        this.age = 12;
        this.gender = "man";
        System.out.println("I am instance init()!");
    }

    // 静态代码块
    static {
        classRoom = "bit306";
        System.out.println("I am static init()!");
    }

    public Student() {
        System.out.println("I am Student init()!");
    }

    public static void main(String[] args) {
        Student s1 = new Student();
        Student s2 = new Student();
    }
}

注意事项：
（1）静态代码块不管生成多少个对象，其只会执行一次。
（2）静态成员变量是类的属性，因此是在JVM加载类时开辟空间并初始化的。
（3）如果一个类中包含多个静态代码块，在编译代码时，编译器会按照定义的先后次序依次执行(合并)。
（4）实例代码块只有在创建对象时才会执行。
（5）执行顺序：静态代码块、实例代码块、调用的对应的构造方法。