面向对象overWord文档下载推荐.docx

面向对象overWord文档下载推荐.docx

《面向对象overWord文档下载推荐.docx》由会员分享，可在线阅读，更多相关《面向对象overWord文档下载推荐.docx（20页珍藏版）》请在冰豆网上搜索。

类型的自动转换

类型的强制转换

/*doubled1=0.1;

doubled2=0.5-0.4;

System.out.println（d2）;

if（d1==d2）{

System.out.println（"

dddd"

）;

}else{

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）{

true"

if（b）{//建议此种写法！

引用类型

控制语句

顺序结构

选择结构

1.单选择结构

2.双选择结构

3.多选择结构

booleanb=true;

if（b）{

false"

intage=18;

if（age>

100）{

老寿星"

}elseif（age>

80）{

小寿星"

60）{

老年人"

30）{

中年人"

18）{

青年人"

小屁孩"

intgrade=1;

//1,2,3,4,5

switch（grade）{//多值选择结构！

case1:

case2:

学的凑合"

break;

case3:

学的一般"

case4:

学的不及格"

case5:

太差了！

"

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++）{//初始化、条件判断、迭代

//循环体

*/

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）;

}

}

方法

voidtest1（）{

System.out.println（"

Person.test1（）"

inttest2（）{

Person.test2（）"

return3;

//return两个作用：

返回值，结束方法的运行！

inttest3（inta,doubled）{

return（int）（a+d）;

inta=p.test2（）;

Return既可以用于返回值，也可以用于终止方法的执行：

voidtest2（）{

if（man）{

man"

voidtest3（）{

if（!

man）{

return;

方法的重载（overload）

方法名相同、形参列表不同（类型不同/个数不同/顺序不同）则构成重载。

publicclassCalculator{

intadd（inta,intb）{

sddsds"

returna+b;

intadd（inta,intb,intc）{

returna+b+c;

doubleadd（doublea,doubleb）{

doubleadd（doublea,intb）{

doubleadd（inta,doubleb）{

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.如果我们没有定义构造器，则编译器会帮助我们自动添加；

如果我们手动定义构造器，则编译器不会帮助我们添加无参构造器。

intage;

voidrun（）{

我在跑步！

Person（intage）{

this.age=age;

正在构造一个person对象！

Person（）{

p.run（）;

内存分析

堆：

存放new出的对象。

栈：

存放局部变量（方法内部定义的变量）

方法区：

存放类的信息、static变量、字符串常量等。

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）;

哈哈"

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;

static

static变量位于方法区，被所有的该类的对象共享，可以称为类属性（静态属性）、类方法（静态方法）。

Static变量可以使用：

类名.变量名来引用。

static变量（方法）是从属于类的。

可以通过：

类.名字来调用

普通变量（方法）是从属于对象的。

对象名.名字来调用。

static方法中，不能调用普通方法或普通属性。

final

final修饰普通变量：

常量！

super

面向对象的三大特征

封装/隐藏

可以将类的内部实现细节进行封装（隐藏了内部实现的细节、复杂性），方便外部调用。

这样的话，就利于软件的维护和扩展。

关键字

同一个类

同一个包

子类

所有类

private

√

X

default（默认，不需要写出来）

protected

public

封装的使用方式：

1．所有的属性都使用private。

但是一般会提供get/set方法便于访问和设置属性。

2．除非确认你的方法要被外部调用，否则一般都可以使用private。

继承

子类扩展了父类。

使用extends关键字。

JAVA类的继承中，只有单继承，没有多继承。

为什么需要继承?

1.抽象概念，便于建模

2.代码复用

Object类

Object是所有类的根类！

掌握：

toString（）方法的使用！

用来打印对象的字符串表示形式！

学习使用API文档

学习怎么查询API文档

学习使用DOC注释，生成项目的API文档（右键单击项目exportjava,javadocnext,finish,yes）

方法的重写（override）

多态

多态的三个必要条件：

继承、重写、父类引用指向子类对象。

publicclassTestOverride{

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）{

voidtest（DazhaiMobilenm）{

}*/

classMobile{

publicvoidcall（intnum）{

使用手机打电话给：

+num）;

}

classNokiaMobileextendsMobile{

//super.call（num）;

使用诺基亚手机打电话给：

classOppoMobileextendsMobile{

publicvoidcall（intnum）{

使用Oppo手机打电话给：

publicvoidcallByOppo（intnum）{

333333使用Oppo手机打电话给：

classDazhaiMobileextendsMobile{

使用Dazhai手机打电话给：

抽象类

抽象类：

包含抽象方法的类。

抽象方法必须被子类重写。

注意：

1.抽象类可以包含构造方法，但是不能被实例化。

2.抽象类包含了：

具体实现和规范！

接口

为什么需要接口？

项目需求是多变的！

我们要从这些多变的需求中抽象出不变的内容，以不变应万变，提高我们的开发效率。

接口是做什么的？

用来描述规范！

体现了现实中这样的逻辑“如果你是…则必须能….”。

接口：

只包含了抽象方法，常量！

publicinterfaceFly{

publicstaticfinalintMAX_HEIGHT=100;

intMIN_HEIGHT=1;

//常量总是：

publicstaticfinal

voidfly（）;

//方法总是：

publicabstract

voidstop（）;

voidstartup（）;

voidupup（）;

voiddown（）;

如何使用接口?

classAirbusimplementsFly{

@Override

publicvoiddown（）{

publicvoidfly（）{

publicvoidstartup（）{

publicvoidstop（）{

publicvoidupup（）{

一个类可以实现多个接口

接口可以多继承！

interfaceIA{

voidaaa（）;

interfaceIB{

voidbbb（）;

interfaceICextendsIA,IB{

面向接口编程！