java抽象类与接口的自学入门.docx
《java抽象类与接口的自学入门.docx》由会员分享，可在线阅读，更多相关《java抽象类与接口的自学入门.docx（14页珍藏版）》请在冰豆网上搜索。
java抽象类与接口的自学入门
abstractclassA
{
publicabstractvoidf（）;
}
classBextendsA
{
publicvoidf（）
{
System.out.println（"哈哈"）;
}
}
publicclassTestAbs_1
{
publicstaticvoidmain（String[]args）
{
//Aaa1=newA（）;//error
Aaa2=null;//可以定义一个抽象类的引用
aa2=newB（）;//将子类对象的地址赋给抽象类的引用
aa2.f（）;//用抽象类的引用访问子类的方法这就是多态
}
}
abstractclassA//如果f方法没有方法体，则必须的在class前加abstract如果f方法含有方法体，则class前面可加也可不加abstract，因为“一个抽象类中是可以不包含任何抽象方法，尽管比较少见”
{
privateinti;
publicabstractvoidf（）;//如果f方法没有方法体，则f方法必须的声明为抽象方法，即必须的在前面加abstract
}
classTestAbsClass_1
{
publicstaticvoidmain（String[]args）
{
System.out.println（"今天我很高兴!
"）;
}
}
/*
不能new出抽象类对象，但可以用抽象类的引用指向抽象类的子类对象，即抽象类也可以实现多态
*/
abstractclassA
{
abstractpublicvoidf（）;
}
classBextendsA
{
publicvoidf（）
{
System.out.println（"BBB"）;
}
}
publicclassTestAbsClass_2
{
publicstaticvoidmain（String[]args）
{
//Aaa=newA（）;//error不能new出抽象类对象
Aaa=newB（）;//OK
aa.f（）;//多态
}
}
classA//如果在class前面加final编译时程序就会报错
{
}
classBextendsA
{
}
publicclassTestFinal_1
{
publicstaticvoidmain（String[]args）
{
}
}
classA//如果在class前面加final编译时程序就会报错
{
}
classBextendsA
{
}
publicclassTestFinal_1
{
publicstaticvoidmain（String[]args）
{
}
}
/*
final类型修饰的属性必须在定义的同时初始化
如果final类型修饰的属性没有在定义的同时初始化，则必须在该类中的所有构造函数中完成初始化
不过这两种初始化只能存在一种，否则编译时会报错！
因为final表示常量的意思，常变量当然不能被初始化两次了
*/
classPoint
{
intx;
finaldoublePI=1.9;//10final定义的变量必须在定义的同时初始化如果这里只定义不初始化则我们就必须在所有的构造函数中完成对final变量的初始化不过这两种方式只能选择其中的一种
Point（）
{
//PI=1.234;//只要10行对PI进行了初始化，本语句就必须的被注释掉，否则编译时会报错!
}
Point（intm,intn）
{
//PI=2.33;//只要10行对PI进行了初始化，本语句就必须的被注释掉，否则编译时会报错!
}
voidoutput（）
{
//PI=2;//error因为“一个类的所有方法内部都不可以修改final修饰过的成员变量的”
System.out.printf（"%d%f\n",x,PI）;
}
publicstaticvoidmain（String[]args）
{
Pointpt=newPoint（）;
pt.output（）;
}
}
/*
在JDK1.6中的运行结果是：
-----------------
01.900000
-----------------
*/
/*
接口中定义的属性的值在实现类中不能被更改
接口的属性是publicstaticfinal类型
*/
//接口中是不可以定义构造函数的
interfaceIt
{
inti=10;//不能改为inti;
}
classAimplementsIt
{
publicA（intj）
{
//this.i=j;//接口It中的属性i是publicstaticfinal类型，不可以在实现类中被改变
}
}
classTestInter_1
{
publicstaticvoidmain（String[]args）
{
Aaa=newA（10）;
System.out.println（"aa.i="+aa.i）;
System.out.println（"aa.i="+A.i）;
}
}
classA
{
}
interfaceIt1
{
}
interfaceIt2{
}
//接口可以多重继承，即一个接口可以有多个父接口，但是一个类只能有一个父类，Java类不允许多继承，接口却允许多继承
interfaceIt3extendsIt1,It2
{
}
interfaceIt4
{
inti=20;
}
//一个类可以在继承一个父类的同时实现一个或多个接口，但extends关键字必须的在implements之前
classTextendsAimplementsIt4,It3
{
}
classTestInter_2
{
publicstaticvoidmain（String[]args）
{
System.out.println（"嘿嘿!
"）;
}
}
classA
{
publicvoidf（）
{
System.out.printf（"AAAA\n"）;
}
}
classBextendsA
{
publicvoidf（）//重写方法的权限不能低于被重写方法的访问权限
{
System.out.printf（"BBBB\n"）;
}
}
publicclassTestA
{
publicstaticvoidmain（String[]args）
{
Bbb=newB（）;
//bb.f（）;
Aaa=newA（）;
aa.f（）;
aa=bb;
aa.f（）;//（*aa）.f（）;
//bb=aa;//error
}
}
classA
{
publicvoidf（）
{
System.out.printf（"AAAA\n"）;
}
}
classBextendsA
{
publicvoidf（）
{
System.out.printf（"BBBB\n"）;
}
}
publicclassTestA_2
{
publicstaticvoidmain（String[]args）
{
Aaa=newA（）;
Bbb=newB（）;
aa=bb;
//bb=aa;//error
bb=（B）aa;
bb.f（）;
aa.f（）;
}
}
abstractclassA
{
abstractpublicvoidf（）;
}
classBextendsA
{
publicvoidf（）
{
System.out.printf（"BBBB\n"）;
}
}
publicclassTestAbsPoly_1
{
publicstaticvoidmain（String[]args）
{
//Aaa=newA（）;//error18行
Bbb=newB（）;//OK
bb.f（）;//OK
Aaa;//23行OK可以定义一个抽象类的引用，但是不可以定义一个抽象类的对象，所以18行error，本行OK
aa=bb;
aa.f（）;
}
}
//有抽象方法的类一定是抽象类
abstractclassA
{
abstractpublicvoidf（）;//没有方法体的方法叫做抽象方法，抽象方法要求末尾必须得加分号，前面必须得加abstract
}
//抽象类不一定有抽象方法
abstractclassB
{
publicvoidg（）
{
}
}
publicclassTestAbstract_1
{
publicstaticvoidmain（String[]args）
{
}
}
classA
{
finalpublicinti=10;//常变量
publicA（）
{
i=10;
}
publicvoidf（）
{
//i=22;
}
}
classTestFinal_1
{
publicstaticvoidmain（String[]args）
{
}
}
classA
{
finalpublicvoidf（）//如果在public前面加final，则编译时就会报错
{
System.out.println（"AAAA"）;
}
}
classBextendsA
{
//publicvoidf（）
//{
//System.out.println（"BBBB"）;
//}
}
publicclassTestFinal_2
{
publicstaticvoidmain（String[]args）
{
}
}
classA
{
publicvoidf（）
{
System.out.printf（"AAAA\n"）;
}
}
classBextendsA
{
publicvoidf（）
{
System.out.printf（"BBBB\n"）;
}
}
classCextendsB
{
publicvoidf（）
{
System.out.printf（"CCCC\n"）;
}
}
classDextendsC
{
publicvoidf（）
{
System.out.printf（"DDDD\n"）;
}
}
publicclassTestPoly_1
{
publicstaticvoidg（Aaa）
{
aa.g（）;//类似于C语言的：
（*aa）.f（）;
}
publicstaticvoidmain（String[]args）
{
Aaa=newA（）;
Bbb=newB（）;
Ccc=newC（）;
Ddd=newD（）;
g（aa）;
g（bb）;
g（cc）;
g（dd）;
}
}
classA
{
publicvoidf（）
{
System.out.printf（"AAAA\n"）;
}
}
classBextendsA
{
publicvoidf（）
{
System.out.printf（"BBBB\n"）;
}
publicvoidg（）
{
System.out.printf（"GGGG\n"）;
}
}
publicclassTestPoly_2
{
publicstaticvoidmain（String[]args）
{
Aaa=newA（）;
Bbb=newB（）;
aa=bb;
aa.g（）;//error（*aa）.g（）;
}
}
升级会员 