黑马程序员_Java语言_面向对象_多态
来源：互联网 发布：杜兰特总得分最新数据 编辑：程序博客网 时间：2024/04/27 21:54
——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——-
09.01_面向对象(多态的概述及其代码体现)
- A:多态概述
- 事物存在的多种形态
- B:多态前提
- a:要有继承关系。
- b:要有方法重写。
- c:要有父类引用指向子类对象。
- C:案例演示
- 代码体现多态
/* 程序中的多态 父类的引用 = 自己的子类的对象*/class Fu{ public void show(){ System.out.println("父类的show"); }}class Zi extends Fu{ public void show(){ System.out.println("子类重写show"); }}class Zi1 extends Fu{ public void show(){ System.out.println("子类重写show1111"); }}class DuoTaiDemo { public static void main(String[] args) { Fu f = new Zi(); f.show(); //. System.out.println("Hello World!"); }}09.02_面向对象(多态中的成员访问特点)
- A:多态中的成员访问特点
- a:成员变量
- 编译看左边，运行看左边。
- b:成员方法
- 编译看左边，运行看右边。
- c:静态方法
- 编译看左边，运行看左边。
- (静态和类相关，算不上重写，所以，访问还是左边的)
- a:成员变量
- B:案例演示
- 多态中的成员访问特点
/* 多态中，子类父类中成员访问的特点*/class Fu{ int i = 3; public static void show(){ System.out.println("父类..show"); }}class Zi extends Fu{ int i = 4; public static void show(){ System.out.println("子类..show"); }}class DuoTaiDemo1 { public static void main(String[] args) { //多态形式进行调用 Fu f = new Zi(); f.show(); //System.out.println(f.i); }}09.03_面向对象(故事)
- 人： 军人，老百姓，老板
09.04_面向对象(多态中向上转型和向下转型)
A:案例演示
- 详细讲解多态中向上转型和向下转型
- 父类是Animal,子类是Cat
- Animal a = new Cat();向上转型
- Cat c = new Animal();错误的
Cat c = (Cat)a;向下转型
Cat c = new Cat();
- Animal a = (Animal)c; //其实加不加Animal都是一样的,都是向上转型
- //c其实就是猫
B: 多态转型中的类型判断 instanceof运算符
java.lang.ClassCastException 类型转换异常
案例：将Dog对象，强制转成了Cat关键字，也是运算符 instanceof 运算结果是布尔类型
检查 引用变量是不是这个类创建的
Animal a = new Dog();
Cat c = (Cat)a;instanceof 判断出变量a 是不狗类创建的对象
固定格式：
引用变量 instanceof 类
a instanceof Dog 判断a 是不是狗类对象，如果是运算符返回true
写在if语句中使用子类特有功能，需要强制转换，保证安全，使用instanceof判断
C: 多态的设计原理
为什么多态中，有的走父类，有的走子类
编译为什么看左边 Fu f = new Zi();
编译期间特点，检查语法问题，变量没有值，对象也是不存在
编译的时候，看见左边的类类型变量，看不到对象具体是谁除了非静态的成员方法以外，运行时期，JVM静态的绑定在父类的引用中
但是如果运行的是非静态成员方法，运行时期，JVM动态绑定在子类的对象中，会调用子类的重写方法为什么，必须运行子类重写方法，设计的原因，扩展父类
子类重写父类方法，目的就为了沿袭父类功能，扩展自己的功能
后面知识点 抽象类，接口，方法是没有主体
public abstract void aa(); 这样的方法根本不能运行
抽象的方法，没有主体的，没有大括号的方法，只能依赖子类重写
09.05_面向对象(多态的好处和弊端)
- A:多态的好处
- a:提高了代码的维护性(继承保证)
- b:提高了代码的扩展性(由多态保证)
- B:案例演示
- 多态的好处
- C:多态的弊端
- 不能使用子类的特有功能。
- D:案例演示
- 多态的弊端
/* 孔O装爹案例 有2个事物，一个是孔O，他爹 他爹： 年龄：70 讲学功能：经商 孔O： 年龄：40 讲学功能：论语 玩游戏： 和徒弟一起丢手绢 有人找孔O爹，讲学，但是没找到，孔O在家， 化妆成他爹，去讲学。 你的年龄：70 回家，徒弟找他玩游戏， 卸妆变回他自己，打游戏*/class KongZiDie{ int age = 70; public void teacher(){ System.out.println("经商"); }}class KongZi extends KongZiDie{ int age = 40; public void teacher(){ System.out.println("论语"); } public void playGame(){ System.out.println("打游戏"); }}class DuoTaiDemo2 { public static void main(String[] args) { //有人找孔O爹，讲学，但是没找到，孔O在家， //化妆成他爹，去讲学。 KongZiDie k = new KongZi();//孔O提升为了父类类型 k.teacher(); System.out.println(k.age); //使用打游戏功能，不可以，是子类特有功能，多态弊端 //k.playGame(); //孔O卸妆，由孔O爹变成孔O，大转向为小的，强制转换 //目标类型 变量 = (目标类型)被转数据 KongZi z = (KongZi)k; z.playGame(); }}09.06_面向对象(多态中的题目分析题)
- A:看下面程序是否有问题，如果没有，说出结果
class Fu { public void show() { System.out.println("fu show"); }}class Zi extends Fu { public void show() { System.out.println("zi show"); } public void method() { System.out.println("zi method"); }}class Test1Demo { public static void main(String[] args) { Fu f = new Zi(); f.method();//错误,父类未定义method()方法//The method method() is undefined for the type Fu f.show(); }}- B:看下面程序是否有问题，如果没有，说出结果
class A { public void show() { show2(); } public void show2() { System.out.println("我"); }}class B extends A { public void show2() { System.out.println("爱"); }}class C extends B { public void show() { super.show(); } public void show2() { System.out.println("你"); }}public class Test2DuoTai { public static void main(String[] args) { A a = new B(); a.show(); B b = new C(); b.show(); }}//爱 你
09.07_面向对象(抽象类的概述及其特点)
- A:抽象类概述
- B:抽象类特点
- a:抽象类和抽象方法必须用abstract关键字修饰
- abstract class 类名 {}
- public abstract void eat();
- b:抽象类不一定有抽象方法，有抽象方法的类一定是抽象类
- c:抽象类不能实例化那么，抽象类如何实例化呢?
- 按照多态的方式，由具体的子类实例化。其实这也是多态的一种，抽象类多态。
- d:抽象类的子类
- 要么是抽象类
- 要么重写抽象类中的所有抽象方法
- a:抽象类和抽象方法必须用abstract关键字修饰
- C:案例演示
- 抽象类特点
/* 定义抽象类 定义抽象方法*/abstract class Abstract{ public abstract void show();}//定义子类继承抽象类，重写抽象方法，建立子类的对象class SubAbstract extends Abstract{ //重写抽象方法，去掉修饰符abstract,加上方法体 public void show(){ System.out.println("重写抽象方法"); }}class AbstractClassDemo { public static void main(String[] args) { //创建抽象类的子类对象 SubAbstract sub = new SubAbstract(); sub.show(); //写成多态调用 Abstract a = new SubAbstract(); a.show(); //System.out.println("Hello World!"); }}09.08_面向对象(抽象类的成员特点)
- A:抽象类的成员特点
- a:成员变量：既可以是变量，也可以是常量。
- b:构造方法：有。
- 用于子类访问父类数据的初始化。
- c:成员方法：既可以是抽象的，也可以是非抽象的。
- B:案例演示
- 抽象类的成员特点
abstract class Abstract{ Abstract(){ super(); } public static int i = 1; public void show(){} public abstract void function(); public static void haha(){ System.out.println("hahahah"); }} class AbstractClassDemo1 { public static void main(String[] args) { Abstract.haha(); System.out.println(Abstract.i); }}- C:抽象类的成员方法特性：
- a:抽象方法 强制要求子类做的事情。
- b:非抽象方法 子类继承的事情，提高代码复用性。
09.09_面向对象(作用)
- 案例演示
- 抽象类的作用
整个继承体系最顶层类,所有子类…都具备,强制子类重写抽象方法,保证继承体系完整.
- 抽象类的作用
abstract class Abstract{ public final void show(){System.out.println("Hello World!");} public void haha(){}}class SubAbstract extends Abstract{}class AbstractClassDemo2 { public static void main(String[] args) { new SubAbstract().show(); // System.out.println("Hello World!"); }}09.10_面向对象(抽象类练习猫狗案例)
- A:案例演示
- 具体事物：猫，狗
- 共性：姓名，年龄，吃饭
- 猫的特性:抓老鼠
- 狗的特性:看家
/* 具体事物：猫，狗 共性：姓名，年龄，吃饭 抽象类存在意义:强制子类重写抽象方法 抽象类，是整个继承体系的最顶层类，里面功能所有小弟都具备的 抽象类保证继承体系的完整性 猫：存在的时候，应该具有姓名和年龄 创建对象的时候，猫必须具有姓名和年龄，创建对象赋值成员变量，使用构造器*/abstract class Animal{ private String name; private int age; Animal(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; } public abstract void eat();}class Cat extends Animal{ Cat(String name,int age){ //super调用父类构造器，完成成员变量赋值 super(name,age); } public void eat(){ System.out.println("猫吃猫粮"+getName()+"..."+getAge()); }}class Dog extends Animal{ Dog(String name,int age){ super(name,age); } public void eat(){ System.out.println("狗啃骨头"+getName()+"..."+getAge()); }}class AbstractTest { public static void main(String[] args) { Animal c = new Cat("小白",1); c.eat(); //修改猫名字和年龄 set c.setName("机器猫"); c.setAge(2); c.eat(); System.out.println(c.getName()+"..."+c.getAge()); }}09.11_面向对象(抽象类练习老师案例)
- A:案例演示
- 具体事物：基础班老师，就业班老师
- 共性：姓名，年龄，讲课。
/* 具体事物：基础班老师，就业班老师 共性：姓名，年龄，讲课。*///将老师共性内容抽取，一个父类abstract class Teacher{ private String name; private int age; Teacher(String name,int age){ this.name = name; this.age = age; } public void setName(String name){this.name=name;} public void setAge(int age){this.age=age;} public String getName(){return name;} public int getAge(){return age;} public abstract void teacher();}//定义基础老师，姓名年龄，讲课功能class BaseTeacher extends Teacher{ BaseTeacher(String name,int age){super(name,age);} public void teacher(){ System.out.println("JAVA基础SE"); }}//定义就业班老师，姓名年龄，讲课功能class AdvancedTeacher extends Teacher{ AdvancedTeacher(String name,int age){super(name,age);} public void teacher(){ System.out.println("JAVA企业班EE"); }}//定义就业辅导老师，姓名年龄，讲课功能class JobTeacher extends Teacher{ JobTeacher(String name,int age){super(name,age);} public void teacher(){ System.out.println("面试技巧"); }}class AbstractTest1{ public static void main(String[] args) { //多态形式调用老师的功能 /*Teacher t = new BaseTeacher("张三",101); t.teacher(); System.out.println(t.getName()+"..."+t.getAge()); t = new AdvancedTeacher("李四",29); t.teacher(); System.out.println(t.getName()+"..."+t.getAge()); t = new JobTeacher("王五",44); t.teacher(); System.out.println(t.getName()+"..."+t.getAge());*/ //调用teacher传递Teacher的子类对象 teacher(new BaseTeacher("张三",100)); teacher(new BaseTeacher("张三丰",30)); } //定义方法，将main重复代码抽取方法 public static void teacher(Teacher t){ t.teacher(); System.out.println(t.getName()+"..."+t.getAge()); }}09.12_面向对象(抽象类练习员工案例)
- A:案例演示
- 假如我们在开发一个系统时需要对程序员类进行设计，程序员包含3个属性：姓名、工号以及工资。
- 经理，除了含有程序员的属性外，另为还有一个奖金属性。
- 请使用继承的思想设计出程序员类和经理类。要求类中提供必要的方法进行属性访问。
/* 员工与经理 继承思想，共性抽取 采用两种方法创建子类对象 先创建子类对象，调用set方法赋值 再来一种，创建子类对象同时赋值变量*///共性抽取，奖金不能动abstract class Company{ private String name; private String id; private double money; Company(){} Company(String name,String id,double money){ this.name = name; this.id = id; this.money = money; } public void setName(String name){this.name=name;} public void setId(String id){this.id=id;} public void setMoney(double money){this.money=money;} public String getName(){return name;} public String getId(){return id;} public double getMoney(){return money;} public abstract void work();}//定义员工类class Employee extends Company{ Employee(){} public void work(){ System.out.println("员工在写代码"); }}//定义经理类class Manager extends Company{ Manager(String name,String id,double money,double bonus){ super(name,id,money); this.bonus = bonus; } private double bonus; public void setBonus(double bonus){this.bonus=bonus;} public double getBonus(){return bonus;} public void work(){ System.out.println("经理指挥你写代码"); }}class AbstractTest2 { public static void main(String[] args) { //创建员工类对象，调用set方法赋值 Company e = new Employee(); e.setName("张三"); e.setId("研发部001"); e.setMoney(10000.01); e.work(); System.out.println(e.getName()+".."+e.getId()+".."+e.getMoney()); //创建经理类对象，构造方法直接赋值 e = new Manager("李四","董事会001",1234.56,567890.98); e.work(); Manager m = (Manager)e; System.out.println(e.getName()+".."+e.getId()+".."+e.getMoney()+".."+m.getBonus()); }}09.13_面向对象(抽象类中的面试题)
- A:面试题1
- 一个抽象类如果没有抽象方法，可不可以定义为抽象类?如果可以，有什么意义?
- 可以
- 这么做目的只有一个,就是不让其他类创建本类对象,交给子类完成
- B:面试题2
- abstract不能和哪些关键字共存
修饰符的冲突问题 final 抽象目的，子类重写，final不能重写 private 抽象目的，子类重写，但是子类不知道父类有这个方法 static 静态方法类名直接调用，如果是抽象没有方法体，怎么调用09.14_面向对象(接口的概述及其特点)
- A:接口概述
- 从狭义的角度讲就是指java中的interface
- 从广义的角度讲对外提供规则的都是接口
B:接口特点
- a:接口用关键字interface表示
- interface 接口名 {}
- b:类实现接口用implements表示
- class 类名 implements 接口名 {}
- c:接口不能实例化
- 那么，接口如何实例化呢?
- 按照多态的方式来实例化。
- d:接口的子类
- a:可以是抽象类。但是意义不大。
- b:可以是具体类。要重写接口中的所有抽象方法。(推荐方案)
- 接口是一个对外暴露的规则
规定内容，并没有具体的实现
接口降低程序的耦合性(紧密连接)，提高扩展性
面向接口编程- a:接口用关键字interface表示
- C:案例演示
- 接口特点
/* 定义接口，关键字interface 注意：修饰符，可写，不写，也可以选择性书写，任意写一个都行 编译的时候定义的是interface 编译器，检查，少哪一个，补充哪一个*/interface Inter{ //定义接口成员变量 public static final int I = 10; //定义接口成员方法，全抽象 public abstract void show();}class InterFaceDemo { public static void main(String[] args) { System.out.println(); }}09.15_面向对象(接口的成员特点)
- A:接口成员特点
- 成员变量；只能是常量，并且是静态的。
* 默认修饰符：public static final
* 建议：自己手动给出。 - 构造方法：接口没有构造方法。
- 成员方法：只能是抽象方法。
* 默认修饰符：public abstract
* 建议：自己手动给出。
- 成员变量；只能是常量，并且是静态的。
- B:案例演示
- 接口成员特点
/* 定义接口，定义实现类，实现接口 创建实现类的对象*/interface Inter{ public static final int I = 3 ; public abstract void show(); public abstract void show2();}//定义接口实现类，实现接口重写抽象方法class InterImpl implements Inter{ public void show(){ System.out.println("实现类重写方法"); }}class InterFaceDemo { public static void main(String[] args) { InterImpl impl = new InterImpl(); impl.show(); System.out.println(Inter.I); //常见调用方式 System.out.println(InterImpl.I); System.out.println(impl.I); }}09.16_面向对象(类与类,类与接口,接口与接口的关系)
- A:类与类,类与接口,接口与接口的关系
- a:类与类：
- 继承关系,只能单继承,可以多层继承。
- b:类与接口：
- 实现关系,可以单实现,也可以多实现。
- 并且还可以在继承一个类的同时实现多个接口。
- c:接口与接口：
- 继承关系,可以单继承,也可以多继承。
- a:类与类：
- B:案例演示
- 类与类,类与接口,接口与接口的关系
/* 接口的多实现 一个类，同时实现多个接口 多实现没有安全隐患的 但是方法没有主体，怎么运行，实现什么功能，完全由实现类自己说了算*/interface A{ public abstract void a();}interface B{ public abstract void a();}abstract class C{ public abstract void c();}class D extends C implements A,B{ public void a(){} public void c(){}}class InterFaceDemo2 { public static void main(String[] args) { System.out.println("Hello World!"); }}/* 接口之间的多继承关系*/interface A{ void a();}interface B{ void b();}interface C extends A,B{ void c();}class D implements C{ public void a(){} public void b(){} public void c(){}}class InterFaceDemo3 { public static void main(String[] args) { System.out.println("Hello World!"); }}09.17_面向对象(抽象类和接口的区别)
A:成员区别
- 抽象类：
- 成员变量：可以变量，也可以常量
- 构造方法：有
- 成员方法：可以抽象，也可以非抽象
- 接口：
- 成员变量：只可以常量
- 成员方法：只可以抽象
- 抽象类：
B:关系区别
- 类与类
- 继承，单继承
- 类与接口
- 实现，单实现，多实现
- 接口与接口
- 继承，单继承，多继承
- 类与类
C:设计理念区别
- 抽象类 被继承体现的是：”is a”的关系。抽象类中定义的是该继承体系的共性功能。
- 接口 被实现体现的是：”like a” 的关系。接口中定义的是该继承体系的扩展功能。
09.18_面向对象(老师和学生)
/*所有的东西都加上。(分析，实现，测试) 人类：姓名，年龄，吃饭，睡觉。 吸烟接口：吸烟 老师继承人类 学生继承人类 部分老师继承人类并实现吸烟接口 部分学生继承人类并实现吸烟接口 具体的事物 人： 属性成员变量，姓名年龄 人： 行为功能方法，吃饭睡觉 老师：属于人的一种，具备人的特性，继承人 老师的姓名和年龄，需要使用父类方法赋值 自己的特点，上课成功 老师：扩展出来的功能，吸烟 学生：属于人的一种，具备人的特性，继承人 学生自己的姓名和年龄，需要使用父类方法赋值 自己的功能学习 学生：扩展出来的，吸烟 is a 老师和学生是人类中的一种 like a 老师和学生是人类中的一致，但是看上去更像烟民*//* 定义人的抽象类*/abstract class Person{ private String name; private int age; Person(){} Person(String name,int age){ this.name = name; this.age = age; } public void setName(String name){this.name=name;} public void setAge(int age){this.age=age;} public String getName(){return name;} public int getAge(){return age;} //人类具备功能，吃饭，睡觉，写成抽象，子类实现，还是写好，子类调用 public abstract void eat(); public abstract void sleep();}/* 定义吸烟接口，谁吸烟，谁实现*/interface Smoking{ public abstract void smoking();}//定义老师类，继承Personclass Teacher extends Person{ //定义空参数构造 Teacher(){} Teacher(String name,int age){ super(name,age); } //继承重写功能 public void eat(){ System.out.println("老师在吃饭"); } public void sleep(){ System.out.println("老师在睡觉"); } public void teacher(){ System.out.println("老师在上课"); }}//定义吸烟的老师，是人类一种，还吸烟class SmokingTeacher extends Person implements Smoking{ SmokingTeacher(){} SmokingTeacher(String name,int age){ super(name,age); } public void eat(){ System.out.println("吸烟的老师在吃饭"); } public void sleep(){ System.out.println("吸烟的老师在睡觉"); } public void teacher(){ System.out.println("吸烟的老师在上课"); } public void smoking(){ System.out.println("老师下课在抽烟"); }}class InterFaceTest{ public static void main(String[] args) { Teacher t1 = new Teacher(); t1.setName("张三"); t1.setAge(35); t1.eat(); t1.sleep(); t1.teacher(); System.out.println(t1.getName()+"..."+t1.getAge()); Teacher t2 = new Teacher("李四",43); t2.eat(); t2.sleep(); t2.teacher(); System.out.println(t2.getName()+"..."+t2.getAge()); SmokingTeacher st1 = new SmokingTeacher("王五",20); st1.eat(); st1.sleep(); st1.teacher(); st1.smoking(); System.out.println(st1.getName()+"..."+st1.getAge()); }} 0 0
- 黑马程序员_Java语言_面向对象_多态
- 黑马程序员_Java语言_面向对象
- 黑马程序员_Java语言_面向对象
- 黑马程序员_Java语言_面向对象_
- 黑马程序员_Java语言_面向对象_内部类
- 黑马程序员_Java语言_面向对象__
- 黑马程序员_java入门_面向对象
- 黑马程序员_java面向对象_封装
- 黑马程序员_Java基础_面向对象
- 黑马程序员_Java基础_面向对象
- 黑马程序员_Java基础_面向对象
- 黑马程序员_java基础_面向对象
- 黑马程序员_面向对象_多态
- 黑马程序员_java学习日记_面向对象
- 黑马程序员_JAVA学习日记_面向对象2
- 黑马程序员_java面向对象_构造函数
- 黑马程序员_Java基础_面向对象（一）_05
- 黑马程序员_Java基础_面向对象（二）_06
- 【重构机房】 设计数据库
- 一个Android菜鸟“面霸”的面试经历，如何少走弯路多加薪！
- 进阶_计时器(Handler+TimerTask实现)_150503
- 控制领域主要学术期刊 Major Journals in Control Field
- VC++ 和 Native .NET 编译器后端 C2 的更新介绍
- 黑马程序员_Java语言_面向对象_多态
- 去哪儿网校园招聘java开发面试回忆
- 素数判定Miller_Rabin 算法详解
- Remove Duplicates from Sorted List
- BZOJ 4031: [HEOI2015]小Z的房间
- c++之超越c的语法04-变量作用域
- 病毒的分类和命名规则
- Spring 注解 AOP 出现错误::0 can't find referenced pointcut XXX 的原因
- VC6.0--- Unable to register this add-in because its DllR
