您的位置：首页 > 编程语言 > Java开发

java 自学日志【六】---面向对象之继承

2013-04-12 01:16 204 查看
------android培训，java培训，期待与您交流------

面向对象特征二--->继承 extends
继承：把很多类的相同特征和行为进行抽取，用一个类来描述。让多个类和这个类产生一个关系。这样的话，多个类就可以省略很多代码。这个关系就是继承。java中用extends关键字表示。

继承特点：1 提高了代码的复用性； 2 让类与类之间产生了关系，有了关系，才有了多态的特性；
注意：千万不要为了获取其他类的功能，简化代码而继承，必须是类与类之间有关系，有所属关系。

怎样判断是否继承？？
看父类里的内容是否在子类中都具备，如不是，则不继承。

java语言中，只支持单继承，不支持多继承。因为多继承容易带来安全隐患，当多个父类中定义了相同功能，而功能内容不同，子类对父类的继承不能确定要运用哪一个，但java保留了这种机制，并用另外一种形式来体现，就是接口的多实现。

java支持多层继承，即一个继承体系，如果使用一个继承体系的功能？
1 先查阅父类的描述，以为父类中定义的是该体系中的共性方法；
2 在具体调用时，要创建最子类对象，因为父类可能不能创建对象，而创建子类可以使用更多的功能，包括父类的也包括子类特有的；
总结就是：先查阅父类功能，然后创建子类对象使用；
类与类之间的关系除了继承，还有聚合，聚集，组合.....

一个类的成员包括：变量，函数，构造函数；
子类，父类中变量的特点： 如果子类父类中出现 非私有的成员变量时，子类要访问本类的变量用this，要访问父类中的同名变量用super；
class  Fu
{
int num=4;
//int num1 =4;
}
class Zi extends Fu
{
//int num2 =5;
int num=5;
void show()
{
System.out.println(num);// 省略了this关键字，
}
}
class ExtendsDemo
{
public static void main(String[] args)
{
Zi z = new Zi();
z.show();//打印子类的num,如果打印父类的num,需要在show（super.num）声明
//System.out.println(z.num+"---"z.num);//打印子类的num
//System.out.println(z.num1+"---"z.num2);
}
}


子类，父类中函数的特性：重写：当子类中出现与父类一模一样的函数时，子类对象调用该函数时，会运行子类函数的内容，如同父类的函数被覆盖一样，这种情况就叫重写。
注意：子类覆盖父类的方法，必须保证子类的该方法访问权限大于等于父类权限；静态只能覆盖静态；

重写与重载的区别（函数的两个特性）：1 重写要求子类与父类的函数要一模一样 ； 2 重载只看函数的参数列表，不同即可；
class  Fu
{
void show()
{
System.out.println("fu show");
}
}
class Zi extends Fu
{
void show()//子类覆盖了父类的show方法,权限要大于等于父类权限。
{
System.out.println("zi show");
}
}
class ExtendsDemo
{
public static void main(String[] args)
{
Zi z = new Zi();
z.show();//子类的show覆盖了父类的show，打印子类的show。

}
}


子类，父类中构造函数的特点：
在对子类对象进行初始化时，父类的构造函数也会运行，这是因为子类构造函数默认第一行有一条隐式语句super（）,super()会访问父类的空参构造函数，而且子类中所有的构造函数默认第一行都是super();

为什么子类一定要访问父类的构造函数？
以为父类的数据子类可以直接读取，所以子类建立对象时，需要先查阅父类是如何对这些数据进行初始化的，所以子类对象在初始化时，要先访问一下父类的构造函数，如果要访问父类中指定的构造函数，可以手动定义super语句来指定。
注意：super 语句一定要在子类的构造函数的第一行，构造函数不存在重写（覆盖）。
当然，子类的构造函数第一行也可以手动指定this语句，来访问本类中的构造函数，子类中至少有一个构造函数会访问父类中的构造函数，当父类没有空构造函数时，子类必须手动super（）指定访问。

