Java知识总结-继承
2014-02-10 23:35
232 查看
<span style="font-family: Arial, Helvetica, sans-serif; background-color: rgb(255, 255, 255);">通过提取不同类的共性,并进行单独描述,作为一个新的类。</span>
例如,下面有两个类:学生类,工人类;
class Student{ String name; int age; void study(){ System.out.println("学生要学习"); } } class Worker{ String name; int age; void work(){ System.out.println("工人要工作"); } }很明显这两个类具有明显的共性,现在将这些共性提取出来作为一个新的类:人类:
class Person{ String name; int age; }
接着让学生类和工人类与新的类通过继承联系起来;
class Student extends Person{ void study(){ System.out.println("学生要学习"); } } class Worker extends Person{ void work(){ System.out.println("工人要工作"); } }当学生类和工人类继承Person类后,就可以直接使用Person类中的成员,所以不需要再定义这些成员。例:
从上面的例子可以看出继承的特点:
1.提高了代码的复用性;
2.让类与类之间产生了关系;
注意:继承的前提是类与类之间存在所属关系,不能为了获取其他类的功能和简化代码而继承。
二:
Java中只支持单继承,不支持多继承。
class A{ void show(){ System.out.println("A"); } } class B{ void show(){ System.out.println("B"); } }当一个类C同时继承上面两个类A和B时,
class C extends A,B{ }当调用C的 show方法时,子类对象无法确定运行那个父类的show方法。
同时Java支持多层次的继承。
如:子类继承父类,父类还有自己的父类……例:
class A{ } class B extends A{ } class C extends B{ } class D extends C{ }这样就会形成一个继承体系。如何使用一个继承体系中的功能呢?
想要使用一个继承体系,先查询该父类的描述,父类中定义的是该体系的共性功能;
通过了解共性功能,就可以找到该体系的基本功能。那么这个体系就基本可以使用了;
再具体调用时,要创建最子类的对象;
因为父类有可能是不能创建对象,如抽象类。而且创建子类对象可以使用更多的功能,包括父类功能和子类功能。
简而言之:查询父类功能,创建子类对象使用功能。
三:
子父类中成员的调用特点:
1.变量
当子父类出现非私有同名变量时,子类对象访问本类中的变量时用this,此时this可省略;
子类对象访问父类中的变量时用super。
super的使用和this的使用几乎一致;
this代表本类对象的引用;
super代表父类对象的引用。
class Fu{ int num=2; } class Zi extends Fu{ int num=3; void show(){ System.out.println(this.num); //结果为3. } }此时的this可以省略。
class Fu{ int num=2; } class Zi extends Fu{ int num=3; void show(){ System.out.println(num);//省略this后结果仍为3 System.out.println(super.num);//结果为2. } }另,当子父类中变量不同名时,子类对象可以直接访问父类变量。
class Fu{ int num=3; } class Zi extends Fu{ int num2=7; void show(){ System.out.println(num);//结果为3,此时访问父类变量可省略super } }
2.子父类中函数
当子父类出现一模一样的函数时,当子类对象调用该函数,运行子类函数的内容。这种情况叫做函数的覆盖。
覆盖:当子类继承父类,沿袭了父类的功能到子类中,当子类具备该功能,但功能内容和父类不一致时,没有必要定义新功能,而是使用覆盖特性,保留父类的功能定义,并重写功能内容。
注意:1,子类覆盖父类,必须保证子类函数权限大于等于父类权限才可以覆盖,否则编译失败。
2.,静态不能覆盖非静态。
例:
class Fu{ void show(){ System.out.println("父类方法"); } } class Zi extends Fu{ void show(){ System.out.println("子类方法"); } } public class Test { public static void main(String[] args) { Zi z=new Zi(); z.show(); } }运行结果:
子类方法
此时也可以通过super关键词在子类中直接调用父类被覆盖的函数。
class Fu{ void show(){ System.out.println("父类方法"); } } class Zi extends Fu{ void show(){ System.out.println("子类方法"); } void print(){ super.show();//调用父类被覆盖函数 } } public class Test { public static void main(String[] args) { Zi z=new Zi(); z.print(); } }运行结果
父类方法在子类函数中通过super调用父类函数,可以实现子类函数在父类函数的基础上进行扩展。例如:
class Fu{ void show(){ System.out.println("父类原有功能"); } } class Zi extends Fu{ void show(){ super.show(); System.out.println("子类扩展功能"); } } public class Test { public static void main(String[] args) { Zi z=new Zi(); z.show(); } }运行结果:
父类原有功能 子类扩展功能
注:当父类函数私有化时,子类没有覆盖父类的函数。
3.子父类中构造函数的特点
在对子类对象进行初始化时,父类的构造函数也会进行初始化。
因为子类的构造函数默认第一行有一条隐式语句super();
super()会访问父类中空参数的构造函数,而且子类所有构造函数默认第一行都是super();
为什么子类一定要访问父类中的构造函数:
因为子类可以直接获取父类中的数据,所以子类对象在建立时,需要先查看父类是如何对这些数据进行初始化的。
如果要访问父类中指定的构造函数,可以 通过手动定义super语句来定义。
只有子类才有super();
构造函数里面只能有一个隐式语句,如果有了super();,就不能在有this();
结论:
子类的所有构造函数,默认都会访问父类中空参数的构造函数。
因为子类每一个构造函数的第一行都有一句隐式super();
当父类中没有空参数的构造函数时,子类必须手动通过super或者this语句形式来指定要
访问父类中的构造函数。当然,子类的构造函数第一行也可以手动指定this语句来访问本
类中的构造函数。子类中至少会有一个构造函数会访问父类中的构造函数。
例:
class Fu{ Fu(){ System.out.println("a"); } } class Zi extends Fu{ Zi(){ System.out.println("b"); } } public class Test { public static void main(String[] args) { Zi z=new Zi(); } }
运行结果:
a b
从运行结果可以看出,在初始化子类对象时,父类也进行了初始化,并且是在子类之前。
class Fu{ Fu(){ System.out.println("a"); } } class Zi extends Fu{ Zi(){ System.out.println("b"); } Zi(int x){ System.out.println("c"); } Zi(int x,int y){ System.out.println("d"); } } public class Test { public static void main(String[] args) { Zi z1=new Zi(); Zi z2=new Zi(3); Zi z3=new Zi(3,5); } }
运行结果:
a b
a
c
a
d
从上面例子的结果可以看书,子类所有的构造函数都调用了父类的构造函数。即默认隐式存在语句super()。
当父类没有空参数的构造函数时,子类构造函数默认的super()就没有调用对象了,所以这时需要手动指定父类构造函数,例:
class Fu{ Fu(int x){ System.out.println("a"); } } class Zi extends Fu{ Zi() 4000 { super(3);//访问父类指定构造函数 System.out.println("b"); } Zi(int x){ this();//访问本类空参数构造函数,并通过本类空参数函数访问父类构造函数。 System.out.println("c"); } } public class Test { public static void main(String[] args) { Zi z1=new Zi(); Zi z2=new Zi(3); } }
运行结果:
a b
a b
c
当一个继承体系中,一个类B及其父类A都具有同一函数,类B中的函数覆盖了其父类A的函数,当一个新的类C继承类B并调用这个函数时,访问的是类C的父类B中的函数,例:
class A{ void show(){ System.out.println("A"); } } class B extends A{ void show(){ System.out.println("B"); } } class C extends B{ } public class Test { public static void main(String[] args) { C c=new C(); c.show(); } }
运行结果
B
所以在多重继承中,如果一个类的父类,父类的父类都有同一函数,则继承最近父类中函数。
四:
final关键字
final可以修饰类,方法,变量。
1.被final修饰的类不可以被继承。例:
final class Fu{ void show(){ System.out.println("父类"); } } class Zi extends Fu{ void show(){ System.out.println("子类"); } }
当一个类继承被final修饰的类时,编译会报错。
2.被final修饰的方法不可以被覆盖。例:
class Fu{ final void show(){ System.out.println("父类"); } } class Zi extends Fu{ void show(){ System.out.println("子类"); } } public class Test { public static void main(String[] args) { Zi z=new Zi(); z.show();//报错 } }
3.被final修饰的变量时常量,其该变量只能被赋值一次,final可以修饰成员变量和局部变量。
public class Test { public static void main(String[] args) { final int X=44; X=33; System.out.println("x="+x); } }编译器报错
相关文章推荐
- Java知识总结-继承
- Java【多线程知识总结(5)】比较继承Thread类创建线程和实现Runnable接口创建线程这两种方式
- java知识总结(三)封装、继承和多态
- Java【多线程知识总结(5)】比较继承Thread类创建线程和实现Runnable接口创建线程这两种方式
- 黑马程序员_Java继承、多态、接口零碎知识总结
- JAVA面向对象初步知识总结:封装、继承、多态
- Java基础知识总结之类的继承
- java继承知识总结
- Java继承知识总结
- Java继承知识总结
- Java继承相关知识总结
- 关于Java中的继承,包括重写、构造器、访问权限、构造过程等知识总结
- java 自我知识总结(十一)构造函数 继承 及类的加载顺序
- Java知识总结-基础
- 黑马程序员----------java基础知识之JDK5.0新特性总结
- JAVA基础知识精华总结
- Java开发知识之Java的继承多态跟接口*
- Java【多线程知识总结(6)】使用Runnable接口创建多线程,处理同一个资源
- JAVA基础知识精华总结
- 文件上传(java后台)的小知识总结