JavaSE 多态抽象类接口

最新推荐文章于 2022-12-15 20:27:13 发布

Hoooooope!

最新推荐文章于 2022-12-15 20:27:13 发布

阅读量208

点赞数

分类专栏： JavaSE 文章标签： java

本文链接：https://blog.csdn.net/qq_43563187/article/details/110533260

版权

JavaSE 专栏收录该内容

28 篇文章 0 订阅

订阅专栏

day09目录：

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

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

A:多态概述
	某一个事物，在不同时刻表现出来的不同状态。
	举例：				Cat c=new Cat();
					Animal a=new Cat();
		猫可以是猫的类型。猫 m = new 猫();
		同时猫也是动物的一种，也可以把猫称为动物。动物 d = new 猫();		
B:多态前提
	a:要有继承关系。
	b:要有方法重写。 其实没有也是可以的，但是如果没有这个就没有意义。
	c:要有父类引用指向子类对象。
		父 f =  new 子();
C:案例演示
	代码体现多态

public class Animal {
    public void eat(){
        System.out.println("吃饭");
    }
}



public class AnimalUtils {
    private AnimalUtils(){}
    //面向父类编程，面向接口
    public static void test(Animal an) { //Animal an=new Dog()
                                          //Animal an=new Cat()//Animal an=new Tiger()
        an.eat();
    }

    /*
    public static void test(Dog dog) {
        dog.eat();
    }

    public static void test(Cat cat) {
        cat.eat();
    }

    public static void test(Tiger tiger) {
        tiger.eat();
    }

    public static void test(Rabbit rabbit) {
        rabbit.eat();
    }

     */
}


public class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("猫喜欢吃小鱼干");
    }
}
public class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }
}
public class Pig extends Animal{
    @Override
    public void eat() {
        System.out.println("佩奇爱吃饼干");
    }
}



public class MyTest {
    public static void main(String[] args) {
        Dog dog = new Dog();
        AnimalUtils.test(dog);
        Cat cat = new Cat();
        AnimalUtils.test(cat);
        Tiger tiger = new Tiger();
        AnimalUtils.test(tiger);
        Rabbit rabbit = new Rabbit();
        AnimalUtils.test(rabbit);
        Pig pig = new Pig();
        AnimalUtils.test(pig);
    }
    //作为有入口的测试类，我们只需要提供一个main方法，作为入口去使用其他类，一般不会在入口类里面再去提供其他的成员方法和成员变量

}

09.02_面向对象(多态中的成员访问特点)(掌握)

A:多态中的成员访问特点
	a:成员变量
		编译看左边，运行看左边。
	b:构造方法
		创建子类对象的时候，会访问父类的构造方法，对父类的数据进行初始化。
	c:成员方法
		编译看左边，运行看右边。
	d:静态方法
		编译看左边，运行看左边。
		(静态和类相关，算不上重写，所以，访问还是左边的)
B:案例演示
	多态中的成员访问特点:

public class MyTest {
    public static void main(String[] args) {
        Zi zi = new Zi();
        System.out.println(zi.num);
        System.out.println("========================");
        //多态
        //左  =     右
        Fu fu = new Zi();
        //1.多态的形式来访问成员变量，编译看左边(父类)，运行还是看左边（父类）。
        int num = fu.num;
        System.out.println(num);
        //2.多态的形式来调用成员方法,如果子类有重写，编译看左边，运行看右边，当然子类没有重写该方法，那调用的还是父类的
        fu.show();
        //3.构造方法，多态的形式，还是先去调用父类的构造方法，先完成父类数据的初始化
        //4.多态的形式调用静态方法,调用的还是父类的静态方法。
        fu.hehe();
        Fu.hehe();
        Zi.hehe();
    }
}

class Fu {
    int num = 100;

    public Fu() {
        System.out.println("父类的构造方法执行了");
    }

    public void show() {
        System.out.println("fu show");
    }

    public static void hehe() {
        System.out.println("fu hehe");
    }
}

class Zi extends Fu {
    int num = 50;

    public Zi() {
        System.out.println("子类的构造方法执行了");
    }

    @Override
    public void show() {
        System.out.println("zi Show");
    }


    public static void hehe() {
        System.out.println("zi hehe");
    }
}

09.03_面向对象(多态的好处)(理解)

