前两天写东西,本来想把定义和实现分开来写的。类A有两个方法f1和f2,想把类A的定义、f1的实现和f2的实现分为三个java文件来写,看了看抽象类和接口。不过貌似都不是搞这个的样子。(求方法)
总结一下,自己看的继承和接口。
继承
Java中很基本的概念。如书所言:
(1)java不支持多重继承,也就是说子类至多只能有一个父类
(2)子类继承了其父类中不是私有的成员变量和成员方法,作为自己的成员变量和方法
(3)子类中定义的成员变量和父类中定义的成员变量相同时,则父类中的成员变量不能被继承
(4)子类中定义的成员方法,并且这个成员方法的名字,返回类型,及参数个数和类型与父类的某个成员方法完全相同,则父类的成员方法不能被继承。
其实看这个,远远不够啊。还是看代码,能跑出什么来才是真啊。
先看看java对象如何初始化过程吧。
代码如下:
public class test_java {
public static String a = "a";
private String b = "b";
{
System.out.println("no static");
System.out.println("b:"+b);
}
static{
System.out.println("static");
System.out.println("a:"+a);
}
public test_java() {
// TODO Auto-generated constructor stub
this("Un");
System.out.println("test_java() "+this.b);
}
public test_java(String c){
this.b = c;
System.out.println("test_java(string)" +this.b);
}
public static void main(String[]args ){
new test_java();
}
}
输出如下:
static
a:a
no static
b:b
test_java(string)Un
test_java() Un
分析一下:
1 在实例化对象时,先对给静态变量分配内存空间并初始化,然后执行静态块。
因此,在这里会输出:
static
a:a
a:a的输出也说明是先初始化静态变量然后再执行静态块,否则a将为null。同时,如果将“"a:"+a”修改为“"a:"+b”,eclipse自动报错也说明静态变量->静态快,再其它。
2然后在内存中为Employee分配内存空间,并做默认初始化(即所有变量初始化为默认值,这里都初始化为null)。
3 默认初始化完成后,开始显示初始化。即执行“private String b = "b";
”,将b初始化"b",并且执行非静态方法块;因此在这里会有以下输出:
no static
b:b
4 最后才调用默认构造函数,在默认构造函数中调用了带参数的构造函数,所以在这里先输出带参数构造test_java(string),此时b已经被修改为“Un”,再输出test_java()。
可以看出:如果在类内有静态变量和静态块,就先静态后非静态,最后才是构造函数;
接下分析一下
抽象类、子类的变量和函数与父类的关系
父类:
//父类,抽象类
abstract public class A {
static{
System.out.println("A");
}
int i;
A(int i){
this.i = i;
System.out.println("A "+i);
}
abstract public void f1();
abstract public void f2();
public void f3(){
System.out.println("A f3 "+i);
}
}
父类是个抽象类,可以有自己的数据成员,也可以有非abstarct的成员方法。但是不能被实例化。
子类1:
//子类,
public class C1 extends A{
C1(int i) {
super(i);
i++;
System.out.println("C1 "+i);
}
@Override
public void f1() {
System.out.println("C1 f1 "+i);
}
@Override
public void f2() {
}
public void f3(){
i = 5;
System.out.println("C1 f3 "+i);
System.out.println("C1 f3 super "+super.i);
super.f3();
}
}
该子类C1实现了父类所有的方法,抽象和非抽象的。
// 子类
public class C2 extends A{
C2(int i) {
super(i); // 必须在第一行,且
this.i=8;
System.out.println("C2 "+this.i);
}
@Override
public void f1() {
// TODO Auto-generated method stub
}
@Override
public void f2() {
// TODO Auto-generated method stub
System.out.println("C2 f2 "+i);
}
}
子类C2实现了父类的抽象方法。子类在继承抽象类时,必须实现抽象类中的所有抽象方法。
来看看下面一段代码会有什么样的输出。
publicstaticvoid main(String[]args ){
System.out.println("main start");
C1 c1 = new C1(0);
C2 c2 = new C2(0);
System.out.println("new");
c1.f1();
c1.f2();
c1.f3();
System.out.println("c1 over");
c2.f1();
c2.f2();
c2.f3();
}
先自己看看,再来对照结果:
main start
A
A 0
C1 1
A 0
C2 8
new
C1 f1 0
C1 f3 5
C1 f3 super 5
A f3 5
c1 over
C2 f2 8
A f3 8
哇,还是有点多。我们来仔细分析一下。
从整体上来说,我们知道从对象的内存角度来说,假设现在有一个父类Father,它里面的变量需要占用1M内存.有一个它的子类Son,它里面的变量需要占用0.5M内存.
现在通过代码来看看内存的分配情况:
Father f = new Father();//系统将分配1M内存.
Son s = new Son();//系统将分配1.5M内存!因为子类中有一个隐藏的引用super会指向父类实例,所以在实例化子类之前会先实例化一个父类,也就是说会先执行父类的构造函数.由于s中包含了父类的实例,所以s可以调用父类的方法.
有了整体认识,来一个一个看输出。
1、C1 c1 = new C1(0);对应输出了A ;A 0;C1 1;先输出A,这点同时验证了子类先初始化父类,再执行父类构造函数A 0;再子类的构造函数C1 1.
2、C2 c2 = new C2(0);对应输出了A 0;C2 8;看出父类初始化只有一次,当构造函数必须在执行一次。
3、子类c1实现了自己的f1、f2、f3,使用时就是使用的自己的实现;子类c2没有实现f3,调用父类的实现。但是只使用父类的方法,数据成员还是自己的,所有输出“A f3 8”。
由此,可推断,这三个类内存结构如图:
父类A子类C1子类C2
i | I | I |
F1 F2 F3 | F1 F2 F3 | F1 F2 F3 |
F1 F2 F3 | F1 F2 |
现在在回去看看开头出的四点,确实是那样,并且后面对凌乱的代码验证有更好的认识。下面讲讲继承中的一些其它内容。
super关键字
super关键字在java中的作用是使被屏蔽的成员变量或者成员方法或变为可见,或者说用来引用被屏蔽的成员变量和成员成员方法。super是用在子类中,目的是访问直接父类中被屏蔽的成员。
父类引用指向子类对象
Father f = new Father();//系统将分配1M内存.
Son s = new Son();//系统将分配1.5M内存!因为子类中有一个隐藏的引用super会指向父类实例,所以在实例化子类之前会先实例化一个父类,也就是说会先执行父类的构造函数.由于s中包含了父类的实例,所以s可以调用父类的方法.
Son s1 = s;//s1指向那1.5M的内存.
Father f1 = (Father)s;//这时f1会指向那1.5M内存中的1M内存,即是说,f1只是指向了s中实例的父类实例对象,所以f1只能调用父类的方法(存储在1M内存中),而不能调用子类的方法(存储在0.5M内存中).
Son s2 = (Son)f;//这句代码运行时会报ClassCastException.因为f中只有1M内存,而子类的引用都必须要有1.5M的内存,所以无法转换.
Son s3 = (Son)f1;//这句可以通过运行,这时s3指向那1.5M的内存.由于f1是由s转换过来的,所以它是有1.5M的内存的,只是它指向的只有1M内存.
接口
Java语言不支持一个类有多个直接的父类(多继承),但可以实现(implements)多个接口,间接的实现了多继承.
接口使用有几点需要注意的:
1、Java接口与c++的纯虚基类类似。成员变量默认都是public,static,final类型的(都可省略),必须被显示初始化,即接口中的成员变量为常量(大写,单词之间用"_"分隔)
2, Java接口中的方法默认都是public,abstract类型的(都可省略),没有方法体,不能被实例化
下面都是不对的。
public interface A
{
int var; //错,var是常量,必须显示初始化
void method(){...}; //错,接口中只能包含抽象方法
protected void method2(); //错,接口中的方法必须是public类型
static void method3(){...}; //错,接口中不能包含静态方法
}
我个人以为,接口就是一个纯抽象类,只有抽象方法,坚决不能有实现。实现接口即是在给自己的类添加一个或多个方法。使用接口是为了在设计模式上的规范。
抽象类与接口区别
这个我还是推荐看看http://www.blogjava.net/chunkyo/archive/2007/01/21/95093.html。讲的非常好,只是不知道原创是谁。
参考:
详论JAVA对象的初始化过程 http://peixun.it168.com/showart.php?id=97
Java 中深层理解父类引用指向子类对象 http://hi.baidu.com/startym/blog/item/c6e9073ec3c417d67d1e71a3.html
Java抽象类和接口的区别 http://www.blogjava.net/chunkyo/archive/2007/01/21/95093.html
C++的虚基类与Java的多态性http://akai.yo2.cn/articles/c的虚基类与java的多态性.html
Java与C++在面象对象基本概念上的区分 http://blog.csdn.net/adcxf/article/details/2072009
Java接口学习笔记 http://developer.51cto.com/art/200906/130540.htm