----------------------ASP.Net+Android+IOS开发----------------------期待与您交流!
面向对象3
l 继承
l 子父类中变量的特点(super关键字,覆写)
l 子父类中构造函数的特点 - 子类实例化过程
l final关键字
l 抽象类
l 模版方法模式
l 接口
继承
在Java中,通过继承可以简化类的定义,扩展类的功能。在Java中支持类的单继承和多层继承,但是不支持多继承,即一个类智能继承一个类而不能继承多个类。
Class 子类名 extends 父类
例:
class Person{
String name;
int age;
}
//这里用到了extends就是继承,即Student继承Person
class Student extends Person{
String school;
}
public class JiCheng{
public static void main(String[] args){
Student s = new Student();
//访问Person类中的name属性
s.name = "张三";
//访问Person类总的age属性
s.age = 22;
//访问Student类中的school属性
s.school = "北京";
System.out.println("姓名: " + s.name + ", 年龄: " + s.age + ", 学校: " + s.school);
}
}
从上段程序中可以看到,Student类中虽然并没有定义name ,age属性,但在程序外部却依然可以调用name和age。这是因为Student类直接继承Person类,也就是说Student类直接继承了Person类的属性,所以Student类的对象才可以访问到父类的中的成员。
继承:1.提高了代码的复用性。
2.让类与类之间产生了联系。有了这个关系,才有了多态的特性。
注意:千万不要为了获取其他类的功能,简化代码而继承。必须是类与类之间有所属关系才可以继承。
Java语言中:java只支持单继承,不支持多继承。因为多继承容易带来安全隐患:当多个父类中定义了相同功能,当功能内容不同时,不确定要运行哪一个。但是Java保留了这种机制,并用另一种体现形式来完成表示:多实现。
Java支持多层继承,也就是一个继承ixia。
如何使用一个继承体系中的功能呢?
想要使用体系,先查阅体系父类的描述,因为父类中定义的是该体系中共性功能。
通过了解共性功能,就可以知道该体系的基本功能。
那么这个体系已经可以基本使用了。
那么在具体调用时,要创建最子类的对象,为什么呢?
一是因为有可能父类不能创建对象,二是创建子类对象可以使用更多的功能,包括基本的也包括特有的。
简单一句话:查阅父类功能,创建子类对象使用功能。
子父类中变量的特点(super关键字,覆写)
子父类出现后,类成员的特点:
类中成员:
1. 变量
2. 函数
3. 构造函数
1. 变量:
如果子类中出现非私有的同名成员变量时,子类要访问本类中的变量,用this,子类要访问父类中的同名变量,用super。
Super 的使用和this的使用几乎一致。This代表的是本类对象。Super代表的是父类对象的引用。
例:
class Fu{
int num = 3;
}
class Zi extends Fu{
int num = 5;
void show(){
//这里super调用的是父类中的num
System.out.println(super.num);
}
}
public class JiCheng{
public static void main(String[] args){
Zi z = new Zi();
z.show();
}
}
2. 子父类中的函数:
当子类出现和父类一模一样的函数时,且子类对象调用该函数,会运行子类函数的内容。如同父类的函数被覆盖一样。
这种情况就是函数的另一个特性:重写(覆盖)。
覆写的概念与重载相似,它们均是Java多态的技术之一。
例:
class Fu{
void show(){
System.out.println("Fu show");
}
}
class Zi extends Fu{
void show(){
System.out.println("Zi show");
}
}
public class JiCheng{
public static void main(String[] args){
Zi z = new Zi();
z.show();
}
}
运行结果是:Zi show
当子类继承父类,沿袭了父类的功能到子类中,但是子类虽具备该功能,但是功能的内容却和父类不一致,这是,没有必要定义新功能,而是使用覆盖特殊,保留父类的功能定义,并重写功能内容。
覆写:
1. 子类覆写父类,必须保证子类权限大雨等于父类权限,才可以覆写,否则编译失败。
2. 静态只能覆写静态。
记住:重载:只看同名函数的参数列表。
覆写:子父类方法要一模一样。
子父类中构造函数的特点 -子类实例化过程
3. 子父类中的构造函数:
在对子类对象进行初始化时,父类的构造函数也会运行,那是因为子类的构造函数默认第一行都有一条隐式的super(),super()会访问父类中空参数的构造函数,而且子类中所有的构造函数默认第一行都是super();
例:
class Fu{
Fu(){
System.out.println("Fu show");
}
}
class Zi extends Fu{
Zi(){
// super();这里就是隐式的super()语句
System.out.println("Zi show");
}
}
public class JiCheng{
public static void main(String[] args){
Zi z = new Zi();
}
}
为什么子类一定要访问父类中的构造函数呢?
因为父类中的数据子类可以直接获取,所以子类对象在建立时,需要先查看父类是如何对这些数据进行初始化的。所以子类在对象初始化时,要先访问以下父类中的构造函数。如果要访问父类中指定的构造函数,可以通过手动定义super语句的方式来指定。
注意:super语句一定定义在子类构造函数的第一行。
结论:子类所有的构造函数,默认都会访父类中空参数的构造函数。因为子类每一个构造函数内的第一行都有一句隐式super()。
当父类中没有空参数的构造函数时,子类必须手动通过super语句形式来指定要访问父类中的构造函数。
当然,子类的构造函数第一行也可以手动指定this语句来访问本类中的构造函数,子类中至少有一个构造函数会访问父类的构造函数。
final关键字
1. final可以修饰类,方法,变量。
2. final修饰的类不可以被继承。
3. fianl修饰的方法不可以被覆写。
4. final修饰的变量是一个常量,只能被赋值一次,既可以修饰成员变量,也可以修饰局部变量。
5. 内部类只能访问被final修饰的局部变量。
6. 当在描述事物时,一些数据的出现值是固定的,那么这是为了增强阅读性,都给这些值起个名字,方便阅读,而这个值不需要改变,所以加上fianl修饰,作为常量:常量的书写规范所有字母都大些,如果由多个单词组成,那么单词之间通过_连接。
抽象类
在Java中可以创建一种类专门用来当做父类,这种类称为“抽象类”。抽象类实际上也是一个类,只是与之前的普通类相比,其中多了抽象方法。
抽下ng方法是只声明而未实现的方法,所有的抽象方法必须使用abstract关键字修饰,包含抽象方法的类也必须使用abstract class声明。
抽象类的特点:
1. 抽象方法一定在抽象类中。
2. 抽象方法和抽象类都必须被abstract关键字修饰。
3. 抽象类不可以用new创建对象,因为调用抽象方法没意义。
4. 抽象类中的抽象方法要被使用,必须由子类覆写起所有的抽象方法后,建立子类对象调用。如果子类只覆写了部分抽象方法,那么该子类还是一个抽象类。
例:
abstract class Student{
//抽象方法
abstract void study();
abstract void study1();
}
class BaseStudent extends Student{
void study(){
System.out.println("base study");
}
void study1(){}
}
class AdvStudent extends Student{
void study(){
System.out.println("adv study");
}
void study1(){}
}
class TestStudent{
public static void main(String[] args){
new BaseStudent().study();
}
}
上段程序中,抽象类里定义了2个抽象方法,所以其子类都得覆写。
抽象类和一般类没有太大的不同。该如何描述事物,就如何描述事物,只顾过该事物出现了一些看不懂的东西,这些不确定的部分,也是该事物的功能,需要明确出现,但是无法定义主体。通过抽象方法来表示。
抽象类比一般类多了个抽象函数,就是在类中可以定义抽象方法。抽象类不可以实例化,也就是不能直接用new去产生对象。
特殊:抽象类中可以不定义抽象方法,这样做仅仅是不让改类建立对象。
模板方法模式
需求:获取一段程序运行的时间。
原理:获取程序开始和结束的时间并相见即可。
获取时间:System.currentTimieMillis();
例:
abstract class GetTime{
//这里用final修饰是因为不想让这个方法被覆写
public final void getTime(){
long start = System.currentTimeMillis();
runcode();
long end = System.currentTimeMillis();
System.out.println("毫秒: " + (end - start));
}
public abstract void runcode();
}
class SubTime extends GetTime{
public void runcode(){
for(int x = 0; x<4000; x++){
System.out.println(x);
}
}
}
public class GetTimeDemo{
public static void main(String[] args){
SubTime st = new SubTime();
st.getTime();
}
}
这种方式,就是模板方法模式。
什么事模板方法呢?
在定义功能时,功能的一部分是确定的,但是有一部分是不确定,而确定的部分在使用不确定的部分。那么这时就将不确定的部分暴漏出去,由该类的子类去完成。
接口
接口(interface)是Java所提供的另一种重要技术,它的结构和抽象类非常相似,也具有数据成员与抽象方法,但它与抽象类又有一想两点不同:
1. 接口里的数据成员必须初始化,且数据成员均为常量。
2. 接口里的方法必须全部声明为abstract,也就是说,接口不能像抽象类一样保有一般的方法,必须全部是“抽象方法”。
Class用于定义类,interface用于定义接口。
接口定义时,格式特点:
1. 接口中常见的定义:常量,抽象方法。
2. 接口中的成员都有固定修饰符:
常量:public static final
方法:public abstract
记住:接口中的成员都是public的。
接口:是不可以创建对象的,因为有抽象方法。需要被子类实现,子类对接口中的抽象方法全都覆写后,子类才可以实例化,否则子类是一个抽象类。
implements:实现接口
例:
//定义一个接口Inter
interface Inter{
public static final int NUM = 3;
public abstract void show();
}
//Test类实现Inter接口并且覆写show()方法
class Test implements Inter{
public void show(){
System.out.println("***");
}
}
public class InterfaceDemo{
public static void main(String[] args){
//实现了接口才可以实例化对象
Test t = new Test();
System.out.println(t.NUM);
t.show();
}
}
以上程序就是定义接口和实现接口的例子。
接口可以被类多实现,也是对多继承不支持的转换形式。Java支持多实现。
例:
interface Inter{
public static final int NUM = 3;
public abstract void show();
}
interface InterA{
public abstract void show();
}
class Demo{
public void function(){}
}
//这里Test继承Demo同时又实现接口Inter和InterA
class Test extends Demo implements Inter, InterA{
public void show(){}
}
interface A{
void methodA();
}
interface B{
void methodB();
}
//这里C接口可以同时继承B和A接口
interface C extends B,A{
void methodC();
}
//D实现接口C必须要覆写3个方法
class D implements C{
public void methodA(){}
public void methodB(){}
public void methodC(){}
}
public class InterfaceDemo{
public static void main(String[] args){
//实现了接口才可以实例化对象
D d = new D();
}
}
接口的特点:
1. 接口是对外暴露的规则。
2. 接口是程序的功能扩展。
3. 接口可以用来多实现。
4. 类与接口之间是实现关系,而且类可以继承一个类的同时实现多个接口。
5. 接口与接口之间可以有继承关系。
----------------------ASP.Net+Android+IOS开发----------------------期待与您交流!
详情请查看:http://edu.csdn.net