Java SE面向对象部分15面向对象高级03.docx
《Java SE面向对象部分15面向对象高级03.docx》由会员分享，可在线阅读，更多相关《Java SE面向对象部分15面向对象高级03.docx（16页珍藏版）》请在冰点文库上搜索。
JavaSE面向对象部分15面向对象高级03
JavaSE面向对象部分-15.面向对象高级（03）
上季内容回顾：
1、super与this关键字
2、方法的重载与覆写
本季主要知识点：
1、final关键字
2、简单了解一下抽象类与接口（是JAVA中最重要的部分）
final关键字
终结器——final
1、被final标记的类不能被继承
finalclassA
{
};
classBextendsA
{
};
验证一下：
2、被final标记的方法不能被子类覆写
finalclassA
{
publicfinalvoidprint（）{}
};
classBextendsA
{
publicvoidprint（）{}
};
3、被final标记的变量就成为常量，如果成为常量，则以后不能修改
classA
{
finalStringNAME="Hello";
publicfinalvoidprint（）
{
NAME="World";
}
};
之前在声明变量的时候是第一个单词的首字母小写，之后每个单词的首字母大写。
如果使用final声明常量，则所有单词的字母都要大写。
重点：
全局常量：
·static：
是所有对象共享的
·final：
是一个常量
·public：
表示可以让外部看见
publicstaticfinalStringFLAG=""; 全局常量
抽象类
抽象类：
包含一个抽象方法的类就称为抽象类。
抽象方法：
只声明而未实现的方法称为抽象方法。
方法没有方法体（方法体：
“{}”），则称为是一个抽象方法。
除了抽象方法之外其他的定义如同普通类一样。
抽象类=普通类的功能+抽象方法
abstractclassA
{
publicstaticfinalStringFLAG="";
publicvoidprint（）
{
//有方法体，所以是一个普通方法
System.out.println（"HelloWorld~~~"）;
}
//此处定义了一个抽象方法
publicabstractvoidfun（）;
};
publicclassDemo04
{
publicstaticvoidmain（Stringargs[]）
{
Aa=newA（）;
}
};
如果要使用一个抽象类，不能直接实例化，抽象类是必须有子类的。
抽象类必须被继承，被继承的子类如果不是一个抽象类的话，则肯定要覆写全部的抽象方法。
abstractclassA
{
publicstaticfinalStringFLAG="";
publicvoidprint（）
{
//有方法体，所以是一个普通方法
System.out.println（"HelloWorld~~~"）;
}
//此处定义了一个抽象方法
publicabstractvoidfun（）;
};
//子类中覆写了抽象类中的全部抽象方法
classBextendsA
{
publicvoidfun（）
{
//super.FLAG也可以写成FLAG,因为FLAG已经是全局常量了哈~~~
System.out.println（"FLAG="+super.FLAG）;
}
};
publicclassDemo04
{
publicstaticvoidmain（Stringargs[]）
{
Bb=newB（）;
b.fun（）;
b.print（）;
}
};
验证效果，证明抽象类必须这样写哈~~~
抽象类的定义
抽象类的使用规则
抽象类的思考
abstractclassPerson
{
//Person类应该有姓名和年龄
privateStringname;
privateintage;
publicPerson（Stringname,intage）
{
this.name=name;
this.age=age;
}
publicvoidsetName（Stringname）
{
this.name=name;
}
publicvoidsetAge（intage）
{
this.age=age;
}
publicStringgetName（）
{
returnthis.name;
}
publicintgetAge（）
{
returnthis.age;
}
//定义一个输出方法，但是此方法为抽象方法
publicabstractStringgetInfo（）;
};
我们测试一下，发现编译正常，说明抽象类可以有构造方法哈~
我们继续哈~
abstractclassPerson
{
//Person类应该有姓名和年龄
privateStringname;
privateintage;
publicPerson（）{}
//如果已经不是无参的，则必须在子类中明确调用无参构造
publicPerson（Stringname,intage）
{
this.name=name;
this.age=age;
}
publicvoidsetName（Stringname）
{
this.name=name;
}
publicvoidsetAge（intage）
{
this.age=age;
}
publicStringgetName（）
{
returnthis.name;
}
publicintgetAge（）
{
returnthis.age;
}
//定义一个输出方法，但是此方法为抽象方法
publicabstractStringgetInfo（）;
};
classStudentextendsPerson
{
publicStudent（Stringname,intage）
{
//调用Person类中有两个参数的构造方法
super（name,age）;
}
//覆写父类的抽象方法
publicStringgetInfo（）
{
return"姓名：
"+super.getName（）+"，年龄：
"+super.getAge（）;
}
};
publicclassDemo05
{
publicstaticvoidmain（Stringargs[]）
{
Students=newStudent（"王乾",27）;
System.out.println（s.getInfo（））;
}
}
抽象类中允许有构造方法，但是此构造方法并不是直接实例化抽象类自己的对象使的，如果在抽象类中没有明确的无参构造方法，即：
存在有参构造，则必须在子类明确的使用super指明要调用父类中的那个构造方法。
注意：
如果一个抽象类中没有任何一个抽象方法，则也是不能直接实例化的。
abstractclassA
{
publicvoidprint（）{}
};
publicclassDemo06
{
publicstaticvoidmain（Stringargs[]）
{
newA（）;
}
};
final可以声明一个类，但是此类是绝对不能有子类的。
而抽象类又必须被子类继承。
==>矛盾的
finalabstractclassA
{
};
验证下效果，我们发现抽象类是不能使用final声明的。
如果假设一个类就是抽象方法和常量的集合，那么此时往往都不再使用抽象类声明了，而使用接口声明。
接口（interface）
interfaceA
{
//接口中包含了抽象方法和全局常量
publicstaticStringNAME="";
publicabstractvoidprint（）;
};
接口的使用规则
（1）
一个子类继承接口实际上称为实现了接口。
如果实现接口的子类不是抽象类的话，则子类必须覆写接口中的全部抽象方法。
interfaceA
{
//接口中包含了抽象方法和全局常量
publicstaticStringNAME="";
publicabstractvoidprint（）;
};
classBimplementsA
{
publicvoidprint（）
{
System.out.println（"NAME="+NAME）;
}
};
publicclassDemo09
{
publicstaticvoidmain（Stringargs[]）
{
Bb=newB（）;
b.print（）;
}
};
接口使用的事项：
1、抽象类使的是extends关键字，表示一个类只能继承一个父类，但是接口不同，一个类可以同时实现多个接口，但是此时子类就必须同时覆写好多个接口中的抽象方法。
interfaceA
{
//接口中包含了抽象方法和全局常量
publicstaticStringNAME="";
publicabstractvoidprint（）;
};
interfaceX
{
publicabstractvoidfun（）;
};
classBimplementsA,X
{
publicvoidprint（）
{
System.out.println（"NAME="+NAME）;
}
publicvoidfun（）
{
this.print（）;
}
};
publicclassDemo10
{
publicstaticvoidmain（Stringargs[]）
{
Bb=newB（）;
b.fun（）;
}
};
抽象类拥有单继承的局限，而接口没有此限制，即：
一个子类可以同时实现多个接口。
2、既然在定义中已经明确的说明了接口是抽象方法和全局常量的集合，则在定义接口的时候就可以简单定义。
interfaceA
{
//接口中包含了抽象方法和全局常量
//publicstaticStringNAME="";
StringNAME="";
//publicabstractvoidprint（）;
voidprint（）;
};
classBimplementsA
{
publicvoidprint（）
{
System.out.println（"NAME="+NAME）;
}
};
publicclassDemo11
{
publicstaticvoidmain（Stringargs[]）
{
Bb=newB（）;
b.print（）;
}
};
简化后实现的效果一样哈~
一般习惯在简化时还在前面加上public,呵呵~~~
interfaceA
{
//接口中包含了抽象方法和全局常量
//publicstaticStringNAME="";
publicStringNAME="";
//publicabstractvoidprint（）;
publicvoidprint（）;
};
classBimplementsA
{
publicvoidprint（）
{
System.out.println（"NAME="+NAME）;
}
};
publicclassDemo12
{
publicstaticvoidmain（Stringargs[]）
{
Bb=newB（）;
b.print（）;
}
};
接口的使用规则
（2）
interfaceA
{
publicvoidprintA（）;
}
interfaceB
{
publicvoidprintB（）;
}
interfaceCextendsA,B
{
publicvoidprintC（）;
}
classXimplementsC
{
//如果实现了（继承）C接口，则在子类中就必须覆写全部的抽象方法
publicvoidprintA（）
{
System.out.println（"A接口===>HelloWorld~~~"）;
}
publicvoidprintB（）
{
System.out.println（"B接口===>HelloWorld~~~"）;
}
publicvoidprintC（）
{
System.out.println（"C接口===>HelloWorld~~~"）;
}
}
publicclassDemo13
{
publicstaticvoidmain（Stringargs[]）
{
Xx=newX（）;
x.printA（）;
x.printB（）;
x.printC（）;
}
}
如果一个子类即要实现一个接口又要继承一个抽象类呢？
则此时按以下格式编写：
class类名称extends抽象类implements接口
interfaceX
{
publicvoidprintX（）;
}
interfaceY
{
publicvoidprintY（）;
}
//一个抽象类也是可以实现接口的
abstractclassZimplementsY
{
publicabstractvoidprintZ（）;
}
//D类同时继承Z类和实现X接口
classDextendsZimplementsX
{
publicvoidprintX（）
{
System.out.println（"X===>Hello~~~"）;
}
publicvoidprintY（）
{
System.out.println（"Y===>Hello~~~"）;
}
publicvoidprintZ（）
{
System.out.println（"Z===>Hello~~~"）;
}
}
publicclassDemo14
{
publicstaticvoidmain（Stringargs[]）
升级会员 