JAVA基础-面向对象06

一、封装

　　1. 封装概念和体现　　　　

　　　　封装：包装的意思，隐藏被封装的事物的信息；生活中的包装：快递；食品；电子产品……方便；好看易用；安全；

　　　　Java程序中的包装：

　　　　　　　　　　　　类：包装了同一类事物的共性信息；

　　　　　　　　　　　　函数：包装了一段实现功能的代码；

　　　　可以提高程序的复用性；

　　2.举例　　

　　　　买电脑（台式机）：

　　　　cpu；主板；显卡；电源；风扇；光驱；内存；硬盘；

　　　　最后还要买个机箱把这些元件包装起来；

　　　　不要机箱，直接把这些东西安装在主板上，也可以使用，那为什么要机箱？安全；使用方便；

　　　　总结：程序中使用封装的好处：

　　　　　　　提高程序的安全性；

　　　　　　　提高程序的易用性；

　　　　　　　提高程序的复用性；

　　3.封装的实现

　　

总结：如果可以直接操作对象的成员变量，会存在风险；

怎么解决？

可以考虑使用封装，将事物的信息隐藏起来，不让人直接使用；

怎么隐藏？使用关键字：private；

private：私有的；java中的访问权限修饰符（作用是控制被修饰的成员的访问权限）；被private修饰的成员，只能在本类中使用；

public：公开的，表示被修饰的成员，在任何地方都能使用；

访问权限修饰符修饰成员变量，直接写在变量的数据类型前面；

修饰函数，写在函数声明的最前方；

被私有的成员，只能在定义这个成员的类中使用；

所以被私有的成员需要在外界访问，还需要提供一个公共的方法；

一般对成员变量的操作主要有两个，赋值和取值，所以一般对私有的成员变量需要提供两个公开的方法，

而且这两个方法在开发中有命名规范：

设值：set + 变量名（变量名的首字母大写）；

取值：get + 变量名（变量名的首字母大写）；

在set方法里，可以对传入的参数进行验证；

注意：在开发中，一般类的成员变量都要私有化，然后提供get和set方法；

总结：封装，就是包装，可以隐藏事物的细节信息；同时为了外界能够访问这些细节，还需要提供公开的访问方法；

封装的好处：

可以提高程序的安全性、复用性、易用性；

封装的实现：使用private关键字将需要隐藏的成员修饰；

二、构造函数

1. 构造函数的引入　　　

　　　　　　在生活中，一个物体，一旦被创建，就具有某些属性值，而且是不能后天人为指定的；

　　　　　　比如，人一出生，性别，年龄，体重……

　　　　　　在Java程序中要模拟这种情况，就需要在对象创建的时候，就把这些属性赋好值，不能等到对象创建完毕了，再去赋值；

　　　　　　怎么在创建对象的同时，就给他的成员变量赋值呢？

　　　　　　就需要使用，构造函数；

　　2. 概念：构造函数，又叫做构造器，是JVM在创建对象的时候，自动调用的函数；　　

　　3. 作用：创建对象给对象成员变量赋初始值

　　4. 写法：

　　　　　　 a. 要与类名一致

　　　　　　b. 没有返回值类型（void都不写）

　　　　　　c.有return语句，一般不写

　　　　　　d.参数列表：构造函数可以重载，参数列表可以有不同情况，就提该怎么写，根据需求而定；

　　　　　　e.可以被访问权限修饰符修饰，不能static修饰

　　　　　　

　　　　　　　　　　

　　5. 调用

　　　　　　直接写在new关键字后面，也是通过函数名和参数调用；

　　　　　　

　　6. 内存图解

　　　　　　

　　7. 默认构造函数　　　

　　　　实际上，所有类，都至少有一个构造函数，创建对象时都会调用这个构造函数，如果我们没写，编译器会帮我们加上；

　　　　

编译器帮我们加上的构造函数，叫做默认构造函数，默认构造函数的特点： a.无参  b.方法体是空的

