黑马程序员_Java语言_面向对象_多态
——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();
}
//定义老师类，继承Person
class 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());
}
}