赞
踩
------Java培训、Android培训、iOS培训、.Net培训、期待与您交流! -------
不知道大家第一次看到这个词会想到什么,反正我是想到了一部韩剧叫“继承者们”,在电视剧中,年轻的孩子们会因为他们的父亲特别有钱而也变得非常富裕(心里好不平衡啊),而且我发现基本那些年轻人都是他们父亲的加强版,会很多他们父亲不会的,同时还拥有他们父亲的财富。
在这里我们就可以说年轻人继承于他们的父亲,为什么他们有那么多东西(属性),会做那么多事(方法)呢?因为他们的父亲会,而他又继承自他的父亲,因此他也会,同时年轻人在继承的基础上,又可以有自己的功能,比如年轻人不仅会经商,还会飙车,而飙车是他父亲不具有的,因此这个飙车的能力就是年轻人自己特有的。
其实还有一个好处,那就是让类之间有了关系,继承关系,这主要是为了以后实现多态的前提。
- class Fu
- {}
- class Zi extends Fu
- {}
- class C
- {
- void show(){s.o.p("C");}
- }
- class B
- {
- void show(){s.o.p("B");}
- }
- class A extends B,C
- {
-
- }
- main()
- {
- A a=new A();
- a.show();
- }
那么
此时是调用哪个类中的show方法呢?这就是二义性。
- interface C
- {
- public abstract void show();
- }
- interface B
- {
- public abstract void show();
- }
- interface A extends B,C
- {
-
- }
- class Demo implements A
- {
- public void show()
- {
- s.o.p("Demo");
- }
- }
- main()
- {
- Demo d=new Demo();
- d.show();
- }<span style="white-space:pre"> </span>
我们发现,虽然接口B,C中也有同名的方法,但是当A继承于B,C时,实际上
对于这样的方法声明只会保存一个,因为他们一模一样,这就导致了使用B的或者C的都一样的结果,最本质的原因就是这两个方法声明没有方法体,因此不存在二义性问题。
- class Person
- {
- //String name="baba";
- int age;
- }
- class Student extends Person
- {
- String name="erzi";
- public void show()
- {
- System.out.println("I am "+this.name+", my father is "+super.name);
- }
- }
- class Worker extends Person
- {
- String name="worke";
- public void show()
- {
- System.out.println("my name is "+name);
- System.out.println("my name is "+this.name);
- System.out.println("my name is "+super.name);
- //不管是直接访问name,还是this,还是super,最终都是父类的name
- }
- }
-
- class ExtendsDemo
- {
- public static void main(String[] args)
- {
- Student s=new Student();
- s.show();
- Worker w = new Worker();
- w.show();
- Person p = new Student();
- ((Student)p).show();
- }
- }
运行图
- class Student
- {
- String name;
- int age;
- String num;
- void eat(){.....}
- void walk(){......}
- void study(){....}
- }
- class Teacher
- {
- String name;
- int age;
- String tell;
- void eat(){....}
- void walk(){....}
- void teach(){....}
- }
- class Worker
- {
- String name;
- int age;
- int workYear;
- void eat(){....}
- void walk(){....}
- void work(){....}
- }
我们看到,就是简单的三个类,而且也没有多少属性和方法,但是已经非常繁琐了,而且我们发现有大量的重复代码,这不符合我们的代码复用的思想,因此我们就要考虑该怎么设计类使得代码的复用能够提高呢?
- class Person
- {
- String name;
- int age;
- void eat(){....}
- void walk(){....}
- }
- class Student extends Person
- {
- String num;
- void study(){....}
- }
- class Teacher extends Person
- {
- String tell;
- void teach(){....}
- }
- class Worker extends Person
- {
- int workYear;
- void work(){....}
- }
我们发现,重复的代码大大减少了,基本已经没有重复代码了,这就是继承的威力,大大的提高了代码的复用性。当然了使用继承也有一点一定要注意的,观察一下问题:假如要我们设计两个类:学生类(name,age,weight,study()),电脑类(name,age,weight,run())。我们发现这两个类也有很多一样的属性,那我们能不能设计一个父类呢,例如:学生电脑类(name,age,weigth),然后让学生类和电脑类继承于该类呢?答案是:NO,从第一节我们知道,
如果想让一个类继承于另一个类,那么必须是这两个类本身存在着继承关系,不能单纯的为了复用代码而继承。
- /**
- 测试某段代码运行时间
- System.currentTimeMillis()
- 返回当前时间与协调世界时之差的毫秒数
- 同时:GetTime类就应该是用于给测试运行时间的类所继承,它的getTime方法不能被复写,用final修饰
- 同样的:此类也可以不讲code()方法抽象,也可以给它默认实现方式,如果子类有其他需求,再复写它即可,
- 也不是一定要getTime方法为final,只是此处需求而已,关键是模板方法的思想,而不是具体代码实现。
- */
- abstract class GetTime
- {
- public final void getTime()
- {
- long start=System.currentTimeMillis();
- code();
- long end=System.currentTimeMillis();
- System.out.println("运行时间:"+(end-start)+"毫秒");
- }
- public abstract void code();
- }
-
- class GetCodeTime extends GetTime
- {
- public void code()
- {
- for(int x=0;x<200;x++)
- System.out.println(x);
- }
- }
-
- class templateDemo
- {
- public static void main(String[] args)
- {
- GetCodeTime gct=new GetCodeTime();
- gct.getTime();
- }
- }
运行图
- interface Demo1
- {}
- interface Demo2
- {}
- class A implements Demo1,Demo2
- {}
我们可以看到一个类是可以实现多个接口的,这在某些方面也
大大提高了代码的扩展性。
- /*
- 员工类:姓名,工号,工资
- 经理类:继承自员工类,多个奖金
- 普通员工类:继承自员工类
- */
- /*
- 乍一看好像Employee是一个普通员工类,其实不是,因为经理跟普通员工之间是同层次的,不可能
- 有继承的关系(否则就是为了简化代码,实现功能而继承了,大忌),所以员工类应该是经理类和
- 真正的普通员工类共性抽取出来的抽象类,其实应该有经理类和普通员工类都有的属性,和功能(
- 抽象方法),而且每个继承自员工类的类都必须实现。
- 假如说继承自员工类的有老师类,但是老师类的工作方法不确定,因为要看是教什么的老师,那么
- 老师只需实现能实现的方法,然后再作为父类被语文老师,数学老师等继承。
- */
- abstract class Employee
- {
- private String name;
- public void setName(String name){this.name=name;}
- public String getName(){return name;}
-
- private String num;
- public void setNum(String num){this.num=num;}
- public String getNum(){return num;}
-
- private double salary;
- public void setSalary(double salary){this.salary=salary;}
- public double getSalary(){return salary;}
-
- Employee(String name,String num,double salary)
- {
- this.name=name;
- this.num=num;
- this.salary=salary;
- }
-
- public abstract void work();
- public abstract void show();
- }
-
- class Manager extends Employee
- {
- private double bonus;
- public void setBonus(double bonus){this.bonus=bonus;}
- public double getBonus(){return bonus;}
-
- Manager(String name,String num,double salary,double bonus)
- {
- super(name,num,salary);
- this.bonus=bonus;
- }
-
- public void work()
- {System.out.println("manager work");}
- public void show()
- {System.out.println(getName()+","+getNum()+","+getSalary()+","+bonus);}
- }
-
- class Pro extends Employee
- {
- Pro(String name,String num,double salary)
- {
- super(name,num,salary);
- }
-
- public void work()
- {System.out.println("pro work");}
- public void show()
- {System.out.println(getName()+","+getNum()+","+getSalary());}
- }
-
- abstract class Teacher extends Employee
- {
- Teacher(String name,String num,double salary)
- {
- super(name,num,salary);
- }
-
- public void show()
- {System.out.println(getName()+","+getNum()+","+getSalary());}
- }
-
- class EnTeacher extends Teacher
- {
- EnTeacher(String name,String num,double salary)
- {super(name,num,salary);}
-
- public void work()
- {System.out.println("teach En");}
- }
-
- class CnTeacher extends Teacher
- {
- CnTeacher(String name,String num,double salary)
- {super(name,num,salary);}
-
- public void work()
- {System.out.println("teach Cn");}
- }
-
- class abstractDemo
- {
- public static void main(String[] args)
- {
- Manager m=new Manager("helong","JS01",1234,234);
- m.work();
- m.show();
- Pro p=new Pro("ldy","CS01",1234);
- p.work();
- p.show();
- EnTeacher et=new EnTeacher("haha","YY01",234.2);
- et.work();
- et.show();
- CnTeacher ct=new CnTeacher("heihei","YW01",345.3);
- ct.work();
- ct.show();
- }
- }
运行图
- /**
- 1.模版方法设计模式:GetTime类,使用abstract和不用两种实现,final看情况用
- 2.接口:单继承(接口与接口,类与类),多继承(接口与接口),单实现,多实现(接口与类)
- 3.不支持多继承(类与类)原因,支持多实现,多继承(接口与接口)的原因
- 4.接口特点,用处(什么情况用接口)
- 5.哪种功能定义在类中,哪种又在接口中
- */
- /*
- 单继承:类单继承与类,接口单继承与接口
- 多继承:接口多继承与接口
- 实现:类实现接口,可多个
- 不支持多继承:多个父类可能存在同名且参数列表相同的方法例如父类A:int f(int x)父类B:void f(int x)
- 此时用子类调用时zi.f(x);JVM根本不能确定调用的是哪个方法
- 支持多实现:即便多个接口出现了同名,同参的方法也没有问题,因为本来都是抽象方法,没有方法体,
- 不存在二义性问题,实现哪个都一样
- 接口特点:1.程序对外暴露的规则。2.提供程序的扩展性。3.降低了各部分的耦合性
- 用处:当部分子类存在某功能,但是部分不存在,那么该功能不能放到父类中让子类继承,
- 而是因为作为接口,成为该继承体系的扩展功能。
- 子类都具有的基本功能放到父类中定义,而特有功能放到接口中作为部分子类的扩展。
- */
- //模板方法设计模式,提高代码复用性,扩展性
- class GetTime
- {
- public final void getTime()
- {
- long start=System.currentTimeMillis();
- code();
- long end=System.currentTimeMillis();
- System.out.println("程序用时:"+(end-start));
- }
- public void code()
- {
- //默认实现
- for(int i=0;i<5000;i++)
- {
- System.out.println(i);
- }
- }
- }
-
- class My_GetTime extends GetTime
- {
- public void code()
- {
- int x=0;
- for(int i=0;i<10000;i++)
- {x+=5;System.out.println(x);}
- }
- }
-
- //接口的使用,提高代码扩展性
- abstract class Student
- {
- public String name;
- public int age;
- public abstract void study();
- public void sleep()
- {
- System.out.println("I am sleeping");
- }
- }
- interface Smoke
- {
- public static final int COUNT=10;
- public abstract void smoke();
- }
- interface Drike
- {
- public abstract void drike();
- }
- class JavaStudent extends Student
- {
- public void study()
- {System.out.println("学习java知识");}
- }
- class RubyStudent extends Student
- {
- public void study()
- {System.out.println("学习ruby知识");}
- }
- class SmokeJavaStudent extends JavaStudent implements Smoke
- {
- public void smoke()
- {
- System.out.println("I am smoke "+COUNT+" package");
- }
- }
- class DrikeSmokeJavaStudent extends SmokeJavaStudent implements Drike
- {
- public void drike()
- {
- System.out.println("I am driking");
- }
- //public void smoke()
- //{
- // System.out.println("自己抽烟,不用父类的");
- //}
- }
- class DSJStudent extends Student implements Smoke,Drike
- {
- public void study()
- {
- System.out.println("自己实现学习java");
- }
- public void smoke()
- {
- System.out.println("自己实现抽烟方法");
- }
- public void drike()
- {
- System.out.println("自己实现喝酒方法");
- }
- }
- class interfaceDemo
- {
- public static void main(String[] args)
- {
- My_GetTime mgt=new My_GetTime();
- //mgt.getTime();
-
- //接口测试
- JavaStudent js = new JavaStudent();
- js.study();js.sleep();
- RubyStudent rs = new RubyStudent();
- rs.study();rs.sleep();
- SmokeJavaStudent sjs = new SmokeJavaStudent();
- sjs.smoke();sjs.study();sjs.sleep();
- DrikeSmokeJavaStudent dsjs = new DrikeSmokeJavaStudent();
- dsjs.smoke();dsjs.drike();dsjs.study();dsjs.sleep();
- DSJStudent d=new DSJStudent();
- d.study();d.smoke();d.drike();
- }
- }
运行图
------Java培训、Android培训、iOS培训、.Net培训、期待与您交流! -------
Copyright © 2003-2013 www.wpsshop.cn 版权所有,并保留所有权利。