07面向对象2.docx

07面向对象2.docx

《07面向对象2.docx》由会员分享，可在线阅读，更多相关《07面向对象2.docx（25页珍藏版）》请在冰豆网上搜索。

07面向对象2

第7天面向对象2

今日任务

1、理解封装的思想，会使用private关键字隐藏类的属性和行为；

2、理解并掌握构造函数的用法；

3、理解并掌握this关键字的用法

4、理解掌握static关键字的用法

面向对象的基本特征：

封装；继承；多态

1.封装

1.1.封装的概念和体现

封装：

包装的意思，隐藏被封装的事物的信息；

生活中的包装：

快递；食品；电子产品……

方便；好看易用；安全；

Java程序中的包装：

类：

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

函数：

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

可以提高程序的复用性；

1.2.封装举例

买电脑（台式机）：

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

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

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

安全；

使用方便；

总结：

程序中使用封装的好处：

提高程序的安全性；

提高程序的易用性；

提高程序的复用性；

1.3.封装的实现—private关键字

需求：

描述学生的信息；

1、找对象：

学生；

2、伪代码描述：

学生{

//属性：

姓名；

年龄；

学号

……

//行为

学习（）{

}

}

3、使用Java代码描述：

4、创建测试类，测试对象：

总结：

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

怎么解决？

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

怎么隐藏？

使用关键字：

private；

private：

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

public：

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

java中的访问权限有四种，访问权限修饰符，有三个，具体到以后学习包的使用时再学；

使用private关键字改造：

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

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

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

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

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

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

设值：

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

取值：

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

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

注意：

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

总结：

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

封装的好处：

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

封装的实现：

使用private关键字将需要隐藏的成员修饰；

2.构造函数

2.1.构造函数的引入

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

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

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

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

就需要使用，构造函数；

2.1.1.概念

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

2.1.2.作用

就是在创建对象的时候，给对象的成员变量赋初始值；

2.1.3.写法

函数名：

必须和类名一致（包括大小写）

返回值类型：

没有返回值类型（连void都不能写）

return语句：

也有return语句，不过一般不写；

参数列表：

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

修饰符：

可以被访问权限修饰符修饰；不能被static修饰；

实例：

2.1.4.调用

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

2.2.构造函数的内存图解

2.3.默认构造函数

实际上，所有类，都至少有一个构造函数；

创建对象时都会调用这个构造函数；

如果我们没写，编译器会帮我们加上；

编译器帮我们加上的构造函数，叫做默认构造函数；

默认构造函数的特点：

1、无参；

2、方法体是空的；

2.4.构造函数的使用细节

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

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

2、构造函数能不能调用一般函数？

可以：

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

一般构函数，不能调用构造函数！

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

1、从书写格式上看：

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

b）一般函数：

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

如果函数的名字和类名一样，判断是不是构造函数，就通过有没有返回值类型来确定；

2、从调用方式上看：

a）构造函数：

在创建对象时，由JVM自动调用；

b）一般函数：

创建对象后，由对象名来调用；

3、从作用上看：

a）构造函数：

在创建对象时，就给成员变量赋值；

b）一般函数：

实现各种功能，描述事物的行为信息；

4、从一个对象可以调用次数上看：

a）构造函数：

只在创建对象时被调用一次；

b）一般函数：

可以使用对象名调用无数次；

2.6.构造函数之间的调用

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

2、this调用构造函数，必须写在构造函数的第一行；

3、调用其他构造函数，要避免交叉调用；

构造函数总结：

构造函数，又叫构造器，由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、构造函数相互调用，不能交叉调用；

1、什么时候需要使用构造函数？

2、什么时候需要自定义构造函数？

3、使用构造函数，可以在创建对象的时候就给对象的成员变量赋初始值，那么，有了构造函数，还需要提供get和set方法吗？

3.this关键字

3.1.this的作用

this：

这个，表示自身所属对象的引用；

（就相当于平时大家说的一个字：

我）

总结：

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

3.2.关键字this的应用

1、在构造函数中调用其他构造函数；

2、可以区分成员变量和局部变量；

3.3.this练习

需求：

创建一个描述人的类，并提供比较是否是同龄人的功能；

1、找对象：

人；

2、描述：

人{

年龄；

人（年龄）{

this.年龄=年龄；

}

是否是同龄人（人）{

this.年龄==人.年龄；

}

}

模拟：

人张三=new人（34）；

人李四=new人（23）；

张三.是否是同龄人（李四）;//表示张三和李四比

李四.是否是同龄人（张三）;//表示李四和张三比

3、java代码：

内存图解：

4.static关键字

4.1.static引入

需求：

定义一个描述学生信息的类，需要提供学习的方法；

问题：

怎么解决呢？

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

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

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

结论：

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

4.2.static修饰函数

回忆：

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

static：

静态的，可以修饰成员函数，书写格式是：

直接写在函数的返回值类型前面；

作用：

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

4.3.静态函数使用特点

1、静态函数是不需要对象的，直接可以使用类名来调用；

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

非静态函数都是通过对象调用的；

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

结论：

非静态函数可以调用静态函数；

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

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

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

this；super；

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

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

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

6、静态函数不能使用非静态成员变量，但可以使用静态成员变量；

4.4.静态成员变量

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

4.4.1.问题引入

需求：

定义一个表示圆形的类，需要提供获取面积的功能；

4.4.2.静态修饰成员变量

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

书写格式是：

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

总结：

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

4.4.3.静态成员变量和非静态成员变量的区别

1、从保存位置：

a）静态成员变量：

方法区的静态区域

b）非静态成员变量：

堆内存中

2、从书写格式上看：

a）静态成员变量：

使用static修饰；

b）非静态成员变量：

不使用static修饰；

3、从生命周期上看：

a）静态成员变量：

类加载的时候，开始分配空间，类卸载的时候；

b）非静态成员变量：

创建对象的时候分配空间；对象被回收的时候；

4、从使用方法上看：

a）静态成员变量：

通过类名直接访问，不需要对象；

b）非静态成员变量：

必须通过对象来使用；

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

a）静态成员变量：

一旦修改，一个类的所有实例对象都会受到影响；

b）非静态成员变量：

一旦修改，受影响的只有修改它的一个对象；

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

static使用总结：

static：

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

修饰函数：

直接写在函数返回值类型前面；如：

publicstaticvoidmain（String[]args）{}

修饰成员变量：

直接写在变量的数据类型前面；如：

staticinta；

静态成员的特点：

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

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

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

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

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

this；super；

问题：

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

如果要使用非静态成员；