day12 多态 内部类

最新推荐文章于 2024-09-16 20:08:29 发布
最新推荐文章于 2024-09-16 20:08:29 发布
阅读量154 收藏 1
点赞数
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_52346838/article/details/125046539
版权

本学习内容来着b站：黑马程序员

注：痛苦啊真痛苦，明明觉得学习Java特别厉害，非常羡慕技术大佬，但是我自己总是感觉有心无力，备受打击，真的痛苦，啥时候才能见到光明啊，我也知道必须经过黎明前的黑暗我们才能见到光明，还得继续坚持下去。今天的内容可以说是不全的，只有多态和内部类，还有常见的api我没有敲过代码，就不放到这里来了。结尾：本内容，当做笔记的复习材料，如果你看到了这篇文章能对你有所帮助，给我点个赞或者评论也是对我更新的最大动力！感谢，内容如果有错误，欢迎各位兄弟姐妹批评指正！！！

一. 多态

1.1 什么是多态

 

代码实现：抽象类父类 animal

package com.xiaochen.d1_polymorphic;

public class Tortoise extends Animal{
    public String name = "子类乌龟";
    @Override
    public void run() {
        System.out.println("跑的慢");

    }
}

代码实现：子类 dog

package com.xiaochen.d1_polymorphic;

public class Dog extends Animal{
    public String name = "子类狗";
    @Override
    public void run() {
        System.out.println("狗跑的很快");

    }
}

代码实现：子类 tortoise

package com.xiaochen.d1_polymorphic;

public class Tortoise extends Animal{
    public String name = "子类乌龟";
    @Override
    public void run() {
        System.out.println("跑的慢");

    }
}

代码实现：测试类 

package com.xiaochen.d1_polymorphic;
//目标：认识多态，理解多态的形式和概念
public class Test {
    public static void main(String[] args) {
        //1、多态的形式： 父类构造器 对象名称 = new 子类构造器
        Animal a = new Dog();
        a.run();//编译看左边，运行看右边
        System.out.println(a.name);//对于变量的调用，编译看左，运行也看左


        Animal a2 = new Tortoise();
        a2.run();//编译看左边，运行看右边
        System.out.println(a2.name);//对于变量的调用，编译看左，运行也看左
    }
}

1.2 多态的优势

代码实现：父类 animal

package com.xiaochen.d2_polymorphic_advantage;
//父类
public class Animal {
    public String name = "动物名称";
    public void run(){
        System.out.println("动物可以跑");
    }
}

代码实现：子类 Dog

package com.xiaochen.d2_polymorphic_advantage;

public class Dog extends Animal {
    public String name = "狗名称";
    @Override
    public void run(){
        System.out.println("狗跑的快");
    }
    /*
    独有功能
     */
    public void lookDoor(){
        System.out.println("狗在看门");
    }
}

代码实现：子类 tortoise

package com.xiaochen.d2_polymorphic_advantage;

public class Tortoise extends Animal{
    public String name = "乌龟名称";
    @Override
    public void run(){
        System.out.println("乌龟跑的慢");
    }
    /*
   独有功能
    */
    public void lookDoor(){
        System.out.println("乌龟在爬");
    }
}

代码实现：测试类 

package com.xiaochen.d2_polymorphic_advantage;


public class Test {
    public static void main(String[] args) {
        Animal a = new Tortoise();
        go(a);
        Animal a2 = new Dog();
        go(a2);
        //a2.lookDoor();//多态下不能访问子类的独有功能


    }
    /*
    要求：所有的动物都可以进来比赛
     */
    public static void go(Animal a){
        System.out.println("开始");
        a.run();
        System.out.println("结束");
    }
}

 1.3 多态下引用类型数据转换

代码实现：父类 animal

package com.xiaochen.d3_polymorphic_convert;
//父类
public class Animal {
    public void run(){
        System.out.println("动物可以跑");
    }

}

代码实现：子类 dog 

package com.xiaochen.d3_polymorphic_convert;

public class Dog extends Animal{
    @Override
    public void run(){
        System.out.println("狗跑的快");
    }
    /*
    独有功能
     */
    public void lookDoor(){
        System.out.println("狗在看门");
    }
}

代码实现：子类 cat

package com.xiaochen.d3_polymorphic_convert;

