java封装继承和多态.docx
- 文档编号:8148302
- 上传时间:2023-01-29
- 格式:DOCX
- 页数:23
- 大小:290.32KB
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
- 配套讲稿:
如PPT文件的首页显示word图标,表示该PPT已包含配套word讲稿。双击word图标可打开word文档。
- 特殊限制:
部分文档作品中含有的国旗、国徽等图片,仅作为作品整体效果示例展示,禁止商用。设计者仅对作品中独创性部分享有著作权。
- 关 键 词:
- java 封装 继承