多态
多态的概述
多态的成员访问特点
多态的好处和弊端
向上转型和向下转型
多态内存图
抽象类
抽象类的概述
抽象类的成员特点
抽象类的案例
接口
接口的概述
接口的成员特点
类与类,类与接口,接口与接口的关系
抽象类与接口的区别
接口的案例
面向对象(多态的概述及其代码体现)
A:多态概述
某一个事物,在不同时刻表现出来的不同状态。
举例: Cat c=new Cat();
Animal a=new Cat();
猫可以是猫的类型。猫 m = new 猫();
同时猫也是动物的一种,也可以把猫称为动物。动物 d = new 猫();
B:多态前提
a:要有继承关系。
b:要有方法重写。 其实没有也是可以的,但是如果没有这个就没有意义。
c:要有父类引用指向子类对象。
父 f = new 子();
C:案例演示
代码体现多态
public class MyTest {
public static void main(String[] args) {
Cat cat = new Cat();
cat.eat();
Animal an= new Cat();
an.eat();
}
}
class Animal{
public void eat(){
System.out.println("吃饭");
}
}
class Cat extends Animal{
public void eat(){
System.out.println("猫吃鱼");
}
}
面向对象(多态中的成员访问特点)
A:多态中的成员访问特点
a:成员变量
编译看左边,运行看左边。
b:构造方法
创建子类对象的时候,会访问父类的构造方法,对父类的数据进行初始化。
c:成员方法
编译看左边,运行看右边。
d:静态方法
编译看左边,运行看左边。
(静态和类相关,算不上重写,所以,访问还是左边的)
B:案例演示
多态中的成员访问特点
public class MyTest {
public static void main(String[] args) {
Fu fu = new Zi();
System.out.println(fu.num);
fu.fushow();
}
}
class Fu{
int num=100;
public void fushow(){
System.out.println("fushow");
}
}
class Zi extends Fu{
int num=200;
@Override
public void fushow() {
System.out.println("zishow");
}
}
面向对象(多态的好处)
A:多态的好处
a:提高了代码的维护性(继承保证)
b:提高了代码的扩展性(由多态保证)
面向对象(多态的弊端以及多态中向上转型和向下转型)
A:通过多态的弊端引出问题
不能使用子类特有的功能
B:解决问题
a:把父类的引用强制转换为子类的引用。(向下转型)
案例演示 孔子装爹
public class MyTest {
public static void main(String[] args) {
孔子 k爹 = new 孔子();
System.out.println(k爹.age);
k爹.teach();
孔子 kz=(孔子) k爹;//向下转型
System.out.println(kz.age);
kz.playGame();
}
}
class 孔子爹{
int age=60;
public void teach(){
System.out.println("讲java");
}
}
class 孔子 extends 孔子爹{
int age=30;
@Override
public void teach() {
System.out.println("讲论语");
}
public void playGame(){
System.out.println("玩游戏");
}
}
面向对象(抽象类的概述及其特点)
A:抽象类概述
在Java中,一个没有方法体的方法应该定义为抽象方法,而类中如果有抽象方法,该类必须定义为抽象类。
B:抽象类特点
a:抽象类和抽象方法必须用abstract关键字修饰
抽象类格式: abstract class 类名 {}
抽象方法格式: public abstract void eat();
b:抽象类不一定有抽象方法,有抽象方法的类一定是抽象类
c:抽象类中可以有构造方法,抽象类不能进行实例化,那么要构造方法有什么作用呢?
用于子类访问父类数据时的初始化
d:抽象类不能直接实例化那么,抽象类如何实例化呢?
按照多态的方式,由具体的子类实例化。其实这也是多态的一种,抽象类多态。
e:抽象类的子类
要么是抽象类
要么重写抽象类中的所有抽象方法
面向对象(抽象类的成员特点)
A:抽象类的成员特点
a:成员变量:既可以是变量,也可以是常量。
b:构造方法:有。
用于子类访问父类数据的初始化。
c:成员方法:既可以是抽象的,也可以是非抽象的。
B:抽象类的成员方法特性:
a:抽象方法 强制要求子类做的事情。
b:非抽象方法 子类继承的事情,提高代码复用性。
面向对象(抽象类练习猫狗案例)
A:案例演示
具体事物:猫,狗
共性:姓名,年龄,吃饭
public class MyTest {
public static void main(String[] args) {
Animal an = new Cat();
an.eat();
an.sleep();
an=new Dog();
an.eat();
an.sleep();
}
}
public abstract class Animal {
public abstract void eat();
public abstract void sleep();
}
public class Cat extends Animal{
public void catchMouse(){
System.out.println("抓老鼠");
}
@Override
public void eat() {
System.out.println("猫吃鱼");
}
@Override
public void sleep() {
System.out.println("猫趴着睡觉");
}
}
public class Dog extends Animal{
@Override
public void eat() {
System.out.println("狗吃骨头");
}
@Override
public void sleep() {
System.out.println("狗躺着睡觉");
}
public void lookDoor(){
System.out.println("狗看门");
}
}
面向对象(抽象类练习老师案例)
A:案例演示
具体事物:基础班老师,就业班老师
共性:姓名,年龄,讲课。
public class MyTest {
private static Student p;
public static void main(String[] args) {
Person person = new Teacher();
person.name="沈老师";
System.out.println(person.name);
person.eat();
Teacher teacher=(Teacher) person;
teacher.teach();
person=new Student();
person.name="赵一";
System.out.println(person.name);
person.eat();
Student student= (Student) person;
student.playGame();
}
}
abstract class Person{
String name;
int age;
public abstract void eat();
public void show(){
System.out.println("fu show");
}
}
class Teacher extends Person{
public void teach(){
System.out.println("讲课");
}
@Override
public void eat() {
System.out.println("老师喜欢吃面");
}
}
class Student extends Person{
@Override
public void eat() {
System.out.println("学生喜欢吃米饭");
}
public void playGame(){
System.out.println("玩游戏");
}
}
面向对象(接口的概述及其特点)
A:接口概述
狗一般就是看门,猫一般就是作为宠物了。
但是,现在有很多的驯养员或者是驯兽师,可以训练出:猫钻火圈,狗跳高,狗做计算等。
而这些额外的动作,并不是所有猫或者狗一开始就具备的,这应该属于经过特殊的培训训练出来的。
所以,这些额外的动作定义到动物类中就不合适,也不适合直接定义到猫或者狗中,因为只有部分猫狗具备这些功能。
所以,为了体现事物功能的扩展性,Java中就提供了接口来定义这些额外功能,并不给出具体实现,将来哪些猫狗需要被培训,只需要这部分猫狗把这些额外功能实现即可
B:接口特点
a:接口用关键字interface表示 格式: interface 接口名 {}
b:类实现接口用implements表示 格式: class 类名 implements 接口名 {}
c:接口不能实例化
那么,接口如何实例化呢?
按照多态的方式来实例化。
d:接口的子类
a:可以是抽象类。但是意义不大。
b:可以是具体类。要重写接口中的所有抽象方法。(推荐方案)
C:案例演示
接口特点
public class MyTest {
public static void main(String[] args) {
MyInterface my = new Cat();
my.jump();
((Cat) my).eat();
}
}
public interface MyInterface {
public void jump();
}
public class Cat implements MyInterface{
public void eat(){
System.out.println("猫吃鱼");
}
public void catMouse(){
System.out.println("猫抓老鼠");
}
@Override
public void jump() {
System.out.println("经过练习,猫会调高");
}
}
面向对象(接口的成员特点)
A:接口成员特点
成员变量;只能是常量,并且是静态的。
默认修饰符:public static final
建议:自己手动给出。
构造方法:接口没有构造方法。
成员方法:只能是抽象方法。
默认修饰符:public abstract
建议:自己手动给出。
面向对象(类与类,类与接口,接口与接口的关系)
A:类与类,类与接口,接口与接口的关系
a:类与类:
继承关系,只能单继承,可以多层继承。
b:类与接口:
实现关系,可以单实现,也可以多实现。
并且还可以在继承一个类的同时实现多个接口。
c:接口与接口:
继承关系,可以单继承,也可以多继承。
面向对象(抽象类和接口的区别)
A:成员区别
抽象类:
成员变量:可以变量,也可以常量
构造方法:有
成员方法:可以抽象,也可以非抽象
接口:
成员变量:只可以常量
成员方法:只可以抽象
B:关系区别
类与类
继承,单继承
类与接口
实现,单实现,多实现
接口与接口
继承,单继承,多继承
C:设计理念区别
抽象类 被继承体现的是:”is a”的关系。 抽象类中定义的是该继承体系的共性功能。
接口 被实现体现的是:”like a”的关系。 接口中定义的是该继承体系的扩展功能。
注意:JDK1.8之后在接口中提供了用default修饰的方法,可以给出功能的具体实现,子类可以继承下去用
面向对象(猫狗案例加入跳高功能分析及其代码实现)
A:案例演示
动物类:姓名,年龄,吃饭,睡觉。
动物培训接口:跳高
猫继承动物类
狗继承动物类
部分猫继承猫类并实现跳高接口
部分狗继承狗类并实现跳高接口
通过抽象类测试基本功能。
通过接口测试扩展功能。
只测试猫,狗的测试留给学生自己练习
public class MyTest {
public static void main(String[] args) {
// Dog dog = new Dog;
Animal an = new 旺财();
an.name = "旺财";
an.age = 2;
System.out.println(an.name);
System.out.println(an.age);
an.sleep();
an.eat();
旺财 wc=(旺财) an;
wc.lookDoor();
高菲狗 gf=new 高菲狗();
an=gf;
an.name="高菲";
an.age=2;
System.out.println(an.name);
System.out.println(an.age);
an.eat();
an.sleep();
JumpInterface jumpInterface=gf;
jumpInterface.jump();
}
}
public abstract class Animal {
String name;
int age;
public abstract void eat();
public abstract void sleep();
}
public class Cat extends Animal{
public void catchMouse(){
System.out.println("猫抓老鼠");
}
@Override
public void eat() {
System.out.println("猫吃鱼");
}
@Override
public void sleep() {
System.out.println("猫趴着睡觉");
}
}
public class Dog extends Animal{
public void lookDoor(){
System.out.println("狗看门");
}
@Override
public void eat() {
System.out.println("狗吃骨头");
}
@Override
public void sleep() {
System.out.println("狗躺着睡觉");
}
}
public interface JumpInterface {
void jump();
}
public class 加菲猫 extends Cat implements JumpInterface{
@Override
public void eat() {
System.out.println("加菲猫吃小鱼干");
}
@Override
public void jump() {
System.out.println("加菲猫学会跳高");
}
}
public class 狸花猫 extends Cat {
@Override
public void eat() {
System.out.println("狸花猫吃老鼠");
}
}
public class 旺财 extends Dog {
@Override
public void eat() {
System.out.println("旺财吃狗粮");
}
}
public class 高菲狗 extends Dog implements JumpInterface{
@Override
public void eat() {
System.out.println("高=高菲狗吃狗罐头");
}
@Override
public void jump() {
System.out.println("高菲学会了调高");
}
}