public class Cat extends Animal{
    public void run(){
        System.out.println("猫跑的也很快");
    }
    /*
    独有功能
     */
    public void maojiao(){
        System.out.println("猫叫");
    }
}

代码实现：测试类 

package com.xiaochen.d3_polymorphic_convert;

public class Test {
    public static void main(String[] args) {
        //自动类型转换
        Animal a = new Dog();
        a.run();

        //强制类型转换
        Animal a2 = new Cat();
        a2.run();


        //Dog d = (Dog) a2;//强制类型转换，编译阶段不报错的（注意：有继承或者实现关系编译阶段可以强转，没有毛病）运行时可能会出错的
        if(a2 instanceof Cat){
            Cat t = (Cat) a2;//从父类类型到子类类型，必须强制类型转换
            t.maojiao();
        }else if(a2 instanceof Dog){
            Dog d = new Dog();
            d.lookDoor();
        }
        System.out.println("=================");
        go(new Dog());
        go(new Cat());
    }
    public static void go(Animal a){
        //a到底是狗还是猫
        if(a instanceof Cat){
            Cat t = (Cat) a;//从父类类型到子类类型，必须强制类型转换
            t.maojiao();
        }else if(a instanceof Dog){
            Dog d = new Dog();
            d.lookDoor();
        }
    }


}

 1.4 多态的案例

代码实现：接口

package com.xiaochen.d4_polymorphic_test;
//USB接口 = 规范
public interface USB {
    //接入 拔出
    void connect();
    void unconnerct();
}

代码实现：实现类 keyboard

package com.xiaochen.d4_polymorphic_test;
//实现类
public class KeyBoard implements USB{
    private String name;

    public KeyBoard(String name) {
        this.name = name;
    }

    @Override
    public void connect() {
        System.out.println(name + "成功连接了电脑");

    }
    /*
    独有功能
     */
    public void keyDown(){
        System.out.println(name + "敲击了，来了，老铁666666");
    }