A:多态的好处
	a:提高了代码的维护性(继承保证)
	b:提高了代码的扩展性(由多态保证) 
B:案例演示
	多态的好处
D:案例演示
	多态的弊端:

public class MyTest {
    public static void main(String[] args) {
        Father f = new Son();
        f.show();
        //多态的弊端，就是不能直接调用子类特有的功能。
        //f.hehe();
        //向下转型：把父类引用，向下转换为子类型。
        Son son= (Son) f;
        son.hehe();

}
}

class Father{
    public void show(){
        System.out.println("fu show");
    }

}

class Son extends Father{

    @Override
    public void show() {
        System.out.println("zi show");
    }

    public void hehe(){
        System.out.println("子类特有的功能 呵呵");
    }
}

09.04_面向对象(多态的弊端以及多态中向上转型和向下转型)(掌握)

A:通过多态的弊端引出问题
	不能使用子类特有的功能
B:解决问题
	a:把父类的引用强制转换为子类的引用。(向下转型)
C:案例演示
	详细讲解多态中向上转型和向下转型:

public class MyTest2 {
    public static void main(String[] args) {
        /*
      Animal an=  new Cat();
      an.eat();
      an=new Dog();
      an.eat();

         */
        //多态就是向上转型
        Animal an = new Cat();
        an.eat();
        //向下转型
        Cat cat= (Cat) an;
        cat.catchMouse();

        //an.lookDoor();
       // ClassCastException: 类型转换异常
      //  org.westos.demo5.Cat cannot be cast to org.westos.demo5.Dog
       // an = new Dog();
        Dog dog= (Dog) an;
        dog.lookDoor();

        //向上转型，

    }

}

class Animal{
    public void eat(){
        System.out.println("吃饭");
    }

}
class Dog extends Animal{
    @Override
    public void eat() {
        System.out.println("吃骨头");
    }


    public void lookDoor() {
        System.out.println("狗看门");
    }

}

class Cat extends Animal{
    @Override
    public void eat() {
        System.out.println("吃小鱼干");
    }


    public void catchMouse() {
        System.out.println("抓老鼠");
    }
}

09.05_案例演示孔子装爹

public class MyTest {
    public static void main(String[] args) {
        /*
         * 孔子爹，是西开资深金牌Java讲师，很多学员慕名前来学习Java, 张三，家里很有钱，到孔子爹的家里，把孔子爹请去他的家里讲课去了。
         * 家里就剩孔子一个人在玩吃鸡游戏，那么这个时候，李四也来到了孔子爹的家里。想请孔子爹去他家里讲课。
         * 孔子爹，不在家了，孔子不想失去这个学员，就乔装打扮一番，装扮成他爹的模样，去李四家里给将Java,实际上给讲的是论语。
         * 讲完之后，孔子回到家里，觉得装他爹太累了，想做回自己，于是卸下装扮，痛快的玩了一把游戏
        * */
        孔子爹 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("玩 吃鸡游戏");
    }
}

09.06_面向对象(多态的内存图解)(理解)

A:画图演示:	多态的内存图解

09.07_面向对象(猫狗案例多态版)(掌握)

A:案例演示:	猫狗案例多态版

