Java-----类与对象、封装的基础知识（超详细讲解）

 1、面向象的初步认识

       Java是一门纯面向对象的语言，在面向对象的世界里，一切皆为对象。面向对象是解决问题的一种思想，主要依靠对象之间的交互完成一件事情。用面向对象的思想来涉及程序，更符合人们对事物的认知，对于大型程序的设计、扩展以及维护都非常友好。而C语言就是一门面向过程的面向过程的编程语言,C++是一门既可以面向过程又可以面向对象。

1.1、面向过程与面向对象的区别

        用简单的话来概述便是：面向过程更加注重过程，而面向对象则就更注重对象与对象之间的交互，不那么注重过程。用一个常例子来说：“将大象放入冰箱需要几步”，对于面向对象的思维而言就只需要三步，第一步将冰箱门打开、第二步将大象放进冰箱里、第三步把冰箱门关上，这就明显的通过对象之间的交互完成的。至于怎么将大象放入冰箱里不是其考虑的事，而面向过程则必须要考虑如何去实现这个事情。

2、 对类的基本认识

2.1、什么类？什么是对象？

       我们用一个形象的比喻，类就相当于是建楼的图纸，而对象就是一座座建好的高楼，用一张图纸可以建起多座楼层。类是描述对象的，对象是一个真正存在的一个实体。

2.2、用简单的代码实现一个学生类

public class student {
    {
        String name;
        int age;
        String num;
    }
}

       以上我定义了一个学生类，定义了成员变量姓名、年龄、电话号码。我们对类里面的变量和方法分别叫做成员变量和成员方法（也可以叫做字段的属性）。

3、 类的实例化

3.1、什么是实例化？

       定义了一个类，就相当于在计算机中定义了一种新的类型，与int、double类似，不过int和double是Java语言自带的内置类型，而类是用户自己定义的一个新的类型，比如上面的student便是一个学生类，有了这些类之后便可以用这些类来定义实例。用类类型创建对象的过程，称为类的实例化。1、使用new关键字来实例化对象.2、使用new关键字1可以实例化多个对象。

public class student {

        String name;
        int age;
        String num;

}

public class Text {
    public static void main(String[] args) {
        student student1 = new student();
        student1.name = "张三";
        student1.age = 10;
        student1.num = "351651";
    }
}

3.2 对类详细的说明：

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

4、 this关键字

4.1、了解this关键字

在了解this关键字的时候我们首先就要想到为什么我们需要使用关键字。

我们举一个非常形象的例子：

public class date {
        int year;
        int mouth;
        int day;
        public void date(int year, int mouth, int day)
        {
                int year = year;
                int mouth = mouth;
                int day = day;
        }
}

  在这个代码中，形参数名和成员变量相同时，这个时候编译器不清楚是成员变量给成员变量赋值？参数给参数赋值？还是参数给成员变量赋值？

还有一种情况便是：

public class date {
    int year;
    int mouth;
    int  day;
    public void setdate(int y, int m, int d)
    {
        year= y;
        mouth = m;
        day = d;
    }
    public void print()
    {
        System.out.println(year + "年" + mouth + "月" + day + "日");
    }
}

public class Text {
    public static void main(String[] args) {
        date date1 = new date();
        date date2 = new date();
        date date3 = new date();
        date1.setdate(2024, 9, 28);
        date2.setdate(2024, 9, 28);
        date3.setdate(2024, 9, 28);
        date1.print();
        date2.print();
        date3.print();
    }
}

       在成员方法在真正执行的时候，方法体中并没有任何关于对象的说明，哪setdate是如何要如何知道要设置那个对象的？printdate是如何知道要打印那个对象的？

4.2 这时候就该this关键字发挥作用了。

public class date {
        int year;
        int mouth;
        int day;
        public void date(int year, int mouth, int day)
        {
               this.year = year;
               this.mouth = mouth;
               this.day = day;
        }
        public void print()
        {
             System.out.println(this.year + "年" + this.mouth + "月" + this.day + "日");
        }
}

这时候的this关键字就能只想date的成员变量。

4.3、this关键字 的使用方法：

1、this来访问当前对象的成员变量。

2、this来访问当前对象的成员方法。