    @Override
    public void unconnerct() {
        System.out.println(name + "成功从电脑拔出");
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

代码实现：实现类 mouse

package com.xiaochen.d4_polymorphic_test;
//实现类
public class Mouse implements USB{
    private String name;

    public Mouse(String name) {
        this.name = name;
    }

    @Override
    public void connect() {
        System.out.println(name + "成功连接了电脑");

    }
    /*
    独有功能
     */
    public void dbClick(){
        System.out.println(name + "双击点亮小红心，一键三连");
    }

    @Override
    public void unconnerct() {
        System.out.println(name + "成功从电脑拔出");
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

代码实现：电脑类

package com.xiaochen.d4_polymorphic_test;

public class Computer {
    private String name;

    public Computer(String name) {
        this.name = name;
    }
    public void start(){
        System.out.println(name + "开机了");
    }
    /*
    提供安装USB设备的入口
     */
    public void installUSB(USB usb){
        //多态 usb == 可能是鼠标，也可以是键盘
        usb.connect();
        //独有功能：先判断，再强转
        if(usb instanceof KeyBoard){
            KeyBoard k = (KeyBoard) usb;
            k.keyDown();
        }else if(usb instanceof Mouse){
            Mouse m = (Mouse) usb;
            m.dbClick();
        }
        usb.unconnerct();
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

代码实现：测试类 

package com.xiaochen.d4_polymorphic_test;
/*
目标：USB设备模型
1、定义USB接口：接入 拔出
2、定义2个USB的实现类：鼠标 键盘
3、创建一个电脑对象，创建USB设备对象，安装启动
 */
public class Test {
    public static void main(String[] args) {
        //1、创建电脑对象
        Computer c = new Computer("华为");
        c.start();
        //2、创建鼠标对象，键盘对象
        USB u = new KeyBoard("小陈");
        c.installUSB(u);
        USB u1 = new KeyBoard("罗技鼠标");
        c.installUSB(u1);

    }
}

 

二.内部类

 2.1 什么是内部类

 2.2 静态内部类

 

代码实现 ：Outer

package com.xiaochen.d5_innerclass_static;
/*
外部类
 */
public class Outer {
    public static int a = 100;
    private String hobby;

    /*
    学习静态成员内部类
     */
    public static class Inner{
        private String name;
        private int age;
        public static String schoolName;

        public Inner() {
        }

        public Inner(String name, int age) {
            this.name = name;
            this.age = age;
        }

        public void show(){
            System.out.println("名称：" + name);
            System.out.println(a);
            Outer o = new Outer();
            System.out.println(o.hobby);//间接访问
           // System.out.println(hobby);

        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public int getAge() {
            return age;
        }

        public void setAge(int age) {
            this.age = age;
        }

        public static String getSchoolName() {
            return schoolName;
        }

        public static void setSchoolName(String schoolName) {
            Inner.schoolName = schoolName;
        }
    }

}

代码实现：测试类 

package com.xiaochen.d5_innerclass_static;

public class Test {
    public static void main(String[] args) {
        Outer.Inner in = new Outer.Inner();
        in.setName("小陈");
        in.show();
    }
}

 2.3 成员内部类

 

 

代码实现：outer类

package com.xiaochen.d6_innerclass;



//外部类
public class Outer {
    public static int num = 111;
    private String hobby;

    public Outer() {
    }

    public Outer(String hobby) {
        this.hobby = hobby;
    }

    /*
        成员内部类：不能加static修饰属于外部类对象的
         */
    public class Inner{
        private String name;
        private int age;
        public static int a = 100 ;//jdk16开始支持静态成员了

        public static void test(){
            System.out.println(a);

        }
        public void show(){
            System.out.println("名称：" + name);
            System.out.println("数量：" + num);
            System.out.println("爱好：" + hobby);

        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public int getAge() {
            return age;
        }

        public void setAge(int age) {
            this.age = age;
        }
    }
}

代码实现： 测试类

package com.xiaochen.d6_innerclass;

public class Test {
    public static void main(String[] args) {
        Outer.Inner in = new Outer().new Inner();
        in.setName("内部");
        in.show();
        Outer.Inner.test();

        System.out.println("========");
        Outer.Inner in1 = new Outer().new Inner();
        in1.show();

    }
}

2.4 局部内部类 

 

package com.xiaochen.d7_innerclass;
目标：了解局部内部类的语法
public class Test {
    public static void main(String[] args) {
        class Cat{
            private String name;

            public static int onlineNumber =100;

            public String getName() {
                return name;
            }

            public void setName(String name) {
                this.name = name;
            }
        }
    }
}

 2.5 匿名内部类重点

 

 

package com.xiaochen.d8_innerclass_anonymous;
//目标：学习匿名内部类的形式和特点
public class Test {
    public static void main(String[] args) {
        Animal a = new Animal() {
            @Override
            public void run() {
                System.out.println("老虎跑得快");
            }
        };
        a.run();

    }
}
//class Tiger extends Animal{
//    @Override
//    public void run() {
//        System.out.println("老虎跑得快");
//    }
//}

abstract class Animal{
    public abstract void run();
}

 

 

 

代码实现： 

package com.xiaochen.d8_innerclass_anonymous;
//目标：掌握匿名内部类的使用形式
public class Test2 {
    public static void main(String[] args) {
        Swimming s = new Swimming() {
            @Override
            public void swim() {
                System.out.println("学生快乐的自由泳");
            }
        };
        go(s);
        System.out.println("===============");
        Swimming s1 = new Swimming() {
            @Override
            public void swim() {
                System.out.println("老师泳得快");
            }
        };
        go(s1);
        System.out.println("=================");
        go(new Swimming() {
            @Override
            public void swim() {
                System.out.println("运动员快");
            }
        });

    }
    /*
    学生 老师 运动员可以一起参加游戏比赛
     */
    public static void go(Swimming s){
        System.out.println("开始");
        s.swim();
        System.out.println("结束");
    }
}
class Student implements Swimming{
    @Override
    public void swim() {
        System.out.println("学生快乐的自由泳");
    }
}

interface Swimming{
    void swim();
}

 

 

代码实现： 

package com.xiaochen.d8_innerclass_anonymous;

import javax.swing.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

//目标：通过GUI编程 理解匿名内部类的真实使用场景
public class Test3 {
    public static void main(String[] args) {
        //1、创建窗口
        JFrame  win = new JFrame("登录界面");
        JPanel panel = new JPanel();
        win.add(panel);

        //2、创建一个按钮对象
        JButton btn = new JButton("登录");


        //注意：讲解匿名内部类的使用
//        btn.addActionListener(new ActionListener() {
//            @Override
//            public void actionPerformed(ActionEvent e) {
//                JOptionPane.showConfirmDialog(win,"点我一下，说明爱我");
//            }
//        });

        btn.addActionListener( e -> JOptionPane.showConfirmDialog(win,"点我一下，说明爱我"));

        //3、把按钮对象添加到桌布上展示
        panel.add(btn);

        //4、展示窗口
        win.setSize(400,300);
        win.setLocationRelativeTo(null);
        win.setVisible(true);
    }
}

new一个“对象”
关注
Day12 instanceof 内部类
m0_67113020的博客
03-17 495
instanceof 运算符——判断对象是否属于指定类型 ​ // ( arr[i] instanceof Zi011 ) 向上转型 : 通过子类对象(小范围)实例化父类对象(大范围), 这种属于自动转换 向下转型 : 通过父类对象(大范围)实例化子类对象(小范围), 这种属于强制转换 ​ // Zi011 z1 = (Zi011) arr[i];
Java知识总结2
wangxuyangwxy的博客
07-31 107
Java基础知识
day06多态、内部、权限修饰符、Object类
JayvenJavaUPUP
02-09 105
1、多态 概述 面向对象的三大特征：封装、继承、多态 多态的形式： 父类 对象名称 = new 子类构造器; 接口 对象名称 = new 实现类构造器; 父类类型范围 > 子类类型范围 相同类型的变量调用同一个行为，在不同状态下可以表现出不同的特征 使用前提： 必须存在继承或实现关系 存在父类类型的变量引用子类类型的对象 存在方法重写 识别技巧： 对于方法调用：编译看左，运行看右 对于变量的调用：编译看左，运行也看左 public class PolymorphicDem
多态内部类API
weixin_61800817的博客
06-24 876
多态，内部类，API
java 毕向东 内部类_毕向东Java视频学习笔记【Day10 多态+内部类】
weixin_30083369的博客
02-16 122
------- android培训、java培训、期待与您交流！ ----------  继承,总结: 一.代码块： 1.代码块的种类： 1).局部代码块：定义在某个Java_Day10 多态+内部类.01 .02 多态 猫 x = new 猫()； 动物 x = new 猫()； 一个对象对应着不同类型。 多态在代码中的体现：父类或者接口的引用指向了其子类的对象。 .03 多态的好处...
java 毕向东 内部类_毕向东视频学习笔记【Java_Day10 多态+内部类】
weixin_42476888的博客
02-25 131
Java_Day10 多态+内部类.01.02多态猫 x = new猫()；动物 x = new猫()；一个对象对应着不同类型。多态在代码中的体现：父类或者接口的引用指向了其子类的对象。.03多态的好处：提高了代码的扩展性，前期定义的代码可以使用后期的内容。 第100行(animal a)使代码简单，其下面的两个method就可以省略 ，这是多态性的使用。.04动态的弊端前期定义的内容 不能调用后...
Java面试知识点：多态、内部类
岁月求索
08-13 141
问题：Java面试知识点：多态、内部类 答案： 多态中成员访问特点 • 构造方法：同继承一样，子类会通过super访问父类构造方法 • 成员变量：编译看左边（父类），执行看左边（父类） • 成员方法：编译看左边（父类），执行看右边（子类） 多态中的转型 • 向上转型 从子到父 父类引用指向子类对象 • 向下转型 从父到子 父类引用转为子类对象 避免强转出现的问题 •关键字 instanceof •使用格式： 变量名 instanceof 类型 通俗的理解...
Java day08——多态、内部类
qq_40905010的博客
07-15 119
这里写目录标题多态前提实现总结类型转换异常内部类访问特点创建内部类对象格式匿名内部类 多态 前提 不同种类，两种类型 向上造型 实现 父类型引用 指向 子类型对象 成员变量 方法 总结 左边决定了。。。。右边决定了。。。。 类型转换异常 内部类 访问特点 创建内部类对象格式 外部类名.内部类名 对象名 = new 外部类型().new 内部类型(); 匿名内部类 ...
Day_10 面向对象多态 匿名内部类
lbw18的博客
01-19 1496
多态(重要) 多态性 : 事物的多种形态 举例: 人类 -> 黄种人,白种人,黑种人,红种人.. 水 -> 液态水,固态冰,气态水蒸气 Java基本数据类型的特性 : 自动提升和强制转换 -> 基本数据类型之间的类型转换问题! //byte,short,char < int < long < float < double 多态的本质描述的就是 : Java引用数据类型子父类之间类型转换的问题; //子类 < 父
day10-final、接口、多态.pdf
11-02
"day10-final、接口、多态.pdf" 本文档主要讲解了 Java 语言中的 final 关键字、接口和多态的概念。 首先，final 关键字用于修饰不可改变的内容，可以修饰类、方法和变量。被 final 修饰的类不能被继承，方法不能...
12.java基础----多态，内部类，常用API编程题
weixin_44140163的博客
03-19 933
命名要求： 1. 类名，接口名，枚举名，注解名使用大驼峰 2. 变量名，方法名，包名均使用小驼峰 3. 常量名全大写，多个单词下划线分割 4. 名字要见名知意，如果不知道对应的英文，可以使用拼音代替。不可使用无意义字符 代码规范： 格式要良好，使用IDEA格式化缩进（快捷键：Ctrl+Alt+L） 答题规范： 1. 每道题完整代码请贴入对应题目中的代码区。 2. 如果有运行结果的，请把代码运行结果放到文档中 【多态】 题目1 有以下类定义： 动物类 属性：名称、年龄、性..
C#基础知识及题目练习 Day12 多态 虚方法 里氏转换 抽象类 部分类 密封类 访问修饰符 接口 简单工厂设计模式
Aurora_m的博客
08-06 592
虚方法：父类的方法加关键字virtual，有方法体；子类添加关键字override，重写父类的虚方法，方法名要与父类一致。 抽象类：定义类的时候添加关键字abstract,抽象类中的成员只声明，不实现；子类继承抽象类的时候，要全部实现父类的抽象成员；抽象类可以有构造函数，但是不能被实例化。 接口：定义接口的时候在前面添加interface关键字，也就是说把class关键字替换成interface关键字，它就变成了接口。
【学习笔记】手写 Tomcat 三
LearnTech_123的博客
09-12 1111
响应动态资源不需要写文件名了，只需要写功能的名称即可。比如登录功能，可以定义名称为 doLogin
Gradle
xiaocaij_icai的博客
09-15 153
");
计算机毕业设计 基于SpringBoot的课程教学平台的设计与实现 Java+SpringBoot+Vue 前后端分离 文档报告 代码讲解 安装调试
weixin_19164791635
09-12 919
本文介绍了一款基于Java、SpringBoot和Vue.js技术的课程教学平台。该平台服务于管理员、学生和教师，提供教学资源管理、课程信息浏览、作业提交与批改等功能，旨在优化教学流程，提升教育质量，促进教育资源的数字化共享，推动教育信息化发展。
spring security中几大组件的作用和执行顺序
阿信今天的代码没bug的博客
09-11 346
spirng security中的几大组件的差异和执行顺序
计算机毕业设计 网上书店系统 Java+SpringBoot+Vue 前后端分离 文档报告 代码讲解 安装调试
最新发布
weixin_19164791635
09-16 840
本文介绍了一款基于Java、SpringBoot和Vue.js技术的网上书店系统。该系统为管理员、用户和卖家提供了图书信息浏览、订单管理、个人中心管理等功能，旨在打造一个便捷、高效的在线购书平台。系统通过优化图书销售流程，提升用户体验，推动出版行业的数字化转型，促进知识传播和文化交流。
模拟面试后端开发复盘
Java小白的博客 致力分享每一天学到的知识
09-11 1195
一般来说系统的开发和设计思路的话，就是一般现在的项目基本上都是前后端分离架构来实现的，所以在项目的设计时，要分层次结构来划定。前后端分离架构中，前端一般是有专业的前端工程师来写的，因此我们步需要过分的关注前端，可以在github上找到相关的前端项目即可。
Java接口与多态：final关键字的应用
在Java编程中，"day10-final、接口、多态.pdf"文档主要探讨了Java中的关键概念，包括final关键字、接口和多态。这些内容对于理解Java语言的封装和面向对象原则至关重要。 首先，final关键字被用来表示"不可变性"，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值