java封装继承和多态.docx
《java封装继承和多态.docx》由会员分享，可在线阅读，更多相关《java封装继承和多态.docx（23页珍藏版）》请在冰豆网上搜索。
java封装继承和多态
1方法
方法是类或对象的行为特征的抽象，方法是类或对象最重要的组成部分
[访问修饰符]返回值的数据类型方法名（参数1，参数2…）{
语句；
[return返回值;]
}
访问修饰符
public、protected、default、private
返回值
如果方法有返回值，则需要为方法指定返回类
publicvoidsetName（）；//void关键字表示的是没有返回值的方法
publicStringsetName（return“湖北武汉”）；//有返回值的方法使用return关键字指定其返回值
publicintage（intnum1，intnum2）（returnnum1+num2）；
2形参和实参的概念
形参：
全称为“形式参数”，是在定义方法名和方法体的时候使用的参数，用于接收调用该方法时传入的实际值
实参：
全称为“实际参数”，是在调用方法时传递给该方法的实际值
调用方法时给定的实际参数类型要与定义方法时形式参数类型相同，而且顺序也要相同。
Java中的方法不能独立存在，调用方法必须使用类或对象作为主调者。
调用方法传入的参数称为实参。
3构造方法
构造方法是用于初始化一个对象的内部状态的特殊方法
classTest{
publicstaticvoidmain（String[]args）{
Peoplemy；
my=newPeople（）;
my.age=20;
my.printAge;
}
}
无返回值，不需要void,方法名只能是类名
<修饰符><类名>（[<参数列表>]）{
语句块;
}
classPerson{
intage;
Person（）{age=18;} //不带参数的构造方法
Person（inti）{age=i;} //带参数的构造方法
voidsetAge（inti）{age=i;}
}
classTest{
publicstaticvoidmain（String[]args）{
Personp1=newPerson（）;
Personp2=newPerson（21）;
System.out.println（p1.age）;
System.out.println（p2.age）;
}}
构造方法
定义构造方法
classPerson{
intage;
Person（inti）{age=i;} //带参数的构造方法
voidsetAge（inti）{age=i;}
}
classTest{
publicstaticvoidmain（String[]args）{
Personp1=newPerson（）;
System.out.println（p1.age）;
}
}
publicclassOverload{
publicvoidtest（）{//无参数的构造方法
System.out.println（"无参数方法"）;
}
publicvoidtest（Stringmsg）{//有参数的构造方法
System.out.println（"重载方法，参数值为：
"+msg）;
}
publicstaticvoidmain（String[]args）{
Overloadol=newOverload（）;
ol.test（）;
ol.test（"字符串"）;
}
}
构造方法的特殊性
1、构造方法的主要作用是完成对类对象的初始化工作
2、在创建new（）中一个类的新对象时，系统会自动调用该类的构造方法为新对象初始化
3、构造方法不能由编程人员显式地直接调用
4、构造方法没有返回类型
5、构造方法的方法名与类名相同
在Java语言中，每个类都至少有一个构造方法
如果类的定义者没有显式地定义任何构造方法，java编译器将自动为类提供一个默认的构造方法，默认构造方法没有参数，默认构造方法没有方法体
在Java类中，一旦类的定义者显式地定义了一个或多个构造方法，系统将不再提供默认的构造方法
4构造方法的重载
方法的重载就是在同一个类中允许同时存在一个以上的同名方法，只要它们的参数个数或类型不同即可。
在这种情况下，该方法被称为重载，这个过程称为方法的重载（overloading）
classPerson{
intage;
Person（）{age=18;} //不带参数的构造方法
Person（inti）{age=i;} //带参数的构造方法，构造方法被重载了
voidsetAge（inti）{age=i;}
}
构造方法的调用
Java编译器能根据调用方法时所传递的参数个数和类型选择相应的方法
classPerson{
intage;
Person（）{age=18;} //不带参数的构造方法
Person（inti）{age=i;} //带参数的构造方法
voidsetAge（inti）{age=i;}}
classTest{//根据传递参数的不同，Java会自动选择相应的构造方法
publicstaticvoidmain（String[]args）{
Personp1=newPerson（）;
Personp2=newPerson（21）;
}}
5什么是静态变量
静态变量是指被static修饰的变量
静态变量属于某个类，被所有实例共享
可以通过类名访问或通过实例名访问
静态变量
编写一个猴子类（Monkey），要求
在此类中存在一个变量，用于统计
此类被实例化了多少个对象。
classMonkey{
staticintcount=0;//声明静态变量
}
classTest{
publicstaticvoidmain（String[]args）{
for（inti=0;i<3;i++）{
Monkeym=newMonkey（）;
m.count=m.count+1;
}
//通过类名访问静态变量
System.out.println（Monkey.count）;
}
静态变量与非静态变量的区别
classTest{
publicstaticvoidmain（String[]args）{
StaticVars1=newStaticVar（）;
s1.a++;
s1.b++;
System.out.println（"实例变量a="+s1.a）;
System.out.println（"静态变量b="+StaticVar.b）;
StaticVars2=newStaticVar（）;
s2.a++;
s2.b++;
System.out.println（"实例变量a="+s2.a）;
System.out.println（"静态变量b="+s2.b）;
}
}
静态方法：
被static修饰的方法称为静态方法或类方法
static[修饰符]返回值类型方法名（类型参数1,类型参数2…）{
方法体
}
静态方法可以直接通过类名访问
classTest{
publicstaticvoidmain（String[]args）{
//示例化10个对象
for（inti=1;i<=10;i++）{
Monkeyhouge=newMonkey（）;
//通过类名调用静态方法，静态方法直接通过类名来调用
Monkey.play（）;
}
}
}
6静态方法
classMonkey{
intage=10;//实例变量age
staticintpeach=10;
staticvoidplay（）{
//访问实例变量
System.out.println（"实例变量age="+age）;//在静态方法内访问实例变量age
//访问静态变量
System.out.println（"实例变量peach="+peach）;
}
静态方法只能访问静态变量，不能访问实例变量
（1）可以通过类名直接调用该类的静态方法。
（2）静态方法不能访问非静态的实例变量和实例方法。
（3）静态方法必须用static关键字修饰。
（4）静态方法不能使用this关键字和super关键字，因为这两个关键字与特定的实例相关。
（5）实例方法可以访问静态成员和非静态成员。
静态代码块不存在于任何方法体中。
静态代码块只会被执行一次，它在Java虚拟机加载类时执行
classStaticBlock{
static{//静态代码块
System.out.println（“我是静态代码块"）;
}
}
classOrder{
inta=1;
staticintb=1;//静态变量
{
System.out.println（"实例变量a="+a）;
System.out.println（"代码块执行！
"）;
}
static{//静态代码块
System.out.println（"静态变量b="+b）;
System.out.println（"静态代码块执行！
"）;
}
Order（）{//构造方法
System.out.println（"构造方法执行"）;
}}
⏹初始化顺序
classTest{
publicstaticvoidmain（String[]args）{
Orderorder=newOrder（）;
}
}
静态变量初始化→静态代码块→初始化静态方法→初始化实例变量→代码块→构造方法
Java中有3种变量，分别为类变量、实例变量和某个方法中临时定义的局部变量。
不同变量的生命周期不同
classCycle{
intvar1=1;//实例变量
staticintvar2=2;//静态变量
publicintadd（）{
intvar3=var1+var2;//局部变量
returnvar3;
}
}
classTest{
publicstaticvoidmain（String[]args）{
Cyclec=newCycle（）;
c.add（）;
}}
7继承
继承是将已存在的类作为基础，建立新类的技术。
相比已存在的类，新类的定义可以增加新的数据和新的功能，也可以使用已存在类的功能，但不能选择性地继承已存在的类。
在Java的继承体系中，将已知类称为超类（或基类、父类），将新类称为子类。
提供子类可以沿用父类的某些行为和特征的一种方式。
在程序中使用继承，有利于程序的扩展
classEngineer{//工程师类
privateStringname;
privateStringaddress;
publicEngineer（Stringname,Stringaddress）{
this.name=name;
this.address=address;}
publicvoidintroduce（）{
System.out.println（"hello!
我是来自于:
"+address+"的"+name）;}
}
classStudent{//学生类
privateStringname;
privateStringaddress;
publicStudent（Stringname,Stringaddress）{
this.name=name;
this.address=address;}
publicvoidintroduce（）{
System.out.println（"hello!
我是来自于:
"+address+"的"+name）;}
}
每增加一个类将会增加一个相应的introduce方法，这样
在程序中会存在大量的重复代码，导致程序的扩展性很差
简单而言，继承是将程序中共同的特征和行为抽取出来建立一个类，使其他类可以沿用此类中的属性和方法。
这样不仅可以减少程序中的重复代码，而且易于程序扩展
在JAVA程序中，子类继承父类使用extends关键字
[修饰符]class子类名extends超类名{
[属性定义]
[构造方法定义]
[方法声明]
}
1、在JAVA程序中，子类继承父类使用extends关键字
2、子类可以定义自身的属性和方法。
3、子类不能获得超类的构造方法。
继承的实现
1.建立父类
classPerson{
publicStringname=“person”;
publicvoidgetInfo（）{
System.out.println（“thisisaperson”）;}}
2.使用extends建立子父类继承关系，子类通过extends父类
classChildextendsPerson{
publicintage;
publicvoidplay（）{
}}
3,创建子类对象访问父类的属性和方法
classDemo{
publicstaticvoidmain（Stringargs[]）{
Childchild=newChild（）;//子类通过实例化调用父类的方法
System.out.println（child.name）;
child.getInfo（）;
}}
classPerson{
publicStringname="Person";
publicintage=0;
publicvoideat（）{}
}
publicclassChildextendsPerson{
publicStringsex;
publicstaticvoidmain（Stringargs[]）{
Childchild=newChild（）;
System.out.println（child.age）;//使用父类中的age属性
child.eat（）;//调用父类中的方法
}
}
Java不存在多继承，即一个子类不允许有多个父类，例如：
classChildextendsPerson,Car{}
⏹继承具有传递性，即一个类可以既是子类，同时又是父类
classPerson{
publicintage;
publicStringsex;
}
classManextendsPerson{//Man是Person的子类，同时又是Father的父类
publicbooleanmarrired;
}
publicclassFatherextendsMan{
publicStringaddress;
publicvoidgetInfo（）{
System.out.println（“thisisafather”）:
}
}
在Java中，Object是所有类的父类，所有的Java类都直接或间接地继承了java.lang.Object类
publicclassMyClass{
/**
*publicclassMyclass相当于
*publicclassMyClassextendsObject//Object类是所有类的父类，该类实际上隐式继承了Object
*/
}
}
方法描述
clone（）创建并返回此对象的一个副本
equals（Object obj）指示其他某个对象是否与此对象“相等”
hashCode（）返回该对象的哈希码值
notifyAll（）唤醒在此对象监视器上等待的所有线程
toString（）返回该对象的字符串表示
wait（）在其他线程调用此对象的notify（）方法或notifyAll（）方法前，导致当前线程等待
publicclassPerson{
publicStringname="person";
publicvoidprintInfo（）{
System.out.println（"thisisaperson"）;
}}
classChildextendsPerson{//子类继承父类
publicvoidprintInfo（）{
System.out.println（"thisisachild"）;
}
publicstaticvoidmain（Stringargs[]）{
Personperson=newChild（）;//父类引用指向子类对象
person.printInfo（）;//调用子类中的方法
/**
*Childchild=（Child）newPerson（）;
*自定义的数据类型不能够强制类型转换
*/
}}
如果子类中定义了与父类中同名的属性和方法，此时需使用this调用子类中的属性和方法，要调用父类中的属性和方法需使用super
在继承关系中，super和this是两个经常使用的关键字
–this：
表示当前对象本身
–super：
表示对父类或超类的引用
classPerson{
publicStringname="Person";
publicintage=0;
}
publicclassChildextendsPerson{
publicStringsex;
publicintage=2;
publicvoidgetInfo（）{
System.out.println（"年龄是:
"+super.age）;//子类方法中调用父类的属性或方法使用super
System.out.println（"年龄是:
"+this.age）;//当前本身对象中调用自己的属性或方法使用this
}
publicstaticvoidmain（Stringargs[]）{
Childchild=newChild（）;
child.getInfo（）;
}}
8super与this
在使用this（）和super（）时，需要注意以下4个方面
1、每个子类构造方法中首先会隐含地调用super（），然后执行构造方法中的代码
2、super（）和this（）均需放在构造方法内的第一行
3、this（）和super（）不能同时出现在一个构造函数中
4、this（）和super（）均不可以在static环境中使用。
包括static方法、static语句块
super和this的区别
在Java中，final是修饰符，可以修饰类、方法和属性
final修饰的类是最终类，其修饰方法为最终方法，final修饰的变量是常量；最终类不可以被继承，最终方法不可以被重写（之后讲解），常量必须赋初值同时不允许被修改。
private和static修饰的方法隐式的是final方法。
finalclassBase
{
publicvoidgetInfo（）{
System.out.println（"thisissuperclass"）;
}
}
publicclassStudentextendsBase{//最终类不允许被继承
privateStringname;
}
packagecom;
classBase
{
publicfinalintage;//常量必须赋初值，且不可以重新赋值
publicvoidgetInfo（）{
System.out.println（"thisissuperclass"）;
}
}
publicclassStudentextendsBase{
privateStringname;
}
9多态
多态性是指当不同的对象收到相同的消息时，产生不同的动作。
对外只有一个入口，多种实现方式。
即一个接口使用不同实例执行不同的操作。
在Java中多态有两种表现形式，即：
方法重载（overload）与重写（override）
publicclassFarmer{
publicvoidplantApple（Appleapple）{
System.out.println（“plantapple”）;
}
publicvoidplantOrange（Orangeorange）{
System.out.println（“plantorange”）;
}
}
当季节变化时，需要增加相应的plant方法，并修改方法的参数类型，可扩展性和可维护性很差。
多态性是指当不同的对象收到相同的消息时，产生不同的动作。
对外只有一个入口，多种实现方式。
即一个接口使用不同实例执行不同的操作。
在Java中多态有两种表现形式，即：
方法重载（overload）与重写（override）
方法重载应用于同一个类中
构造方法也可以重载
方法的返回类型不做为区分方法重载的条件
publicclassBook{
publicfloatgetPrice（）{
return50;
}
publicfloatgetPrice（intbookPage）{//方法名称相同，参数个数与类型不同
return50*（bookPage/100）;
}
publicfloatgetPrice（intbookPage,floatdiscount）{
return50*（bookPage/100）*discount;
}
publicstaticvoidmain（Stringargs[]）{
Bookbook=newBook（）;
System.out.println（“图书的单价:
”+book.getPrice（））;
System.out.println（“根据页数计算的价格:
”+book.getPrice（200））;
System.out.println（“根据页数折扣的价格:
”+book.getP
升级会员 