Java程序设计课件：第三章 类与对象的深入理解

类与对象的深入理解计算机教研室主要内容对象的引用和实体数组static关键字this关键字包importpackage访问权限privatefiendlyprotectedpublic对象的创建和使用(1)Students;//声明对象s=newStudent();//实例化一个对象基本数据类型与引用数据类型的区别Students=newStudent();inti;i=5;内存nullsstuNonameage0x11580i基本类型：一块内存引用类型：两块内存对象的创建和使用(2)引用成员变量对象名.成员变量名s.age=23;方法的使用对象名.方法名(参数列表)s.haveCourse()对象的创建和使用(3)classStudent{ //成员变量（属性）的定义

StringstuNo; Stringname; Stringage; //方法的定义

voidhaveCourse(){

System.out.println("执行haveCourse方法"); } voidtest(){

System.out.println("执行test方法"); }}publicclassTestStu{ publicstaticvoidmain(String

args[]){ Students=newStudent();

="张三";

System.out.println();

s.haveCourse();

s.test(); } }创建多个对象classStudent{floatheight,weight;Stringhead,ear,hand,foot,mouth;voidspeak(Strings){System.out.println(s);}}classA{publicstaticvoidmain(String

args[]){Studentzhubajie;//声明对象

zhubajie=newStudent();//为对象分配内存 Studentsunwukong=newStudent();

}}内存创建多个对象0.0weight0.0heightnullheadnullcarnullmouthnullHandnullfootweight0.0height0.0headnullcarnullmouthnullHandnullfootnullzhubajiesunwukong0xAB120x111A内存模型对象的引用和实体n1:30n2:50n1:50n2:50n1:100n2:100classNumber{ inti;}publicclassAssign{ publicstaticvoidmain(String

args[]){ Numbern1=newNumber(); Numbern2=newNumber(); n1.i=30; n2.i=50; System.out.println("n1:"+n1.i+"n2:"+n2.i);

n1=n2; System.out.println("n1:"+n1.i+"n2:"+n2.i); n1.i=100; System.out.println("n1:"+n1.i+"n2:"+n2.i); }}对象的引用和实体i=30i=50i=100Numbern1=newNumber();Numbern2=newNumber();n1.i=30;n2.i=50;System.out.println("n1:"+n1.i+"n2:"+n2.i);n1=n2;System.out.println("n1:"+n1.i+"n2:"+n2.i);n1.i=100;System.out.println("n1:"+n1.i+"n2:"+n2.i);n1:30n2:50n1:50n2:50n1:100n2:100#1000#200010002000n1n22000基本数据类型的参数传递classPassValue{

voidchange(int

x,inty){ x=x+100; y=y+200; }

}classTestClass{ publicstaticvoidmain(String

args[]){

intnumber1=10;

intnumber2=20;

PassValue

pv=newPassValue();

System.out.println("方法调用前number1="+number1);

System.out.println("方法调用前number2="+number2); pv.change(number1,number2);

System.out.println("方法调用后number1="+number1);

System.out.println("方法调用后number2="+number2); }}引用数据类型参数传递classStudent{ Stringname;

int

stuNo;

Student(String

studentName,int

studentNo){ name=studentName;

stuNo=studentNo; } voidchange(Studentstudent){

="猪八戒";

student.stuNo=111; }}classTestClass{ publicstaticvoidmain(String

args[]){ Students=newStudent("孙悟空",110);

System.out.println("name="+);

s.change(s);

System.out.println("name="+); }}方法的参数传递基本数据类型传递的是该值本身引用类型传递的是对象的引用，而不是对象的实体例3－8，3－9引用数据类型的参数传递classPeople{

intmoney=1000;}publicclassExample4_5{ staticvoidf(Peoplep){

p.money=8000; } publicstaticvoidmain(String

args[]){ Peoplezhang=newPeople();

f(zhang);

System.out.println(zhang.money); }}8000

基本数据类型的参数传递publicclassX{ inta=0; publicstaticvoidmain(String[]args){ Xx=newX();

modify(x.a);

System.out.println(x.a); } publicstaticvoidmodify(inta){ a++; }}0