3、this来调用当前对象的构造方法。

4.4、this关键字 引用特性：

                                 1. this的类型：对应类类型引用，即哪个对象调用就是哪个对象的引用类型

                                 2. this只能在"成员方法"中使用

                                 3. 在"成员方法"中，this只能引用当前对象，不能再引用其他对象 

                                 4. this是“成员方法”第一个隐藏的参数，编译器会自动传递，在成员方法执行                                   时，编译器会负责将调用成员方法 对象的引用传递给该成员方法，this负责                                     来接收。

4.5、 this关键字的注意事项：

          1、this()这个必须是在第一行。2、不能形成环状。

5、构造方法

5.1、构造方法的概念：

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

public class date {
    int year;
    int mouth;
    int day;
    // 有参构造
    public date(int year, int mouth, int day)
    {
        this.year = year;
        this.mouth = mouth;
        this.day = day;
    }
    //无参构造
    public date()
    {
        this.year = 1990;
        this.mouth = 9;
        this.day = 28;
    }
    public void print()
    {
        System.out.println(this.year + "年" + this.mouth + "月" + this.day + "日");
    }
}

无参构造时一般采用的是就地初始化。

实例化一个对象的时候，一个对象的产生至少有2步是必须的：

1、为对象分配内存。

2、调用合适的构造方法。

如果当前类 没有提供任何的构造方法，那么java本身也会给这个类提供一个不带参数的构造方法。

如若已经有了构造方法则不提供。

5.2、构造方法的特性：

1. 名字必须与类名相同。

2. 没有返回值类型，设置为void也不行。

3. 创建对象时由编译器自动调用，并且在对象的生命周期内只调用一次(相当于人的出生，每个人只能出生一次)。

4. 构造方法可以重载(用户根据自己的需求提供不同参数的构造方法)。

6、封装

6.1、封装的基本概念：

        面向对象程序三大特性：封装、继承、多态。而类和对象阶段，主要研究的就是封装特性。何为封装呢？简单来说 就是套壳屏蔽细节。将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行交互。封装后只能通过类的内部赋值来调用。

6.2、封装中private的使用：

public class date {
    public int year;
    public int mouth;
    public int day;
    private void print()
    {
        System.out.println("封装后的被打印了");
    }
    public void print1()
    {
        System.out.println("未被封装后的被打印了");
    }
}

        这其中被private修饰的print方法只能在该被定义的类里面被访问，而不能在类外被访问。

6.3、该访问限定符入该表所示：

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

说明：1、protected主要是用在继承中，继承部分详细介绍

2、default权限指：什么都不写时的默认权限

3、访问权限除了可以限定类中成员的可见性，也可以控制类的可见性

6.4、 包的基本概念：

        在面向对象体系中，提出了一个软件包的概念，即：为了更好的管理类，把多个类收集在一起成为一组，称为软件包，也有点类似与目录。

6.4.1 Java中常见的包

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

7、static关键字

封装就是隐藏对类中的一些细节，对外提供一些公开的接口。

对于静态成员变量来说，通过类名进行访问。但是如果拿对象的引用访问也是可以的。但是这个是不合理的！！！静态的不依赖对象。

静态的成员方法当中，不能访问非静态的成员变量和成员方法。

为什么不能访问？在static方法当中不存在this关键字，都是通过对象的引用去调用的。

但是非静态方法可以调用静态中的成员变量和方法。

静态变量就叫类的变量，将他放在方法中就变成局部变量，局部变量不能加static。 (加static叫做类变量)

8、代码块的基本使用

       代码块分为：1、静态代码块 2、非静态代码块(实例代码块/构造代码块) 3、普通代码块 4、同步代码块

普通代码块：

    public static void main(String[] args) {

        {
            int x = 10;
            System.out.println("x2 = " + x);
        }
        int x = 100;
        System.out.println("x2 = " + x);
   }
}

2、构造代码块： 先编译静态代码块然后是构造代码块最后编译编译构造方法块

3、静态代码块：static{}... 且静态代码块只能执行一次。 如果都是静态代码块则谁在上方就先执行谁。静态方法不依赖于对象，在调用静态方法的时候也会调用静态代码块。