首页 > 代码库 > 黑马程序员-学习日记(接口和多态)
黑马程序员-学习日记(接口和多态)
1.继承
1-1 继承的概念
1-1-1 继承的概述
通过 extends 关键字让类与类之间产生继承关系。
多个类中存在相同属性和行为时,将这些内容抽取到单独一个类中,那么多个类无需再定义这些属性和行为,只要继承那个类即可。
多个类可以称为子类,单独这个类称为父类或者超类。
多个类可以称为子类,单独这个类称为父类或者超类。
注意:
①子类可以直接访问父类中的非私有的属性和行为。②子类无法继承父类中私有的内容。
③父类怎么来的?共性不断向上抽取而来的。
③父类怎么来的?共性不断向上抽取而来的。
ExtendDemo.javaclass Person{ String name; int age ;}class Student extends Person{ void study(){ System. out.println("student study..." + age); }}class Worker extends Person{ void work(){ System. out.println("worker work..." + age); }}class ExtendDemo{ public static void main(String[] args){ Student s = new Student(); s. name = "zhangsan" ; s. age = 20; s.study(); Worker w = new Worker(); w. name = "lisi" ; w. age = 30; w.work(); }}
好处:
继承的出现提高了代码的复用性。继承的出现让类与类之间产生了关系,提供了多态的前提。
1-1-2 继承的特点
Java只支持单继承,不支持多继承。
一个类只能有一个父类,不可以有多个父类。
一个类只能有一个父类,不可以有多个父类。
原因:因为多继承容易出现问题。两个父类中有相同的方法。子类到底要执行哪一个是不确定的。
class A{ void show(){ System. out.println("a" ); }}class B{ void show(){ System. out.println("b" ); }}class C extends B,A{}
那么创建类C的对象,调用show方法就不知道调用类A中的show方法还是类B中的show方法。
所以java是不支持多继承,但将这种机制以另一种安全的方式来体现,也就是多实现。
Java支持多层继承(继承体系)
C继承B,B继承A,就会出现继承体系。
多层继承出现的继承体系中,通常看父类中的功能,了解该体系的基本功能,建立子类对象,即可使用该体系功能。
定义继承需要注意:
不要仅为了获取其他类中某个功能而去继承,类与类之间要有所属( "is a")关系。
2、覆盖,子类中,覆盖也称为重写,覆写,override。
不要仅为了获取其他类中某个功能而去继承,类与类之间要有所属( "is a")关系。
1-1-3 super关键字 & 函数覆盖
在子父类中,成员的特点体现:
①成员变量
①成员变量
this和super的用法很相似。this代表本类对象的引用。super代表父类的内存空间的标识。
当本类的成员和局部变量同名用this区分。当子父类中的成员变量同名用super区分父类。
1 //ExtendDemo.java 2 class Fu{ 3 private int num = 4; 4 public int getNum(){ 5 return num ; 6 } 7 } 8 9 class Zi extends Fu{10 private int num = 5; 11 void show(){12 System. out.println(this.num + "..." + super.getNum());13 }14 }15 16 class ExtendDemo{17 public static void main(String[] args){18 Zi z = new Zi();19 z.show();20 }21 }
②成员函数
当子父类中出现成员函数一模一样的情况,会运行子类的函数。
这种现象,称为覆盖操作,这是函数在子父类中的特性。
这种现象,称为覆盖操作,这是函数在子父类中的特性。
在子类覆盖方法中,继续使用被覆盖的方法可以通过super.函数名获取。
函数两个特性:
1、重载,同一个类中。2、覆盖,子类中,覆盖也称为重写,覆写,override。
class Fu{ public void show(){ System. out.println("fu show run" ); }}class Zi extends Fu{ public void show(){ System. out.println("zi show run" ); }}class ExtendDemo{ public static void main(String[] args){ Zi z = new Zi(); z.show(); }}
什么时候使用覆盖操作?
当子类需要父类的功能,而功能主体子类有自己特有内容时,可以复写父类中的方法,这样,即沿袭了父类的功能,又定义了子类特有的内容。
class Phone{ void call(){} void show(){ System. out.println("number" ); }}class NewPhone extends Phone{ void show(){ System. out.println("name" ); System. out.println("pic" ); super.show(); }}class ExtendDemo{ public static void main(String[] args){ NewPhone p = new NewPhone(); p.show(); }}
注意:
①父类中的私有方法不可以被覆盖。②父类为static的方法无法覆盖。③覆盖时,子类方法权限一定要大于等于父类方法权限。
class Fu{ public void show(){ System. out .println("fu show run" ); }}class Zi extends Fu{ private void show(){ System. out .println("zi show run" ); }}class ExtendDemo{ public static void main(String[] args){ Zi z = new Zi(); z. show(); }}
③构造函数
子父类中构造函数的特点:
在子类构造函数执行时,发现父类构造函数也运行了。
原因:在子类的构造函数中,第一行有一个默认的隐式语句:super();。
在子类构造函数执行时,发现父类构造函数也运行了。
原因:在子类的构造函数中,第一行有一个默认的隐式语句:super();。
注意:如果使用super(4);语句调用父类的其他构造函数,那么默认的父类构造函数将不会再被调用。
class Fu{ int num ; Fu(){ num = 10; System. out.println("A fu run" ); } Fu( int x){ System. out.println("B fu run..." + x); }}class Zi extends Fu{ Zi(){ //super();//默认调用的就是父类中的空参数的构造函数 System. out.println("C zi run " + num); } Zi( int x){ super(4); System. out.println("D zi run " + x); }}class ExtendDemo{ public static void main(String[] args){ new Zi(); System. out.println("1-1-4 子类的实例化过程子类中所有的构造函数默认都会访问父类中空参数的构造函数。
因为每一个构造函数的第一行都有一条默认的语句super();。子类会具备父类中的数据,所以要先明确父类是如何对这些数据初始化的。为什么子类实例化的时候要访问父类中的构造函数呢?
那是因为子类继承了父类,获取到了父类中内容(属性),所以在使用父类内容之前,要先看父类是如何对自己的内容进行初始化的。注意:①当父类中没有空参数的构造函数时,子类的构造函数必须通过this或者super语句指定要访问的构造函数。②子类构造函数中如果使用this调用了本类构造函数,那么默认的super();就没有了,因为super和this都只能定义在第一行,所以只能有一个。但是可以保证的是,子类中肯定会有其他的构造函数访问父类的构造函数。③super语句必须要定义在子类构造函数的第一行!因为父类的初始化动作要先完成。ExtendDemo.javaclass Fu{ Fu()
{ super(); show(); return; } void show(){ System. out.println("fu show" ); }}class Zi extends Fu{ int num = 8; Zi(){ super(); //通过super初始化父类内容时,子类的成员变量并未显示初始化,等super()父类初始化完毕后,才进行子类的成员变量显示初始化 return; } void show(){ System. out.println("zi show..." + num); }}class ExtendDemo{ public static void main(String[] args){ Zi z = new Zi();//调用的是子类的show方法,此时其成员变量 num还未进行显示初始化 z.show(); }}不正确的案例:
class fu{ fu(int num) { show(); return; } void show() { System.out.println("fu show"); }}class zi extends fu{ int num = 9; zi() {return; } void show() { System.out.println("zi show"+num); }}总结:一个对象实例化过程,以Person p = new Person();为例:
1、JVM会读取指定的路径下的Person.class文件,并加载进内存,并会先加载Person的父类(如果有直接的父类的情况下)。
2、在内存中开辟空间,并分配地址。
3、并在对象空间中,对对象的属性进行默认初始化。
4、调用对应的构造函数进行初始化。
5、在构造函数中,第一行会先到调用父类中构造函数进行初始化。
6、父类初始化完毕后,再对子类的属性进行显示初始化。
7、再进行子类构造函数的特定初始化。
8、初始化完毕后,将地址值赋值给引用变量。--------------------------------------------------------------------------------------------------------------------------1-1-5 final关键字final可以修饰类,方法,变量。
final修饰的类不可以被继承。final修饰的方法不可以被覆盖。final修饰的变量是一个常量,只能被赋值一次。
为什么要用final修饰变量,其实在程序中如果一个数据是固定的。
那么直接使用这个数据就可以了,但是这种阅读性差,所以应该给数据起个名称。
而且这个变量名称的值不能变化,所以加上final固定。
写法规范:常量所有字母都大写,多个单词,中间用_连接。FinalDemo.java//继承弊端:打破了封装性class Fu{ void method(){ }}class Zi extends Fu{ public static final double PI = 3.14; void method(){ System. out.println(PI); }}class FinalDemo{ public static void main(String[] args){ Zi zi = new Zi(); zi.method(); }}1 //FinalDemo.java2 class FinalDemo{3 public static void main(String[] args){4 final int x = 4;5 x = 5;6 }7 }---------------------------------------------------------------------------------------------------------
1-2 抽象类1-2-1 抽象类概述抽象定义:
抽象就是从多个事物中将共性的,本质的内容抽取出来。
例如:猫和虎共性都是猫科,猫科就是抽象出来的概念。
抽象类:
Java中可以定义没有方法体的方法,该方法的具体实现由子类完成,该方法称为抽象方法,包含抽象方法的类就是抽象类。抽象方法的由来:多个对象都具备相同的功能,但是功能具体内容有所不同,那么在抽取过程中,只抽取了功能定义,并未抽取功能主体,那么只有功能声明,没有功能主体的方法称为抽象方法。//AbstractDemo.javaabstract class Demo{ abstract void show();}class DemoA extends Demo{ void show(){ System. out.println("demoa show" ); }}class DemoB extends Demo{ void show(){ System. out.println("demob show" ); }}class AbstractDemo{ public static void main(String[] args){ DemoA demoA = new DemoA(); demoA.show(); DemoB demoB = new DemoB(); demoB.show(); }}
例如:猫和虎都有吼叫的方法,可是吼叫内容是不一样的。所以抽象出来的猫科虽然有吼叫功能,但是并不明确吼叫的细节。-------------------------------------------------------------------------------------------------------------------1-2-3 抽象类举例代码讲解雇员示例需求:公司中程序员有姓名,工号,薪水,工作内容。
项目经理除了有姓名,工号,薪水,还有奖金,工作内容。分析:在这个问题领域中,通过名词提炼法:
程序员:
属性:姓名,工号,薪水。
行为:工作。
经理:
属性:姓名,工号,薪水,奖金。
行为:工作。程序员和经理不存在着直接继承关系。但是,程序员和经理却具有共性内容,可以进行抽取,因为他们都是公司的雇员。可以将程序员和经理进行抽取,建立体系。//描述雇员。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 Programmer extends Employee{ Programmer(String name,String id, double pay){ super(name,id,pay); } public void work(){ System. out.println("code..." ); }}//描述经理class Manager extends Employee{ private int bonus ; Manager(String name,String id, double pay,int bonus){ super(name,id,pay); this.bonus = bonus; } public void work(){ System. out.println("manage" ); }}--------------------------------------------------------------------------------------------------
1-2-3 抽象类相关问题抽象类中是否有构造函数?答:有,用于给子类对象进行初始化。抽象关键字abstract不可以和哪些关键字共存?答:private、static、final。抽象类中可不可以没有抽象方法?答:可以,但是很少见。目的就是不让该类创建对象,AWT的适配器对象就是这种类。通常这个类中的方法有方法体,但是却没有内容。abstract class Demo{ void show1(){} void show2(){}}抽象类和一般类的区别?答:相同点:
抽象类和一般类都是用来描述事物的,都在内部定义了成员。不同点:
①一般类有足够的信息描述事物。 抽象类描述事物的信息有可能不足。
②一般类中不能定义抽象方法,只能定义非抽象方法。 抽象类中可定义抽象方法,同时也可以定义非抽象方法。
③一般类可以被实例化。抽象类不可以被实例化。抽象类一定是个父类吗?答:是的,因为需要子类覆盖其方法后才可以对子类实例化。------------------------------------------------------------------------------------------------------------------1-2-4 接口当一个抽象类中的方法都是抽象的时候,这时可以将该抽象类用另一种形式定义和表示,就是接口。格式:interface {}
接口中的成员修饰符是固定的:
成员常量:public static final
成员函数:public abstract由此得出结论,接口中的成员都是公共的权限。接口是对外暴露的规则。接口是程序的功能扩展。注意:①虽然抽象类中的全局变量和抽象方法的修饰符都可以不用写,但是这样阅读性很差。所以,最好写上。②类与类之间是继承关系,类与接口直接是实现关系。③接口不可以实例化,只能由实现了接口的子类并覆盖了接口中所有的抽象方法后,该子类才可以实例化。否则,这个子类就是一个抽象类。interface Demo{ public static final int NUM = 4; public abstract void show1(); public abstract void show2();}class DemoImpl implements /*实现*/Demo{ public void show1(){} public void show2(){}}class InterfaceDemo{ public static void main(String[] args){ DemoImpl d = new DemoImpl(); System. out.println(d.NUM); System. out.println(DemoImpl.NUM); System. out.println(Demo.NUM); }}接口的出现将“多继承”通过另一种形式体现出来,即“多实现”。在java中不直接支持多继承,因为会出现调用的不确定性。所以,java将多继承机制进行改良,在java中变成了多实现,一个类可以实现多个接口。接口的出现避免了单继承的局限性。interface A{ public void show();}interface Z{ public void show();}//多实现class Test implements A,Z{ public void show(){ System.out.println("Test"); }}class InterfaceDemo{ public static void main(String[] args){ Test t = new Test(); t.show(); }}一个类在继承另一个类的同时,还可以实现多个接口。
interface A{ public void show();}interface Z{ public void show();}class Q{ public void method(){ }}abstract class Test2 extends Q implements A,Z{ }
interface CC{ void show();}interface MM{ void method();}//接口与接口之间是继承关系,而且接口可以多继承interface QQ extends CC,MM{ public void function();}class WW implements QQ{ //覆盖3个方法 public void show(){} public void method(){} public void function(){}}抽象类和接口的异同点?
相同点:
都是不断向上抽取而来的。
不同点:
①抽象类需要被继承,而且只能单继承。
接口需要被实现,而且可以多实现。
②抽象类中可以定义抽象方法和非抽象方法,子类继承后,可以直接使用非抽象方法。
接口中只能定义抽象方法,必须由子类去实现。
③抽象类的继承,是is a关系,定义该体系的基本共性内容。
接口的实现是like a关系。接口应用综合案例:
/*笔记本电脑使用。为了扩展笔记本的功能,但日后出现什么功能设备不知道。因此需要定义一个规则,只要日后出现的设备都符合这个规则就可以了。规则在java中就是接口。*/interface USB{//暴露的原则 public void open(); public void close();}//实现原则//这些设备和电脑的耦合性降低了class UPan implements USB{ public void open(){ System. out.println("upan open" ); } public void close(){ System. out.println("upan close" ); }}class UsbMouse implements USB{ public void open(){ System. out.println("usbMouse open" ); } public void close(){ System. out.println("usbMouse close" ); }}class BookPC{ public static void main(String[] args){ //功能扩展了 useUSB(new UPan()); } //使用原则 public static void useUSB(USB u){//接口类型的引用,用于接收(指向)接口的子类对象 if(u != null ){ u.open(); u.close(); } }}
黑马程序员-学习日记(接口和多态)
声明:以上内容来自用户投稿及互联网公开渠道收集整理发布,本网站不拥有所有权,未作人工编辑处理,也不承担相关法律责任,若内容有误或涉及侵权可进行投诉: 投诉/举报 工作人员会在5个工作日内联系你,一经查实,本站将立刻删除涉嫌侵权内容。