classDog{ privateStringname; privateintage; publicintstep;

Dog(Strings,inta){ name=s; age=a; step=0; }}publicclassAnimal{ publicvoidrun(Dogfast){

fast.step++; } publicstaticvoidmain(String

args[]){ Animala=newAnimal(); Dogd=newDog("Tom",3);

a.run(d);

System.out.println(d.step); }}1static关键字classCircle{ doublepi; doubleradius;

Circle(double

pi,doubleradius){

this.pi=pi;

this.radius=radius; } doublegetArea(){ returnradius*radius*pi; }}classTestClass{ publicstaticvoidmain(String

args[]){ Circlec1=newCircle(3.14,10); Circlec2=newCircle(3.14159,20);

System.out.println(“pi:"+c1.pi+"radius:"+c1.radius);

System.out.println(“pi:"+c2.pi+"radius:"+c2.radius); }}static关键字classCircle{ doublepi; doubleradius;

Circle(double

pi,doubleradius){

this.pi=pi;

this.radius=radius; } doublegetArea(){ returnradius*radius*pi; } publicstaticvoidmain(String

args[]){ Circlec1=newCircle(3.14,10); Circlec2=newCircle(3.14159,20);

System.out.println(pi);

System.out.println(“pi:"+c1.pi+"radius:"+c1.radius);

System.out.println(“pi:"+c2.pi+"radius:"+c2.radius); }}实例变量与静态变量classCircle{

staticdoublepi; doubleradius;

Circle(double

pi,doubleradius){

this.pi=pi;

this.radius=radius; } doublegetArea(){ returnradius*radius*pi; } publicstaticvoidmain(String

args[]){ Circlec1=newCircle(3.14,10); Circlec2=newCircle(3.14159,20);

System.out.println(pi);

System.out.println(“pi:"+c1.pi+"radius:"+c1.radius);

System.out.println(“pi:"+c2.pi+"radius:"+c2.radius); }}实例变量与静态变量classCircle{ staticdoublepi; doubleradius;

Circle(double

pi,doubleradius){

this.pi=pi;

this.radius=radius; } doublegetArea(){ returnradius*radius*pi; } publicstaticvoidmain(String

args[]){ Circlec1=newCircle(3.14,10); Circlec2=newCircle(3.14159,20);

System.out.println(Circle.pi);

System.out.println(“pi:"+c1.pi+"radius:"+c1.radius);

System.out.println(“pi:"+c2.pi+"radius:"+c2.radius); }}静态变量和实例变量的区别(2)静态变量每个类的所有对象共享，使类的对象间可以传递数据，扮演“牧羊人”publicclassCat{privatestaticinttype=0;//静态变量privateStringname;//实例变量publicstaticvoidmain(String

arg[]){ Catc1=newCat();Catc2=newCat(); System.out.println(“c1.type:”+c1.type); System.out.println(“c2.type:”+c2.type); c2.type=1; System.out.println(“c1.type:”+c1.type); System.out.println(“c2.type:”+c2.type);}}静态变量和实例变量的区别(3)内存说明pi0xAB200xAB16radiusradiusc1c2静态变量和实例变量的区别静态变量实例变量初始化当类被加载到内存时，就分配了相应的内存空间当创建类的第一个对象时分配内存空间释放程序退出运行时才释放释放对象时释放空间访问方式可以通过类名直接访问，也可以通过对象访问只能通过对象访问分配空间该类的所有对象分配相同的一块内存不同的对象分配不同的内存空间静态变量和实例变量classTakeCare{ staticintx;

inty;}classA{ publicstaticvoidmain(String

args[]){

TakeCareA1=newTakeCare();

TakeCareA2=newTakeCare(); A1.x=18; A1.y=36; System.out.println(A2.x); System.out.println(A2.y);

System.out.println(TakeCare.x); }}静态方法和实例方法classA{ floata; voidsetA(){ a=get(1,2); } floatget(floatx,floaty){ floatc=max(x,y); returnc; } floatmax(float

x,floaty){ returnx>y?x:y; }}静态方法和实例方法classA{ floata; voidsetA(){ a=get(1,2); } floatget(floatx,floaty){ floatc=max(x,y); returnc; } floatmax(float

x,floaty){ returnx>y?x:y; } publicstaticvoidmain(String

args[]){

setA(); }}静态方法和实例方法classA{ floata; voidsetA(){ a=get(1,2); } floatget(floatx,floaty){ floatc=max(x,y); returnc; } floatmax(float

x,floaty){ returnx>y?x:y; } publicstaticvoidmain(String

args[]){ Aa=newA();

a.setA(); }}静态方法和实例方法classA{ floata; voidsetA(){ a=get(1,2); } floatget(floatx,floaty){ floatc=max(x,y); returnc; }

staticfloatmax(float

x,floaty){ returnx>y?x:y; } publicstaticvoidmain(String

args[]){ Aa=newA();

a.setA(); }}静态方法和实例方法classA{ floata; voidsetA(){ a=get(1,2); }

staticfloatget(floatx,floaty){ floatc=max(x,y); returnc; } floatmax(float

x,floaty){ returnx>y?x:y; } publicstaticvoidmain(String

args[]){ Aa=newA();

a.setA(); }}静态方法和实例方法classA{ floata; voidsetA(){ a=get(1,2); }

staticfloatget(floatx,floaty){ floatc=max(x,y); returnc; }

staticfloatmax(float

x,floaty){ returnx>y?x:y; } publicstaticvoidmain(String

args[]){ Aa=newA();

a.setA(); }}实例方法和静态方法的区别当类被加载到内存时，为静态方法分配入口地址可以被类创建的任何对象调用，也可以直接通过类名调用入口地址在程序退出时取消当创建第一个对象时为实例方法分配入口地址，再创建对象时不再分配必须通过对象来调用，调用某个对象的实例方法时，使用该对象的成员变量入口地址在所有对象都不存在时取消静态方法

实例方法

实例方法和静态方法的区别(2)publicclassCat{privatestaticinttype=0;//静态变量privateStringname;//实例变量publicvoidsetName(Strings){//实例方法name=s;}

publicstaticvoidcatchDog(){//静态方法

System.out.println(“killself!”);}publicstaticvoidmain(String

arg[]){ Catc=newCat();

c.setName(“miaomiao”);

Cat.catchDog();

System.out.println(Cat.type);}}实例方法和静态方法的使用(3)实例方法既可以操作实例变量，又可以操作静态变量静态方法只能直接操作静态变量实例方法可以调用该类的其他方法静态方法只能直接调用该类的静态方法实例方法和静态方法的使用(4)classA{

inta; staticintb; voidf(intx,inty){ a=x;//合法

b=y;//合法

} staticvoidg(){ b=23;//合法

a=2;//非法

}}方法——课堂练习publicclassJ_Test{ staticshortm_index; staticintm_age; publicstaticvoidmb_setData(shortn){

m_index=n; } publicstaticvoidmain(String

args[]){ mb_setData(98);

System.out.println("Index="+m_index+"；Age="+m_age);

}}编译不能通过（不能将mb_setData(short)应用于（int））方法——课堂练习publicclassJ_Test{ staticlongm_index; staticintm_age; publicstaticvoidmb_setData(longn){

m_index=n; } publicstaticvoidmain(String

args[]){ mb_setData(98);

System.out.println("Index="+m_index+"；Age="+m_age); }}Index=98；Age=0this关键字this关键字出现在类的构造方法中时，代表使用该构造方所创建的对象使用this可以处理方法中成员变量＆参数重名的情况publicclassLeaf{

inti=0; Strings;

Leaf(inti){

this.i=i;

System.out.println("为i赋值"); }

Leaf(inti,Strings){

this(i);

this.s=s;

System.out.println("为i和s赋值"); }}课堂练习classB{

intx=100,y=200; publicvoidsetX(intx){ x=x; } publicvoidsetY(inty){

this.y=y; } publicint

getXYSum(){ returnx+y }}publicclassA{ publicstaticvoidmain(String

args[]){ Bb=newB(); b.setX(-100); b.setY(-200);

System.out.println("sum="+b.getXYSum()); }}sum＝-100包为了便于管理大型软件系统中数目众多的类，防止命名冲突，Java引入了包的机制，提供多重类命名空间一般是域名的反转作为包名http://.dluflpackage语句package.dlufl类必须位于\cn\edu\dlufl\目录下.dlufl.Catc;c=new.dlufl.Cat();package语句作为Java源文件的第一条语句如果没有package语句，源文件被默认定义到default包中包名是标识符，中间一般加“.”来说明层次如果将一个类打包，其他包中的类引用该类时必须使用该类的全名（包名.类名）或者显示的导入该类import语句在文件的头部java.lang包是Java的核心类库，系统自动引入，不用显示地使用import语句用*表示引用一个包中的全部类位于同一个包中的类不需要引入，可以直接使用如果当前目录某个类与引入包中的类重名，想使用引入包中的类，必须写出全名importjava.applet.Applet;importjava.awt.*;publicclassExample4_10extendsApplet{……}JDK提供的类库java.applet：实现Javaapplet的类java.awt：图形、文本窗口GUI类java.awt.image：窗口工具中的图像处理类java.lang：

Java的核心类，包括String,

System,Thread,Math等java.io：包含一些输入和输出类：实现网络功能的类java.util：包含一些有用的数据类型，如日期和时间等访问权限访问权限就是指对象是否可以通过“.”运算符操作类内的变量或使用类中的方法在一个类中，实例方法可以访问成员变量，类方法可以访问静态变量，与访问控制符无关访问权限classTom{ floatweight; voidf(float

a,floatb){

System.out.println(a+b); }}classJerry{ voidg(){ Tomcat=newTom();

cat.weight=23f; cat.f(3f,4f); }}访问权限classTom{

privatefloatweight;

privatevoidf(float

a,floatb){

System.out.println(a+b); }}classJerry{ voidg(){ Tomcat=newTom();

cat.weight=23f;//非法 cat.f(3f,4f);//非法 }}访问权限classTom{

privatefloatweight;

privatevoidf(float

a,floatb){

System.out.println(a+b); } voidg(){ Tomcat=newTom();

cat.weight=23f;//合法 cat.f(3f,4f);//合法 }}访问权限classTom{ floatweight; voidf(float

a,floatb){

System.out.println(a+b); }}classJerry{ voidg(){ Tomcat=newTom();

cat.weight=23f;//合法 cat.f(3f,4f);//合法 }}访问权限packagea;classTom{ floatweight; voidf(float

a,floatb){

System.out.println(a+b); }}packageb;classJerry{ voidg(){ Tomcat=newTom();

cat.weight=23f;//非法 cat.f(3f,4f);//非法 }}访问权限packagea;classTom{

publicfloatweight;

publicvoidf(float

a,floatb){

System.out.println(a+b); }}packageb;classJerry{ voidg(){ Tomcat=newTom();

cat.weight=23f;//合法 cat.f(3f,4f);