09.08_面向对象(多态中的题目分析题)(掌握)

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 DuoTaiTest3 {
		public static void main(String[] args){
			Fu f = new Zi();

			f.method(); //报错 ，不能直接调用子类特有的方法
			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 DuoTaiTest4 {
		public static void main(String[] args) {
			A a = new B();
			a.show(); // 爱
			
			B b = new C();
			b.show();// 你
		}
	}

09.09_面向对象(抽象类的概述及其特点)(掌握)

A:抽象类概述
	回想前面我们的猫狗案例，提取出了一个动物类。并且我们在前面也创建过了动物对象，其实这是不对的。
		为什么呢?因为，我说动物，你知道我说的是什么动物吗?只有看到了具体的动物，你才知道，这是什么动物。 
	所以说，动物本身并不是一个具体的事物，而是一个抽象的事物。只有真正的猫，狗才是具体的动物。
	同理，我们也可以推想，不同的动物吃的东西应该是不一样的，所以，我们不应该在动物类中给出具体体现，而是应该给出一个声明即可。
	在Java中，一个没有方法体的方法应该定义为抽象方法，而类中如果有抽象方法，该类必须定义为抽象类。
B:抽象类特点
	a:抽象类和抽象方法必须用abstract关键字修饰
		抽象类格式:		abstract class 类名 {}
		抽象方法格式:	public abstract void eat();
	b:抽象类不一定有抽象方法，有抽象方法的类一定是抽象类
	c:抽象类中可以有构造方法,抽象类不能进行实例化,那么要构造方法有什么作用呢?
		用于子类访问父类数据时的初始化
	d:抽象类不能直接实例化那么，抽象类如何实例化呢?
		按照多态的方式，由具体的子类实例化。其实这也是多态的一种，抽象类多态。
	e:抽象类的子类
		要么是抽象类
		要么重写抽象类中的所有抽象方法
C:案例演示
	抽象类特点

public class MyTest {
    public static void main(String[] args) {
        //1.一旦一个类中有了抽象方法，此类必须为一个抽象类
        //2.一个抽象类中,可以没有抽象方法，当然可以有非抽象方法。
        //3.抽象类中可以有抽象方法，也可以有非抽象方法。非抽象方法，可以让子类继承使用，抽象方法，强制子类必须重写。
        //4.抽象类中存在构造方法，作用：创建子类时，先初始化父类的数据。
        //5.抽象类，不能直接创建其对象。我们可以采用多态的形式，间接的去初始化他
        ///6.作为抽象类的子类，必须重写父类的所有的抽象方法，如果你不重写，你自己也定义为抽像类。
        Fu fu = new Zi();
        System.out.println(fu.num);
    }
}

abstract class AA {
    public void aa() {

    }

    public void bb() {

    }

    public abstract void hehe();
}

abstract class Fu {
    int num = 100;

    public Fu() {
        System.out.println("父类构造执行了");
    }

    public abstract void show();
}

class Zi extends Fu {
    int num = 20;

    public Zi() {
        System.out.println("子类的构造方法执行了");
    }

    @Override
    public void show() {

    }
}

abstract class CC {
    public abstract void cc();

    public abstract void cc1();

    public abstract void cc2();
}

abstract class DD extends CC {
    public abstract void dd();
}

class EE extends DD {

    @Override
    public void cc() {

    }

    @Override
    public void cc1() {

    }

    @Override
    public void cc2() {

    }

    @Override
    public void dd() {

    }
}

09.10_面向对象(抽象类的成员特点)(掌握)

A:抽象类的成员特点
	a:成员变量：既可以是变量，也可以是常量。
	b:构造方法：有。
				用于子类访问父类数据的初始化。
	c:成员方法：既可以是抽象的，也可以是非抽象的。
B:案例演示
	抽象类的成员特点
C:抽象类的成员方法特性：
	a:抽象方法 		强制要求子类做的事情。
	b:非抽象方法    子类继承的事情，提高代码复用性。

public class MyTest {
    public static void main(String[] args) {
        //多态
        Animal an = new Cat();
        an.eat();
        an.sleep();
        Cat cat= (Cat) an;
        cat.catchMouse();
        cat.sing();
        System.out.println("======================");
        an=new Dog();
        an.sleep();
        an.eat();
        Dog dog= (Dog) an;
        dog.lookDoor();
        dog.sing();

        System.out.println(dog.num);
        System.out.println(Dog.A);
        System.out.println(Animal.A);

        //抽象类中的成员特点。
        //抽象类中可以定义成员变量，也可以定义常量
        //抽象类中有构造方法，作用，创建子类 时 调用父类构造方法，完成父类数据的初始化。
        //抽象类中可以定义抽象方法，也可以定义非抽象方法，抽象方法，是强制子类必须重写，非抽象方法可以让子类继承使用。

        // 一个类如果没有抽象方法，可不可以定义为抽象类 ? 如果可以，有什么意义 ?
        //可以，外界就不能创建该类对象

         //abstract不能和哪些关键字共存 ?
        //final:  矛盾，abstract强制子类重写，final又不让子类重写
        //private:矛盾：abstract强制子类重写  private子类无法继承，也就无法重写
        //static 静态方法不参与重写，abstract强制子类重写 没有意义

    }
}

09.11_面向对象(抽象类练习猫狗案例)(掌握)

A:案例演示
	具体事物：猫，狗
	共性：姓名，年龄，吃饭

09.12_面向对象(抽象类练习老师案例)(掌握)

A:案例演示
	具体事物：基础班老师，就业班老师
	共性：姓名，年龄，讲课。

09.13_面向对象(抽象类练习员工案例)(掌握)

A:案例演示
	假如我们在开发一个系统时需要对员工(Employee)类进行设计，员工包含3个属性：姓名、工号以及工资(salary)。
	经理(Manager)也是员工，除了含有员工的属性外，另为还有一个奖金(bonus)属性。
	然后定义工作的方法.
	请使用继承的思想设计出员工类和经理类。

09.14_面向对象(抽象类中的面试题)(掌握)

A:面试题1
	一个类如果没有抽象方法，可不可以定义为抽象类?如果可以，有什么意义?
	答案: 可以 . 不能创建对象.
B:面试题2
	abstract不能和哪些关键字共存?
		private    冲突
		final      冲突
		static     不能共存 无意义

09.15_面向对象(接口的概述及其特点)(掌握)

A:接口概述
	继续回到我们的猫狗案例，我们想想狗一般就是看门，猫一般就是作为宠物了。
	但是，现在有很多的驯养员或者是驯兽师，可以训练出：猫钻火圈，狗跳高，狗做计算等。
	而这些额外的动作，并不是所有猫或者狗一开始就具备的，这应该属于经过特殊的培训训练出来的。
	所以，这些额外的动作定义到动物类中就不合适，也不适合直接定义到猫或者狗中，因为只有部分猫狗具备这些功能。
	所以，为了体现事物功能的扩展性，Java中就提供了接口来定义这些额外功能，并不给出具体实现，将来哪些猫狗需要被培训，只需要这部分猫狗把这些额外功能实现即可
B:接口特点
	a:接口用关键字interface表示		 格式: 	interface 接口名 {}
	b:类实现接口用implements表示	 格式:	class 类名 implements 接口名 {}
	c:接口不能实例化
		那么，接口如何实例化呢?
		按照多态的方式来实例化。
	d:接口的子类
		a:可以是抽象类。但是意义不大。
		b:可以是具体类。要重写接口中的所有抽象方法。(推荐方案)
C:案例演示
	接口特点

public class Cat implements MyInterface{

    public void catchMouse(){
        System.out.println("抓老鼠");
    }


    public void eat() {
        System.out.println("猫吃鱼");
    }


    public void sleep() {
        System.out.println("猫喜欢白天睡觉");
    }

    @Override
    public void calc() {
        System.out.println("猫经过不断练习，学会了做算术。");
    }
}



public class Dog implements MyInterface{
    public void lookDoor() {
        System.out.println("狗看门");
    }


    public void eat() {
        System.out.println("狗吃骨头");
    }


    public void sleep() {
        System.out.println("狗睡觉");
    }

    @Override
    public void calc() {
        System.out.println("狗经过不断的练习学会了做算术");
    }
}

public interface MyInterface {
    public abstract void calc();
}

public class MyTest {
    public static void main(String[] args) {
        //1.接口不能创建对象。
        //2.子类和接口之间是叫做实现关系 implements  可以叫做父接口，子类
        MyInterface myInterface = new Dog();
        myInterface.calc();
        myInterface=new Cat();
        myInterface.calc();

    }
}

09.16_面向对象(接口的成员特点)(掌握)

A:接口成员特点
	成员变量；只能是常量，并且是静态的。
			默认修饰符：public static final
			建议：自己手动给出。
	构造方法：接口没有构造方法。
	成员方法：只能是抽象方法。
			默认修饰符：public abstract
			建议：自己手动给出。
B:案例演示
	接口成员特点

public class MyTest {
    public static void main(String[] args) {
        //接口中成员的特点
        //1.接口不能创建对象。
        //2.接口中没有构造方法这一说。
        //3.接口中的成员变量全部都是公共的静态常量,存在 public  static final 默认修饰符
        //4.接口中的没有非抽象方法，全部都是抽象方法。存在默认修饰符  public abstract JDK1.8之前


        System.out.println(HeHe.num);

    }
}

interface HeHe {
    public static final int num = 100;
    int aa=500;
    public abstract void aa();
}

09.17_面向对象(类与类,类与接口,接口与接口的关系)(掌握)

A:类与类,类与接口,接口与接口的关系
	a:类与类：
		继承关系,只能单继承,可以多层继承。
	b:类与接口：
		实现关系,可以单实现,也可以多实现。
		并且还可以在继承一个类的同时实现多个接口。
	c:接口与接口：
		继承关系,可以单继承,也可以多继承。
B:案例演示
	类与类,类与接口,接口与接口的关系

09.18_面向对象(抽象类和接口的区别)(掌握)

A:成员区别
	抽象类：
		成员变量：可以变量，也可以常量
		构造方法：有
		成员方法：可以抽象，也可以非抽象
	接口：
		成员变量：只可以常量
		成员方法：只可以抽象	
B:关系区别
	类与类
		继承，单继承
	类与接口
		实现，单实现，多实现
	接口与接口
		继承，单继承，多继承	
C:设计理念区别
	抽象类 	被继承体现的是：”is a”的关系。	抽象类中定义的是该继承体系的共性功能。
	接口 	被实现体现的是：”like a”的关系。	接口中定义的是该继承体系的扩展功能。


 注意：JDK1.8之后在接口中提供了用default修饰的方法，可以给出功能的具体实现，子类可以继承下去用
      JDK1.8之后在接口中也可以定义静态方法

09.19_面向对象(猫狗案例加入跳高功能分析及其代码实现)(掌握)

A:案例演示
	动物类：姓名，年龄，吃饭，睡觉。
	动物培训接口：跳高
	猫继承动物类
	狗继承动物类
	部分猫继承猫类并实现跳高接口
	部分狗继承狗类并实现跳高接口

	通过抽象类测试基本功能。
	通过接口测试扩展功能。
	只测试猫，狗的测试留给学生自己练习

09.20_day09重点总结

多态：一种事物，在不同的时期，所表现出不同的状态

多态的前提要有继承

多态的语法表现形态：父类引用指向子类对象

多态的好处：提高了代码的复用性，维护性，主要是提高代码的扩展性

抽象

父类抽取出了所有子类的共性功能，但是并不知道每个子类对共性功能的具体实现，当然也没有必要去知道。所以父类可以将共性功能抽象出来。具体的实现细节由子类根据自身的差异性去具体重写和实现。所以父类只需要给出共性功能的声明即可。也就是把共性功能定义为抽象即可。抽象类的子类必须实现抽象方法，否则会报错。

//abstract 抽象的可以修饰方法也可以修饰类。

语法层面：一旦一个类中有了抽象方法，此类必须为一个抽象类。；一个抽象类中可以没有抽象方法，当然也可以有非抽象方法。

抽象类中可以有抽象方法，也可以有非抽象方法，非抽象方法可以让子类继承使用，抽象方法强制子类必须重写。

抽象类中存在构造方法，作用：创建子类时，先初始化父类的数据。

抽象类不能直接创建其对象。我们可以采用多态的形式，间接的初始化，创建子类向上转型到父类。

作为抽象类的子类，必须重写父类的所有的抽象方法。如果你不重写，你自己也定义为抽象类就行。

抽象类中可以定义成员变量，也可以定义常量

抽象类中有构造方法，完成对父类的初始化.

abstract的作用：不能外界new对象。

私有的构造方法：也不能外界new对象

abstract不能和哪些关键字共存：final—不让子类重写；private: 子类无法继承； static: 静态方法属于类，不参与重写。

接口：

接口用来定义一些事物的额外功能，属于后天学习的。

Interface定义一个接口，接口中定义的都是一些扩展的功能。

哪类事物想要具备该扩展功能，只需要实现该接口

接口中只是定义了功能，但需要在使用时具体实现。-=—implements

接口不能创建对象，类和接口之间叫做实现关系。可以叫做父接口，子类。

接口中成员特点：

接口不能创建对象
接口中没有构造方法这一说
接口中的成员变量全部是公共的静态常量，存在public static final修饰符
接口中所有方法全是抽象方法，存在默认修饰符public abstract

类与类之间是继承关系，而且是单继承，可以多层继承

类与接口，之间是实现关系，并且可以多实现，也就是一个类可以实现多个接口

接口与接口之间是继承关系，可以多层继承。

问java是否支持多继承分情况，类之间不行，接口之间可以多继承。

JDK1.8之后对接口的一些改变：之前—接口中全是抽象方法；之后—方法可以给出具体的实现，但是这个方法，必须要default修饰。之后–接口中也可以定义静态方法。

类可以同时继承和多实现