Java--面向对象--多态、抽象类、接口

多态
多态的概述
多态的成员访问特点
多态的好处和弊端
向上转型和向下转型
多态内存图
抽象类
抽象类的概述
抽象类的成员特点
抽象类的案例
接口
接口的概述
接口的成员特点
类与类,类与接口,接口与接口的关系
抽象类与接口的区别
接口的案例

面向对象(多态的概述及其代码体现)

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("高菲学会了调高");
    }
}