【黑马程序员】Java学习笔记之继承（二）（面向对象）
来源：互联网 发布：整形网络咨询招聘 编辑：程序博客网 时间：2024/04/29 11:39
继承（二）
一、接口
1、定义：当一个抽象类中的方法都是抽象的时候，这时可以将该抽象类用另一种形式定义和表示，就是接口。(初期理解)
2.格式：interface {}
示例：
interface Inter{ public abstract void show(); public static final int NUM=2;}接口中的成员修饰符是固定的：
成员常量：public static final
成员函数：public abstract
由此得出结论，接口中的成员都是公共的权限。
接口是对外暴露的规则。
接口是程序的功能扩展。
P.S.
1、虽然抽象类中的全局变量和抽象方法的修饰符都可以不用写，但是这样阅读性很差。所以，最好写上。
2、类与类之间是继承关系，类与接口直接是实现关系。
3、接口不可以实例化，能由实现了接口并覆盖了接口中所有的抽象方法的子类实例化。否则，这个子类就是一个抽象类。
示例：
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); }}运行结果：4443.作用
a.接口的出现将“多继承”通过另一种形式体现出来，即“多实现”。
在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(); }} 运行结果：Testb. 一个类在继承另一个类的同时，还可以实现多个接口。
示例1：
interface A{ public void show();}interface Z{ public void show();}class Q{ public void method(){ }}abstract class Test2 extends Q implements A,Z{}示例2：
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(){}} 4.抽象类和接口的异同点
相同点：
都是不断向上抽取而来的。
不同点：
1. 抽象类需要被继承，而且只能单继承。
接口需要被实现，而且可以多实现。
2. 抽象类中可以定义抽象方法和非抽象方法，子类继承后，可以直接使用非抽象方法。
接口中只能定义抽象方法，必须由子类去实现。
3. 抽象类的继承，是is a关系，定义该体系的基本共性内容。 接口的实现是like a关系。
5.综合应用案例
示例：
/*笔记本电脑使用。为了扩展笔记本的功能，但日后出现什么功能设备不知道。因此需要定义一个规则，只要日后出现的设备都符合这个规则就可以了。规则在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(); } }}运行结果：upan openupan close二、多态
1、定义：某一类事物的多种存在形态。
例如：动物中猫，狗。
猫这个对象对应的类型是猫类型：猫 x = new 猫();
同时猫也是动物中的一种，也可以把猫称为动物：动物 y = new 猫();
动物是猫和狗具体事物中抽取出来的父类型。
父类型引用指向了子类对象。多态性简单说就是一个对象对应着不同类型。2.体现：
父类（或者接口）引用指向（或者接收）自己的子类对象。
3.作用：
多态的存在提高了程序的扩展性和后期可维护性。
4.前提
- 需要存在继承或者实现关系。
- 需要有覆盖操作。
5.好处与弊端：
好处：提高了代码的扩展性，前期定义的代码可以使用后期的内容。
弊端： 前期定义的内容不能使用（调用）后期子类的特有内容。
示例1：
abstract class Animal{ abstract void eat();}class Dog extends Animal{ void eat(){ System.out.println("啃骨头"); } void lookHome(){ System.out.println("看家"); }}class Cat extends Animal{ void eat(){ System.out.println("吃鱼"); } void catchMouse(){ System.out.println("抓老鼠"); }}class Pig extends Animal{ void eat(){ System.out.println("饲料"); } void gongdi(){ System.out.println("拱地"); }}class DuoTaiDemo{ public static void main(String[] args){ Cat c = new Cat(); Dog d = new Dog(); method(c); method(d); method(new Pig()); } public static void method(Animal a) //相当于实现了对象的多态：Animal a=new Cat(); { a.eat(); }}运行结果：吃鱼啃骨头饲料示例2：
class DuoTaiDemo{ public static void main(String[] args){ //自动类型提升，猫对象提升到了动物类型。但是特有功能无法访问，作用就是限制对特有功能的访问。 //专业讲：向上转型，将子类型隐藏。就不能使用子类的特有方法了。 Animal a = new Cat(); a.eat(); //a.catchMouse();//报错 //如果还想用具体动物猫的特有功能。 //你可以将该对象进行向下转型。 Cat c = (Cat)a; //向下转型的目的是为了能够使用子类中的特有方法。 c.eat(); c.catchMouse(); //注意：对于转型，自始至终都是子类对象在做类型的变化。 //Animal a = new Dog(); //Cat c = (Cat)a;//但是类型不能随意转换，否则可能会报出ClassCastException的异常 } public static void method(Animal a){ a.eat(); }}运行结果：吃鱼吃鱼抓老鼠示例3：
/*毕老师和毕姥爷的故事*/class 毕姥爷{ void 讲课(){ System.out.println("管理"); } void 钓鱼(){ System.out.println("钓鱼"); }}class 毕老师 extends 毕姥爷{ void 讲课(){ System.out.println("Java"); } void 看电影(){ System.out.println("看电影"); }}class DuoTaiDemo{ public static void main(String[] args){ 毕老师 x = new 毕老师(); x.讲课(); //Java x.看电影(); //看电影 毕姥爷 y = new 毕老师(); y.讲课(); //Java y.钓鱼(); //钓鱼 毕老师 z = (毕老师)y; z.看电影(); //看电影 }}运行结果：Java看电影Java钓鱼看电影（重点）P.S.instanceof ：用于判断对象的具体类型，只能用于引用数据类型判断，通常在向下转型前用于健壮性的判断。
示例4：
class DuoTaiDemo{ public static void main(String[] args){ } public static void method(Animal a){ a.eat(); if(a instanceof Cat){ Cat c = (Cat )a; c.catchMouse(); } else if (a instanceof Dog){ Dog d = (Dog )a; d.lookHome(); } }}6.多态时，成员的特点：
1. 成员变量
编译时：参考引用型变量所属的类中是否有调用的成员变量。有，编译通过，没有，编译失败。
运行时：参考引用型变量所属的类中是否有调用的成员变量，并运行该所属类中的成员变量。
简单说：编译和运行都参考等号的左边。
示例：
class Fu{ int num = 3;}class Zi extends Fu{ int num = 4;}class DuoTaiDemo{ public static void main(String[] args){ Zi f1 = new Zi(); System.out.println(f1.num); Fu f2 = new Zi(); System.out.println(f2.num); }}运行结果：432. 成员函数（非静态–动态绑定函数）
编译时：参考引用型变量所属的类中是否有调用的函数。有，编译通过。没有，编译失败。
运行时：参考的是对象所属的类中是否有调用的函数。
简单说：编译看左边，运行看右边。
示例：
class Fu{ void show(){ System.out.println("fu show"); }}class Zi extends Fu{ void show(){ System.out.println("zi show"); }}class DuoTaiDemo{ public static void main(String[] args){ Fu f = new Zi(); f.show(); }}运行结果：zi show3. 静态函数（静态绑定函数）
编译时：参考的是引用型变量所属的类中是否有调用的函数
运行时：参考的是引用型变量所属的类中是否有调用的函数
简单说：编译和运行看左边。
示例：
class Fu{ static void method(){ System.out.println("fu static method"); }}class Zi extends Fu{ static void method(){ System.out.println("zi static method"); }}class DuoTaiDemo{ public static void main(String[] args){ Fu f = new Zi(); f.method();// fu static method Fu.method(); }}运行结果：fu static methodfu static method三、内部类
1.定义
将一个类定义在另一个类的里面，里面那个类就称为内部类（内置类，嵌套类）。
2.访问特点
内部类可以直接访问外部类中的成员，包括私有成员。
而外部类要访问内部类中的成员必须要建立内部类的对象。
示例：
/*内部类的设计：分析事物时，发现该事物描述中还有事物，而且这个事物还在访问被描述事物的内容，这时候就定义内部类。*/class Outer{ private int num = 3; class Inner //内部类 { void show(){ System.out.println("show run..." + num); } } public void method(){ Inner in = new Inner(); in.show(); }}class InnerClassDemo{ public static void main(String[] args){ Outer out = new Outer(); out.method(); }}运行结果：show run...3示例2：
class Outer{ private int num = 3; class Inner { void show(){ System.out.println("show run..." + num); } }}class InnerClassDemo{ public static void main(String[] args){ //直接访问外部类中的内部类中的成员 Outer.Inner in = new Outer().new Inner(); in.show(); }}运行结果：show run...3内部类的位置：
内部类定义在成员位置上，可以被private、static成员修饰符修饰。被static修饰的内部类只能访问外部类中的静态成员。
示例1：
class Outer{ private static int num = 3; static class Inner { void show(){ System.out.println("show run..." + num); } }}class InnerClassDemo{ public static void main(String[] args){ //如果内部类是静态的，相当于一个外部类 Outer.Inner in = new Outer.Inner(); in.show(); }}运行结果：show run...3示例2：如果内部类是静态的，内部类成员也是静态的，可以不用创建内部类对象，直接调用。
class Outer{ private static int num = 3; static class Inner { static void show(){ System.out.println("show run..." + num); } }}class InnerClassDemo{ public static void main(String[] args){ Outer.Inner.show(); }}运行结果：show run...33.注意事项
1、如果内部类中定义了静态成员，该内部类也必须是静态的！
class Outer{ private static int num = 3; static class Inner { static void show(){ System.out.println("show run..." + num); } }}2、为什么内部类能直接访问外部类中的成员呢？
那是因为内部类持有了外部类的引用，外部类名.this。
示例：
class Outer{ int num = 3; class Inner{ int num = 4; void show(){ int num = 5; System.out.println(num); System.out.println(this.num); System.out.println(Outer.this.num); } } void method(){ new Inner().show(); }}class InnerClassDemo{ public static void main(String[] args){ new Outer().method(); }}运行结果：5433、内部类定义在局部位置上，也可以直接访问外部类中的成员。
同时可以访问所在局部中的局部变量，但必须是被final修饰的。
示例：
class Outer{ int num = 3; void method(final int y){ final int x = 9; class Inner{ void show(){ System.out.println("show..." + x + "," + y); } } Inner in = new Inner(); in.show(); }}class InnerClassDemo{ public static void main(String[] args){ new Outer().method(4); }}运行结果：show...9,44.匿名内部类
1、定义：
就是内部类的简化写法。2、前提：
内部类可以继承或实现一个外部类或者接口。3、格式：
new 外部类名或者接口名(){覆盖类或者接口中的代码，(也可以自定义内容。)}4、简单理解：
就是建立一个带内容的外部类或者接口的子类匿名对象。5、什么时候使用匿名内部类呢？
通常使用方法是接口类型参数，并且该接口中的方法不超过三个，可以将匿名内部类作为参数传递。 好处：增强阅读性。示例1：
abstract class Demo{ abstract void show();}class Outer{ int num = 4; void method(){ new Demo(){//匿名内部类 void show(){ System.out.println("show......" + num); } }.show(); }}class InnerClassDemo{ public static void main(String[] args){ new Outer().method(); }}运行结果：show......4示例2：
interface Inter{ void show1(); void show2();}class Outer{ public void method(){ Inter in = new Inter(){ public void show1(){ System.out.println("...show1...." ); } public void show2(){ System.out.println("...show2...." ); } }; in.show1(); in.show2(); }}class InnerClassDemo{ public static void main(String[] args){ new Outer().method(); }}运行结果：...show1.......show2....示例3：
interface Inter{ void show1(); void show2();}/*通常的使用场景之一：当函数参数是接口类型时，而且接口中的方法不超过三个。可以用匿名内部类作为实际参数进行传递。*/class InnerClassDemo{ public static void main(String[] args){ show(new Inter(){ public void show1(){ System.out.println("...show1..." ); } public void show2(){ System.out.println("...show2..." ); } }); } public static void show(Inter in){ in.show1(); in.show2(); }}运行结果：...show1......show2...对象的初始化过程
示例：
class Fu{ int num = 9; { System.out.println("Fu" ); } Fu(){ super();//Object //显示初始化 //构造代码块初始化 show(); } void show(){ System.out.println("fu show " + num);//被覆盖，运行子类的 }}class Zi extends Fu{ int num = 8; { System.out.println("Zi" ); } Zi(){ super(); //显示初始化 //构造代码块初始化 show(); } void show(){ System.out.println("zi show " + num); }}public class Demo{ public static void main(String[] args){ new Zi(); }}运行结果：Fuzi show 0Zizi show 8 0 0
- 【黑马程序员】Java学习笔记之继承（二）（面向对象）
- 黑马程序员---java学习笔记之面向对象：继承
- 【黑马程序员】Java学习笔记之继承(一)（面向对象）
- 黑马程序员——Java面向对象（二）之封装、继承、多态、接口等
- 黑马程序员--面向对象之二：继承
- 黑马程序员——面向对象之继承学习笔记
- 黑马程序员笔记——Java面向对象之继承
- 黑马程序员学习笔记四——Java 面向对象 特点之 继承
- 黑马程序员-JAVA面向对象之继承
- 黑马程序员@java面向对象之继承
- 黑马程序员--java基础知识之面向对象（二）
- 黑马程序员---java基础知识之面向对象（二）
- 黑马程序员----Java基础（六）：面向对象之二
- 黑马程序员——JAVA之面向对象（二）
- 黑马程序员 java面向对象（二）
- 黑马程序员 JAVA-面向对象（二 ）
- java面向对象 黑马程序员学习笔记（5）
- 黑马程序员---面向对象（二）（继承）
- eclipse关联support-v4.jar源码
- Hadoop的Text类getBytes字节数据put到HBase后有多余字符串问题
- css画电脑键盘
- 天了噜，我国4G用户超过2亿了！
- 哈夫曼编码树(最优编码树)
- 【黑马程序员】Java学习笔记之继承（二）（面向对象）
- XShell 技巧分享
- dubbo:webservice基于servlet容器的实现demo
- 如何在Fragment中使用ViewPager，并实现导航随手势滑动效果
- ERROR:duplicate key in table MYsql
- jQuery Callbacks应用关键点
- linux SD卡驱动分析
- 常见HTTP错误代码大全
- 小作：brainfuck解释器
