java基础3.docx
《java基础3.docx》由会员分享，可在线阅读，更多相关《java基础3.docx（15页珍藏版）》请在冰豆网上搜索。
java基础3
Java基础三
1、继承：
Test9.java
publicclassTest9{
publicstaticvoidmain（String[]args）{
Personteacher=newTeacher（"老师1",22,"老师"）;
teacher.eat（）;
//teacher.teaching（）;因为teacher是Person类型，Person类中看不到子类扩展的方法teaching方法。
Personstudent=newStudent（"学生1",23,"学生"）;
student.eat（）;
}
}
classPerson{
Stringname;
intage;
Stringjob;
publicPerson（）{}
publicPerson（Stringname,intage,Stringjob）{
this.name=name;
this.age=age;
this.job=job;
}
publicvoideat（）{
System.out.println（this.name+"在吃……"）;
}
}
classStudentextendsPerson{
publicStudent（Stringname,intage,Stringjob）{
this.name=name;
this.age=age;
this.job=job;
}
publicvoidstuding（）{
System.out.println（this.name+"在学习"）;
}
}
classTeacherextendsPerson{
publicTeacher（Stringname,intage,Stringjob）{
this.name=name;
this.age=age;
this.job=job;
}
publicvoidteaching（）{
System.out.println（this.name+"在讲课"）;
}
}
上面的程序说明：
要想让我们的Teacher类和Student类也是Person，必须将Teacher类和Student类通过关键字“extends”继承Person类，此时Teacher类和Student类也是一种Person了。
我们子类（导出类）就可以省略父类中已经定义的属性和功能了，子类并且可以扩展父类（基类）。
程序中的高亮处表示：
Student和Teacher也是Person。
但是上面的引用只能访问属性Person中的功能，子类扩展的该引用看不到。
2、重写：
Test9.java
publicclassTest9{
publicstaticvoidmain（String[]args）{
Personmonk=newMonk（"释永信",45,"花和尚"）;
monk.eat（）;
}
}
classPerson{
Stringname;
intage;
Stringjob;
publicPerson（）{}
publicPerson（Stringname,intage,Stringjob）{
this.name=name;
this.age=age;
this.job=job;
}
publicvoideat（）{
System.out.println（this.name+"在吃肉包子。
"）;
}
}
classMonkextendsPerson{
publicMonk（Stringname,intage,Stringjob）{
this.name=name;
this.age=age;
this.job=job;
}
publicvoideat（）{
if（"花和尚"==job）{
super.eat（）;
}
System.out.println（this.name+"在吃素包子。
"）;
}
}
上面的程序说明：
子类继承父类之后，如果对父类中方法的实现不满意，可以重写，即是方法的名称和接收的参数类型都不可以发生变化，唯一可以改变的是：
1、访问级别可以大于等于，但是不能小于原有的方法的访问级别；2、方法的实现可以修改。
如果修改之后，无论引用的类型是父类还是子类，只要实例化的对象是子类对象，那么调用的方法永远都是调用子类中的方法。
这就叫重写。
3、继承关系中方法的调用：
Test9.java
classMonkextendsPerson{
publicMonk（Stringname,intage,Stringjob）{
this.name=name;
this.age=age;
this.job=job;
}
publicvoidkongfu（）{
System.out.println（this.name+"在练功……"）;
}
}
classPerson{
Stringname;
intage;
Stringjob;
publicPerson（）{}
publicPerson（Stringname,intage,Stringjob）{
this.name=name;
this.age=age;
this.job=job;
}
publicvoideat（）{
System.out.println（this.name+"在吃肉包子。
"）;
}
}
publicclassTest9{
publicstaticvoidmain（String[]args）{
Monkm=newMonk（"唐僧",49,"和尚"）;
m.eat（）;//Monk.eat（m）;
m.kongfu（）;//Monk.kongfu（m）;
}
}
上面的程序说明：
如果子类的引用访问方法时：
先从子类找该方法，如果子类没有该方法，它会去父类找这个方法，如果没有，还要继续往父类的父类找，直到找到Object类，如果都没找到才报错。
4、继承中属性的访问
Demo1.java
publicclassDemo1{
publicstaticvoidmain（String[]args）{
Baseb=newBase（）;
System.out.println（"访问属于自己的：
"+b.name）;
SubClasssc=newSubClass（）;
System.out.println（"子类对象访问：
"+sc.name）;
}
}
classBase{
Stringname="nameofbase.";
}
classSubClassextendsBase{
}
上面的程序说明：
当用子类对象访问属性时，如果子类不存在该属性，会进一步去其父类中访问。
如果父类有，就用父类的；没有的化，继续去父类的父类找，直到找到Object类。
最后到Object都没有的化，就报错了。
Demo1.java
publicclassDemo1{
publicstaticvoidmain（String[]args）{
Baseb=newBase（）;
System.out.println（"访问属于自己的：
"+b.name）;
SubClasssc=newSubClass（）;
System.out.println（"子类对象访问：
"+sc.name）;
}
}
classBase{
Stringname="nameofbase.";
}
classSubClassextendsBase{
Stringname="nameofSubClass.";
}
上面的程序说明：
如果用子类的对象访问属性，如果子类有，就用子类的。
没有才去父类找。
Demo1.java
publicclassDemo1{
publicstaticvoidmain（String[]args）{
Baseb=newBase（）;
System.out.println（"访问属于自己的：
"+b.name）;
SubClasssc=newSubClass（）;
System.out.println（"子类对象访问：
"+sc.name）;
Baseb2=newSubClass（）;
System.out.println（"父类引用指向的是子类对象：
"+b2.name）;
}
}
classBase{
Stringname="nameofbase.";
}
classSubClassextendsBase{//SubClass也是Base。
Stringname="nameofSubClass.";
}
上面的程序说明：
属性的访问和对象本质上没有关系，访问属性就看引用的类型，引用是什么类型的，就从那个类中找起，如果找到就用，找不到，去其父类找。
Demo1.java属性和方法的区别
publicclassDemo1{
publicstaticvoidmain（String[]args）{
Baseb=newBase（）;
System.out.println（"访问属于自己的：
"+b.name）;
b.print（）;
System.out.println（"***************************"）;
SubClasssc=newSubClass（）;
System.out.println（"子类引用访问属性：
"+sc.name）;
sc.print（）;
}
}
classBase{
Stringname="nameofbase.";
publicvoidprint（）{
System.out.println（"printmethodofBase."）;
}
}
classSubClassextendsBase{//SubClass也是Base。
Stringname="nameofSubClass.";
}
上面的程序说明：
如果用子类对象访问方法时，如果子类没有该方法，会进一步去其父类调用方法，如果还是没有，去其父类的父类找，一直找到Object类。
都没找到就报错，在哪个类找到，就调用哪个类中的方法。
Demo1.java
publicclassDemo1{
publicstaticvoidmain（String[]args）{
Baseb=newBase（）;
System.out.println（"访问属于自己的：
"+b.name）;
b.print（）;
System.out.println（"***************************"）;
SubClasssc=newSubClass（）;
System.out.println（"子类引用访问属性：
"+sc.name）;
sc.print（）;
System.out.println（"***************************"）;
Baseb2=newSubClass（）;
System.out.println（"父类的引用（指向的是子类对象）调用属性"+b2.name）;
b2.print（）;
}
}
classBase{
Stringname="nameofbase.";
publicvoidprint（）{
System.out.println（"printmethodofBase."）;
}
}
classSubClassextendsBase{//SubClass也是Base。
Stringname="nameofSubClass.";
publicvoidprint（）{
System.out.println（"printmethodofSubClass."）;
}
}
上面的程序说明：
方法的调用和属性的调用是不同的，如果父子类中都有该方法，到底使用的方法是父类的还是子类的，由引用指向的对象决定，如果对象是子类对象，即使引用是父类型的，方法依然调用子类的方法。
和属性不同。
属性是由引用的类型决定的。
原因是子类和父类都有相同方法时，如果我们实例化的是子类对象，那么子类就重写了父类中同名的方法，即方法重写。
5、抽象类
Demo2.java
publicclassDemo2{
publicstaticvoidmain（String[]args）{
newPerson（）;
}
}
abstractclassPerson{//要做的事自己不会做、或不愿意做，找别人做。
abstractpublicvoidcooking（Stringcaidan）;
}
写Person类的目的：
某人想做某种事情，但是自己又不知该如何做。
只能靠别人帮助自己来做。
我们要通过抽象方法来定义要想做的事情，那么该方法所在的类要声明为抽象类，抽象类不能实例化。
Demo2.java
publicclassDemo2{
publicstaticvoidmain（String[]args）{
Personwhz=newStudent（"范祥"）;
whz.cooking（"西红柿炒鸡蛋"）;
}
}
abstractclassPerson{//我们想吃东西，但是自己不会做，或不愿意做，等别人做。
abstractpublicvoidcooking（Stringcaidan）;
}
classStudentextendsPerson{
Stringname;
Student（Stringname）{
this.name=name;
}
publicvoidcooking（Stringname）{
System.out.println（this.name+"为你做了"+name）;
}
}
Person类不会cooking或者不愿意cooking，找Student类为他cooking。
6、接口：
是描述一种能力的类型。
和类、抽象类都是有区别的。
Demo3.java
publicclassDemo3{
publicstaticvoidmain（String[]args）{
Personp=newStudent（"学生A"）;
p.eat（）;
Studentst=newStudent（"学生B"）;
st.eat（）;
st.study（）;
Studablesa=newStudent（"学生C"）;
sa.study（）;
sa=newCooker（"厨师A"）;
sa.study（）;
}
}
classPerson{
Stringname;
Person（Stringname）{
this.name=name;
}
publicvoideat（）{
System.out.println（this.name+"蹲在墙角吃了一顿饭。
"）;
}
}
interfaceCookable{
publicvoidcooking（）;
}
interfaceStudable{
publicvoidstudy（）;
}
classStudentextendsPersonimplementsStudable{
Student（Stringname）{
super（name）;
}
publicvoidstudy（）{
System.out.println（"学习普通文化知识。
"）;
}
}
classCookerextendsPersonimplementsCookable,Studable{
Cooker（Stringname）{
super（name）;
}
publicvoidcooking（）{
System.out.println（"专业做饭。
"）;
}
publicvoidstudy（）{
System.out.println（"学习厨艺。
"）;
}
}
上面的程序说明：
1）java不支持多继承，但是支持多实现。
意思是：
一类事物只能有一种类型，而不能有多种类型。
但是一类事物可以具备多种功能。
2）接口描述的是能力。
而不是类型。
3）一类事物要想具备多种功能，可以实现接口，因为接口描述的就是功能。
升级会员 