　　8. 使用细节　　

　　　　a.如果使用private修饰构造函数，会有什么结果？

　　　　　　　　

　　　　构造函数私有化，就只能在被类中使用，别的地方调用不了；单例设计模式时会用到；　　

　　　　b. 构造函数能不能调用一般函数（可以）

　　　　　　

　　c.一般函数能不能调用构造函数

　　　　

　　9.构造函数和一般函数的区别

　　　　a. 从书写格式上看　　　　

　　　　　　  构造函数，没有返回值类型；函数名必须和类名一致；

　　　　　　 一般函数：必须有返回值类型；函数名可以自定义；一般不要和类名一样;　　　　

　　　 b. 从调用方式上看：

　　　　　　 构造函数：在创建对象时，由JVM自动调用；

　　　　　　一般函数：创建对象后，由对象名来调用；

　　　c. 从作用上看：

　　　　　　 构造函数：在创建对象时，就给成员变量赋值；

　　　　　　一般函数：实现各种功能，描述事物的行为信息；

　　　d.从一个对象可以调用次数上看：

　　　　　　 构造函数：只在创建对象时被调用一次；

　　　　　　 一般函数：可以使用对象名调用无数次；

　　10.构造函数之间的调用

　　　　a. 构造函数可以调用其他构造函数，需要使用this关键字来实现；

　　　　

　　b.this调用构造函数，必须卸载构造函数的第一行

　　c. 调用其他构造函数，要避免交叉调用；

　　

构造函数总结：

构造函数，又叫构造器，由JVM在创建对象的时候自动调用的函数，作用是在创建对象的时候给对象的成员变量赋初始值；

写法：

1、函数名必须和类名一致；

2、没有返回值类型（void都不要写）

3、有，构造函数也是通过return语句出栈的，但是一般都不写；

4、参数列表根据实际需要，可以自定义的；构造函数是可以重载的；

5、修饰符：可以使用访问权限修饰符；不能使用static关键字修饰；

用法：直接写在new关键字后面，也是通过函数名和参数来调用的；

创建对象的大概过程：

1、先在堆内存中开辟空间，得到一个内存地址；

2、将类的所有成员变量加载到这个内存空间中；

3、给加载到内存中的成员变量赋默认值；

4、根据new关键字后面调用情况，找到相应的构造函数，然后构造函数进栈执行；

a)         构造函数执行，先要执行一个隐式三步；

b)        执行完隐式三步，执行书写在构造函数中的代码；

5、构造函数执行完毕，出栈，对象就创建完成；

在所有的类中，都至少有一个构造函数，我们通过new关键字创建对象，都要调用构造函数；

如果类中没有书写构造函数，编译器会自动添加一个构造函数，就是默认构造函数；

默认构造函数没有参数和方法体；

如果类中写了构造函数，就不会再有默认构造函数；

如果在创建对象时试图调用不存在的构造函数，就会报错，解决办法：

1、在类中创建一个需要调用的构造函数；

2、调用存在的构造函数；

构造函数的使用细节：

1、私有的构造函数，不能被外界使用；

2、构造函数可以调用一般函数；

3、一般函数不能调用构造函数；

4、构造函数之间可以相互调用，使用this关键字实现的；

5、使用this关键字调用其他构造函数，this语句必须写在构造函数的第一行；

6、构造函数相互调用，不能交叉调用；

三、This关键字

　　1. this的作用 ： this---表示自身所属对象的引用（就相当于平时大家说的一个字：我）；

　　

　　哪个对象调用this，this就指向哪个对象；

　　2.关键字this的应用

　　　　a. 在构造函数中调用其他构造函数；

　　　　b. 可以区分成员变量和局部变量；

　　3.this练习

　　　　

　　　　

　　　　内存图解

　　　　

四、static关键字

　　1. static 引入

　　　　　

　　　　问题：

怎么解决呢？

