java语言基础（十）

最新推荐文章于 2024-07-10 21:37:49 发布

siriusone

最新推荐文章于 2024-07-10 21:37:49 发布

阅读量103

点赞数

文章标签： java 开发语言

本文链接：https://blog.csdn.net/siriusone/article/details/122942156

版权

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

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

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

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

package org.westos.demo;

public class MyTest {
    public static void main(String[] args) {
        //多态：指的是一种事物，在不同时刻所表现出的不同状态。
        //猫是猫的一种，我也可以说猫是动物的一种。
        //所以，猫既可以表现为猫这种形态，也可以表现为动物的这种形态。
        // Cat cat = new Cat();  Animal cat = new Cat();
        //1.多态的前提，必须要有继承，如果没有继承，那么多态就无从谈起。
        //2.多态需要有，方法重写，当然你可以不重写，但是就失去了多态的意义。
        //3.多态： 父类引用 执行子类对象    Animal an = new Cat();




       /* Cat cat = new Cat();
        System.out.println(cat.a);
        System.out.println(cat.num);*/
        //多态：父类引用指向子类对象
        //左边       右边
        Animal an = new Cat();
        //多态的方式，来访问成员变量的特点：编译看左边，运行也看左边，
        System.out.println(an.num);
        //多态的方式，来访问成员方法的特点：编译左边，运行看右边， 以子类重写的为准，当然你没有重写，那就调用父类，当然多态我们都会去重写父类的方法。
        //多态的构造方法特点：先调用父类的构造方法，再调用子类的构造方法
        an.show();

    }
}

class Animal {

    int num = 120;

    public Animal() {
        System.out.println("父类的构造方法");
    }

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

class Cat extends Animal {
    int a = 20;
    int num = 600;

    public Cat() {
        System.out.println("子类的空参构造");
    }

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

面向对象(多态的好处)

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

package org.westos.demo2;


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

package org.westos.demo2;


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

package org.westos.demo2;

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

package org.westos.demo2;

public class MyTest {
    public static void main(String[] args) {
        //多态的好处：1. 提高了代码的维护性复用性，继承保证  2. 多态可以提供代码的扩展性。
        Cat cat = new Cat();
        MyUtils.testEat(cat);
        Dog dog = new Dog();
        MyUtils.testEat(dog);
        //我们一般在这个入口类里面，不去定义 其他的成员变量和成员方法，只提供一个主方法，在主方法里面去使用其他类。

        Tiger tiger = new Tiger();
        MyUtils.testEat(tiger);
        Rabbit rabbit = new Rabbit();
        MyUtils.testEat(rabbit);
        Panda panda = new Panda();
        MyUtils.testEat(panda);
    }
}

package org.westos.demo2;


public class MyUtils {
    private MyUtils(){}
    public static void testEat(Animal an) {  //Animal  an=cat;   Animal  an=dog    Animal  an=tiger
        an.eat();
    }
    /*
    public static void testEat(Cat cat) {
        cat.eat();
    }

    public static void testEat(Dog dog) {
        dog.eat();
    }


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

    public static void testEat(Rabbit rabbit) {
        rabbit.eat();
    }*/
}

package org.westos.demo2;


public class Panda extends Animal{
    @Override
    public void eat() {
        System.out.println("熊猫爱吃竹子");
    }
}

package org.westos.demo2;

public class Rabbit extends Animal {
    @Override
    public void eat() {
        System.out.println("兔子爱吃胡萝卜");
    }
}

package org.westos.demo2;


public class Tiger extends Animal{
    @Override
    public void eat() {
        System.out.println("老虎爱吃肉");
    }
}

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

A:通过多态的弊端引出问题
不能使用子类特有的功能
B:解决问题
a:把父类的引用强制转换为子类的引用。(向下转型)

package org.westos.demo4;


public class MyTest {
    public static void main(String[] args) {
        Animal an = new Cat();
        an.eat();
       // an.catchMouse();
        Cat cat= (Cat) an; //向下转型。
        cat.catchMouse();

        //ClassCastException: 类型转换异常。
        an=new Dog();
        Dog dog= (Dog) an;

        dog.looDoor();

    }
}
class Animal{
    public void eat(){
        System.out.println("吃饭");
    }
}
class Cat extends Animal{
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
    public void catchMouse(){
        System.out.println("猫抓老鼠");
    }
}
class Dog extends Animal{
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }
    public void looDoor(){
        System.out.println("狗看门");
    }
}

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

孔子装爹

package org.westos.demo5;


public class MyTest {
    public static void main(String[] args) {
        /*
         * 孔子装爹：
         * 孔子爹，是一个资深的Java讲师，很多人慕名前来，有一天张三，来到孔子的家里，把孔子爹请到了家里去讲Java
         * 就剩孔子一个人在家，这时，李四也来家里请孔子爹，去讲课，但是孔子爹不在家，但是李四没有讲过孔子爹。
         * 孔子想了想，不能失去这个学员，所以孔子就乔装打扮一翻，扮成他爹的模样，去给李四讲课，他其实讲的是论语。
         * 讲完论语后，孔子说装爹太累了，就卸下装扮，做回自己，玩游戏去了
         *
         * */

        孔子爹  k爹 = new 孔子();
        System.out.println(k爹.age);// 60
        k爹.teach();
        //做回自己 向下转型
        孔子 k= (孔子) k爹;
        System.out.println(k.age);
        k.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:抽象类的子类
       要么是抽象类
       要么重写抽象类中的所有抽象方法

package org.westos.demo2;


//抽象类  abstract
public abstract class Animal {
    //抽象方法，没有方法体，也就是没有方法的具体的功能逻辑
    public abstract void eat();

    public abstract void sleep();

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

package org.westos.demo2;

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

    @Override
    public void sleep() {
        System.out.println("猫白天爱睡觉");
    }
}

package org.westos.demo2;


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

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

}

package org.westos.demo2;


public class MyTest {
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.eat();
        cat.sleep();

