《day09---继承-抽象类-接口》
2016-03-29 12:07
267 查看
//面向对象_继承_概述---单继承_多继承。 //描述学生。 /* class Student { //属性。 String name; int age; //行为: void study() { System.out.println("good good study"); } } class Worker { //属性: String name; int age; //行为; void work() { System.out.println("hard work"); } } */ /* 为了提高代码的复用性,只建立一份代码就可以了。 一个类只要和另一个类产生关系就可以了。 关系:继承。 发现了获取到所需内容的同时也获取到不该具备的内容。 为什么? 发现原来这两个类之间根本就不存在继承关系。 怎么解决呢? 找到学生和工人的共性类型。将需要提供复用的代码进行抽取。 定义到一个共性的类中。 Person name age. 怎么在代码体现中,让学生和Persong产生关系呢? 只要通过关键字extends(继承),就可以了。 */ class Person { //属性: String name; int age; } class Student extends Person//学生继承了Person,学生就是子类,Person就是父类(基类。超类) { //行为: void study() { System.out.println("good good study"); } } class Worker extends Person { //行为; void work() { System.out.println("hard work"); } } /* 面向对象的另一个特征:继承。 好处:提高了代码的复用性。让类和类产生了关系,给另一个特征。多态提供了前提。 什么时候定义继承? 必须保证类与类之间有所需(is a)关系.xxx是zzz中的一种。 学生是人中的一种。 苹果是水果中的一种。 狗是犬科中的一种。 在Java中继承的体现。 Java允许单继承。不直接支持多继承。将多继承进行其他方式的体现。 单继承:一个子类只能有一个父类。 多继承:一个子类可以有多个父类。 看上去,多继承很厉害!为什么? class Fu1 { void show1() {} } class Fu2 { void show2() {} } //多继承。 class Zi extends Fu1,Fu2 { } Zi z = new Zi(); z.show1(); z.show2(); //问题随之而来, 万一多个父类具备了相同的功能呢? class Fu1 { void show() { sop("fu1 show run"); } } class Fu2 { void show() { sop("fu2 show run"); } } //多继承。 class Zi extends Fu1,Fu2 { } Zi z = new Zi(); z.show();//调用就会产生不确定性。所以java保留了多继承的好处。 //改良了它的弊端,用多实现来体现。用多实现来体现。 //即将学到。 ---------------------------------- java中还支持多重继承。 class A {} class B extends A {} class C extends B {} //形成继承体系。 学习继承体系时,应该参阅顶层的类中的内容。 了解这个体系的基本功能。 使用这个体系功能,需要创建最子类的对象。 看顶层,建底层。 */ class ExtendsDemo { public static void main(String[] args) { Student stu = new Student(); stu.name = "xiaoming"; stu.age = 12; stu.study(); } }
//面向对象_继承_子父类中成员变量的特点。 /* 继承出现后,在代码中的体现。 重点在于成员的体现: 1,成员变量。重点明确原理。 特殊情况: 子父类中定义了一模一样的成员变量。 都存在于子类对象中。 如何在子类中直接访问同名的父类中的变量呢? 通过关键字super来调用。 super和this的用法很相似。 this代表的是本类对象的引用。 super代表的是父类的内存空间。 注意:这种情况开发见不到。因为父类一旦描述完了属性, 子类直接使用就可以了。 2,成员函数。 3,构造函数。 */ //父类 class Fu { /*private int num1 = 3;*///父类中私有的内容子类不可以直接访问。 int num = 3; } class Zi extends Fu { /*int num2 = 4;*/ int num = 4; void show() { // System.out.println("num1="+num1); // System.out.println("num2="+num2); System.out.println("fu num="+super.num); System.out.println("zi num="+this.num); System.out.println(this); } } class ExtendsDemo { public static void main(String[] args) { Zi z = new Zi(); // System.out.println(z.num1); // System.out.println(z.num2); z.show(); } }
/* 子父类中成员函数的特点。 特殊情况: 子父类中定义了一模一样的函数。 运行的结果是子类的函数在运行。 这种情况在子父类中,是函数另一个的特性,Override 重写(覆盖,复写) 重写什么时候用? 举例: //描述手机 class Phone { //打电话。 void call() {} //来点显示。 void show() { System.out.println("电话号码"); } } Phone p = new Phone(); p.show(); //随着电话的升级,只显示号码不爽,希望显示姓名,大头贴等。 修改源码,虽然费劲,但是可以解决问题,但是不利于后期的维护和扩展。 为了扩展方便,新功能是不是新的电话具备呢? 单独描述,单独封装。新电话也是电话中的一种,继承。直接获取父类中的功能。 但是新电话的来电显功能已经变化了。需要重新定义。 那么定义一个新功能合适吗?比如NewShow,不合适,因为父类已经将来点显功能定义了。 子类完全不需要重新定义新功能,直接用就可以了,如果子类的来显功能内容不同。 只需要保留来显功能,定义子类的内容即可,这就是重写的应用。 class NewPhone extends Phone { void show() { //System.out.println("电话号码"); super.show();//如果还需要父类中原有的部分功能,可以通过super调用。 sop("姓名"); sop("大头贴"); } } 重写的注意事项: 1,子类覆盖父类,必须保证权限要大于或者等于父类的权限。(private除外,因为子类 中不能直接访问父类中的private。) Fu: void show(){} Zi: void show(){} 2,静态覆盖静态。 写法上注意:不行一模一样:函数的返回值类型 函数名 函数的参数列表都要一样。 */ class Fu { void show() { System.out.println("fu show1 run"); } } class Zi extends Fu { static void show() { System.out.println("zi show2 run"); } } class ExtendsDemo2 { public static void main(String[] args) { Zi z = new Zi(); z.show(); } }
/* 子父类中构造函数的特点。 当子父类中都有构造函数时,发现结果为: Fu constructor run zi constructor run 先执行了父类的构造函数,再执行子类中的构造函数。 为啥呢? 因为子类中的所有的构造函数中的第一行都有一句隐式额语句Super(); //默认调用的是父类中空参数的构造函数。 子类中构造函数为什么有一句隐式的super呢? 原因:子类会继承父类中的内容,所以子类在初始化时,必须先到父类中去 执行父类的初始化动作。 才可以更方便子类使用。 当父类中没有空参数构造时,子类的构造函数必须显示的super语句指定 要访问的父类中构造函数。 这就是传说中的子类实例化过程。 细节: 1,如果子类的构造函数第一行写了this调用了本类的构造函数,那么super调用父类的 语句还有吗? 没有的,因为this()或者super(),只能定义在构造函数的第一行,因为初始化动作要先执行。 2,子类构造函数里有super,那么父类构造函数有没有super呢? 是有的,记住:只要是构造函数默认第一行都是super(); 父类的父类是谁呢?super 调用的到底是谁的构造函数呢? Java体系在设计时,定义了一个所有对象的父类Object. 总结: 类中的构造函数默认第一行都由隐式的super语句,在访问父类中的构造函数。 所以父类的构造函数既可以给自己的对象初始化,也可以给自己的子类对象初始化。 如果默认的隐式super语句没有对应的构造函数,必须在构造函数中通过this或者super 的形式明确要调用的构造函数。 问题: 1,this 语句和super语句是否可以在同一个构造函数中出现呢?不行:因为必须定义在第一行。 2,为什么要定义在第一行呢?因为初始化动作要先执行。 */ class Fu extends Object { int count = 3; //Fu(){} Fu() { //super(); //显示初始化。 System.out.println("Fu constructor run..A.."+count); } Fu(int x) { //显示初始化。 System.out.println("Fu constructor run..."+x); } } class Zi extends Fu { Zi() { System.out.println("zi constructor run..C.."); } Zi(int x) { this(); System.out.println("zi constructor run..."+x); } } class ExtendsDemo { public static void main(String[] args) { //New Zi(); new Zi(6); new Student("lisi",21); } } /* class Fu { Fu() { System.out.println("Fu constructor run..A.."); } Fu(int x) { //显示初始化。 System.out.println("Fu constructor run..B.."); } } class Zi extends Fu { Zi() { //super(); System.out.println("Fu constructor run..C.."); } Zi(int x) { //super(); System.out.println("Fu constructor run..D.."); } } class ExtendsDemo { public static void main(String[] args) { new Zi(); new Zi(6);//打印结果是A C A D. } } */ //子类的实例化过程的应用。也是super调用的应用。 //什么时候用super调用父类中的构造函数,只要使用父类的指定初始化动作, //就在子类中使用super()调用就可以了。 class Person { private String name; private int age; public Person(String name,int age) { this.name = name; this.age = age; } public void setName(String name) { this.name = name; } public String getName() { return name; } public void setAge(int age) { this.age = age; } public int getAge() { return age; } } class Student extends Person { public Student(String name,int age) { //调用父类,使用父类的初始化动作。 super(name,age); } } class Worker extends Person { public Worker(String name,int age) { //调用父类,使用父类的初始化动作。 super(name,age); } }
//final关键字。 /* 继承的弊端:打破封装性。 不让其他类去继承该类,就不会有重写。 怎么能实现呢?通过java中的关键字来实现。final(最终化) 【final】 是一个修饰符。可以修饰类,方法,变量(成员变量,局部变量,静态变量) 【特点】 1,final修饰的类是一个最终类,不能再派生子类。 如果类中出现部分可以重写,部分不可以?怎么办?只要让指定的方法最终化就可以了。 2,final修饰的方法是最终方法,不可以重写。 3,fianl修饰变量是一个常量。只能被赋值一次。 【什么时候需要在程序中定义final常量呢?】 当程序中一个数据使用时是固定不变的,这时为了增加阅读性,可以给该数据起个名字。 这就是变量,为了保证这个变量的值不被修改,加上final修饰,这就是一个阅读性很强的 常量。书写规范,被final修饰的常量名所有的字母都是大写的。如果由多个单词组成,单词 之间用下划线连接。 */ /*final*/ class Fu { /*final*/ void show() { //调用到一些系统的功能。 //功能的内容是不可以改变的。 } } class Zi extends Fu { static final int number = 9;//这个编译会失败,final修饰的变量必须赋初值。 static final double PI = 3.14;//为了访问方便,直接用static修饰,可以直接用类名调用。 //覆盖 void show() { final int count = 21; //count = 2;//失败。 System.out.println(count); } } class FinalDemo { public static void main(String[] args) { System.out.println("Hello World!"); } }
/* 描述狗,行为,吼叫。 描述狼,行为:吼叫。 发现他们之间有共性,可以进行向上抽取。 当然是抽取它们的所属共性类型,犬科。 犬科这类事物,都具备吼叫行为。但是具体怎么叫,是不确定的,是由具体的子类来 明确的。 这些不具体的功能,需要在类中标识出来,通过java中的关键字来体现。 定义了抽象函数的类也必须别abstract修饰。 抽象类,在描述事物时,没有足够的信息描述一个事物,这时该事物就是抽象事物。 */ /* 【抽象类的特点】 1,抽象类和抽象方法都需要被abstract修饰。 抽象方法一定要定义在抽象类中。 2,抽象类不可以创建实例。原因就在于调用抽象方法没意义。 3,只有覆盖了抽象类中所有的抽象方法后,其子类才可以实例化。 否则,该子类还是一个抽象类。 之所以继承,更多的是在思想上,是面对共性类型操作会更简单。 【细节问题】 1,抽象类一定是一个父类。 是的,因为是不断向上抽取而来的。 2,抽象类中是否有构造函数。 有,虽然不能给自己的对象初始化,但是可以给自己的子类对象初始化。 抽象类和一般类的异同点: 相同: 1,它们都是用来描述事物的。 2,它们之中都可以定义属性和行为。 不同: 1,一般类可以具体的描述事物, 抽象类描述事物的信息不具体。 2,抽象类中可以多定义一个成员,抽象汉。 3,一般类可以创建对象,而抽象类不能创建对象。 3,抽象类中是否可以不定义抽象方法。 是可以的。那这个抽象类的存在到底有什么意义呢?仅仅是不让不让该类创建对象。 4,抽象类关键字不可以哪些关键字共存。 1,final. 被final修饰的类是最终类,不能被继承,而抽象类就是要被子类继承的。 2,private. 被private修饰的方法,其子类无法直接访问,而抽象的方法就是要让子类覆盖的。 3,static. 被static修饰的方法要随着类的加载而加载,且可以直接由类名调用。 */ abstract class 犬科 //extends Object { abstract void 吼叫();//抽象函数,需要abstract修饰。并分号;结束 } //代码体现。 class Dog extends 犬科 { void 吼叫() { System.out.println("汪汪汪汪"); } } class Wolf extends 犬科 { void 吼叫() { System.out.println("嗷嗷嗷嗷"); } } class AbstractDemo { public static void main(String[] args) { System.out.println("Hello World!"); } }
/*抽象类联系 需求:公司中程序员有姓名,工号,薪水,工作内容。 项目经理除了姓名,工号,薪水,还有奖金,工作内容。 对给定的需求进行数据建模。 在问题领域中先找寻其中的涉及的对象。 程序员: 属性:姓名,工号,薪水。 行为:工作。 项目经理: 属性:姓名,共号,薪水。 行为:工作。 这些对象是否有关系呢?因为发现了它们之间的共性,应该存在着关系。 可以将他们的共性向上抽取到共性类型,员工。 员工: 属性:姓名,工号,薪水。 行为:工作。 发现员工的工作内容本身就不具体,应该是抽象的,由具体的子类来体现。 */ abstract class Employee { private String name; private String id; private double pay; /** 构造一个员工对象,一初始化就具备三个属性。 */ Employee(String name,String id,double pay) { this.name = name; this.id = id; this.pay = pay; } /** 工作行为: */ public abstract void work(); } //具体的子类实现,程序员: class Programer extends Employee { Programer(String name,String id,double pay) { super(name,id,pay); } public void work() { System.out.println("code...."); } } //具体的子类,经理: class Manager extends Employee { //特有属性。 private double bouns; public Manager(String name,String id,double pay,double bouns) { super(name,id,pay); this.bouns = bouns; } public void work() { System.out.pritnln("work"); } } class AbstractTest { public static void main(String[] args) { System.out.println("Hello World!"); } }
/* 抽象类中是可以定义抽象方法的,当一个抽象类中方法全是抽象的, 这时,可以通过另一种特殊的形式来体现。 不再用class来定义,用接口来表示。 接口该如何定义呢? interface abstract class Demo { abstract void show1(); abstract void show2(); } */ /* 接口中的成员已经被限定为固定的几种。 【接口的定义格式先介绍两种】 1,定义变量,但是变量必须有固定的修饰符修饰,public static final所以接口中的变量 也称之为常量。 2,定义方法,方法也有固定的修饰符,public abstract 接口中的成员都是公共的。 【接口的特点】 1,接口不能创建对象。 2,子类必须覆盖掉接口中所有的抽象方法后子类才可以实例化。 否则子类是一个抽象类。 */ interface Demo//定义一个名称为Demo的接口。 { public static final int NUM = 3; public abstract void show1(); public abstract void show2(); } //定义子类去覆盖接口中的方法。子类必须和接口产生关系,类与类的关系是继承 //类与接口之间是实现。 class Demoimpl implements Demo //子类实现接口。 { //重写接口中的方法。 public void show1(){} public void show2(){} } /* 【接口最重要的体现】 解决了多继承的弊端。将多继承这种机制在java中通过多实现完成了。 */ /* interface A { void show1(); } interface B { void show2(); } class C implements A,B//多实现。同时实现多个接口。 { public void show1(){} public void show2(){} } */ /* 【怎么解决多继承的弊端呢?】 弊端:多继承时,当多个父类中有相同的功能时,子类调用会产生不确定性。 其实核心原因就在于多继承父类中的功能有主体,而导致调用运行时,不确定运行哪个主体内容。 为什么多实现就解决了呢? 因为接口中的功能都没有方法体,由子类来明确。 interface A { void show(); } interface B { void show(); } class C implements A,B//多实现。同时实现多个接口。 { public void show(){} } C c = new C(); c.show(); */ /* 【基于接口的扩展】 class Fu { public void show(){} } //子类通过继承父类扩展功能,通过基础扩展的功能都是子类应该具备的基础功能。 //如果子类想要继续扩展其他类中的功能呢?这时可以通过实现接口来完成。 Interface Inter { public abstract void show1(); } class Zi exntends Fu implements Inter { public void show1() { } } 接口的出现避免了单继承的局限。 父类中定义的事物的基本功能。 接口中定义的事物的扩展功能。 */ /* 接口出现后的一些小细节。 1,类与类之间是继承(is a)关系。类与接口之间是实现(like a)关系。 接口与接口之间有关系吗?接口与接口之间是继承关系。 */ interface InterA { void show1(); } interface InterAA { void show11(); } interface InterB extends InterA,InterAA//接口支持多继承。 { void show2(); } class Test implements InterB { public void show1(){} public void show2(){} public void show11(){} } class InterfaceDemo { public static void main(String[] args) { Demoimpl d = new Demoimpl(); d.show1(); d.show2(); } }
/* 抽象类中是否可以不定义抽象方法, 是可以的。原因是不让该类创建对象。 */ interface Inter { //定义了四种显示功能。 public void show1(); public void show2(); public void show3(); public void show4(); } //定义子类,要使用第一种显示方式, class InterImpl1 implements Inter { //覆盖show1方法。 public void show1() { System.out.println("show1 run"); } //为了让该类示例化,还需要覆盖其他三个方法,虽然该类用不上。 public void show2(){} public void show3(){} public void show4(){} } //另一个子类需要显示三方法。 class InterImpl3 implements Inter { //覆盖show1方法。 public void show3() { System.out.println("show3 run"); } //为了让该类示例化,还需要覆盖其他三个方法,虽然该类用不上。 public void show2(){} public void show1(){} public void show4(){} } /* 出现问题, 为了使用接口中的部分方法,而覆盖了全部的方法。而且每一个子类都要 这么做,复用性差。 将这些不用的方法都单独抽取到一个独立的类中, 让这个类去实现接口,并覆盖接口中的所有方法。 这个类知道这些方法的具体实现内容么?不知道。 所有只能为了后期子类创建对象方便,而进行空实现。 而这时,这个类创建对象有有意义吗?没有意义,这个类创建对象就不需要,直接将其抽象化。 这就是没有抽象方法的抽象类。 */ abstract class InterImpl implements Inter { //实现inter接口中的所有方法。 public void show1(){} public void show2(){} public void show3(){} public void show4(){} } //如果有子类去使用show1方法。让子类继承实现类就可以。 class InterImpl11 extends InterImpl { public void show1() { System.out.println("show1 run"); } } class { public static void main(String[] args) { InterImpl1 in1 = new InterImpl1(); in1.show1(); InterImpl3 in3 = new InterImpl3(); in1.show3(); } }
相关文章推荐
- IIS6.0禁止用户下载txt文件
- 多版本并控制MVCC 在分布式系统中的应用
- http://www.ibm.com/developerworks/cn/java/j-lo-spring-principle/
- 滴滴快车奖励政策,高峰奖励,翻倍奖励,按成交率,指派单数分级(3月29日)
- kmp之初识
- mybatis自增主键无效
- VMwareworkstation 12 安装
- Java反编译插件 Jad和JD-Core
- 记一次oracle表空间不足的错误
- 大型网站系统架构的演化
- c++primer(第五版) 第十三章 拷贝控制习题答案
- 189. Rotate Array
- Crosstool-ng 制作交叉编译器
- 泛型--Generic
- Listview与Adapter用法
- jsp常见的指令总结
- Fraction to Recurring Decimal
- 国企,外企,还是民企?
- Swith-实现单例的四种方法
- ORACLE 日期加减操作