前言：

1.什么是面向对象

2.类的定义和使用

3.this引用

3.1this引用的概念

3.2this引用的特性

3.3this的使用

4.构造方法

4.1构造方法概念

4.2构造方法的特性

5.默认初始化

6.就地初始化

7.封装

8.封装扩展之包

8.1为什么对提出包的概念呢？

8.2包的概念

8.3包的作用

8.4导入包中的类

8.5常见的包

8.6自定义的包

9.static成员

10.static成员变量初始化

10.1初识化方法的介绍

10.2代码块

10.2.1普通代码块

10.2.2构造代码块

10.2.3静态代码块

结束语：

前言：

在之前我们学习了Java的一些基础知识点了也接触到了Java和C语言的不同之处，那么今天我们就来讲讲Java中是怎么面向对象的。

1.什么是面向对象

Java是一门纯面向对象的语言（Object Oriented Program，简称OOP），在面向对象的世界里，一切皆为对象。面向对象是解决问题的一种思想，主要依靠对象之间的交互完成一件事情。

2.类的定义和使用

类名注意使用大驼峰定义。
成员前写完统一为public。
此处写的方法不带static关键字。

格式：

class 类名 {

        属性 / 成员属性 / 成员变量

        行为 / 成员方法

}

类是用来对一个实体（对象）来进行描述的。定义了一个类，就相当于在计算机中定义了一种新的类型。

实例化：用类类型来创建对象的过程，称为类的实例化。

new关键字用于创建一个对象的实例
使用·来访问对象中的属性和方法。
同一个类可以创建多个实例。
每个对象都有自己的成员。

代码如下所示：

class Student {
    //属性
    public String name;
    public String gender;
    public int age;

    //行为
    public void Exam() {
        System.out.println("考试");
    }
}
public class Test1 {
    public static void main(String[] args) {
        Student student = new Student();//创建一个对象
        student.age = 10;
        student.name = "张三";
        student.gender = "三年级";
        student.Exam();
    }
}

结果如下所示：

对类的简单理解：

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

代码如下所示：

class Student {
    //属性
    public String name;
    public String gender;
    public int age;

    //行为
    public void Exam() {
        System.out.println("考试");
    }
}
public class Test1 {
    public static void main(String[] args) {
        Student student1 = new Student();//创建出第一个对象
        Student student2 = new Student();//创建出第二个对象
        Student student3 = new Student();//创建出第三个对象
    }
}

但是在上述代码中还有一些要注意的事项：

1.引用不能指向引用。

2.一个引用不能同时指向多个对象。

3.当一个引用被赋值为null时表示这个引用不指向任何一个对象。

 Person person = null;

上面代码中的person不指向任何对象。

3.this引用

3.1this引用的概念

this引用指向当前对象（成员方法运行时调用该方法的对象），在成员方法中所有成员变量的操作，都是通过该引用方法去访问，只不过所有的操作对用户是透明的，即用户不需要来传递，编译器自动完成。

代码如下所示：

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;
    }
}

3.2this引用的特性

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

3.3this的使用

this.date：访问当前对象的成员变量。

this.func()：访问当前对象的成员方法。

this不能调用静态的成员方法和属性。

this（）：必须放在构造方法中的第一条，不能成环。

4.构造方法

4.1构造方法概念

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

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

代码如下所示：

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

    //无参的构造方法：
    public Date() {
    }

    //有参的构造方法：
    public Date(int year, int month, int day) {
        this.year = year;
        this.month = month;
        this.day = day;
    }

    @Override
    public String toString() {
        return "Date{" +
                "year=" + year +
                ", month=" + month +
                ", day=" + day +
                '}';
    }
}
public class Test4 {
    public static void main(String[] args) {
        Date date = new Date(2022,11,21);
        System.out.println(date.toString());
    }
}

结果如下所示：

4.2构造方法的特性

名字必须与类名相同。
没有返回类型，设置为void也不行。
创建对象时由编译器自动调用，并且在对象的生命周期内只调用一次。
构造方法可以重载（用户根据自己的需求提供不同的参数的构造方法）。
如果你没有写任何的构造方法，此时Java中会帮我们提供一个默认的，不带参数构造方法。
如果自己写了，就会在创建对象的时候调用自己的构造方法，不管你写的是啥，Java中都不会给你提供不带参数的构造方法了。

5.默认初始化

在局部变量在使用时必须要初始化，而成员变量可以不用初始化。

下来我们看一下JVM所做的事：
1.检测对象对应的类是否加载了，如果没有加载则加载。

2.为对象分配内存空间。

3.处理并发安全问题。

4.初始化所分配的空间。（对象在申请好空间之后，对象中包含的成员已经设置好了初始值）

5.设置对象头信息。

6.调用构造方法，给对象中各个成员赋值。

6.就地初始化

所谓就地初始化就是在声明成员变量时，就直接给了初始值。

如下所示：

public class Date {
   //就地初始化
    public int year = 1000;
    public int month = 3;
    public int day = 4;

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

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

7.封装

概念：

封装是面向对象程序的三大特性之一，在类和对象阶段，主要研究的就是封装的特性，那么简单来说就是套壳屏蔽内部细节。官方说法就是将数据和操作数据的方法进行有机结合，隐蔽对象的属性和实现细节，仅对外公开接口来和对象进行交互。

那么在Java中提供了四种访问修饰限定符：private、default（默认）、protected、public。

下面我来具体介绍一下四个访问限定符的使用范围：

