面向对象over.docx
《面向对象over.docx》由会员分享，可在线阅读，更多相关《面向对象over.docx（20页珍藏版）》请在冰豆网上搜索。
面向对象over
数据类型1
基本数据类型1
引用类型3
控制语句3
顺序结构3
选择结构3
循环结构4
面向对象5
面向过程和面向对象的区别5
类和对象5
成员变量5
方法5
方法的重载（overload）5
构造方法5
内存分析5
package6
import6
this6
static6
super6
面向对象的三大特征6
封装6
继承6
方法的重写（override）6
多态6
抽象类7
接口7
面向接口编程7
数据类型
基本数据类型
a）数值型
i.整型
1.byte1个字节（256）-128-127
2.short2个字节（65536）正负3万
3.int4个字节正负21亿
4.long8个字节
ii.浮点型
1.float4个字节
2.double8个字节
注：
类型的自动转换
类型的强制转换
/*doubled1=0.1;
doubled2=0.5-0.4;
System.out.println（d2）;
if（d1==d2）{
System.out.println（"dddd"）;
}else{
System.out.println（"eeeee"）;
}
*/
floatf1=0.134F;
floatf2=（float）0.134;
doubled1=0.345F;
byteb=123;//int可以自动转换为byte,short,char。
只要不超过它们的表述范围。
doubled=23234;
doubled2=123L*234;//表达式类型的自动提升
longi=234231L*234233*23423;//
System.out.println（i）;
b）字符型2个字节65536unicode字符集
c）布尔型
true,false
charc1='a';
charc2='中';
char中2='国';
booleanb=true;
if（b==true）{
System.out.println（"true"）;
}
if（b）{//建议此种写法！
System.out.println（"true"）;
}
引用类型
控制语句
顺序结构
选择结构
1.单选择结构
2.双选择结构
3.多选择结构
booleanb=true;
if（b）{
System.out.println（"true"）;
}
if（b）{
System.out.println（"true"）;
}else{
System.out.println（"false"）;
}
intage=18;
if（age>100）{
System.out.println（"老寿星"）;
}elseif（age>80）{
System.out.println（"小寿星"）;
}elseif（age>60）{
System.out.println（"老年人"）;
}elseif（age>30）{
System.out.println（"中年人"）;
}elseif（age>18）{
System.out.println（"青年人"）;
}else{
System.out.println（"小屁孩"）;
}
intgrade=1;//1,2,3,4,5
switch（grade）{//多值选择结构！
case1:
case2:
System.out.println（"学的凑合"）;
break;
case3:
System.out.println（"学的一般"）;
break;
case4:
System.out.println（"学的不及格"）;
break;
case5:
System.out.println（"太差了！
"）;
break;
}
if（grade==1）{//switch可以完全使用ifelseif代替！
}elseif（grade==2）{
}
循环结构
while
dowhile
for
/*
inti=0;//初始化
while（i<10）{//条件判断
System.out.println（i）;//循环体
i++;//迭代
}*/
/*for（inti=0;i<10;i++）{//初始化、条件判断、迭代
//循环体
System.out.println（i）;
}
*/
inta=0;
do{
System.out.println（a）;
a++;
}while（a<0）;//先执行，后判断！
while：
先判断，后执行！
面向对象
面向过程和面向对象的区别
面向对象帮助我们从宏观上把握项目的整体关系，微观上实现仍然是面向过程。
类和对象
抽象（抽出事务象的部分）和具体。
类是对象的模板。
成员变量（field，属性）
要点：
1.成员变量的自动初始化。
整数：
0,浮点数：
0.0,Boolean:
false.引用类型：
nullchar:
\u0000
publicclassPerson{
intage=13;
Stringname;
intscore;
publicstaticvoidmain（String[]args）{
Personp=newPerson（）;
p.age=23;
p.name="张三";
System.out.println（p.name）;
}
}
方法
publicclassPerson{
intage=13;
Stringname;
intscore;
voidtest1（）{
System.out.println（"Person.test1（）"）;
}
inttest2（）{
System.out.println（"Person.test2（）"）;
return3;//return两个作用：
返回值，结束方法的运行！
}
inttest3（inta,doubled）{
System.out.println（"Person.test2（）"）;
return（int）（a+d）;
}
publicstaticvoidmain（String[]args）{
Personp=newPerson（）;
p.age=23;
p.name="张三";
inta=p.test2（）;
System.out.println（p.name）;
}
}
Return既可以用于返回值，也可以用于终止方法的执行：
voidtest2（）{
if（man）{
System.out.println（"man"）;
System.out.println（"man"）;
System.out.println（"man"）;
}
}
voidtest3（）{
if（!
man）{
return;
}
System.out.println（"man"）;
System.out.println（"man"）;
System.out.println（"man"）;
}
方法的重载（overload）
方法名相同、形参列表不同（类型不同/个数不同/顺序不同）则构成重载。
publicclassCalculator{
intadd（inta,intb）{
System.out.println（"sddsds"）;
returna+b;
}
intadd（inta,intb,intc）{
returna+b+c;
}
doubleadd（doublea,doubleb）{
returna+b;
}
doubleadd（doublea,intb）{
returna+b;
}
doubleadd（inta,doubleb）{
returna+b;
}
publicstaticvoidmain（String[]args）{
Calculatorc=newCalculator（）;
System.out.println（c.add（3,4））;
System.out.println（c.add（3,4,5））;
System.out.println（c.add（3.0,4.0））;
}
}
构造方法（构造器constructor）
构造方法是特殊的方法！
！
！
特殊在什么地方：
1.方法名必须和类名保持一致！
2.无返回值（事实上，他是有返回值的。
）
3.需要通过new来调用！
4.如果我们没有定义构造器，则编译器会帮助我们自动添加；如果我们手动定义构造器，则编译器不会帮助我们添加无参构造器。
publicclassPerson{
intage;
Stringname;
intscore;
voidrun（）{
System.out.println（"我在跑步！
！
"）;
}
Person（intage）{
this.age=age;
System.out.println（"正在构造一个person对象！
"）;
}
Person（）{
}
publicstaticvoidmain（String[]args）{
Personp=newPerson（）;
p.run（）;
}
}
内存分析
堆：
存放new出的对象。
栈：
存放局部变量（方法内部定义的变量）
方法区：
存放类的信息、static变量、字符串常量等。
publicclassPerson{
intage=13;
Stringname;
intscore;
publicstaticvoidmain（String[]args）{
Personp=newPerson（）;
p.age=23;
p.name="张三";
Personp2=newPerson（）;
p2.name="李四";
System.out.println（33==44）;
System.out.println（p==p2）;
Stringstr="张三";
Stringstr2="张三";
Stringstr3=newString（"李四"）;
Stringstr4=newString（"李四"）;
System.out.println（str==str2）;
System.out.println（str3==str4）;
System.out.println（"哈哈"）;
}
}
package
包的两个基本作用：
1.解决类的重名问题
2.管理类
包的具体用法：
1.使用package，必须位于文件的第一句非注释性语句！
2.包名的规范：
域名倒着写+有意义的名字
常见的包：
java.lang核心包（不需要我们import，直接可以使用！
）
java.io输入输出流
java.util工具包
网络
java.awt
java.sql
import
用来引入其他包中的类，方便我们使用。
importtest.Person;
importtest.*;
静态导入：
importstatic，导入某个类的静态属性和方法！
this
用来指定当前的对象！
如果this位于构造方法内，则表示正要初始化的对象。
如果this位于普通方法内，则表示调用该方法的对象（即当前对象）
packagecom.bjsxt.j2se;
publicclassTestThis{
privateinta;
privateintb;
privateintc;
TestThis（inta,intb）{
this.a=a;
this.b=b;
}
TestThis（inta,intb,intc）{
this（a,b）;//Constructorcallmustbethefirststatementinaconstructor
this.c=c;
}
publicstaticvoidmain（String[]args）{
}
}
static
static变量位于方法区，被所有的该类的对象共享，可以称为类属性（静态属性）、类方法（静态方法）。
Static变量可以使用：
类名.变量名来引用。
static变量（方法）是从属于类的。
可以通过：
类.名字来调用
普通变量（方法）是从属于对象的。
可以通过：
对象名.名字来调用。
static方法中，不能调用普通方法或普通属性。
final
final修饰普通变量：
常量！
！
super
面向对象的三大特征
封装/隐藏
可以将类的内部实现细节进行封装（隐藏了内部实现的细节、复杂性），方便外部调用。
这样的话，就利于软件的维护和扩展。
关键字
同一个类
同一个包
子类
所有类
private
√
X
X
X
default（默认，不需要写出来）
√
√
X
X
protected
√
√
√
X
public
√
√
√
√
封装的使用方式：
1．所有的属性都使用private。
但是一般会提供get/set方法便于访问和设置属性。
2．除非确认你的方法要被外部调用，否则一般都可以使用private。
继承
子类扩展了父类。
使用extends关键字。
JAVA类的继承中，只有单继承，没有多继承。
为什么需要继承?
1.抽象概念，便于建模
2.代码复用
Object类
Object是所有类的根类！
掌握：
toString（）方法的使用！
用来打印对象的字符串表示形式！
学习使用API文档
学习怎么查询API文档
学习使用DOC注释，生成项目的API文档（右键单击项目exportjava,javadocnext,finish,yes）
方法的重写（override）
多态
多态的三个必要条件：
继承、重写、父类引用指向子类对象。
publicclassTestOverride{
publicstaticvoidmain（String[]args）{
TestOverrideto=newTestOverride（）;
NokiaMobilenm=newNokiaMobile（）;
Mobileop=newOppoMobile（）;//编译时类型变量名=new运行时类型（）；
op.call（233223）;
OppoMobileom=（OppoMobile）op;//强制转型
om.callByOppo（23423）;
//DazhaiMobiledm=newDazhaiMobile（）;
to.test（op）;
}
voidtest（Mobilenm）{
nm.call（888888）;
}
/*voidtest（OppoMobilenm）{
nm.call（888888）;
}
voidtest（DazhaiMobilenm）{
nm.call（888888）;
}*/
}
classMobile{
publicvoidcall（intnum）{
System.out.println（"使用手机打电话给：
"+num）;
}
}
classNokiaMobileextendsMobile{
publicvoidcall（intnum）{
//super.call（num）;
System.out.println（"使用诺基亚手机打电话给：
"+num）;
}
}
classOppoMobileextendsMobile{
publicvoidcall（intnum）{
System.out.println（"使用Oppo手机打电话给：
"+num）;
}
publicvoidcallByOppo（intnum）{
System.out.println（"333333使用Oppo手机打电话给：
"+num）;
}
}
classDazhaiMobileextendsMobile{
publicvoidcall（intnum）{
System.out.println（"使用Dazhai手机打电话给：
"+num）;
}
}
抽象类
抽象类：
包含抽象方法的类。
抽象方法必须被子类重写。
注意：
1.抽象类可以包含构造方法，但是不能被实例化。
2.抽象类包含了：
具体实现和规范！
！
接口
为什么需要接口？
项目需求是多变的！
我们要从这些多变的需求中抽象出不变的内容，以不变应万变，提高我们的开发效率。
接口是做什么的？
用来描述规范！
体现了现实中这样的逻辑“如果你是…则必须能….”。
接口：
只包含了抽象方法，常量！
！
publicinterfaceFly{
publicstaticfinalintMAX_HEIGHT=100;
intMIN_HEIGHT=1;//常量总是：
publicstaticfinal
voidfly（）;//方法总是：
publicabstract
voidstop（）;
voidstartup（）;
voidupup（）;
voiddown（）;
}
如何使用接口?
classAirbusimplementsFly{
@Override
publicvoiddown（）{
}
@Override
publicvoidfly（）{
}
@Override
publicvoidstartup（）{
}
@Override
publicvoidstop（）{
}
@Override
publicvoidupup（）{
}
}
一个类可以实现多个接口
接口可以多继承！
！
！
interfaceIA{
voidaaa（）;
}
interfaceIB{
voidbbb（）;
}
interfaceICextendsIA,IB{
}
面向接口编程！
！
！
升级会员 