082301面向对象01Word格式.docx
《082301面向对象01Word格式.docx》由会员分享，可在线阅读，更多相关《082301面向对象01Word格式.docx（54页珍藏版）》请在冰豆网上搜索。
}
●方法重载:
方法名称相同，参数类型或个数不同，方法重载的时候虽然允许不同的返回值类型，但是尽量要统一，这样是为了减少开发中的麻烦：
●方法的递归调用：
一个方法自己调用自己的情况称为递归调用，而且方法递归调用的时候一定要考虑到结束条件。
5、数组：
是一组相关类型的变量集合；
.数组的定义格式：
|-动态初始化:
先开辟数组空间，之后数组中的每一个元素都是其默认值；
|-格式：
数据类型数组名称[]=new数据类型[长度]|-格式：
数据类型[]数组名称=new数据类型[长度]|-采用分步完成：
|-声明数组：
数据类型：
数据类型数组名称[]=null;
理解为在栈内存中开辟
|-开辟数组：
数组名称=new数据类型[长度]在堆内存中保存具体的数据
|-静态初始化：
直接开辟数组，并且为其赋值；
|-格式：
数据类型数组名称[]={值1,值2,值3,…..};
数据类型数组名称[]=new数据类型[]{值1,值2,值3,…..};
.数组的引用传递：
数组的所有内容都保存在堆内存之中，每一块堆内存空间都可以同时被多个栈内存所指向，而不同的栈内存修改的时候，由于是同一个内存空间，所以所有的内容都会发生改变；
.在使用方法接收或返回数组的时候，只需要将参数或返回值类型定义为参数即可，这个也属于引用传递；
.数组的两个操作方法：
|-数组排序：
java.util.Arrays.sort（数组名称）;
|-数组拷贝：
System.arraycopy（源数组名称,源数组开始点,目标数组名称,目标数组开始点,拷贝长度）;
2.2习题讲解
1、要求算出：
1！
+2！
+60！
的结果
60！
的阶乘最终的计算结果已经很大了，要使用double类型数据保存；
实现一：
通过循环完成
publicclassSimple{
publicstaticvoidmain（Stringargs[]）{
doublesum=0.0;
//保存最终的计算结果
for（intx=1;
x<
=60;
x++）{
doubletemp=1.0;
for（inty=1;
y<
=x;
y++）{
temp*=y;
}
sum+=temp;
}
System.out.println（sum）;
}
实现二：
通过递归操作完成
System.out.println（mul（60））;
publicstaticdoublemul（intnum）{
if（num==1）{
returnfun
（1）;
returnfun（num）+mul（num-1）;
}
publicstaticdoublefun（intnum）{
return1;
returnnum*fun（num-1）;
2、编写一个方法，些方法可以将一个整数变为二进制输出（提示:
二进制的计算方法是除2取余，倒着取余数。
）
intnum=11;
Stringbin="
"
;
while（num!
=0）{
bin=（num%2）+bin;
num=num/2;
System.out.println（bin）;
通过递归完成
toBinary（11）;
publicstaticvoidtoBinary（intnum）{
if（num/2==0）{//应该已经计算到结束了
System.out.print（num%2）;
}else{
toBinary（num/2）;
//向下继续计算；
3、有5个人坐在一起，问第五个人多少岁？
答：
比第4个人大2岁，问第4个人多少岁的时候，比第3个人大2岁，问第3人多少岁的时候，比第2个人大2岁，问第一个人的时候，第一个人说自己是8岁。
intage=8;
for（intx=0;
4;
age+=2;
System.out.println（age）;
System.out.println（age（5））;
publicstaticintage（intnum）{
return8;
return2+age（num-1）;
以上的三道题目是帮助大家对于递归操作做了进一步的复习，这些内容只有写之后才能明白。
4、将一个给定的整型数组转置输出，
例如：
源数组：
123456
转置后的数组：
654321
如果要想实现数组的转置操作，最方便的做法是取中间之后进依次的替换。
如果想要按照如上的方式实现数组转置功能，则第一步就需要知道数组的中间点是什么。
int[]data=newint[10];
//定义数组
init（data）;
reverse（data）;
//数组转置
print（data）;
publicstaticvoidinit（intarr[]）{
for（intx=0;
x<
arr.length;
x++）{
arr[x]=x;
publicstaticvoidreverse（intarr[]）{
intcenter=arr.length/2;
inthead=0;
inttail=arr.length-1;
center;
inttemp=arr[head];
arr[head]=arr[tail];
arr[tail]=temp;
head++;
tail--;
publicstaticvoidprint（inttemp[]）{
x<
temp.length;
System.out.print（temp[x]+"
、"
）;
本程序在以后的课程讲解中肯定要使用，一定要理解代码的实现，而且在实现本程序的时候，唯一的思路，就在于应该将主方法中的代码变得越少越好。
5、现在有如下一个数组：
intnewArr[]={1,3,4,5,0,0,6,6,0,5,4,76,7,0,5};
要求将以上数组中值为0的项去掉，将不为0的值存入一个新的数组，生成新的数组为：
intnewArr[]={1,3,4,5,6,6,7,6,7,5};
实现思路：
1、应该知道不为0的数字的个数，并且以此个数开辟一个新的数组；
2、将旧的数组中不为0的内容拷贝到新数组中；
intoldArr[]={1,3,4,5,0,0,6,6,0,5,4,7,6,7,0,5};
intnewArr[]=newint[count（oldArr）];
//开辟新的数组
copy（oldArr,newArr）;
print（newArr）;
publicstaticintcount（intarr[]）{
intsum=0;
//保存不为0个数
if（arr[x]!
sum++;
returnsum;
publicstaticvoidcopy（intarr[],intarrB[]）{
intfoot=0;
arr.length;
x++）{
arrB[foot++]=arr[x];
6、现在给出两个数组：
。
数组A:
1,7,9,11,13,15,17,19;
数组B:
2,4,6,8,10
两个合并为数组C，按升序排列。
intdataA[]={1,7,9,11,13,15,17,19};
intdataB[]={1,7,9,11,13,15,17,19};
intdataC[]=count（dataA,dataB）;
java.util.Arrays.sort（dataC）;
print（dataC）;
publicstaticint[]count（intarrA[],intarrB[]）{
intarrC[]=newint[arrA.length+arrB.length];
System.arraycopy（arrA,0,arrC,0,arrA.length）;
System.arraycopy（arrB,0,arrC,arrA.length,arrB.length）;
returnarrC;
本次预计讲解的知识点
1、面向对象的主要特点；
2、类与对象的关系；
3、对象引用传递的初步分析；
4、private封装性的实现；
5、构造方法的定义及使用；
6、匿名对象的操作
7、String类的特点及常用方法
3具体内容
3.1认识面向对象（理解）
面向对象是目前最流行的程序设计方法，在面向对象的设计出现之前都是面向过程的设计方式，至于这两者的区别，只能通过一句简单的话概括：
面向对象具有很强的重用性，而面向过程的开发，只适合一次性的开发操作。
最早的面向对象的概念是由IBMSmalltalk语言所提出，而后开发了C++和Java，而对于面向对象本身有三大主要特点：
。
特点一：
封装性，保护内部的东西对外不可见；
特点二：
继承性，扩充类的功能；
特点三：
多态性，在某一个范围内，任意改变所属类的形式；
在面向对象之中，除了以上的三个特征之外，还有如下三个开发过程：
OOA：
面向对象的分析；
OOD：
面向对象的设计；
OOP：
面向对象的程序；
面向对象的唯一好处就在于，与现实生活是完全接轨的，而且没有这么多的意外出现。
3.2类与对象（重点）
3.2.1类与对象的基本定义
类和对象是面向对象之中最基本的组成单元，也是以后的所有程序的开发基础，下面首先先分析两者之间的关系：
分析：
为什么许先生可以听听懂我说话？
他是一个人，一个活人，一个活着的中国人；
他是一个正常的能够正常沟通的人；
我也是个人，我也能正常沟通；
我和许先生都处于一个特点，都是（中国）人类。
类：
表示某一个群体的共同特征，是一个抽象的概念；
对象：
表示的是一个个体的特征，受到类的控制，类中可以规定出对象的操作行为；
类中主要由两部分所组成：
成员（属性）：
用于描述不同的对象信息；
方法：
用于完成某些功能的实现；
通过以上的分析，可以得出以下的结论：
在操作的时候应该先有类再有对象；
类中规定出了对象的所有操作的方式（属性、方法），而对象是类的具体形式；
如果把类比喻成洗车设计图纸的话，那么对象就是那一辆辆的汽车。
类是对象的操作模板，而对象是类的使用实例，对象是真正可以看得见摸得着的东西，而类只是一个概念。
3.2.2类和对象的基本操作
掌握了类和对象的基本区别之后，下面进行程序的具体实现，首先在开发之中应该先建立类，而所有的类都使用class关键字定义，类中要包含属性（变量）和方法；
范例：
定义一个Person类
classPerson{//定义一个Person类
Stringname;
//属性：
表示姓名
intage;
//属性：
表示年龄
publicvoidtell（）{
System.out.println（"
姓名：
+name+"
，年龄：
+age）;
本类定义了两个属性（name、age）以及一个操作方法（tell（）），而类定义完成之后不能立刻使用，必须要有对象而对象的定义格式如下：
格式一：
声明并实例化对象
类名称对象名称=new类名称（）;
格式二：
分步完成操作
声明对象：
类名称对象名称=null;
实例化对象：
对象=new类名称（）;
些时在对象的定义的格式上出现了关键字“new”，此处肯定表示要开辟堆内存空间。
当声明并实例化一个类的对象后，下面就可以通过如下的语法进行类的操作：
操作属性：
对象属性；
操作方法：
对象.方法（）;
定义对象并使用
年龄：
publicclassOODemo{
publicstaticvoidmain（String[]args）{
Personper=newPerson（）;
//声明并实例化对象
per.name="
张三"
//调用属性
per.age=30;
//调用属性
per.tell（）;
//调用方法
如果说现在的OODemo类之中，没有设置name和age的属性，那么结果是null和0。
些时，由于没有对name和age属性设置内容，所以都是默认值，String是一个类默认值就是null，而age是一个int型的数据，默认值是0。
而且既然是引用数据类型，肯定要有对象的内存关系，实际上这个的内存分析和数组是完全类似：
堆内存：
保存对象的具体信息，实际上就是属性的信息；
栈内存：
保存了堆内存的地址，简单理解保存的就是对象名称；
但是在这里需要说明的，以上的程序在定义对象的时候，使用的是“声明并实例化”的操作完成的，实际上对象操作也可以分为两步完成
Personper=null;
//声明对象
per=newPerson（）//实例化对象
per.naem="
//调用属性
//调用属性
//调用方法
此时的内存分析图，如下：
所以来说，现在规定对于以后的对象名称，有两种叫法：
指已经开辟了栈内存，但是没有堆内存空间；
已经明确地开辟了堆内存空间，则表示对象可以使用。
错误的程序
本程序只是声明了对象，但是并没有进行对象的实例化操作，所以本程序在运行的时候将出现如下的错误信息：
Exceptioninthread“main”java.lang.NullPointterException
此时出现了“NullPointerException”空指向异常，这种异常只发生在引用数据类型之中，表示直接使用了没开辟堆内存的对象，而且这个问题会一直伴随着你。
3.2.3深入分析对象的引用传递
以上只是对程序做了一个简单的实现，但是实际工作之中，对象的引用传递是一个难点，而且对于初学者而言，对象的引用传递也是一个难以理解的部分，下面通过几个程序来分析一下。
如果说现在产生两个对象，那么这两个对象之间是否会互相影响呢？
Personper1=newPerson（）;
//声明并实例化对象
Personper2=newPerson（）;
//声明并实例化第二个对象
per1.name="
//设置name属性
per1.age=30;
//设置age属性
per2.name="
李四"
per2.age=20;
per1.tell（）;
per2.tell（）;
此时的内存关系图如下所示：
因为使用的是关键字new，所以在任何情况下都表示会开辟新的内存空间。
类本身是属于引用数据类型，那么既然是引用数据类型，则肯定一块堆内存同时被多栈内存所指向，所以下面通过一个引用传递的操作来分析：
Personper2=null;
//声明第二个对象
//设置name属性
//设置age属性
per2=per1;
//将per1的堆地
升级会员 