如果可以不创建对象，就能直接使用函数，就可以避免创建对象造成的空间浪费；

回想以前写的程序，发现，main函数是程序的入口，程序执行都是从他开始，在他之前都没有创建对象；

所以，可以考虑使用static关键字修饰函数；

　　　　

结论：使用static关键字修饰函数，函数不需要创建对象，直接使用类名就可以调用；

Java的内存分布，包括栈内存、堆内存、方法区、本地方法区、寄存器；

static：静态的，可以修饰成员函数，书写格式是：直接写在函数的返回值类型前面；

作用：表示被修饰的函数是静态的，可以不需要对象，直接使用类名来调用；

　　3. 静态函数使用特点

　　　　a. 静态函数是不需要对象，直接可以使用类名来调用;

　　　　b. 静态函数能不能调用非静态函数呢？非静态函数都是通过对象调用的；

　　　　

　　4、非静态函数，能不能调用静态函数呢？

　　　　结论：非静态函数可以调用静态函数；

　　　　在底层，依然使用的是类名来调用；

　　5.　　静态函数中不能使用哪些关键字呢？

　　　　　静态函数调用时不需要对象的，所以不能使用和对象有关的关键字；（this,super)

　　　　

　　　　　　　　

　　　　可以在静态函数中创建对象；

　　6.  为什么构造函数不能使用static修饰呢？

　　　　　　构造函数是创建对象，开辟空间，给所有成员变量赋默认值之后，有JVM调用进栈，用来给对象的成员变量赋初始值的

　　7. 静态函数不能使用非晶态成员变量,但可以使用静态成员变量

　　8. 静态成员变量　　　

　　　　static关键字可以修饰成员变量，修饰成员变量，表示这个变量是静态的；

　　　　a. 问题引入：需求：定义一个表示圆形的类，需要提供获取面积的功能；

　　　　　　

　　9. 静态修饰成员变量　　　

　　　　和静态函数一样，可以使用static关键字修饰成员变量，被修饰的就是静态成员变量；

　　　　书写格式是：直接将static关键字写在成员变量的数据类型前面；

　　　　

　　　　

　　　　总结：

　　　　　　静态成员变量放在方法区的静态区域中，不管创建一个类的多少实例对象，静态的成员变量，在这些对象爱你个中都是共享的，所以可以解决上名出现的空间浪费的问题；

1、从保存位置：

a)         静态成员变量：方法区的静态区域

b)        非静态成员变量：堆内存中

2、从书写格式上看：

a)         静态成员变量：使用static修饰；

b)        非静态成员变量：不使用static修饰；

3、从生命周期上看：

a)         静态成员变量：类加载的时候，开始分配空间，类卸载的时候；

b)        非静态成员变量：创建对象的时候分配空间；对象被回收的时候；

4、从使用方法上看：

a)         静态成员变量：通过类名直接访问，不需要对象；

b)        非静态成员变量：必须通过对象来使用；

5、从修改后的影响范围上看：

a)         静态成员变量：一旦修改，一个类的所有实例对象都会受到影响；

b)        非静态成员变量：一旦修改，受影响的只有修改它的一个对象；

所以，像圆形的圆周率这样的成员变量，一般需要定义成静态和私有的（等学习了final后，还需要定义成final的）；

static使用总结：

static：静态的，可以修饰成员变量和成员函数，表示被修饰的成员是静态的（不能修饰构造函数）；

修饰函数：直接写在函数返回值类型前面；如：public static void main(String[]  args){}

修饰成员变量：直接写在变量的数据类型前面；如：static int a；

静态成员的特点：

1、都可以使用类名直接访问，不需要创建对象；

2、都是保存在方法区的静态区域；

静态函数只能使用静态函数和静态成员变量，不能使用非静态的函数和成员变量；

非静态函数可以使用所有成员；

静态函数不能使用的关键字：this；super；

问题：什么时候不能使用静态函数？

如果要使用非静态成员；