	范围	private	default	protected	public
1	同一包中的同一类	✔	✔	✔	✔
2	同一包中的不同类		✔	✔	✔
3	不同包中的子类			✔	✔
4	不同包中的非子类				✔

其中封装就是通过private来实现的。一般情况下成员变量设置为private，成员方法设置为public。

8.封装扩展之包

8.1为什么对提出包的概念呢？

为了更好的管理类，把多个类收集在一起成为一组，称为软件包，有点类似于目录。

8.2包的概念

为了更好的管理类，把多个类收集在一起成一个组，称为软件包，包是对类，接口等的封装机制的体现，是一种对类或者接口等很好的组织方式。

8.3包的作用

使得一个包中的类可以不被其他包中的类所引用。
在同一个工程中允许存在相同名称的类，只要处在不同的包中即可。

8.4导入包中的类

一般是使用import语句来导入包，如：import java.until.Date，如果需要使用java.until中的其他类，可以使用import java.until.*。这种是隐式导入一般还是建议显示的指定要导入包的类名，否则还是容易出现冲突的情况。

8.5常见的包

java.lang：系统常用于基础类（String、Object），此包从JDK1.1后自动导入。
java.lang.reflect：java反射编程包。
java.net：进行网络编程开发包。
java.sal：进行数据开发的支持包。
java.until：是java提供的工具程序包。
java.io：I/O编程开发包。

8.6自定义的包

下面小编演示一下如何在idea中自己定义一个包。

在弹出框中写上包的名字：

在侧边栏中若是看到类似于文件夹一样的一个包就表示已经建好了。

接下来我们就可以在包中新建一个类了

在弹窗中写上类名

然后这样我们就在一个包中建好一个类了

同时我们看到在代码的第一行中有一个package语句来指明这个类具体在哪一个包中。

9.static成员

由static修饰的成员变量称为静态成员变量。

特性：

不属于某个具体的对象，是类的属性，所有对象共享的，不存储在某个对象的空间中。
既可以通过对象访问，也可以通过类名访问，但是一般都是通过类名来访问的。也可以通过静态方法名（…）方式调用，但是一般不推荐后者。
变量存储在方法区当中。
生命周期伴随着类的一生（即：随类的加载而创建，随着类的卸载而销毁）。
不能在静态方法中访问任何非静态的成员变量。
静态方法中不能调用任何非静态方法，因为非静态方法中有this参数，在静态方法中调用时候无法传递this引用。
静态方法不能重写，不能用来实现多态。

建议：

获取静态的成员变量或者是设置静态的成员变量，此时的方法最好是静态的，否则你要是非静态的，你还得实例化对象。

代码如下所示：

package demo1;

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public double getScore() {
        return score;
    }

    public void setScore(double score) {
        this.score = score;
    }

    public static void main(String[] args) {
        //静态成员变量可以直接通过类名来访问
        System.out.println(Student.classRoom);

        //其他非静态成员变量要先实例化对象
        Student s1 = new Student();
        Student s2 = new Student();
        s1.name = "张三";
        s1.gender = "男";
        s1.age = 20;
        s1.score = 90.1;
        System.out.println(s1.getName() + " " + s1.getGender() + " " + s1.getAge() + " " + s1.getScore());
        //也可以通过对象访问，但是两个对象的classRoom是共享的
        System.out.println(s1.classRoom);
        System.out.println(s2.classRoom);
    }
}

结果如下所示：

10.static成员变量初始化

10.1初识化方法的介绍

static成员变量初始化分为两种：

就地初识化
静态代码块初始化

就地初始化：是指在定义的时候直接给出初始值，如上述代码中的classRoom。

所谓静态代码块初始化，那么你得先了解什么是代码块。那么跟着小编继续往下看。

10.2代码块

使用{}定义的一段代码就称为代码块，根据代码块的位置以及关键字，又可以分为一下四种：

普通代码块
构造代码块
静态代码块
同步代码块

下面我们来着重了解前三个。

10.2.1普通代码块

就是定义在方法中的代码块

代码如下所示：

package demo1;

public class Test {
    public static void main(String[] args) {
        //普通代码块
        {
            int y = 10;
            System.out.println(y);
        }
    }
}

10.2.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 = "张三";
        this.gender = "男";
        this.age = 20;
        this.score = 90.0;
        System.out.println("I am instance init()");
    }
    public void show() {
        System.out.println("name:" + name + " gender:" + gender + " age:" + age + " score:" + score);
    }

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

结果如下所示：

由上述代码的执行结果可知在实例化完对象时先会执行实例化代码块中的内容，然后再执行构造函数中的内容，最后执行的调用的函数。

10.2.3静态代码块

使用static定义的代码块称之为静态代码块，一般用于初始化静态成员变量。

代码如下所示：

public class Student {
    private String name;
    private String gender;
    private int age;
    private double score;
    private static String classRoom;
    public Student() {
        System.out.println("I am Student init()");
    }
    //实例化代码块
    {
        this.name = "张三";
        this.gender = "男";
        this.age = 20;
        this.score = 90.0;
        System.out.println("I am instance init()");
    }
    //静态代码块
    static {
        classRoom = "207";
        System.out.println("I am static init()");
    }
    public void show() {
        System.out.println("name:" + name + " gender:" + gender + " age:" + age + " score:" + score);
    }

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

结果如下所示：

由上述代码执行结果可以看出它们的执行顺序静态代码块是最先执行的。