        Dog dog = new Dog();
        dog.eat();
        dog.sleep();

        /*
        * 因为父类抽取类有子类共性的功能，但是父类并不知道，共性功能的子类对其具体实现，那
        * 么就把这些共性功能抽象出来，交由子类根据自身的差异性，对这些抽象功能进行重写。
        * 一旦这个类中定义了抽象方法，此类必须为抽象类，如果此类为抽象类，就不能直接创建其对象。
        */

        //关于抽象的语法
        //1.一个抽象类中，可以有抽象方法，也可以有非抽象方法。抽象的方法，强制子类必须重写，非抽象的方法，可以让子类继承下去用。
        //2. 一旦这个类中定义了抽象方法，此类必须为抽象类，
        //3. 抽象类中可以不定义抽象方法。
        //4. 抽象类不能直接创建对象，但是我们可以使用多态的形式初始化他。
        //5. 抽象类的子类，必须全部重写抽象类中的抽象方法。如果你不重写，你自己定义为抽象类

    }
}

abstract class AA{
    public abstract void aa();

    public abstract void cc();

}

abstract class BB extends AA{
    public abstract void bb();

}

class CC extends BB{

    @Override
    public void aa() {

    }

    @Override
    public void cc() {

    }

    @Override
    public void bb() {

    }
}

面向对象(抽象类的成员特点)

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

package org.westos.demo3;


public class MyTest {
    public static void main(String[] args) {
        //采用多态的形式，间接完成抽象类的实例化。
        Fu fu = new Zi();
        fu.eat();

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

abstract class Fu {
    int num = 100;
    public static final int AA = 30;

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

    public abstract void eat();
}

class Zi extends Fu {
    public Zi() {
        System.out.println("子类构造执行了");
    }

    @Override
    public void eat() {
        System.out.println("吃面" + num);
    }
}

面向对象(接口的概述及其特点)

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

面向对象(接口的成员特点)

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

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

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

package org.westos.demo6;


public abstract class Animal {
    String name;
    int age;
    public abstract void eat();
    public abstract void sleep();
}

package org.westos.demo6;


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

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

package org.westos.demo6;

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

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

package org.westos.demo6;


public class ErHaDog extends Dog implements JumpInterface{
    @Override
    public void eat() {
        System.out.println("二哈吃的是狗粮");
    }

    @Override
    public void sleep() {
        System.out.println("二哈在沙发上睡觉");
    }


    @Override
    public void jump() {
        System.out.println("二哈学会了跳高");
    }
}

package org.westos.demo6;


//一个类在继承一个类的同时，也可以去实现接口
public class JiaFeiCat extends Cat implements JumpInterface {
    @Override
    public void eat() {
        System.out.println("加菲猫爱吃鱼罐头");
    }

    @Override
    public void sleep() {
        System.out.println("加菲猫，在猫窝里睡觉");
    }


    @Override
    public void jump() {
        System.out.println("加菲猫学会了跳高");
    }
}

package org.westos.demo6;

public interface JumpInterface {
    void jump();
}

package org.westos.demo6;

public class MyTest {
    public static void main(String[] args) {
        /*
        *  A:案例演示
	动物类：姓名，年龄，吃饭，睡觉。
	动物培训接口：跳高
	猫继承动物类
	狗继承动物类
	部分猫继承猫类并实现跳高接口
	部分狗继承狗类并实现跳高接口

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

        Cat tomCat = new TomCat();
        tomCat.name="汤姆";
        tomCat.age=15;
        System.out.println(tomCat.name);
        System.out.println(tomCat.age);
        tomCat.eat();
        tomCat.sleep();
        //向下转型
        TomCat cat= (TomCat) tomCat;
        cat.catchMouse();
        JiaFeiCat jiaFeiCat = new JiaFeiCat();
        tomCat= jiaFeiCat;
        tomCat.name="加菲";
        tomCat.age=10;
        System.out.println(tomCat.name);
        System.out.println(tomCat.age);
        tomCat.sleep();
        tomCat.eat();
        JumpInterface jumpInterface=jiaFeiCat;
        jumpInterface.jump();

    }
}

package org.westos.demo6;

public class TomCat extends Cat {
    @Override
    public void eat() {
        System.out.println("汤姆猫爱吃鱼");
    }

    @Override
    public void sleep() {
        System.out.println("汤姆猫在沙发上睡觉");
    }

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

package org.westos.demo6;


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

    @Override
    public void sleep() {
        System.out.println("旺财在门口睡觉");
    }

    public void lookDoor(){
        System.out.println("旺财在看门");
    }
}

siriusone

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java语言基础（十）

面向对象(多态的概述及其代码体现)A:多态概述某一个事物，在不同时刻表现出来的不同状态。举例： Cat c=new Cat(); Animal a=new Cat(); 猫可以是猫的类型。猫 m = new 猫(); 同时猫也是动物的一种，也可以把猫称为动物。动物 d = new 猫(); B:多态前提 a:要有继承关系。 b:要有方法重写。其实没...
复制链接

扫一扫