为什么this和super不能同时存在构造函数中？
因为他们都必须写在构造函数的第一行，初始化动作要先执行；
class  Fu
{
Fu(int x)//此时父类中没有默认空参构造函数，子类需要手动指定super语句。
{
System.out.println("FU RUN");
}
}
class Zi extends Fu
{
Zi()
{
super(4);//子类手动定义。
//super();隐式语句，调用父类的构造函数。
System.out.println("zi run");
}
Zi(int x)
{
super(4);//隐式语句
System.out.println("zi。。"+x);
}
}
class ExtendsDemo
{
public static void main(String[] args)
{
Zi z = new Zi();//创建对象，会打印FU RUN，zi run;
Zi z1 = new Zi(4);
}
}
final 关键字
final 最终，修饰符，可以修饰类，变量，函数；
1 被final修饰的类 不可以被继承；而没有子类，就不可以被重写；
2 被final修饰的函数方法不可以被重写（覆盖）；
3 被final修饰的变量是一个常量，只能赋值一次，既可以修饰成员变量，也可以修饰局部变量；
4 内部类定义在类的局部位置上时，只能访问被final修饰的局部变量；

抽象类 abstract
当多个类中出现相同的方法，但方法体不同，可以进行向上抽取，只抽取定义，而不抽取方法体，让子类继承后，自己去实现方法体。没有方法体的方法，我们需要用抽象标志下。抽象的关键字是：abstract，修饰类和方法。该方法称为抽象方法，包含抽象方法的类就是抽象类。

抽象类的特点：
1 抽象方法一定定义在抽象类中；
2 抽象方法和抽象类都必须被关键字 abstract所修饰；
3 抽象类不可以创建对象，因为调用抽象方法无意义；
4 抽象类中的抽象方法必须由子类复写其所有抽象方法后，建立子类对象调用，如果子类只复写了部分抽象方法，那么该子类还是一个抽象类；抽象类比一般类多了个抽象函数，就是类中可以定义抽象方法。抽象类不可以实例化。特殊：抽象类中可以不定义抽象方法，这样做仅仅是为了不让给类建立对象。

模板设计模式：

在定义功能时，功能的一部分是确定的，但是有一部分是不确定的，而确定的部分又在使用不确定的部分，那么这时就将不确定的部分暴露出去，由该类的子类去实现。

abstract class  GetTime
{
public final void getTime()
{
long start = System.currentTimeMillis();

run();

long end = System.currentTimeMillis();

System.out.println("time="+(end-start));
}        public abstract void run();
}
class SubTime extends GetTime
{
public void run()
{
for (int x=0;x<4000 ;x++ )
{
System.out.println(x);
}
}
}
class Time
{
public static void main(String[] args)
{
SubTime st = new SubTime();
st.getTime();
}
}
接口 interface

当一个类中的方法都是抽象的时候，java提供了另一种表示方式，叫接口。用interface关键字表示。类与接口关系用实现implements表示。

class用于定义类，interface用于定义接口。

接口中的成员修饰符都是固定的：常量：public static final ；抽象方法：public abstract 。接口中的成员都是用public修饰的。

接口是不可以创建对象的，因为有抽象方法，需要被子类实现，子类对接口中的抽象方法全部覆盖后，子类才可以实例化，否则，子类是一个抽象类。

接口可以被多实现，即一个类可以实现多个接口，这也是对类不支持多继承的另一种体现形式，接口间可以多继承，但被继承的接口之间不能存在只有返回值类型不同的同名函数。

interface Person
{
public static final int FEET=4;

punlic abstract void speak();
}
class Man implements Person
{
public void speak()
{
System.out.println("chinese")；
}
}


接口的特点：

1 接口是对外暴露的规则。

2 接口是程序的功能扩展。

3 接口可以用来多实现。

4 类与接口之间是实现关系，而且类可以继承一个类的同时实现多个接口。

5 接口与接口之间可以有多继承关系。

接口和抽象类的区别：

1：抽象类只能被单继承

接口可以多实现,接口的出现避免了多继承的局限性。

2：抽象类中的数据特点：

成员变量：可以是变量，也可以是常量

成员方法：可以是抽象方法，也可以是非抽象方法

构造方法：有构造方法

接口中的数据特点：

成员变量：是常量。默认修饰 public static final

成员方法：都是抽象方法。都有默认修饰 public abstract

构造方法：没有构造方法

3：抽象类中定义的是继承体系中的共性功能。

接口中定义的是继承体系中的扩展功能。

4：抽象类被继承是"is a"关系:xx是yy的一种。

接口被实现是"like a"关系:xx像yy的一种。
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 点击这里给我发消息
标签： 
相关文章推荐
新的分享
章节导航